R/RcppExports.R

In spEDM: Spatial Empirical Dynamic Modeling

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

RcppEntropy_Cont <- function(vec, k = 3L, base = 10, NA_rm = FALSE) {
    .Call(`_spEDM_RcppEntropy_Cont`, vec, k, base, NA_rm)
}

RcppJoinEntropy_Cont <- function(mat, columns, k = 3L, base = 10, NA_rm = FALSE) {
    .Call(`_spEDM_RcppJoinEntropy_Cont`, mat, columns, k, base, NA_rm)
}

RcppMutualInformation_Cont <- function(mat, columns1, columns2, k = 3L, alg = 1L, normalize = FALSE, NA_rm = FALSE) {
    .Call(`_spEDM_RcppMutualInformation_Cont`, mat, columns1, columns2, k, alg, normalize, NA_rm)
}

RcppConditionalEntropy_Cont <- function(mat, target_columns, conditional_columns, k = 3L, base = 10, NA_rm = FALSE) {
    .Call(`_spEDM_RcppConditionalEntropy_Cont`, mat, target_columns, conditional_columns, k, base, NA_rm)
}

RcppEntropy_Disc <- function(vec, base = 10, NA_rm = FALSE) {
    .Call(`_spEDM_RcppEntropy_Disc`, vec, base, NA_rm)
}

RcppJoinEntropy_Disc <- function(mat, columns, base = 10, NA_rm = FALSE) {
    .Call(`_spEDM_RcppJoinEntropy_Disc`, mat, columns, base, NA_rm)
}

RcppMutualInformation_Disc <- function(mat, columns1, columns2, base = 10, NA_rm = FALSE) {
    .Call(`_spEDM_RcppMutualInformation_Disc`, mat, columns1, columns2, base, NA_rm)
}

RcppConditionalEntropy_Disc <- function(mat, target_columns, conditional_columns, base = 10, NA_rm = FALSE) {
    .Call(`_spEDM_RcppConditionalEntropy_Disc`, mat, target_columns, conditional_columns, base, NA_rm)
}

RcppSimplexForecast <- function(embedding, target, lib, pred, num_neighbors = 4L, dist_metric = 2L, dist_average = TRUE) {
    .Call(`_spEDM_RcppSimplexForecast`, embedding, target, lib, pred, num_neighbors, dist_metric, dist_average)
}

RcppSimplexForecastCom <- function(embeddings, target, lib, pred, num_neighbors = 4L, dist_metric = 2L, dist_average = TRUE) {
    .Call(`_spEDM_RcppSimplexForecastCom`, embeddings, target, lib, pred, num_neighbors, dist_metric, dist_average)
}

RcppSMapForecast <- function(embedding, target, lib, pred, num_neighbors = 4L, theta = 1.0, dist_metric = 2L, dist_average = TRUE) {
    .Call(`_spEDM_RcppSMapForecast`, embedding, target, lib, pred, num_neighbors, theta, dist_metric, dist_average)
}

RcppSMapForecastCom <- function(embeddings, target, lib, pred, num_neighbors = 4L, theta = 1.0, dist_metric = 2L, dist_average = TRUE) {
    .Call(`_spEDM_RcppSMapForecastCom`, embeddings, target, lib, pred, num_neighbors, theta, dist_metric, dist_average)
}

RcppIntersectionCardinality <- function(embedding_x, embedding_y, lib, pred, num_neighbors = 4L, n_excluded = 0L, dist_metric = 2L, threads = 8L, parallel_level = 0L) {
    .Call(`_spEDM_RcppIntersectionCardinality`, embedding_x, embedding_y, lib, pred, num_neighbors, n_excluded, dist_metric, threads, parallel_level)
}

RcppLocateGridIndices <- function(curRow, curCol, totalRow, totalCol) {
    .Call(`_spEDM_RcppLocateGridIndices`, curRow, curCol, totalRow, totalCol)
}

RcppRowColFromGrid <- function(cellNum, totalCol) {
    .Call(`_spEDM_RcppRowColFromGrid`, cellNum, totalCol)
}

RcppLaggedVal4Grid <- function(mat, lagNum = 1L) {
    .Call(`_spEDM_RcppLaggedVal4Grid`, mat, lagNum)
}

