isotree 0.1.4 → 0.1.5

data/vendor/isotree/src/crit.cpp

@@ -22,7 +22,7 @@
 *     [9] Cortes, David. "Imputing missing values with unsupervised random trees." arXiv preprint arXiv:1911.06646 (2019).
 * 
 *     BSD 2-Clause License
-*     Copyright (c) 2019, David Cortes
+*     Copyright (c) 2020, David Cortes
 *     All rights reserved.
 *     Redistribution and use in source and binary forms, with or without
 *     modification, are permitted provided that the following conditions are met:

data/vendor/isotree/src/dealloc.cpp

@@ -22,7 +22,7 @@
 *     [9] Cortes, David. "Imputing missing values with unsupervised random trees." arXiv preprint arXiv:1911.06646 (2019).
 * 
 *     BSD 2-Clause License
-*     Copyright (c) 2019, David Cortes
+*     Copyright (c) 2020, David Cortes
 *     All rights reserved.
 *     Redistribution and use in source and binary forms, with or without
 *     modification, are permitted provided that the following conditions are met:

data/vendor/isotree/src/dist.cpp

@@ -22,7 +22,7 @@
 *     [9] Cortes, David. "Imputing missing values with unsupervised random trees." arXiv preprint arXiv:1911.06646 (2019).
 * 
 *     BSD 2-Clause License
-*     Copyright (c) 2019, David Cortes
+*     Copyright (c) 2020, David Cortes
 *     All rights reserved.
 *     Redistribution and use in source and binary forms, with or without
 *     modification, are permitted provided that the following conditions are met:
