R/RcppExports.R

In fcaR: Formal Concept Analysis

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

compute_meet_join_cpp <- function(sp_i, sp_p, dim) {
    .Call(`_fcaR_compute_meet_join_cpp`, sp_i, sp_p, dim)
}

compute_lattice_tables_cpp <- function(adj_i, adj_p, dim) {
    .Call(`_fcaR_compute_lattice_tables_cpp`, adj_i, adj_p, dim)
}

check_distributivity_sparse <- function(m_i, m_p, m_x, j_i, j_p, j_x, dim) {
    .Call(`_fcaR_check_distributivity_sparse`, m_i, m_p, m_x, j_i, j_p, j_x, dim)
}

check_modularity_sparse <- function(m_i, m_p, m_x, j_i, j_p, j_x, dim) {
    .Call(`_fcaR_check_modularity_sparse`, m_i, m_p, m_x, j_i, j_p, j_x, dim)
}

check_semimodularity_sparse <- function(m_i, m_p, m_x, j_i, j_p, j_x, cov_i, cov_p, dim) {
    .Call(`_fcaR_check_semimodularity_sparse`, m_i, m_p, m_x, j_i, j_p, j_x, cov_i, cov_p, dim)
}

check_atomicity_sparse <- function(adj_i, adj_p, cov_i, cov_p, dim) {
    .Call(`_fcaR_check_atomicity_sparse`, adj_i, adj_p, cov_i, cov_p, dim)
}

tnorm_Lukasiewicz <- function(x, y) {
    .Call(`_fcaR_tnorm_Lukasiewicz`, x, y)
}

implication_Lukasiewicz <- function(x, y) {
    .Call(`_fcaR_implication_Lukasiewicz`, x, y)
}

tnorm_Godel <- function(x, y) {
    .Call(`_fcaR_tnorm_Godel`, x, y)
}

implication_Godel <- function(x, y) {
    .Call(`_fcaR_implication_Godel`, x, y)
}

tnorm_Product <- function(x, y) {
    .Call(`_fcaR_tnorm_Product`, x, y)
}

implication_Product <- function(x, y) {
    .Call(`_fcaR_implication_Product`, x, y)
}

available_logics <- function() {
    .Call(`_fcaR_available_logics`)
}

grecond_plus_cpp <- function(I, w = 1.0, stop_threshold_ratio = 0.0, logic_name = "Lukasiewicz") {
    .Call(`_fcaR_grecond_plus_cpp`, I, w, stop_threshold_ratio, logic_name)
}

asso_cpp <- function(I, threshold = 0.7, w_pos = 1.0, w_neg = 1.0) {
    .Call(`_fcaR_asso_cpp`, I, threshold, w_pos, w_neg)
}

rsf_es_attr_cpp <- function(R) {
    .Call(`_fcaR_rsf_es_attr_cpp`, R)
}

rsf_attr_cpp <- function(R) {
    .Call(`_fcaR_rsf_attr_cpp`, R)
}

randomize_swap_cpp <- function(I, iterations) {
    .Call(`_fcaR_randomize_swap_cpp`, I, iterations)
}

randomize_rewire_cpp <- function(I, iterations) {
    .Call(`_fcaR_randomize_rewire_cpp`, I, iterations)
}

reduce_transitivity_cpp <- function(sp_i, sp_p, dim) {
    .Call(`_fcaR_reduce_transitivity_cpp`, sp_i, sp_p, dim)
}

bonds_mcis_cpp <- function(extents, intents, verbose = FALSE) {
    .Call(`_fcaR_bonds_mcis_cpp`, extents, intents, verbose)
}

#' @title compute_arrow_relations_cpp
#' @description Computes the arrow relations (swarrow, nearrow, and double arrow)
#' for a binary formal context.
#' @param I (IntegerMatrix) The binary incidence matrix of the formal context.
#' @return An IntegerMatrix where:
#'   - 1: \swarrow
#'   - 2: \nearrow
#'   - 3: \updownarrow
#' @noRd
compute_arrow_relations_cpp <- function(I) {
    .Call(`_fcaR_compute_arrow_relations_cpp`, I)
}

asso_bitwise_cpp <- function(I_in, k_max, threshold, w_pos, w_neg) {
    .Call(`_fcaR_asso_bitwise_cpp`, I_in, k_max, threshold, w_pos, w_neg)
}

