R/RcppExports.R

In rust: Ratio-of-Uniforms Simulation with Transformation

# Generated by using Rcpp::compileAttributes() -> do not edit by hand
# Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393

any_infinite <- function(x) {
    .Call(`_rust_any_infinite`, x)
}

any_naC <- function(x) {
    .Call(`_rust_any_naC`, x)
}

no_naC <- function(x) {
    .Call(`_rust_no_naC`, x)
}

any_nonpos <- function(x) {
    .Call(`_rust_any_nonpos`, x)
}

all_pos <- function(x) {
    .Call(`_rust_all_pos`, x)
}

any_neg <- function(x) {
    .Call(`_rust_any_neg`, x)
}

any_col_nonneg <- function(x) {
    .Call(`_rust_any_col_nonneg`, x)
}

any_pos <- function(x) {
    .Call(`_rust_any_pos`, x)
}

any_col_nonpos <- function(x) {
    .Call(`_rust_any_col_nonpos`, x)
}

vecpow <- function(base, exp) {
    .Call(`_rust_vecpow`, base, exp)
}

cpp_rho_to_psi <- function(rho, psi_mode, rot_mat) {
    .Call(`_rust_cpp_rho_to_psi`, rho, psi_mode, rot_mat)
}

cpp_psi_to_phi <- function(psi, lambda, gm, con) {
    .Call(`_rust_cpp_psi_to_phi`, psi, lambda, gm, con)
}

cpp_psi_to_phi_0 <- function(psi, lambda, gm, con) {
    .Call(`_rust_cpp_psi_to_phi_0`, psi, lambda, gm, con)
}

cpp_logf <- function(theta, logf, pars) {
    .Call(`_rust_cpp_logf`, theta, logf, pars)
}

cpp_logf_scaled <- function(theta, logf, pars) {
    .Call(`_rust_cpp_logf_scaled`, theta, logf, pars)
}

cpp_logf_rho <- function(rho, psi_mode, rot_mat, hscale, logf, pars) {
    .Call(`_rust_cpp_logf_rho`, rho, psi_mode, rot_mat, hscale, logf, pars)
}

trans1 <- function(rho, psi_mode, rot_mat) {
    .Call(`_rust_trans1`, rho, psi_mode, rot_mat)
}

cpp_logf_rho_2 <- function(rho, psi_mode, rot_mat, hscale, logf, pars, tpars, ptpfun, phi_to_theta, log_j, user_args) {
    .Call(`_rust_cpp_logf_rho_2`, rho, psi_mode, rot_mat, hscale, logf, pars, tpars, ptpfun, phi_to_theta, log_j, user_args)
}

trans2 <- function(rho, psi_mode, rot_mat, tpars, ptpfun) {
    .Call(`_rust_trans2`, rho, psi_mode, rot_mat, tpars, ptpfun)
}

cpp_logf_rho_3 <- function(rho, psi_mode, rot_mat, hscale, logf, pars, tpars, ptpfun, phi_to_theta, log_j, user_args) {
    .Call(`_rust_cpp_logf_rho_3`, rho, psi_mode, rot_mat, hscale, logf, pars, tpars, ptpfun, phi_to_theta, log_j, user_args)
}

trans3 <- function(rho, psi_mode, rot_mat, tpars, ptpfun, phi_to_theta, user_args) {
    .Call(`_rust_trans3`, rho, psi_mode, rot_mat, tpars, ptpfun, phi_to_theta, user_args)
}

cpp_logf_rho_4 <- function(rho, psi_mode, rot_mat, hscale, logf, pars, tpars, ptpfun, phi_to_theta, log_j, user_args) {
    .Call(`_rust_cpp_logf_rho_4`, rho, psi_mode, rot_mat, hscale, logf, pars, tpars, ptpfun, phi_to_theta, log_j, user_args)
}

trans4 <- function(rho, psi_mode, rot_mat, ptpfun, phi_to_theta, user_args) {
    .Call(`_rust_trans4`, rho, psi_mode, rot_mat, ptpfun, phi_to_theta, user_args)
}