RcppGenGridEmbeddings <- function(mat, E = 3L, tau = 1L, style = 1L) {
    .Call(`_spEDM_RcppGenGridEmbeddings`, mat, E, tau, style)
}

RcppGenGridEmbeddingsCom <- function(mat, E = 3L, tau = 1L, style = 1L, dir = as.integer( c(0))) {
    .Call(`_spEDM_RcppGenGridEmbeddingsCom`, mat, E, tau, style, dir)
}

RcppGenGridNeighbors <- function(mat, lib, k = 8L) {
    .Call(`_spEDM_RcppGenGridNeighbors`, mat, lib, k)
}

RcppGenGridSymbolization <- function(mat, lib, pred, k = 8L) {
    .Call(`_spEDM_RcppGenGridSymbolization`, mat, lib, pred, k)
}

RcppDivideGrid <- function(mat, b = 9L, shape = 3L) {
    .Call(`_spEDM_RcppDivideGrid`, mat, b, shape)
}

RcppSLMUni4Grid <- function(mat, k = 4L, step = 20L, alpha = 0.77, escape_threshold = 1e10) {
    .Call(`_spEDM_RcppSLMUni4Grid`, mat, k, step, alpha, escape_threshold)
}

RcppSLMBi4Grid <- function(mat1, mat2, k = 4L, step = 20L, alpha_x = 0.625, alpha_y = 0.77, beta_xy = 0.05, beta_yx = 0.4, interact = 0L, escape_threshold = 1e10) {
    .Call(`_spEDM_RcppSLMBi4Grid`, mat1, mat2, k, step, alpha_x, alpha_y, beta_xy, beta_yx, interact, escape_threshold)
}

RcppSLMTri4Grid <- function(mat1, mat2, mat3, k = 4L, step = 20L, alpha_x = 0.625, alpha_y = 0.77, alpha_z = 0.55, beta_xy = 0.05, beta_xz = 0.05, beta_yx = 0.4, beta_yz = 0.4, beta_zx = 0.65, beta_zy = 0.65, interact = 0L, escape_threshold = 1e10) {
    .Call(`_spEDM_RcppSLMTri4Grid`, mat1, mat2, mat3, k, step, alpha_x, alpha_y, alpha_z, beta_xy, beta_xz, beta_yx, beta_yz, beta_zx, beta_zy, interact, escape_threshold)
}

RcppFNN4Grid <- function(mat, rt, eps, lib, pred, E, tau = 1L, style = 1L, stack = 0L, dist_metric = 2L, dir = as.integer( c(0)), threads = 8L, parallel_level = 0L) {
    .Call(`_spEDM_RcppFNN4Grid`, mat, rt, eps, lib, pred, E, tau, style, stack, dist_metric, dir, threads, parallel_level)
}

RcppSimplex4Grid <- function(source, target, lib, pred, E, b, tau, style = 1L, stack = 0L, dist_metric = 2L, dist_average = TRUE, dir = as.integer( c(0)), threads = 8L) {
    .Call(`_spEDM_RcppSimplex4Grid`, source, target, lib, pred, E, b, tau, style, stack, dist_metric, dist_average, dir, threads)
}

RcppSMap4Grid <- function(source, target, lib, pred, theta, E = 3L, tau = 1L, b = 5L, style = 1L, stack = 0L, dist_metric = 2L, dist_average = TRUE, dir = as.integer( c(0)), threads = 8L) {
    .Call(`_spEDM_RcppSMap4Grid`, source, target, lib, pred, theta, E, tau, b, style, stack, dist_metric, dist_average, dir, threads)
}

RcppMultiView4Grid <- function(xMatrix, yMatrix, lib, pred, E = 3L, tau = 1L, b = 5L, top = 5L, nvar = 3L, style = 1L, stack = 0L, dist_metric = 2L, dist_average = TRUE, threads = 8L) {
    .Call(`_spEDM_RcppMultiView4Grid`, xMatrix, yMatrix, lib, pred, E, tau, b, top, nvar, style, stack, dist_metric, dist_average, threads)
}