print_matrix <- function(I) {
    invisible(.Call(`_fcaR_print_matrix`, I))
}

print_vector <- function(I, sz) {
    invisible(.Call(`_fcaR_print_vector`, I, sz))
}

get_element_array <- function(I, i, j, k) {
    .Call(`_fcaR_get_element_array`, I, i, j, k)
}

run_binary_monotonic_optimized <- function(lhs_in, rhs_in, use_pruning = TRUE) {
    .Call(`_fcaR_run_binary_monotonic_optimized`, lhs_in, rhs_in, use_pruning)
}

run_binary_dosp_optimized <- function(lhs_in, rhs_in, use_pruning = TRUE) {
    .Call(`_fcaR_run_binary_dosp_optimized`, lhs_in, rhs_in, use_pruning)
}

run_binary_single_pass_optimized <- function(lhs_in, rhs_in, use_pruning = TRUE) {
    .Call(`_fcaR_run_binary_single_pass_optimized`, lhs_in, rhs_in, use_pruning)
}

run_binary_monotonic_batch_optimized <- function(lhs_in, rhs_in, use_pruning = TRUE) {
    .Call(`_fcaR_run_binary_monotonic_batch_optimized`, lhs_in, rhs_in, use_pruning)
}

run_binary_tree_optimized <- function(lhs_in, rhs_in, use_pruning = TRUE) {
    .Call(`_fcaR_run_binary_tree_optimized`, lhs_in, rhs_in, use_pruning)
}

run_binary_lexicographic_optimized <- function(lhs_in, rhs_in, use_pruning = TRUE) {
    .Call(`_fcaR_run_binary_lexicographic_optimized`, lhs_in, rhs_in, use_pruning)
}

binary_next_closure_implications <- function(I, verbose = FALSE) {
    .Call(`_fcaR_binary_next_closure_implications`, I, verbose)
}

binary_closure_cpp <- function(S_mat, LHS_mat, RHS_mat) {
    .Call(`_fcaR_binary_closure_cpp`, S_mat, LHS_mat, RHS_mat)
}

bonds_closure_cpp <- function(J_in, I_in) {
    .Call(`_fcaR_bonds_closure_cpp`, J_in, I_in)
}

FastCbO_binary <- function(I, attrs, verbose = FALSE) {
    .Call(`_fcaR_FastCbO_binary`, I, attrs, verbose)
}

FuzzyFCbO <- function(I, grades_set, attrs, connection = "standard", name = "Godel", verbose = FALSE) {
    .Call(`_fcaR_FuzzyFCbO`, I, grades_set, attrs, connection, name, verbose)
}

get_concept_strings_cpp <- function(extents, intents, objects, attributes, precision) {
    .Call(`_fcaR_get_concept_strings_cpp`, extents, intents, objects, attributes, precision)
}

run_final_ts_rcpp_optimized <- function(lhs_in, rhs_in, attributes, L, logic_name, use_pruning = TRUE, verbose = FALSE) {
    .Call(`_fcaR_run_final_ts_rcpp_optimized`, lhs_in, rhs_in, attributes, L, logic_name, use_pruning, verbose)
}

run_direct_optimal_sp_rcpp_optimized <- function(lhs_in, rhs_in, attributes, L, logic_name, use_pruning = TRUE, verbose = FALSE) {
    .Call(`_fcaR_run_direct_optimal_sp_rcpp_optimized`, lhs_in, rhs_in, attributes, L, logic_name, use_pruning, verbose)
}

run_monotonic_incremental_rcpp_optimized <- function(lhs_in, rhs_in, attributes, L, logic_name, use_pruning = TRUE, verbose = FALSE) {
    .Call(`_fcaR_run_monotonic_incremental_rcpp_optimized`, lhs_in, rhs_in, attributes, L, logic_name, use_pruning, verbose)
}

run_priority_refinement_rcpp_optimized <- function(lhs_in, rhs_in, attributes, L, logic_name, use_pruning = TRUE, verbose = FALSE) {
    .Call(`_fcaR_run_priority_refinement_rcpp_optimized`, lhs_in, rhs_in, attributes, L, logic_name, use_pruning, verbose)
}

