outliertree 0.2.1 → 0.3.1

data/vendor/outliertree/src/misc.cpp

@@ -39,7 +39,7 @@
 *    at which position will the counts for a given column start. Note that NAs are stored as the last index in each
 *    column, so each one needs one extra category
 */
-int calculate_category_indices(size_t start_ix_cat_counts[], int ncat[], size_t ncols, bool skip_col[], int max_categ)
+int calculate_category_indices(size_t start_ix_cat_counts[], int ncat[], size_t ncols, char skip_col[], int max_categ)
 {
     for (size_t col = 0; col < ncols; col++) {
         max_categ = std::max(ncat[col], max_categ);
@@ -53,7 +53,7 @@ int calculate_category_indices(size_t start_ix_cat_counts[], int ncat[], size_t
 /* Save the counts of each category for each column in the array determined above */
 void calculate_all_cat_counts(size_t start_ix_cat_counts[], size_t cat_counts[], int ncat[],
                               int categorical_data[], size_t ncols, size_t nrows,
-                              bool has_NA[], bool skip_col[], int nthreads)
+                              char has_NA[], char skip_col[], int nthreads)
 {
     size_t col_st_offset;
     size_t col_stop;
@@ -80,7 +80,7 @@ void calculate_all_cat_counts(size_t start_ix_cat_counts[], size_t cat_counts[],
 
 /* Check if some column has a large majority that would make any split fail to meet minimum sizes */
 void check_cat_col_unsplittable(size_t start_ix_cat_counts[], size_t cat_counts[], int ncat[],
-                                size_t ncols, size_t min_conditioned_size, size_t nrows, bool skip_col[], int nthreads)
+                                size_t ncols, size_t min_conditioned_size, size_t nrows, char skip_col[], int nthreads)
 {
     size_t largest_cnt;
     #pragma omp parallel for num_threads(nthreads) private(largest_cnt) shared(ncols, nrows, ncat, cat_counts, start_ix_cat_counts, min_conditioned_size, skip_col)
@@ -127,8 +127,8 @@ void calculate_lowerlim_proportion(long double *restrict prop_small, long double
 
 /* Check if a numerical column has no variance (i.e. will not be splittable).
    Along the way, also record the number of decimals to display for this column. */
-void check_missing_no_variance(double numeric_data[], size_t ncols, size_t nrows, bool has_NA[],
-                               bool skip_col[], int min_decimals[], int nthreads)
+void check_missing_no_variance(double numeric_data[], size_t ncols, size_t nrows, char has_NA[],
+                               char skip_col[], int min_decimals[], int nthreads)
 {
     long double running_mean;
     long double mean_prev;
@@ -145,8 +145,8 @@ void check_missing_no_variance(double numeric_data[], size_t ncols, size_t nrows
             private(running_mean, mean_prev, running_ssq, cnt, col_stop, xval, min_val, max_val, min_decimals_col)
     for (size_t_for col = 0; col < ncols; col++) {
         running_mean = 0;
-        mean_prev = 0;
         running_ssq = 0;
+        mean_prev = numeric_data[col * nrows];
         min_val =  HUGE_VAL;
         max_val = -HUGE_VAL;
         cnt = 0;
@@ -178,11 +178,12 @@ void check_missing_no_variance(double numeric_data[], size_t ncols, size_t nrows
 void calc_central_mean_and_sd(size_t ix_arr[], size_t st, size_t end, double x[], size_t size_quarter, double *mean_central, double *sd_central)
 {
     long double running_mean = 0;
-    long double mean_prev    = 0;
     long double running_ssq  = 0;
+    long double mean_prev    = 0;
     double xval;
     size_t st_offset = st + size_quarter;
     if (ix_arr != NULL) {
+        mean_prev = x[ix_arr[st]];
         for (size_t row = st_offset; row <= (end - size_quarter); row++) {
             xval = x[ix_arr[row]];
             running_mean += (xval - running_mean) / (long double)(row - st_offset + 1);
@@ -190,6 +191,7 @@ void calc_central_mean_and_sd(size_t ix_arr[], size_t st, size_t end, double x[]
             mean_prev     = running_mean;
         }
     } else {
+        mean_prev = x[st_offset];
         for (size_t row = st_offset; row <= (end - size_quarter); row++) {
             xval = x[row];
             running_mean += (xval - running_mean) / (long double)(row - st_offset + 1);
@@ -405,7 +407,7 @@ void divide_subset_split(size_t ix_arr[], double x[], size_t st, size_t end, dou
 }
 
 /* for categorical */
-void divide_subset_split(size_t ix_arr[], int x[], size_t st, size_t end, char subset_categ[], int ncat, bool has_NA, size_t *split_NA, size_t *st_right)
+void divide_subset_split(size_t ix_arr[], int x[], size_t st, size_t end, signed char subset_categ[], int ncat, bool has_NA, size_t *split_NA, size_t *st_right)
 {
     size_t temp;
 
@@ -508,6 +510,7 @@ void backup_recursion_state(Workspace &workspace, RecursionState &state_backup)
     state_backup.has_outliers_restore = workspace.has_outliers;
     state_backup.lev_has_outliers_restore = workspace.lev_has_outliers;
     state_backup.temp_ptr_x = workspace.temp_ptr_x;
+    state_backup.is_binary_split_restore = workspace.is_binary_split;
 }
 
 void restore_recursion_state(Workspace &workspace, RecursionState &state_backup)
@@ -532,6 +535,7 @@ void restore_recursion_state(Workspace &workspace, RecursionState &state_backup)
     workspace.has_outliers = state_backup.has_outliers_restore;
     workspace.lev_has_outliers = state_backup.lev_has_outliers_restore;
     workspace.temp_ptr_x = state_backup.temp_ptr_x;
+    workspace.is_binary_split = state_backup.is_binary_split_restore;
 }
 
 /* Next split on the trees is only decided after they are already initialized */
@@ -542,7 +546,7 @@ void set_tree_as_numeric(ClusterTree &tree, double split_point, size_t col)
     tree.col_num = col;
 }
 
-void set_tree_as_categorical(ClusterTree &tree, int ncat, char *split_subset, size_t col)
+void set_tree_as_categorical(ClusterTree &tree, int ncat, signed char *split_subset, size_t col)
 {
     tree.column_type = Categorical;
     tree.col_num = col;
@@ -587,6 +591,7 @@ void forget_row_outputs(ModelOutputs &model_outputs)
     model_outputs.outlier_trees_final.clear();
     model_outputs.outlier_depth_final.clear();
     model_outputs.outlier_decimals_distr.clear();
+    model_outputs.min_decimals_col.clear();
 
     model_outputs.outlier_scores_final.shrink_to_fit();
     model_outputs.outlier_clusters_final.shrink_to_fit();
@@ -594,6 +599,7 @@ void forget_row_outputs(ModelOutputs &model_outputs)
     model_outputs.outlier_trees_final.shrink_to_fit();
     model_outputs.outlier_depth_final.shrink_to_fit();
     model_outputs.outlier_decimals_distr.shrink_to_fit();
+    model_outputs.min_decimals_col.shrink_to_fit();
 }
 
 void allocate_row_outputs(ModelOutputs &model_outputs, size_t nrows, size_t max_depth)
@@ -605,6 +611,7 @@ void allocate_row_outputs(ModelOutputs &model_outputs, size_t nrows, size_t max_
     model_outputs.outlier_trees_final.resize(nrows);
     model_outputs.outlier_depth_final.resize(nrows, max_depth + 2);
     model_outputs.outlier_decimals_distr.resize(nrows, 0);
+    model_outputs.min_decimals_col.resize(nrows);
 
     model_outputs.outlier_scores_final.shrink_to_fit();
     model_outputs.outlier_clusters_final.shrink_to_fit();
@@ -612,6 +619,7 @@ void allocate_row_outputs(ModelOutputs &model_outputs, size_t nrows, size_t max_
     model_outputs.outlier_trees_final.shrink_to_fit();
     model_outputs.outlier_depth_final.shrink_to_fit();
     model_outputs.outlier_decimals_distr.shrink_to_fit();
+    model_outputs.min_decimals_col.shrink_to_fit();
 }
 
 void check_more_two_values(double arr_num[], size_t nrows, size_t ncols, int nthreads, char too_few_values[])
@@ -672,14 +680,155 @@ int decimals_diff(double val1, double val2)
     return (int) res;
 }
 
+ModelOutputs get_empty_ModelOutputs()
+{
+    return ModelOutputs();
+}
 
-/* Reason behind this function: Cython (as of v0.29) will not auto-deallocate
-   structs which are part of a cdef'd class, which produces a memory leak
-   but can be force-destructed. Unfortunately, Cython itself doesn't even
-   allow calling destructors for structs, so it has to be done externally.
-   This function should otherwise have no reason to exist.
-*/
-void dealloc_ModelOutputs(ModelOutputs &model_outputs)
+bool get_has_openmp()
+{
+    #ifdef _OPENMP
+    return true;
+    #else
+    return false;
+    #endif
+}
+
+bool interrupt_switch = false;
+bool handle_is_locked = false;
+
+/* Function to handle interrupt signals */
+void set_interrup_global_variable(int s)
+{
+    #pragma omp critical
+    {
+        interrupt_switch = true;
+    }
+}
+
+void check_interrupt_switch(SignalSwitcher &ss)
+{
+    if (interrupt_switch)
+    {
+        ss.restore_handle();
+        #ifndef _FOR_R
+        fprintf(stderr, "Error: procedure was interrupted\n");
+        #else
+        REprintf("Error: procedure was interrupted\n");
+        #endif
+        raise(SIGINT);
+        #ifdef _FOR_R
+        Rcpp::checkUserInterrupt();
+        #elif !defined(DONT_THROW_ON_INTERRUPT)
+        throw "Error: procedure was interrupted.\n";
+        #endif
+    }
+}
+
+#ifdef _FOR_PYTHON
+bool cy_check_interrupt_switch()
+{
+    return interrupt_switch;
+}
+void cy_tick_off_interrupt_switch()
+{
+    interrupt_switch = false;
+}
+#endif
+
+SignalSwitcher::SignalSwitcher()
+{
+    #pragma omp critical
+    {
+        if (!handle_is_locked)
+        {
+            handle_is_locked = true;
+            interrupt_switch = false;
+            this->old_sig = signal(SIGINT, set_interrup_global_variable);
+            this->is_active = true;
+        }
+
+        else {
+            this->is_active = false;
+        }
+    }
+}
+
+SignalSwitcher::~SignalSwitcher()
+{
+    #ifndef _FOR_PYTHON
+    #pragma omp critical
+    {
+        if (this->is_active && handle_is_locked)
+            interrupt_switch = false;
+    }
+    #endif
+    this->restore_handle();
+}
+
+void SignalSwitcher::restore_handle()
+{
+    #pragma omp critical
+    {
+        if (this->is_active && handle_is_locked)
+        {
+            signal(SIGINT, this->old_sig);
+            this->is_active = false;
+            handle_is_locked = false;
+        }
+    }
+}
+
+/* ceil(log2(x)) done with bit-wise operations ensures perfect precision (and it's faster too)
+   https://stackoverflow.com/questions/2589096/find-most-significant-bit-left-most-that-is-set-in-a-bit-array
+   https://stackoverflow.com/questions/11376288/fast-computing-of-log2-for-64-bit-integers  */
+#if SIZE_MAX == UINT32_MAX /* 32-bit systems */
+    constexpr static const int MultiplyDeBruijnBitPosition[32] =
+    {
+        0, 9,  1,  10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30,
+        8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6,  26, 5,  4, 31
+    };
+    size_t log2ceil( size_t v )
+    {
+        v--;
+        v |= v >> 1; // first round down to one less than a power of 2
+        v |= v >> 2;
+        v |= v >> 4;
+        v |= v >> 8;
+        v |= v >> 16;
+
+        return MultiplyDeBruijnBitPosition[( uint32_t )( v * 0x07C4ACDDU ) >> 27] + 1;
+    }
+#elif SIZE_MAX == UINT64_MAX /* 64-bit systems */
+    constexpr static const uint64_t tab64[64] = {
+        63,  0, 58,  1, 59, 47, 53,  2,
+        60, 39, 48, 27, 54, 33, 42,  3,
+        61, 51, 37, 40, 49, 18, 28, 20,
+        55, 30, 34, 11, 43, 14, 22,  4,
+        62, 57, 46, 52, 38, 26, 32, 41,
+        50, 36, 17, 19, 29, 10, 13, 21,
+        56, 45, 25, 31, 35, 16,  9, 12,
+        44, 24, 15,  8, 23,  7,  6,  5};
+
+    size_t log2ceil(size_t value)
+    {
+        value--;
+        value |= value >> 1;
+        value |= value >> 2;
+        value |= value >> 4;
+        value |= value >> 8;
+        value |= value >> 16;
+        value |= value >> 32;
+        return tab64[((uint64_t)((value - (value >> 1))*0x07EDD5E59A4E28C2)) >> 58] + 1;
+    }
+#else /* other architectures - might not be entirely precise, and will be slower */
+    size_t log2ceil(size_t x) {return (size_t)(ceill(log2l((long double) x)));}
+#endif
+
+#ifdef _FOR_PYTHON
+ModelOutputs deepcopy(const ModelOutputs &inp)
 {
-    model_outputs.~ModelOutputs();
+    ModelOutputs out = inp;
+    return out;
 }
+#endif