RcppIC4Grid <- function(source, target, lib, pred, E, b, tau, exclude = 0L, style = 1L, dist_metric = 2L, threads = 8L, parallel_level = 0L) {
    .Call(`_spEDM_RcppIC4Grid`, source, target, lib, pred, E, b, tau, exclude, style, dist_metric, threads, parallel_level)
}

RcppPC4Grid <- function(source, target, lib, pred, E, b, tau, style = 1L, zero_tolerance = 0L, dist_metric = 2L, relative = TRUE, weighted = TRUE, threads = 8L, parallel_level = 0L) {
    .Call(`_spEDM_RcppPC4Grid`, source, target, lib, pred, E, b, tau, style, zero_tolerance, dist_metric, relative, weighted, threads, parallel_level)
}

RcppGCCM4Grid <- function(xMatrix, yMatrix, libsizes, lib, pred, E = 3L, tau = 1L, b = 5L, simplex = TRUE, theta = 0, threads = 8L, parallel_level = 0L, style = 1L, stack = 0L, dist_metric = 2L, dist_average = TRUE, single_sig = TRUE, dir = as.integer( c(0)), win_ratio = as.numeric( c(0,0)), progressbar = FALSE) {
    .Call(`_spEDM_RcppGCCM4Grid`, xMatrix, yMatrix, libsizes, lib, pred, E, tau, b, simplex, theta, threads, parallel_level, style, stack, dist_metric, dist_average, single_sig, dir, win_ratio, progressbar)
}

RcppSCPCM4Grid <- function(xMatrix, yMatrix, zMatrix, libsizes, lib, pred, E, tau, b, simplex = TRUE, theta = 0, threads = 8L, parallel_level = 0L, cumulate = FALSE, style = 1L, stack = 0L, dist_metric = 2L, dist_average = TRUE, single_sig = TRUE, dir = as.integer( c(0)), win_ratio = as.numeric( c(0,0)), progressbar = FALSE) {
    .Call(`_spEDM_RcppSCPCM4Grid`, xMatrix, yMatrix, zMatrix, libsizes, lib, pred, E, tau, b, simplex, theta, threads, parallel_level, cumulate, style, stack, dist_metric, dist_average, single_sig, dir, win_ratio, progressbar)
}

RcppGCMC4Grid <- function(xMatrix, yMatrix, libsizes, lib, pred, E, tau, b = 4L, r = 0L, style = 1L, dist_metric = 2L, threads = 8L, parallel_level = 0L, progressbar = FALSE) {
    .Call(`_spEDM_RcppGCMC4Grid`, xMatrix, yMatrix, libsizes, lib, pred, E, tau, b, r, style, dist_metric, threads, parallel_level, progressbar)
}

RcppGPC4Grid <- function(xMatrix, yMatrix, lib, pred, E = 3L, tau = 1L, style = 1L, b = 4L, zero_tolerance = 0L, dist_metric = 2L, relative = TRUE, weighted = TRUE, threads = 8L) {
    .Call(`_spEDM_RcppGPC4Grid`, xMatrix, yMatrix, lib, pred, E, tau, style, b, zero_tolerance, dist_metric, relative, weighted, threads)
}

RcppGPCRobust4Grid <- function(xMatrix, yMatrix, libsizes, lib, pred, E = 3L, tau = 1L, style = 1L, b = 4L, boot = 99L, random = TRUE, seed = 42L, zero_tolerance = 0L, dist_metric = 2L, relative = TRUE, weighted = TRUE, threads = 8L, parallel_level = 0L, progressbar = FALSE) {
    .Call(`_spEDM_RcppGPCRobust4Grid`, xMatrix, yMatrix, libsizes, lib, pred, E, tau, style, b, boot, random, seed, zero_tolerance, dist_metric, relative, weighted, threads, parallel_level, progressbar)
}

RcppSGCSingle4Grid <- function(x, y, lib, pred, k, base = 2, symbolize = TRUE, normalize = FALSE) {
    .Call(`_spEDM_RcppSGCSingle4Grid`, x, y, lib, pred, k, base, symbolize, normalize)
}

RcppSGC4Grid <- function(x, y, lib, pred, block, k, threads = 8L, boot = 399L, base = 2, seed = 42L, symbolize = TRUE, normalize = FALSE, progressbar = TRUE) {
    .Call(`_spEDM_RcppSGC4Grid`, x, y, lib, pred, block, k, threads, boot, base, seed, symbolize, normalize, progressbar)
}