rcpp_apply <- function(x, psi_mode, rot_mat, hscale, logf, pars, tpars, ptpfun, phi_to_theta, log_j, user_args) {
    .Call(`_rust_rcpp_apply`, x, psi_mode, rot_mat, hscale, logf, pars, tpars, ptpfun, phi_to_theta, log_j, user_args)
}

cpp_a_obj <- function(psi, psi_mode, rot_mat, hscale, logf, d, r, big_val, pars) {
    .Call(`_rust_cpp_a_obj`, psi, psi_mode, rot_mat, hscale, logf, d, r, big_val, pars)
}

cpp_a_obj_2 <- function(psi, psi_mode, rot_mat, hscale, d, r, big_val, tfun, tpars, logf, pars, ptpfun, phi_to_theta, log_j, user_args) {
    .Call(`_rust_cpp_a_obj_2`, psi, psi_mode, rot_mat, hscale, d, r, big_val, tfun, tpars, logf, pars, ptpfun, phi_to_theta, log_j, user_args)
}

cpp_lower_box <- function(rho, j, psi_mode, rot_mat, hscale, logf, d, r, big_val, pars) {
    .Call(`_rust_cpp_lower_box`, rho, j, psi_mode, rot_mat, hscale, logf, d, r, big_val, pars)
}

cpp_lower_box_2 <- function(rho, j, psi_mode, rot_mat, hscale, tfun, tpars, logf, pars, d, r, big_val, ptpfun, phi_to_theta, log_j, user_args) {
    .Call(`_rust_cpp_lower_box_2`, rho, j, psi_mode, rot_mat, hscale, tfun, tpars, logf, pars, d, r, big_val, ptpfun, phi_to_theta, log_j, user_args)
}

cpp_upper_box <- function(rho, j, psi_mode, rot_mat, hscale, logf, d, r, big_val, pars) {
    .Call(`_rust_cpp_upper_box`, rho, j, psi_mode, rot_mat, hscale, logf, d, r, big_val, pars)
}

cpp_upper_box_2 <- function(rho, j, psi_mode, rot_mat, hscale, tfun, tpars, logf, pars, d, r, big_val, ptpfun, phi_to_theta, log_j, user_args) {
    .Call(`_rust_cpp_upper_box_2`, rho, j, psi_mode, rot_mat, hscale, tfun, tpars, logf, pars, d, r, big_val, ptpfun, phi_to_theta, log_j, user_args)
}

ru_cpp <- function(n, d, r, a_box, l_box, u_box, logf, psi_mode, rot_mat, hscale, pars) {
    .Call(`_rust_ru_cpp`, n, d, r, a_box, l_box, u_box, logf, psi_mode, rot_mat, hscale, pars)
}

ru_cpp_2 <- function(n, d, r, a_box, l_box, u_box, psi_mode, rot_mat, hscale, logf, pars, tpars, ptpfun, phi_to_theta, log_j, user_args) {
    .Call(`_rust_ru_cpp_2`, n, d, r, a_box, l_box, u_box, psi_mode, rot_mat, hscale, logf, pars, tpars, ptpfun, phi_to_theta, log_j, user_args)
}

ru_cpp_3 <- function(n, d, r, a_box, l_box, u_box, psi_mode, rot_mat, hscale, logf, pars, tpars, ptpfun, phi_to_theta, log_j, user_args) {
    .Call(`_rust_ru_cpp_3`, n, d, r, a_box, l_box, u_box, psi_mode, rot_mat, hscale, logf, pars, tpars, ptpfun, phi_to_theta, log_j, user_args)
}

ru_cpp_4 <- function(n, d, r, a_box, l_box, u_box, psi_mode, rot_mat, hscale, logf, pars, tpars, ptpfun, phi_to_theta, log_j, user_args) {
    .Call(`_rust_ru_cpp_4`, n, d, r, a_box, l_box, u_box, psi_mode, rot_mat, hscale, logf, pars, tpars, ptpfun, phi_to_theta, log_j, user_args)
}

create_trans_xptr <- function(fstr) {
    .Call(`_rust_create_trans_xptr`, fstr)
}