@@ -280,14 +280,14 @@ void traverse_tree_sim(WorkerForSimilarity   &workspace,
 
 
     /* divide according to tree */
-    if (prediction_data.Xc != NULL && !workspace.tmat_sep.size())
+    if (prediction_data.Xc_indptr != NULL && workspace.tmat_sep.size())
         std::sort(workspace.ix_arr.begin() + workspace.st, workspace.ix_arr.begin() + workspace.end + 1);
     size_t st_NA, end_NA, split_ix;
     switch(trees[curr_tree].col_type)
     {
         case Numeric:
         {
-            if (prediction_data.Xc == NULL)
+            if (prediction_data.Xc_indptr == NULL)
                 divide_subset_split(workspace.ix_arr.data(),
                                     prediction_data.numeric_data + prediction_data.nrows * trees[curr_tree].col_num,
                                     workspace.st, workspace.end, trees[curr_tree].num_split,
@@ -477,14 +477,14 @@ void traverse_hplane_sim(WorkerForSimilarity     &workspace,
                                             prediction_data.nrows, workspace.rmat.data(), -1.);
     }
 
-    if (prediction_data.Xc != NULL && !workspace.tmat_sep.size())
+    if (prediction_data.Xc_indptr != NULL && workspace.tmat_sep.size())
         std::sort(workspace.ix_arr.begin() + workspace.st, workspace.ix_arr.begin() + workspace.end + 1);
 
     /* reconstruct linear combination */
     size_t ncols_numeric = 0;
     size_t ncols_categ   = 0;
     std::fill(workspace.comb_val.begin(), workspace.comb_val.begin() + (workspace.end - workspace.st + 1), 0);
-    if (prediction_data.categ_data != NULL || prediction_data.Xc != NULL)
+    if (prediction_data.categ_data != NULL || prediction_data.Xc_indptr != NULL)
     {
         for (size_t col = 0; col < hplanes[curr_tree].col_num.size(); col++)
         {
@@ -492,7 +492,7 @@ void traverse_hplane_sim(WorkerForSimilarity     &workspace,
             {
                 case Numeric:
                 {
-                    if (prediction_data.Xc == NULL)
+                    if (prediction_data.Xc_indptr == NULL)
                         add_linear_comb(workspace.ix_arr.data(), workspace.st, workspace.end, workspace.comb_val.data(),
                                         prediction_data.numeric_data + prediction_data.nrows * hplanes[curr_tree].col_num[col],
                                         hplanes[curr_tree].coef[ncols_numeric], (double)0, hplanes[curr_tree].mean[ncols_numeric],

data/vendor/isotree/src/extended.cpp

@@ -22,7 +22,7 @@
 *     [9] Cortes, David. "Imputing missing values with unsupervised random trees." arXiv preprint arXiv:1911.06646 (2019).
 * 
 *     BSD 2-Clause License
-*     Copyright (c) 2019, David Cortes
+*     Copyright (c) 2020, David Cortes
 *     All rights reserved.
 *     Redistribution and use in source and binary forms, with or without
 *     modification, are permitted provided that the following conditions are met:
@@ -60,7 +60,7 @@ void split_hplane_recursive(std::vector<IsoHPlane>   &hplanes,
     /* calculate imputation statistics if desired */
     if (impute_nodes != NULL)
     {
-        if (input_data.Xc != NULL)
+        if (input_data.Xc_indptr != NULL)
             std::sort(workspace.ix_arr.begin() + workspace.st,
                       workspace.ix_arr.begin() + workspace.end + 1);
         build_impute_node(impute_nodes->back(), workspace,
@@ -85,7 +85,7 @@ void split_hplane_recursive(std::vector<IsoHPlane>   &hplanes,
         goto terminal_statistics;
 
     /* for sparse matrices, need to sort the indices */
-    if (input_data.Xc != NULL && impute_nodes == NULL)
+    if (input_data.Xc_indptr != NULL && impute_nodes == NULL)
         std::sort(workspace.ix_arr.begin() + workspace.st, workspace.ix_arr.begin() + workspace.end + 1);
 
     /* pick column to split according to criteria */
@@ -370,7 +370,7 @@ void split_hplane_recursive(std::vector<IsoHPlane>   &hplanes,
             {
                 case Numeric:
                 {
-                    if (input_data.Xc == NULL)
+                    if (input_data.Xc_indptr == NULL)
                     {
                         add_linear_comb(workspace.ix_arr.data(), workspace.st, workspace.end, workspace.comb_val.data(),
                                         input_data.numeric_data + hplanes.back().col_num[col] * input_data.nrows,
@@ -551,7 +551,7 @@ void add_chosen_column(WorkerMemory &workspace, InputData &input_data, ModelPara
                 }
             }
 
-            if (input_data.Xc == NULL)
+            if (input_data.Xc_indptr == NULL)
             {
                 calc_mean_and_sd(workspace.ix_arr.data(), workspace.st, workspace.end,
                                  input_data.numeric_data + workspace.col_chosen * input_data.nrows,

data/vendor/isotree/src/fit_model.cpp

@@ -1,7 +1,7 @@
 /*    Isolation forests and variations thereof, with adjustments for incorporation
 *     of categorical variables and missing values.
 *     Writen for C++11 standard and aimed at being used in R and Python.
-*
+*     
 *     This library is based on the following works:
 *     [1] Liu, Fei Tony, Kai Ming Ting, and Zhi-Hua Zhou.
 *         "Isolation forest."
@@ -20,9 +20,9 @@
 *     [7] Quinlan, J. Ross. C4. 5: programs for machine learning. Elsevier, 2014.
 *     [8] Cortes, David. "Distance approximation using Isolation Forests." arXiv preprint arXiv:1910.12362 (2019).
 *     [9] Cortes, David. "Imputing missing values with unsupervised random trees." arXiv preprint arXiv:1911.06646 (2019).
-*
+* 
 *     BSD 2-Clause License
-*     Copyright (c) 2019, David Cortes
+*     Copyright (c) 2020, David Cortes
 *     All rights reserved.
 *     Redistribution and use in source and binary forms, with or without
 *     modification, are permitted provided that the following conditions are met:
@@ -47,7 +47,7 @@
 bool interrupt_switch;
 
 /*  Fit Isolation Forest model, or variant of it such as SCiForest
-*
+* 
 * Parameters:
 * ===========
 * - model_outputs (out)
@@ -287,11 +287,15 @@ bool interrupt_switch;
 *       'categ_data', and 'Xc', will get overwritten with the imputations produced.
 * - random_seed
 *       Seed that will be used to generate random numbers used by the model.
+* - handle_interrupt
+*       Whether to handle interrupt signals while the process is running. Note that this will
+*       interfere with interrupt handles when the procedure is called from interpreted languages
+*       such as Python or R.
 * - nthreads
 *       Number of parallel threads to use. Note that, the more threads, the more memory will be
 *       allocated, even if the thread does not end up being used. Ignored when not building with
 *       OpenMP support.
-*
+* 
 * Returns
 * =======
 * Will return macro 'EXIT_SUCCESS' (typically =0) upon completion.
@@ -300,7 +304,7 @@ bool interrupt_switch;
 * what these values correspond to, you can use the functions
 * 'return_EXIT_SUCESS' and 'return_EXIT_FAILURE', which will return them
 * as integers.
-*
+* 
 * References
 * ==========
 * [1] Liu, Fei Tony, Kai Ming Ting, and Zhi-Hua Zhou.
@@ -337,7 +341,7 @@ int fit_iforest(IsoForest *model_outputs, ExtIsoForest *model_outputs_ext,
                 CategSplit cat_split_type, NewCategAction new_cat_action,
                 bool   all_perm, Imputer *imputer, size_t min_imp_obs,
                 UseDepthImp depth_imp, WeighImpRows weigh_imp_rows, bool impute_at_fit,
-                uint64_t random_seed, int nthreads)
+                uint64_t random_seed, bool handle_interrupt, int nthreads)
 {
     /* calculate maximum number of categories to use later */
     int max_categ = 0;
@@ -421,9 +425,13 @@ int fit_iforest(IsoForest *model_outputs, ExtIsoForest *model_outputs_ext,
     /* TODO: find a better way of handling interrupt signals when calling in Python/R.
        The following will still change the behavior of interrupts when called through e.g. Flask */
     #if !defined(_WIN32) && !defined(_WIN64) && !defined(_MSC_VER)
-    struct sigaction sig_handle;
-    sig_handle.sa_flags = SA_RESETHAND;
-    sig_handle.sa_handler = set_interrup_global_variable;
+    struct sigaction sig_handle = {};
+    if (handle_interrupt)
+    {
+        sig_handle.sa_flags = SA_RESETHAND;
+        sig_handle.sa_handler = set_interrup_global_variable;
+        sigemptyset(&sig_handle.sa_mask);
+    }
     #endif
 
     /* grow trees */
@@ -468,11 +476,14 @@ int fit_iforest(IsoForest *model_outputs, ExtIsoForest *model_outputs_ext,
         else
             model_outputs_ext->hplanes[tree].shrink_to_fit();
 
-        #if !defined(_WIN32) && !defined(_WIN64) && !defined(_MSC_VER)
-        // sigaction(SIGINT, &sig_handle, NULL);
-        #else
-        // signal(SIGINT, set_interrup_global_variable);
-        #endif
+        if (handle_interrupt)
+        {
+            #if !defined(_WIN32) && !defined(_WIN64) && !defined(_MSC_VER)
+            sigaction(SIGINT, &sig_handle, NULL);
+            #else
+            signal(SIGINT, set_interrup_global_variable);
+            #endif
+        }
     }
 
     /* check if the procedure got interrupted */
@@ -556,7 +567,7 @@ int fit_iforest(IsoForest *model_outputs, ExtIsoForest *model_outputs_ext,
 
 
 /* Add additional trees to already-fitted isolation forest model
-*
+* 
 * Parameters
 * ==========
 * - model_outputs
@@ -972,7 +983,7 @@ void fit_itree(std::vector<IsoTree>    *tree_root,
                 min_size_chr = input_data.max_categ;
         }
 
-        if (input_data.Xc != NULL && gain)
+        if (input_data.Xc_indptr != NULL && gain)
         {
             min_size_szt = std::max(min_size_szt, model_params.sample_size);
             min_size_dbl = std::max(min_size_dbl, model_params.sample_size);
@@ -1012,7 +1023,7 @@ void fit_itree(std::vector<IsoTree>    *tree_root,
         if (
             model_params.cat_split_type == SubSet &&
             (
-                model_params.prob_pick_by_gain_avg  ||
+                model_params.prob_pick_by_gain_avg  || 
                 model_params.prob_pick_by_gain_pl
             )
            )
@@ -1027,7 +1038,7 @@ void fit_itree(std::vector<IsoTree>    *tree_root,
     {
         std::vector<double> kurt_weights(input_data.ncols_numeric + input_data.ncols_categ);
 
-        if (input_data.Xc == NULL)
+        if (input_data.Xc_indptr == NULL)
         {
             for (size_t col = 0; col < input_data.ncols_numeric; col++)
                 kurt_weights[col] = calc_kurtosis(workspace.ix_arr.data(), workspace.st, workspace.end,

data/vendor/isotree/src/helpers_iforest.cpp

@@ -22,7 +22,7 @@
 *     [9] Cortes, David. "Imputing missing values with unsupervised random trees." arXiv preprint arXiv:1911.06646 (2019).
 * 
 *     BSD 2-Clause License
-*     Copyright (c) 2019, David Cortes
+*     Copyright (c) 2020, David Cortes
 *     All rights reserved.
 *     Redistribution and use in source and binary forms, with or without
 *     modification, are permitted provided that the following conditions are met:
@@ -91,7 +91,7 @@ void get_split_range(WorkerMemory &workspace, InputData &input_data, ModelParams
 {
     if (tree.col_type == Numeric)
     {
-        if (input_data.Xc == NULL)
+        if (input_data.Xc_indptr == NULL)
             get_range(workspace.ix_arr.data(), input_data.numeric_data + input_data.nrows * tree.col_num,
                       workspace.st, workspace.end, model_params.missing_action,
                       workspace.xmin, workspace.xmax, workspace.unsplittable);
@@ -114,7 +114,7 @@ void get_split_range(WorkerMemory &workspace, InputData &input_data, ModelParams
 {
     if (workspace.col_type == Numeric)
     {
-        if (input_data.Xc == NULL)
+        if (input_data.Xc_indptr == NULL)
             get_range(workspace.ix_arr.data(), input_data.numeric_data + input_data.nrows * workspace.col_chosen,
                       workspace.st, workspace.end, model_params.missing_action,
                       workspace.xmin, workspace.xmax, workspace.unsplittable);
@@ -281,10 +281,19 @@ void backup_recursion_state(WorkerMemory &workspace, RecursionState &recursion_s
     /* for the extended model, it's not necessary to copy everything */
     if (!workspace.comb_val.size())
     {
-        /* TODO: here only need to copy the left half, as the right one is untouched */
-        recursion_state.ix_arr        = workspace.ix_arr;
-        recursion_state.weights_map   = workspace.weights_map;
-        recursion_state.weights_arr   = workspace.weights_arr;
+        recursion_state.ix_arr = std::vector<size_t>(workspace.ix_arr.begin() + workspace.st_NA,
+                                                     workspace.ix_arr.begin() + workspace.end + 1);
+        size_t tot = workspace.end - workspace.st_NA + 1;
+        if (workspace.weights_arr.size() || workspace.weights_map.size())
+            recursion_state.weights_arr = std::unique_ptr<double[]>(new double[tot]);
+        if (workspace.weights_arr.size())
+            for (size_t ix = 0; ix < tot; ix++)
+                recursion_state.weights_arr[ix] = workspace.weights_arr[workspace.ix_arr[ix + workspace.st_NA]];
+        else if (workspace.weights_map.size())
+            for (size_t ix = 0; ix < tot; ix++)
+                recursion_state.weights_arr[ix] = workspace.weights_map[workspace.ix_arr[ix + workspace.st_NA]];
+        
+
     }
 }
 
@@ -301,9 +310,15 @@ void restore_recursion_state(WorkerMemory &workspace, RecursionState &recursion_
 
     if (!workspace.comb_val.size())
     {
-        /* TODO: here only need to copy the left half, as the right one is untouched */
-        workspace.ix_arr        = std::move(recursion_state.ix_arr);
-        workspace.weights_map   = std::move(recursion_state.weights_map);
-        workspace.weights_arr   = std::move(recursion_state.weights_arr);
+        std::copy(recursion_state.ix_arr.begin(),
+                  recursion_state.ix_arr.end(),
+                  workspace.ix_arr.begin() + recursion_state.st_NA);
+        size_t tot = workspace.end - workspace.st_NA + 1;
+        if (workspace.weights_arr.size())
+            for (size_t ix = 0; ix < tot; ix++)
+                workspace.weights_arr[workspace.ix_arr[ix + workspace.st_NA]] = recursion_state.weights_arr[ix];
+        else if (workspace.weights_map.size())
+            for (size_t ix = 0; ix < tot; ix++)
+                workspace.weights_map[workspace.ix_arr[ix + workspace.st_NA]] = recursion_state.weights_arr[ix];
     }
 }

data/vendor/isotree/src/impute.cpp

@@ -22,7 +22,7 @@
 *     [9] Cortes, David. "Imputing missing values with unsupervised random trees." arXiv preprint arXiv:1911.06646 (2019).
 * 
 *     BSD 2-Clause License
-*     Copyright (c) 2019, David Cortes
+*     Copyright (c) 2020, David Cortes
 *     All rights reserved.
 *     Redistribution and use in source and binary forms, with or without
 *     modification, are permitted provided that the following conditions are met:
@@ -226,7 +226,7 @@ void initialize_imputer(Imputer &imputer, InputData &input_data, size_t ntrees,
         }
     }
 
-    else if (input_data.Xc != NULL)
+    else if (input_data.Xc_indptr != NULL)
     {
         #pragma omp parallel for schedule(dynamic) num_threads(nthreads) private(cnt) shared(input_data, imputer)
         for (size_t_for col = 0; col < input_data.ncols_numeric; col++)
@@ -304,7 +304,7 @@ void build_impute_node(ImputeNode &imputer,    WorkerMemory &workspace,
     double  weight;
     size_t  ix;
 
-    if ((input_data.Xc == NULL && input_data.ncols_numeric) || input_data.ncols_categ)
+    if ((input_data.Xc_indptr == NULL && input_data.ncols_numeric) || input_data.ncols_categ)
     {
         if (!has_weights)
         {
@@ -401,7 +401,7 @@ void build_impute_node(ImputeNode &imputer,    WorkerMemory &workspace,
         }
     }
 
-    if (input_data.Xc != NULL) /* sparse numeric */
+    if (input_data.Xc_indptr != NULL) /* sparse numeric */
     {
         size_t *ix_arr = workspace.ix_arr.data();
         size_t st_col, end_col, ind_end_col, curr_pos;
@@ -802,7 +802,7 @@ void apply_imputation_results(imp_arr    &impute_vec,
 {
     size_t col;
 
-    if (input_data.Xc != NULL)
+    if (input_data.Xc_indptr != NULL)
     {
         std::vector<size_t> row_pos(input_data.nrows, 0);
         size_t row;
@@ -950,7 +950,7 @@ void initialize_impute_calc(ImputedData &imp, InputData &input_data, size_t row)
         imp.num_weight.assign(imp.n_missing_num, 0);
     }
 
-    else if (input_data.Xc != NULL)
+    else if (input_data.Xc_indptr != NULL)
     {
         imp.missing_sp.resize(input_data.ncols_numeric);
         sparse_ix *res;
@@ -1105,7 +1105,7 @@ void check_for_missing(InputData &input_data,
 {
     input_data.has_missing.assign(input_data.nrows, false);
 
-    if (input_data.Xc != NULL)
+    if (input_data.Xc_indptr != NULL)
     {
         for (size_t col = 0; col < input_data.ncols_numeric; col++)
             #pragma omp parallel for schedule(static) num_threads(nthreads) shared(col, input_data)

data/vendor/isotree/src/isoforest.cpp

@@ -22,7 +22,7 @@
 *     [9] Cortes, David. "Imputing missing values with unsupervised random trees." arXiv preprint arXiv:1911.06646 (2019).
 * 
 *     BSD 2-Clause License
-*     Copyright (c) 2019, David Cortes
+*     Copyright (c) 2020, David Cortes
 *     All rights reserved.
 *     Redistribution and use in source and binary forms, with or without
 *     modification, are permitted provided that the following conditions are met:
@@ -56,7 +56,7 @@ void split_itree_recursive(std::vector<IsoTree>     &trees,
     /* calculate imputation statistics if desired */
     if (impute_nodes != NULL)
     {
-        if (input_data.Xc != NULL)
+        if (input_data.Xc_indptr != NULL)
             std::sort(workspace.ix_arr.begin() + workspace.st,
                       workspace.ix_arr.begin() + workspace.end + 1);
         build_impute_node(impute_nodes->back(), workspace,
@@ -81,7 +81,7 @@ void split_itree_recursive(std::vector<IsoTree>     &trees,
         goto terminal_statistics;
 
     /* for sparse matrices, need to sort the indices */
-    if (input_data.Xc != NULL && impute_nodes == NULL)
+    if (input_data.Xc_indptr != NULL && impute_nodes == NULL)
         std::sort(workspace.ix_arr.begin() + workspace.st, workspace.ix_arr.begin() + workspace.end + 1);
 
     /* pick column to split according to criteria */
@@ -108,7 +108,7 @@ void split_itree_recursive(std::vector<IsoTree>     &trees,
 
         /* evaluate gain for all columns */
         trees.back().score = -HUGE_VAL; /* this is used to track the best gain */
-        if (input_data.Xc == NULL)
+        if (input_data.Xc_indptr == NULL)
         {
             for (size_t col = 0; col < input_data.ncols_numeric; col++)
             {
@@ -291,7 +291,7 @@ void split_itree_recursive(std::vector<IsoTree>     &trees,
             if (workspace.unsplittable)
             {
                 workspace.ncols_tried = 0; /* note: this is used here as a counter for the number of still splittable columns */
-                if (input_data.Xc == NULL)
+                if (input_data.Xc_indptr == NULL)
                 {
                     for (size_t col = 0; col < input_data.ncols_numeric; col++)
                     {
@@ -406,7 +406,7 @@ void split_itree_recursive(std::vector<IsoTree>     &trees,
 
                 default:
                 {
-                    if (input_data.Xc == NULL)
+                    if (input_data.Xc_indptr == NULL)
                     {
                         eval_guided_crit(workspace.ix_arr.data(), workspace.st, workspace.end,
                                          input_data.numeric_data + trees.back().col_num * input_data.nrows,
@@ -441,7 +441,7 @@ void split_itree_recursive(std::vector<IsoTree>     &trees,
             }
         }
         
-        if (input_data.Xc == NULL)
+        if (input_data.Xc_indptr == NULL)
             divide_subset_split(workspace.ix_arr.data(), input_data.numeric_data + input_data.nrows * trees.back().col_num,
                                 workspace.st, workspace.end, trees.back().num_split, model_params.missing_action,
                                 workspace.st_NA, workspace.end_NA, workspace.split_ix);

data/vendor/isotree/src/isotree.hpp

@@ -22,7 +22,7 @@
 *     [9] Cortes, David. "Imputing missing values with unsupervised random trees." arXiv preprint arXiv:1911.06646 (2019).
 * 
 *     BSD 2-Clause License
-*     Copyright (c) 2019, David Cortes
+*     Copyright (c) 2020, David Cortes
 *     All rights reserved.
 *     Redistribution and use in source and binary forms, with or without
 *     modification, are permitted provided that the following conditions are met:
@@ -213,7 +213,7 @@ typedef struct IsoHPlane {
     std::vector<std::vector<double>> cat_coef;
     std::vector<int>      chosen_cat;
     std::vector<double>   fill_val;
-    std::vector<double>   fill_new;
+    std::vector<double>   fill_new; /* <- when using single categ, coef will be here */
 
     double   split_point;
     size_t   hplane_left;
@@ -545,9 +545,8 @@ typedef struct {
     size_t  split_ix;
     size_t  end;
     std::vector<size_t> ix_arr;
-    std::unordered_map<size_t, double> weights_map;
-    std::vector<double> weights_arr;
     std::vector<bool>   cols_possible;
+    std::unique_ptr<double[]> weights_arr;
     std::discrete_distribution<size_t> col_sampler;
 } RecursionState;
 
@@ -572,7 +571,7 @@ int fit_iforest(IsoForest *model_outputs, ExtIsoForest *model_outputs_ext,
                 CategSplit cat_split_type, NewCategAction new_cat_action,
                 bool   all_perm, Imputer *imputer, size_t min_imp_obs,
                 UseDepthImp depth_imp, WeighImpRows weigh_imp_rows, bool impute_at_fit,
-                uint64_t random_seed, int nthreads);
+                uint64_t random_seed, bool handle_interrupt, int nthreads);
 int add_tree(IsoForest *model_outputs, ExtIsoForest *model_outputs_ext,
              double numeric_data[],  size_t ncols_numeric,
              int    categ_data[],    size_t ncols_categ,    int ncat[],
@@ -923,6 +922,29 @@ void deserialize_imputer(Imputer &output_obj, const wchar_t *input_file_path);
 bool has_msvc();
 #endif /* _ENABLE_CEREAL */
 
+/* sql.cpp */
+std::vector<std::string> generate_sql(IsoForest *model_outputs, ExtIsoForest *model_outputs_ext,
+                                      std::vector<std::string> &numeric_colnames, std::vector<std::string> &categ_colnames,
+                                      std::vector<std::vector<std::string>> &categ_levels,
+                                      bool output_tree_num, bool index1, bool single_tree, size_t tree_num,
+                                      int nthreads);
+std::string generate_sql_with_select_from(IsoForest *model_outputs, ExtIsoForest *model_outputs_ext,
+                                          std::string &table_from, std::string &select_as,
+                                          std::vector<std::string> &numeric_colnames, std::vector<std::string> &categ_colnames,
+                                          std::vector<std::vector<std::string>> &categ_levels,
+                                          bool index1, int nthreads);
+void generate_tree_rules(std::vector<IsoTree> *trees, std::vector<IsoHPlane> *hplanes, bool output_score,
+                         size_t curr_ix, bool index1, std::string &prev_cond, std::vector<std::string> &node_rules,
+                         std::vector<std::string> &conditions_left, std::vector<std::string> &conditions_right);
+void extract_cond_isotree(IsoForest &model, IsoTree &tree,
+                          std::string &cond_left, std::string &cond_right,
+                          std::vector<std::string> &numeric_colnames, std::vector<std::string> &categ_colnames,
+                          std::vector<std::vector<std::string>> &categ_levels);
+void extract_cond_ext_isotree(ExtIsoForest &model, IsoHPlane &hplane,
+                              std::string &cond_left, std::string &cond_right,
+                              std::vector<std::string> &numeric_colnames, std::vector<std::string> &categ_colnames,
+                              std::vector<std::vector<std::string>> &categ_levels);
+
 /* dealloc.cpp */
 void dealloc_IsoForest(IsoForest &model_outputs);
 void dealloc_IsoExtForest(ExtIsoForest &model_outputs_ext);