run_direct_optimal_sp_single_pass_rcpp_optimized <- function(lhs_in, rhs_in, attributes, L, logic_name, use_pruning = TRUE, verbose = FALSE) {
    .Call(`_fcaR_run_direct_optimal_sp_single_pass_rcpp_optimized`, lhs_in, rhs_in, attributes, L, logic_name, use_pruning, verbose)
}

grecond_cpp <- function(I, no_of_factors = -1L) {
    .Call(`_fcaR_grecond_cpp`, I, no_of_factors)
}

greess_cpp <- function(I_in) {
    .Call(`_fcaR_greess_cpp`, I_in)
}

hyper_inclose_cpp <- function(I_mat, min_support = 1L) {
    .Call(`_fcaR_hyper_inclose_cpp`, I_mat, min_support)
}

hyper_plus_optimized_cpp <- function(I_mat, hyper_res, beta = 0.1) {
    .Call(`_fcaR_hyper_plus_optimized_cpp`, I_mat, hyper_res, beta)
}

InClose <- function(I, grades_set, attrs, connection = "standard", name = "Godel", verbose = FALSE) {
    .Call(`_fcaR_InClose`, I, grades_set, attrs, connection, name, verbose)
}

InClose_Reorder <- function(sp_i_sexp, sp_p_sexp, dim_sexp, verbose = FALSE) {
    .Call(`_fcaR_InClose_Reorder`, sp_i_sexp, sp_p_sexp, dim_sexp, verbose)
}

InClose_binary <- function(I, attrs, verbose = FALSE) {
    .Call(`_fcaR_InClose_binary`, I, attrs, verbose)
}

calculate_grades_rcpp <- function(concept_ids, edge_from, edge_to) {
    .Call(`_fcaR_calculate_grades_rcpp`, concept_ids, edge_from, edge_to)
}

calculate_lattice_layout_rcpp <- function(concept_ids, layers_vec, y_coords_vec, edge_from, edge_to, method) {
    .Call(`_fcaR_calculate_lattice_layout_rcpp`, concept_ids, layers_vec, y_coords_vec, edge_from, edge_to, method)
}

binary_lincbo_implications <- function(I, save_concepts = FALSE, verbose = FALSE) {
    .Call(`_fcaR_binary_lincbo_implications`, I, save_concepts, verbose)
}

calculate_stability_sparse_rcpp <- function(mat) {
    .Call(`_fcaR_calculate_stability_sparse_rcpp`, mat)
}

calculate_density_rcpp <- function(extents, intents, I) {
    .Call(`_fcaR_calculate_density_rcpp`, extents, intents, I)
}

calculate_separation_rcpp <- function(mat) {
    .Call(`_fcaR_calculate_separation_rcpp`, mat)
}

calculate_fuzzy_density_rcpp <- function(extents, intents, I) {
    .Call(`_fcaR_calculate_fuzzy_density_rcpp`, extents, intents, I)
}

next_closure_implications <- function(I, grades_set, attrs, connection = "standard", name = "Godel", save_concepts = TRUE, verbose = FALSE) {
    .Call(`_fcaR_next_closure_implications`, I, grades_set, attrs, connection, name, save_concepts, verbose)
}

next_closure_concepts <- function(I, grades_set, attrs, connection = "standard", name = "Godel", verbose = FALSE, ret = TRUE) {
    .Call(`_fcaR_next_closure_concepts`, I, grades_set, attrs, connection, name, verbose, ret)
}

binary_next_closure_concepts <- function(I, verbose = FALSE) {
    .Call(`_fcaR_binary_next_closure_concepts`, I, verbose)
}

get_closed_sets_implications <- function(lhs, rhs, attrs, verbose = FALSE) {
    .Call(`_fcaR_get_closed_sets_implications`, lhs, rhs, attrs, verbose)
}

panda_plus_unified_cpp <- function(I_in, k_max, cost_func = "J_P", rho = 1.0) {
    .Call(`_fcaR_panda_plus_unified_cpp`, I_in, k_max, cost_func, rho)
}

panda_plus_jp_cpp <- function(I_in, k_max) {
    .Call(`_fcaR_panda_plus_jp_cpp`, I_in, k_max)
}