bc_no_trans <- function(psi, lambda, gm, con) {
    .Call(`_rust_bc_no_trans`, psi, lambda, gm, con)
}

create_psi_to_phi_xptr <- function(fstr) {
    .Call(`_rust_create_psi_to_phi_xptr`, fstr)
}

log_none_jac <- function(theta, user_args) {
    .Call(`_rust_log_none_jac`, theta, user_args)
}

create_log_jac_xptr <- function(fstr) {
    .Call(`_rust_create_log_jac_xptr`, fstr)
}

no_trans <- function(theta, user_args) {
    .Call(`_rust_no_trans`, theta, user_args)
}

null_phi_to_theta_xptr <- function(fstr) {
    .Call(`_rust_null_phi_to_theta_xptr`, fstr)
}

logdN01 <- function(x, pars) {
    .Call(`_rust_logdN01`, x, pars)
}

logdnorm2 <- function(x, pars) {
    .Call(`_rust_logdnorm2`, x, pars)
}

logdmvnorm <- function(x, pars) {
    .Call(`_rust_logdmvnorm`, x, pars)
}

logcauchy <- function(x, pars) {
    .Call(`_rust_logcauchy`, x, pars)
}

loghalfcauchy <- function(x, pars) {
    .Call(`_rust_loghalfcauchy`, x, pars)
}

lognormalmix <- function(x, pars) {
    .Call(`_rust_lognormalmix`, x, pars)
}

lognormt <- function(x, pars) {
    .Call(`_rust_lognormt`, x, pars)
}

logdlnorm <- function(x, pars) {
    .Call(`_rust_logdlnorm`, x, pars)
}

logdgamma <- function(x, pars) {
    .Call(`_rust_logdgamma`, x, pars)
}

loggp <- function(x, ss) {
    .Call(`_rust_loggp`, x, ss)
}

#' Create external pointer to a C++ function for \code{logf}
#'
#' @param fstr A string indicating the C++ function required.
#' @details See the \href{https://cran.r-project.org/package=rust}{
#' Rusting faster: Simulation using Rcpp} vignette.
#' @section Examples:
#' See the examples in \code{\link{ru_rcpp}}.
#' @export
create_xptr <- function(fstr) {
    .Call(`_rust_create_xptr`, fstr)
}

neglog <- function(theta, user_args) {
    .Call(`_rust_neglog`, theta, user_args)
}

bc_log_j <- function(theta, user_args) {
    .Call(`_rust_bc_log_j`, theta, user_args)
}

#' Create external pointer to a C++ function for \code{log_j}
#'
#' @param fstr A string indicating the C++ function required.
#' @details See the \href{https://cran.r-project.org/package=rust}{
#' Rusting faster: Simulation using Rcpp} vignette.
#' @section Examples:
#' See the examples in \code{\link{ru_rcpp}}.
#' @export
create_log_j_xptr <- function(fstr) {
    .Call(`_rust_create_log_j_xptr`, fstr)
}

exptrans <- function(phi, user_args) {
    .Call(`_rust_exptrans`, phi, user_args)
}

vecpower <- function(base, exp) {
    .Call(`_rust_vecpower`, base, exp)
}

bc_phi_to_theta <- function(phi, user_args) {
    .Call(`_rust_bc_phi_to_theta`, phi, user_args)
}

gp_phi_to_theta <- function(phi, user_args) {
    .Call(`_rust_gp_phi_to_theta`, phi, user_args)
}

#' Create external pointer to a C++ function for \code{phi_to_theta}
#'
#' @param fstr A string indicating the C++ function required.
#' @details See the \href{https://cran.r-project.org/package=rust}{
#' Rusting faster: Simulation using Rcpp} vignette.
#' @section Examples:
#' See the examples in \code{\link{ru_rcpp}}.
#' @export
create_phi_to_theta_xptr <- function(fstr) {
    .Call(`_rust_create_phi_to_theta_xptr`, fstr)
}

# Register entry points for exported C++ functions
methods::setLoadAction(function(ns) {
    .Call(`_rust_RcppExport_registerCCallable`)
})