RcppLaggedNeighbor4Lattice <- function(nb, lagNum = 1L) {
    .Call(`_spEDM_RcppLaggedNeighbor4Lattice`, nb, lagNum)
}

RcppLaggedVal4Lattice <- function(vec, nb, lagNum = 1L) {
    .Call(`_spEDM_RcppLaggedVal4Lattice`, vec, nb, lagNum)
}

RcppGenLatticeEmbeddings <- function(vec, nb, E = 3L, tau = 1L, style = 1L) {
    .Call(`_spEDM_RcppGenLatticeEmbeddings`, vec, nb, E, tau, style)
}

RcppGenLatticeEmbeddingsCom <- function(vec, nb, E = 3L, tau = 1L, style = 1L) {
    .Call(`_spEDM_RcppGenLatticeEmbeddingsCom`, vec, nb, E, tau, style)
}

RcppGenLatticeNeighbors <- function(vec, nb, lib, k = 8L) {
    .Call(`_spEDM_RcppGenLatticeNeighbors`, vec, nb, lib, k)
}

RcppGenLatticeSymbolization <- function(vec, nb, lib, pred, k = 8L) {
    .Call(`_spEDM_RcppGenLatticeSymbolization`, vec, nb, lib, pred, k)
}

RcppDivideLattice <- function(nb, b = 3L) {
    .Call(`_spEDM_RcppDivideLattice`, nb, b)
}

RcppSLMUni4Lattice <- function(vec, nb, k = 4L, step = 20L, alpha = 0.77, escape_threshold = 1e10) {
    .Call(`_spEDM_RcppSLMUni4Lattice`, vec, nb, k, step, alpha, escape_threshold)
}

RcppSLMBi4Lattice <- function(x, y, nb, k = 4L, step = 20L, alpha_x = 0.625, alpha_y = 0.77, beta_xy = 0.05, beta_yx = 0.4, interact = 0L, escape_threshold = 1e10) {
    .Call(`_spEDM_RcppSLMBi4Lattice`, x, y, nb, k, step, alpha_x, alpha_y, beta_xy, beta_yx, interact, escape_threshold)
}

RcppSLMTri4Lattice <- function(x, y, z, nb, k = 4L, step = 20L, alpha_x = 0.625, alpha_y = 0.77, alpha_z = 0.55, beta_xy = 0.05, beta_xz = 0.05, beta_yx = 0.4, beta_yz = 0.4, beta_zx = 0.65, beta_zy = 0.65, interact = 0L, escape_threshold = 1e10) {
    .Call(`_spEDM_RcppSLMTri4Lattice`, x, y, z, nb, k, step, alpha_x, alpha_y, alpha_z, beta_xy, beta_xz, beta_yx, beta_yz, beta_zx, beta_zy, interact, escape_threshold)
}

RcppFNN4Lattice <- function(vec, nb, rt, eps, lib, pred, E, tau = 1L, style = 1L, stack = 0L, dist_metric = 2L, threads = 8L, parallel_level = 0L) {
    .Call(`_spEDM_RcppFNN4Lattice`, vec, nb, rt, eps, lib, pred, E, tau, style, stack, dist_metric, threads, parallel_level)
}

RcppSimplex4Lattice <- function(source, target, nb, lib, pred, E, b, tau, style = 1L, stack = 0L, dist_metric = 2L, dist_average = TRUE, threads = 8L) {
    .Call(`_spEDM_RcppSimplex4Lattice`, source, target, nb, lib, pred, E, b, tau, style, stack, dist_metric, dist_average, threads)
}

RcppSMap4Lattice <- function(source, target, nb, lib, pred, theta, E = 3L, tau = 1L, b = 5L, style = 1L, stack = 0L, dist_metric = 2L, dist_average = TRUE, threads = 8L) {
    .Call(`_spEDM_RcppSMap4Lattice`, source, target, nb, lib, pred, theta, E, tau, b, style, stack, dist_metric, dist_average, threads)
}