panda_plus_ja_cpp <- function(I_in, k_max) {
    .Call(`_fcaR_panda_plus_ja_cpp`, I_in, k_max)
}

panda_plus_jprho_cpp <- function(I_in, k_max, rho) {
    .Call(`_fcaR_panda_plus_jprho_cpp`, I_in, k_max, rho)
}

calculate_width_cpp <- function(i_idx, p_idx, n) {
    .Call(`_fcaR_calculate_width_cpp`, i_idx, p_idx, n)
}

calculate_dimension_heuristic_cpp <- function(i_idx, p_idx, n) {
    .Call(`_fcaR_calculate_dimension_heuristic_cpp`, i_idx, p_idx, n)
}

find_protoconcepts_cpp <- function(I, connection = "standard", name = "Godel", verbose = FALSE) {
    .Call(`_fcaR_find_protoconcepts_cpp`, I, connection, name, verbose)
}

compute_intent <- function(V, I, connection, name) {
    .Call(`_fcaR_compute_intent`, V, I, connection, name)
}

compute_extent <- function(V, I, connection, name) {
    .Call(`_fcaR_compute_extent`, V, I, connection, name)
}

compute_closure <- function(V, I, connection, name) {
    .Call(`_fcaR_compute_closure`, V, I, connection, name)
}

compute_upright_arrow <- function(V, I, name) {
    .Call(`_fcaR_compute_upright_arrow`, V, I, name)
}

compute_downleft_arrow <- function(V, I, name) {
    .Call(`_fcaR_compute_downleft_arrow`, V, I, name)
}

compute_upleft_arrow <- function(V, I, name) {
    .Call(`_fcaR_compute_upleft_arrow`, V, I, name)
}

compute_downright_arrow <- function(V, I, name) {
    .Call(`_fcaR_compute_downright_arrow`, V, I, name)
}

bonds_standard_opt_cpp <- function(I1, I2, verbose = FALSE) {
    .Call(`_fcaR_bonds_standard_opt_cpp`, I1, I2, verbose)
}

sparse_subset_dispatch <- function(X_p, X_i, X_x, Y_p, Y_i, Y_x, num_rows, proper_code, is_binary) {
    .Call(`_fcaR_sparse_subset_dispatch`, X_p, X_i, X_x, Y_p, Y_i, Y_x, num_rows, proper_code, is_binary)
}

self_intersection_C <- function(x_i, x_p, y_i, y_p) {
    .Call(`_fcaR_self_intersection_C`, x_i, x_p, y_i, y_p)
}

is_subset_C <- function(X_P, X_I, X_DIM, X, Y_P, Y_I, Y_DIM, Y, PROPER, OUT_P) {
    .Call(`_fcaR_is_subset_C`, X_P, X_I, X_DIM, X, Y_P, Y_I, Y_DIM, Y, PROPER, OUT_P)
}

intersects_C <- function(X_P, X_I, X_DIM, Y_P, Y_I, Y_DIM, OUT_P) {
    .Call(`_fcaR_intersects_C`, X_P, X_I, X_DIM, Y_P, Y_I, Y_DIM, OUT_P)
}

is_equal_set_C <- function(X_P, X_I, X_DIM, X, Y_P, Y_I, Y_DIM, Y, PROPER, OUT_P) {
    .Call(`_fcaR_is_equal_set_C`, X_P, X_I, X_DIM, X, Y_P, Y_I, Y_DIM, Y, PROPER, OUT_P)
}

which_at_col <- function(x_i, x_p, col) {
    .Call(`_fcaR_which_at_col`, x_i, x_p, col)
}

flatten_sparse_C <- function(p, i, x, dims) {
    .Call(`_fcaR_flatten_sparse_C`, p, i, x, dims)
}

set_difference <- function(xi, xp, xx, yi, yp, yx, number) {
    .Call(`_fcaR_set_difference`, xi, xp, xx, yi, yp, yx, number)
}

set_difference_single <- function(xi, xp, xx, yi, yp, yx, number) {
    .Call(`_fcaR_set_difference_single`, xi, xp, xx, yi, yp, yx, number)
}

set_intersection_single <- function(xi, xp, xx, yi, yp, yx, number) {
    .Call(`_fcaR_set_intersection_single`, xi, xp, xx, yi, yp, yx, number)
}