RcppMultiView4Lattice <- function(x, y, nb, lib, pred, E = 3L, tau = 1L, b = 5L, top = 5L, nvar = 3L, style = 1L, stack = 0L, dist_metric = 2L, dist_average = TRUE, threads = 8L) {
    .Call(`_spEDM_RcppMultiView4Lattice`, x, y, nb, lib, pred, E, tau, b, top, nvar, style, stack, dist_metric, dist_average, threads)
}

RcppIC4Lattice <- function(source, target, nb, lib, pred, E, b, tau, exclude = 0L, style = 1L, dist_metric = 2L, threads = 8L, parallel_level = 0L) {
    .Call(`_spEDM_RcppIC4Lattice`, source, target, nb, lib, pred, E, b, tau, exclude, style, dist_metric, threads, parallel_level)
}

RcppPC4Lattice <- function(source, target, nb, lib, pred, E, b, tau, style = 1L, zero_tolerance = 0L, dist_metric = 2L, relative = TRUE, weighted = TRUE, threads = 8L, parallel_level = 0L) {
    .Call(`_spEDM_RcppPC4Lattice`, source, target, nb, lib, pred, E, b, tau, style, zero_tolerance, dist_metric, relative, weighted, threads, parallel_level)
}

RcppGCCM4Lattice <- function(x, y, nb, libsizes, lib, pred, E = 3L, tau = 1L, b = 5L, simplex = TRUE, theta = 0, threads = 8L, parallel_level = 0L, style = 1L, stack = 0L, dist_metric = 2L, dist_average = TRUE, single_sig = TRUE, progressbar = FALSE) {
    .Call(`_spEDM_RcppGCCM4Lattice`, x, y, nb, libsizes, lib, pred, E, tau, b, simplex, theta, threads, parallel_level, style, stack, dist_metric, dist_average, single_sig, progressbar)
}

RcppSCPCM4Lattice <- function(x, y, z, nb, libsizes, lib, pred, E, tau, b, simplex = TRUE, theta = 0, threads = 8L, parallel_level = 0L, cumulate = FALSE, style = 1L, stack = 0L, dist_metric = 2L, dist_average = TRUE, single_sig = TRUE, progressbar = FALSE) {
    .Call(`_spEDM_RcppSCPCM4Lattice`, x, y, z, nb, libsizes, lib, pred, E, tau, b, simplex, theta, threads, parallel_level, cumulate, style, stack, dist_metric, dist_average, single_sig, progressbar)
}

RcppGCMC4Lattice <- function(x, y, nb, libsizes, lib, pred, E, tau, b = 4L, r = 0L, style = 1L, dist_metric = 2L, threads = 8L, parallel_level = 0L, progressbar = FALSE) {
    .Call(`_spEDM_RcppGCMC4Lattice`, x, y, nb, libsizes, lib, pred, E, tau, b, r, style, dist_metric, threads, parallel_level, progressbar)
}

RcppGPC4Lattice <- function(x, y, nb, lib, pred, E = 3L, tau = 0L, style = 1L, b = 0L, zero_tolerance = 0L, dist_metric = 2L, relative = TRUE, weighted = TRUE, threads = 8L) {
    .Call(`_spEDM_RcppGPC4Lattice`, x, y, nb, lib, pred, E, tau, style, b, zero_tolerance, dist_metric, relative, weighted, threads)
}

RcppGPCRobust4Lattice <- function(x, y, nb, libsizes, lib, pred, E = 3L, tau = 0L, style = 1L, b = 0L, boot = 99L, random = TRUE, seed = 42L, zero_tolerance = 0L, dist_metric = 2L, relative = TRUE, weighted = TRUE, threads = 8L, parallel_level = 0L, progressbar = FALSE) {
    .Call(`_spEDM_RcppGPCRobust4Lattice`, x, y, nb, libsizes, lib, pred, E, tau, style, b, boot, random, seed, zero_tolerance, dist_metric, relative, weighted, threads, parallel_level, progressbar)
}

RcppSGCSingle4Lattice <- function(x, y, nb, lib, pred, k, base = 2, symbolize = TRUE, normalize = FALSE) {
    .Call(`_spEDM_RcppSGCSingle4Lattice`, x, y, nb, lib, pred, k, base, symbolize, normalize)
}

RcppSGC4Lattice <- function(x, y, nb, lib, pred, block, k, threads = 8L, boot = 399L, base = 2, seed = 42L, symbolize = TRUE, normalize = FALSE, progressbar = TRUE) {
    .Call(`_spEDM_RcppSGC4Lattice`, x, y, nb, lib, pred, block, k, threads, boot, base, seed, symbolize, normalize, progressbar)
}

RcppFactorial <- function(n) {
    .Call(`_spEDM_RcppFactorial`, n)
}

RcppCombine <- function(n, k) {
    .Call(`_spEDM_RcppCombine`, n, k)
}

RcppCombn <- function(vec, m) {
    .Call(`_spEDM_RcppCombn`, vec, m)
}

RcppGenSubsets <- function(vec) {
    .Call(`_spEDM_RcppGenSubsets`, vec)
}

RcppDigamma <- function(x) {
    .Call(`_spEDM_RcppDigamma`, x)
}

RcppLog <- function(x, base = 10) {
    .Call(`_spEDM_RcppLog`, x, base)
}

RcppMedian <- function(vec, NA_rm = FALSE) {
    .Call(`_spEDM_RcppMedian`, vec, NA_rm)
}

RcppMean <- function(vec, NA_rm = FALSE) {
    .Call(`_spEDM_RcppMean`, vec, NA_rm)
}

RcppMin <- function(vec, NA_rm = FALSE) {
    .Call(`_spEDM_RcppMin`, vec, NA_rm)
}

RcppMax <- function(vec, NA_rm = FALSE) {
    .Call(`_spEDM_RcppMax`, vec, NA_rm)
}

RcppSum <- function(vec, NA_rm = FALSE) {
    .Call(`_spEDM_RcppSum`, vec, NA_rm)
}

RcppVariance <- function(vec, NA_rm = FALSE) {
    .Call(`_spEDM_RcppVariance`, vec, NA_rm)
}

RcppCovariance <- function(vec1, vec2, NA_rm = FALSE) {
    .Call(`_spEDM_RcppCovariance`, vec1, vec2, NA_rm)
}

RcppMAE <- function(vec1, vec2, NA_rm = FALSE) {
    .Call(`_spEDM_RcppMAE`, vec1, vec2, NA_rm)
}

RcppRMSE <- function(vec1, vec2, NA_rm = FALSE) {
    .Call(`_spEDM_RcppRMSE`, vec1, vec2, NA_rm)
}

RcppCumSum <- function(vec) {
    .Call(`_spEDM_RcppCumSum`, vec)
}

RcppAbsDiff <- function(vec1, vec2) {
    .Call(`_spEDM_RcppAbsDiff`, vec1, vec2)
}

RcppSumNormalize <- function(vec, NA_rm = FALSE) {
    .Call(`_spEDM_RcppSumNormalize`, vec, NA_rm)
}

RcppArithmeticSeq <- function(from, to, length_out) {
    .Call(`_spEDM_RcppArithmeticSeq`, from, to, length_out)
}

RcppQuantile <- function(vec, probs, NA_rm = TRUE) {
    .Call(`_spEDM_RcppQuantile`, vec, probs, NA_rm)
}

RcppPearsonCor <- function(y, y_hat, NA_rm = FALSE) {
    .Call(`_spEDM_RcppPearsonCor`, y, y_hat, NA_rm)
}

RcppSpearmanCor <- function(y, y_hat, NA_rm = FALSE) {
    .Call(`_spEDM_RcppSpearmanCor`, y, y_hat, NA_rm)
}

RcppKendallCor <- function(y, y_hat, NA_rm = FALSE) {
    .Call(`_spEDM_RcppKendallCor`, y, y_hat, NA_rm)
}

RcppPartialCor <- function(y, y_hat, controls, NA_rm = FALSE, linear = FALSE, pinv_tol = 1e-10) {
    .Call(`_spEDM_RcppPartialCor`, y, y_hat, controls, NA_rm, linear, pinv_tol)
}

RcppPartialCorTrivar <- function(y, y_hat, control, NA_rm = FALSE, linear = FALSE, pinv_tol = 1e-10) {
    .Call(`_spEDM_RcppPartialCorTrivar`, y, y_hat, control, NA_rm, linear, pinv_tol)
}

RcppCorSignificance <- function(r, n, k = 0L) {
    .Call(`_spEDM_RcppCorSignificance`, r, n, k)
}

RcppCorConfidence <- function(r, n, k = 0L, level = 0.05) {
    .Call(`_spEDM_RcppCorConfidence`, r, n, k, level)
}

RcppMeanCorSignificance <- function(r, n, k = 0L) {
    .Call(`_spEDM_RcppMeanCorSignificance`, r, n, k)
}

RcppMeanCorConfidence <- function(r, n, k = 0L, level = 0.05) {
    .Call(`_spEDM_RcppMeanCorConfidence`, r, n, k, level)
}

RcppDeLongAUCConfidence <- function(cases, controls, direction, level = 0.05) {
    .Call(`_spEDM_RcppDeLongAUCConfidence`, cases, controls, direction, level)
}

RcppCMCTest <- function(cases, direction, level = 0.05, num_samples = 0L) {
    .Call(`_spEDM_RcppCMCTest`, cases, direction, level, num_samples)
}

RcppDistance <- function(vec1, vec2, L1norm = FALSE, NA_rm = FALSE) {
    .Call(`_spEDM_RcppDistance`, vec1, vec2, L1norm, NA_rm)
}

RcppKNearestDistance <- function(vec1, k, L1norm = FALSE, NA_rm = FALSE) {
    .Call(`_spEDM_RcppKNearestDistance`, vec1, k, L1norm, NA_rm)
}

RcppMatDistance <- function(mat, L1norm = FALSE, NA_rm = FALSE) {
    .Call(`_spEDM_RcppMatDistance`, mat, L1norm, NA_rm)
}

RcppNeighborsNum <- function(vec, radius, equal = FALSE, L1norm = FALSE, NA_rm = FALSE) {
    .Call(`_spEDM_RcppNeighborsNum`, vec, radius, equal, L1norm, NA_rm)
}

RcppKNNIndice <- function(embedding_space, target_idx, k, lib) {
    .Call(`_spEDM_RcppKNNIndice`, embedding_space, target_idx, k, lib)
}

RcppDistKNNIndice <- function(dist_mat, target_idx, k, lib) {
    .Call(`_spEDM_RcppDistKNNIndice`, dist_mat, target_idx, k, lib)
}

RcppDistSortedIndice <- function(dist_mat, lib, k, include_self = FALSE) {
    .Call(`_spEDM_RcppDistSortedIndice`, dist_mat, lib, k, include_self)
}

RcppMatKNNeighbors <- function(embeddings, lib, k, threads = 8L, L1norm = FALSE) {
    .Call(`_spEDM_RcppMatKNNeighbors`, embeddings, lib, k, threads, L1norm)
}

RcppLinearTrendRM <- function(vec, xcoord, ycoord, NA_rm = FALSE) {
    .Call(`_spEDM_RcppLinearTrendRM`, vec, xcoord, ycoord, NA_rm)
}

RcppSVD <- function(X) {
    .Call(`_spEDM_RcppSVD`, X)
}

RcppDeLongPlacements <- function(cases, controls, direction) {
    .Call(`_spEDM_RcppDeLongPlacements`, cases, controls, direction)
}

RcppSpatialBlockBootstrap <- function(block, seed = 42L) {
    .Call(`_spEDM_RcppSpatialBlockBootstrap`, block, seed)
}

DetectMaxNumThreads <- function() {
    .Call(`_spEDM_DetectMaxNumThreads`)
}

OptSimplexParm <- function(Emat) {
    .Call(`_spEDM_OptSimplexParm`, Emat)
}

OptThetaParm <- function(Thetamat) {
    .Call(`_spEDM_OptThetaParm`, Thetamat)
}

OptICparm <- function(Emat) {
    .Call(`_spEDM_OptICparm`, Emat)
}

OptPCparm <- function(Emat, maximize = "positive") {
    .Call(`_spEDM_OptPCparm`, Emat, maximize)
}

MatNotNAIndice <- function(mat, byrow = TRUE) {
    .Call(`_spEDM_MatNotNAIndice`, mat, byrow)
}