outliertree 0.2.1 → 0.3.0

data/vendor/outliertree/src/fit_model.cpp

@@ -134,6 +134,7 @@ bool fit_outliers_models(ModelOutputs &model_outputs,
                          size_t max_depth, double max_perc_outliers, size_t min_size_numeric, size_t min_size_categ,
                          double min_gain, bool gain_as_pct, bool follow_all, double z_norm, double z_outlier)
 {
+    SignalSwitcher ss = SignalSwitcher();
 
     /* put parameters and data into structs to avoid passing too many function arguments each time */
     double z_tail = z_outlier - z_norm;
@@ -188,10 +189,10 @@ bool fit_outliers_models(ModelOutputs &model_outputs,
     /* determine maximum number of categories in a column, allocate arrays for category counts and proportions */
     model_outputs.start_ix_cat_counts[0] = 0;
     if (tot_cols > ncols_numeric) {
-        input_data.max_categ = calculate_category_indices(&model_outputs.start_ix_cat_counts[0], input_data.ncat, input_data.ncols_categ,
-                                                          (bool*) &input_data.skip_col[ncols_numeric]);
-        input_data.max_categ = calculate_category_indices(&model_outputs.start_ix_cat_counts[input_data.ncols_categ], input_data.ncat_ord, input_data.ncols_ord,
-                                                          (bool*) &input_data.skip_col[input_data.ncols_numeric + input_data.ncols_categ], input_data.max_categ);
+        input_data.max_categ = calculate_category_indices(model_outputs.start_ix_cat_counts.data(), input_data.ncat, input_data.ncols_categ,
+                                                          (bool*) input_data.skip_col.data() + ncols_numeric);
+        input_data.max_categ = calculate_category_indices(model_outputs.start_ix_cat_counts.data() + input_data.ncols_categ, input_data.ncat_ord, input_data.ncols_ord,
+                                                          (bool*) input_data.skip_col.data() + input_data.ncols_numeric + input_data.ncols_categ, input_data.max_categ);
     } else {
         input_data.max_categ = 0;
     }
@@ -201,6 +202,11 @@ bool fit_outliers_models(ModelOutputs &model_outputs,
     model_params.prop_small.resize(model_outputs.start_ix_cat_counts[ncols_categ + ncols_ord]);
     model_outputs.prop_categ.resize(model_outputs.start_ix_cat_counts[ncols_categ + ncols_ord]);
 
+    check_interrupt_switch(ss);
+    #if defined(DONT_THROW_ON_INTERRUPT)
+    if (interrupt_switch) return false;
+    #endif
+
     /* calculate prior probabilities for categorical variables (in parallel), see if any is unsplittable */
     if (tot_cols > ncols_numeric) {
         #pragma omp parallel
@@ -211,14 +217,14 @@ bool fit_outliers_models(ModelOutputs &model_outputs,
                 #pragma omp section
                 {
                     if (ncols_categ > 0) {
-                        calculate_all_cat_counts(&model_outputs.start_ix_cat_counts[0], &input_data.cat_counts[0], input_data.ncat,
+                        calculate_all_cat_counts(model_outputs.start_ix_cat_counts.data(), input_data.cat_counts.data(), input_data.ncat,
                                                  input_data.categorical_data, input_data.ncols_categ, input_data.nrows,
-                                                 (bool*) &input_data.has_NA[ncols_numeric], (bool*) &input_data.skip_col[input_data.ncols_numeric],
+                                                 (bool*) input_data.has_NA.data() + ncols_numeric, (bool*) input_data.skip_col.data() + input_data.ncols_numeric,
                                                  std::min(input_data.ncols_categ, (size_t)std::max(1, nthreads - 1)) );
 
-                        check_cat_col_unsplittable(&model_outputs.start_ix_cat_counts[0], &input_data.cat_counts[0], input_data.ncat,
+                        check_cat_col_unsplittable(model_outputs.start_ix_cat_counts.data(), input_data.cat_counts.data(), input_data.ncat,
                                                    input_data.ncols_categ, std::min(model_params.min_size_numeric, model_params.min_size_categ), input_data.nrows,
-                                                   (bool*) &input_data.skip_col[input_data.ncols_numeric],
+                                                   (bool*) input_data.skip_col.data() + input_data.ncols_numeric,
                                                    std::min(input_data.ncols_categ, (size_t)std::max(1, nthreads - 1)));
                     }
 
@@ -228,15 +234,15 @@ bool fit_outliers_models(ModelOutputs &model_outputs,
                 #pragma omp section
                 {
                     if (ncols_ord > 0) {
-                        calculate_all_cat_counts(&model_outputs.start_ix_cat_counts[input_data.ncols_categ], &input_data.cat_counts[0], input_data.ncat_ord,
+                        calculate_all_cat_counts(model_outputs.start_ix_cat_counts.data() + input_data.ncols_categ, input_data.cat_counts.data(), input_data.ncat_ord,
                                                  input_data.ordinal_data, input_data.ncols_ord, input_data.nrows,
-                                                 (bool*) &input_data.has_NA[input_data.ncols_numeric + input_data.ncols_categ],
-                                                 (bool*) &input_data.skip_col[input_data.ncols_numeric + input_data.ncols_categ],
+                                                 (bool*) input_data.has_NA.data() + input_data.ncols_numeric + input_data.ncols_categ,
+                                                 (bool*) input_data.skip_col.data() + input_data.ncols_numeric + input_data.ncols_categ,
                                                  std::max((int)1, nthreads - (int)input_data.ncols_categ) );
 
-                        check_cat_col_unsplittable(&model_outputs.start_ix_cat_counts[input_data.ncols_categ], &input_data.cat_counts[0], input_data.ncat_ord,
+                        check_cat_col_unsplittable(model_outputs.start_ix_cat_counts.data() + input_data.ncols_categ, input_data.cat_counts.data(), input_data.ncat_ord,
                                                    ncols_ord, std::min(model_params.min_size_numeric, model_params.min_size_categ), input_data.nrows,
-                                                   (bool*) &input_data.skip_col[input_data.ncols_numeric + input_data.ncols_categ],
+                                                   (bool*) input_data.skip_col.data() + input_data.ncols_numeric + input_data.ncols_categ,
                                                    std::max((int)1, nthreads - (int)input_data.ncols_categ));
                     }
                 }
@@ -246,15 +252,15 @@ bool fit_outliers_models(ModelOutputs &model_outputs,
     
 
         /* calculate proprotion limit and CI for each category of each column */
-        calculate_lowerlim_proportion(&model_params.prop_small[0], &model_outputs.prop_categ[0], &model_outputs.start_ix_cat_counts[0],
-                                      &input_data.cat_counts[0], input_data.ncols_categ, input_data.nrows, model_params.z_norm, model_params.z_tail);
-        calculate_lowerlim_proportion(&model_params.prop_small[0], &model_outputs.prop_categ[0], &model_outputs.start_ix_cat_counts[input_data.ncols_categ],
-                                      &input_data.cat_counts[0], input_data.ncols_ord,  input_data.nrows, model_params.z_norm, model_params.z_tail);
+        calculate_lowerlim_proportion(model_params.prop_small.data(), model_outputs.prop_categ.data(), model_outputs.start_ix_cat_counts.data(),
+                                      input_data.cat_counts.data(), input_data.ncols_categ, input_data.nrows, model_params.z_norm, model_params.z_tail);
+        calculate_lowerlim_proportion(model_params.prop_small.data(), model_outputs.prop_categ.data(), model_outputs.start_ix_cat_counts.data() + input_data.ncols_categ,
+                                      input_data.cat_counts.data(), input_data.ncols_ord,  input_data.nrows, model_params.z_norm, model_params.z_tail);
     }
 
     /* for numerical columns, check if they have NAs or if total variance is  too small */
     check_missing_no_variance(input_data.numeric_data, input_data.ncols_numeric, input_data.nrows,
-                              (bool*) &input_data.has_NA[0], (bool*) &input_data.skip_col[0],
+                              (bool*) input_data.has_NA.data(), (bool*) input_data.skip_col.data(),
                               model_outputs.min_decimals_col.data(), nthreads);
 
     /* determine an approximate size for the output clusters, and reserve memory right away */
@@ -269,133 +275,159 @@ bool fit_outliers_models(ModelOutputs &model_outputs,
         /* this is not exact as categoricals and ordinals can also be split multiple times */
     }
 
+    check_interrupt_switch(ss);
+    #if defined(DONT_THROW_ON_INTERRUPT)
+    if (interrupt_switch) return false;
+    #endif
 
     /* now run the procedure on each column separately */
     int tid;
+    bool threw_exception = false;
+    std::exception_ptr ex = NULL;
     nthreads = std::min(nthreads, (int)(ncols_numeric + ncols_categ + ncols_ord));
     #pragma omp parallel for num_threads(nthreads) schedule(dynamic, 1) private(tid) shared(workspace, model_outputs, input_data, model_params, tot_cols)
     for (size_t_for col = 0; col < tot_cols; col++) {
 
+        if (interrupt_switch || threw_exception) continue;
+
         if (cols_ignore != NULL && cols_ignore[col]) continue;
         if (input_data.skip_col[col] && col < input_data.ncols_numeric) continue;
         tid = omp_get_thread_num();
 
-        /* re-use thread-private memory if possible */
-        if (!check_workspace_is_allocated(workspace[tid]))
-            allocate_thread_workspace(workspace[tid], input_data.nrows, input_data.max_categ);
-            
-        /* numerical column */
-        if (col < input_data.ncols_numeric) {
-            process_numeric_col(model_outputs.all_clusters[col],
-                                model_outputs.all_trees[col],
-                                col,
-                                workspace[tid],
-                                input_data,
-                                model_params, model_outputs);
-            calculate_cluster_minimums(model_outputs, col);
-        }
+        try {
+            /* re-use thread-private memory if possible */
+            if (!check_workspace_is_allocated(workspace[tid]))
+                allocate_thread_workspace(workspace[tid], input_data.nrows, input_data.max_categ);
+                
+            /* numerical column */
+            if (col < input_data.ncols_numeric) {
+                process_numeric_col(model_outputs.all_clusters[col],
+                                    model_outputs.all_trees[col],
+                                    col,
+                                    workspace[tid],
+                                    input_data,
+                                    model_params, model_outputs);
+                calculate_cluster_minimums(model_outputs, col);
+            }
 
-        /* categorical column */
-        else if (col < (input_data.ncols_numeric + input_data.ncols_categ)) {
-            process_categ_col(model_outputs.all_clusters[col],
-                              model_outputs.all_trees[col],
-                              col, false,
-                              workspace[tid],
-                              input_data,
-                              model_params, model_outputs);
-            calculate_cluster_poss_categs(model_outputs, col, col - input_data.ncols_numeric);
-        }
+            /* categorical column */
+            else if (col < (input_data.ncols_numeric + input_data.ncols_categ)) {
+                process_categ_col(model_outputs.all_clusters[col],
+                                  model_outputs.all_trees[col],
+                                  col, false,
+                                  workspace[tid],
+                                  input_data,
+                                  model_params, model_outputs);
+                calculate_cluster_poss_categs(model_outputs, col, col - input_data.ncols_numeric);
+            }
 
-        /* ordinal column */
-        else {
-            process_categ_col(model_outputs.all_clusters[col],
-                              model_outputs.all_trees[col],
-                              col, true,
-                              workspace[tid],
-                              input_data,
-                              model_params, model_outputs);
-            calculate_cluster_poss_categs(model_outputs, col, col - input_data.ncols_numeric);
-        }
+            /* ordinal column */
+            else {
+                process_categ_col(model_outputs.all_clusters[col],
+                                  model_outputs.all_trees[col],
+                                  col, true,
+                                  workspace[tid],
+                                  input_data,
+                                  model_params, model_outputs);
+                calculate_cluster_poss_categs(model_outputs, col, col - input_data.ncols_numeric);
+            }
 
-        /* shrink the dynamic vectors to what ended up used only */
-        #ifdef TEST_MODE_DEFINE
-        prune_unused_trees(model_outputs.all_trees[col]);
-        #endif
-        if (
-            model_outputs.all_clusters[col].size() == 0 ||
-            model_outputs.all_trees[col].size() == 0 ||
-            check_tree_is_not_needed(model_outputs.all_trees[col][0])
-        )
-        {
-            model_outputs.all_trees[col].clear();
-            model_outputs.all_clusters[col].clear();
-        }
-        model_outputs.all_trees[col].shrink_to_fit();
-        model_outputs.all_clusters[col].shrink_to_fit();
-        
-        /* simplify single-elements in subset to 'equals' or 'not equals' */
-        simplify_when_equal_cond(model_outputs.all_clusters[col], ncat_ord);
-        simplify_when_equal_cond(model_outputs.all_trees[col],    ncat_ord);
+            /* shrink the dynamic vectors to what ended up used only */
+            #ifdef TEST_MODE_DEFINE
+            prune_unused_trees(model_outputs.all_trees[col]);
+            #endif
+            if (
+                model_outputs.all_clusters[col].size() == 0 ||
+                model_outputs.all_trees[col].size() == 0 ||
+                check_tree_is_not_needed(model_outputs.all_trees[col][0])
+            )
+            {
+                model_outputs.all_trees[col].clear();
+                model_outputs.all_clusters[col].clear();
+            }
+            model_outputs.all_trees[col].shrink_to_fit();
+            model_outputs.all_clusters[col].shrink_to_fit();
+            
+            /* simplify single-elements in subset to 'equals' or 'not equals' */
+            simplify_when_equal_cond(model_outputs.all_clusters[col], ncat_ord);
+            simplify_when_equal_cond(model_outputs.all_trees[col],    ncat_ord);
 
-        /* remember only the best (rarest) value for each row */
-        #pragma omp critical
-        if (workspace[tid].col_has_outliers) {
+            /* remember only the best (rarest) value for each row */
+            #pragma omp critical
+            if (workspace[tid].col_has_outliers) {
 
-            found_outliers = true;
-            for (size_t row = 0; row < input_data.nrows; row++) {
+                found_outliers = true;
+                for (size_t row = 0; row < input_data.nrows; row++) {
 
-                if (workspace[tid].outlier_scores[row] < 1.0) {
+                    if (workspace[tid].outlier_scores[row] < 1.0) {
 
-                    if (
-                        model_outputs.outlier_scores_final[row] >= 1.0 ||
-                        (
-                            workspace[tid].outlier_depth[row] < model_outputs.outlier_depth_final[row] &&
-                            (
-                                !model_outputs.all_clusters[col][workspace[tid].outlier_clusters[row]].has_NA_branch ||
-                                model_outputs.all_clusters[model_outputs.outlier_columns_final[row]][model_outputs.outlier_clusters_final[row]].has_NA_branch
-                            )
-                        ) ||
+                        if (
+                            model_outputs.outlier_scores_final[row] >= 1.0 ||
                             (
-                            model_outputs.all_clusters[model_outputs.outlier_columns_final[row]][model_outputs.outlier_clusters_final[row]].has_NA_branch &&
-                            !model_outputs.all_clusters[col][workspace[tid].outlier_clusters[row]].has_NA_branch
+                                workspace[tid].outlier_depth[row] < model_outputs.outlier_depth_final[row] &&
+                                (
+                                    !model_outputs.all_clusters[col][workspace[tid].outlier_clusters[row]].has_NA_branch ||
+                                    model_outputs.all_clusters[model_outputs.outlier_columns_final[row]][model_outputs.outlier_clusters_final[row]].has_NA_branch
+                                )
                             ) ||
-                            (
-                            workspace[tid].outlier_depth[row] == model_outputs.outlier_depth_final[row] &&
-                                model_outputs.all_clusters[col][workspace[tid].outlier_clusters[row]].has_NA_branch
-                                    ==
-                                model_outputs.all_clusters[model_outputs.outlier_columns_final[row]][model_outputs.outlier_clusters_final[row]].has_NA_branch
-                                &&
-                                model_outputs.all_clusters[model_outputs.outlier_columns_final[row]][model_outputs.outlier_clusters_final[row]].cluster_size
-                                    <
-                                model_outputs.all_clusters[col][workspace[tid].outlier_clusters[row]].cluster_size
-                            ) ||
-                            (
+                                (
+                                model_outputs.all_clusters[model_outputs.outlier_columns_final[row]][model_outputs.outlier_clusters_final[row]].has_NA_branch &&
+                                !model_outputs.all_clusters[col][workspace[tid].outlier_clusters[row]].has_NA_branch
+                                ) ||
+                                (
                                 workspace[tid].outlier_depth[row] == model_outputs.outlier_depth_final[row] &&
-                                model_outputs.all_clusters[model_outputs.outlier_columns_final[row]][model_outputs.outlier_clusters_final[row]].cluster_size
-                                    ==
-                                model_outputs.all_clusters[col][workspace[tid].outlier_clusters[row]].cluster_size
-                                &&
-                                model_outputs.all_clusters[col][workspace[tid].outlier_clusters[row]].has_NA_branch
-                                    ==
-                                model_outputs.all_clusters[model_outputs.outlier_columns_final[row]][model_outputs.outlier_clusters_final[row]].has_NA_branch
-                                &&
-                                workspace[tid].outlier_scores[row] < model_outputs.outlier_scores_final[row]
-                            )
-                    )
-                    {
-                        model_outputs.outlier_scores_final[row] = workspace[tid].outlier_scores[row];
-                        model_outputs.outlier_clusters_final[row] = workspace[tid].outlier_clusters[row];
-                        model_outputs.outlier_trees_final[row] = workspace[tid].outlier_trees[row];
-                        model_outputs.outlier_depth_final[row] = workspace[tid].outlier_depth[row];
-                        model_outputs.outlier_columns_final[row] = col;
+                                    model_outputs.all_clusters[col][workspace[tid].outlier_clusters[row]].has_NA_branch
+                                        ==
+                                    model_outputs.all_clusters[model_outputs.outlier_columns_final[row]][model_outputs.outlier_clusters_final[row]].has_NA_branch
+                                    &&
+                                    model_outputs.all_clusters[model_outputs.outlier_columns_final[row]][model_outputs.outlier_clusters_final[row]].cluster_size
+                                        <
+                                    model_outputs.all_clusters[col][workspace[tid].outlier_clusters[row]].cluster_size
+                                ) ||
+                                (
+                                    workspace[tid].outlier_depth[row] == model_outputs.outlier_depth_final[row] &&
+                                    model_outputs.all_clusters[model_outputs.outlier_columns_final[row]][model_outputs.outlier_clusters_final[row]].cluster_size
+                                        ==
+                                    model_outputs.all_clusters[col][workspace[tid].outlier_clusters[row]].cluster_size
+                                    &&
+                                    model_outputs.all_clusters[col][workspace[tid].outlier_clusters[row]].has_NA_branch
+                                        ==
+                                    model_outputs.all_clusters[model_outputs.outlier_columns_final[row]][model_outputs.outlier_clusters_final[row]].has_NA_branch
+                                    &&
+                                    workspace[tid].outlier_scores[row] < model_outputs.outlier_scores_final[row]
+                                )
+                        )
+                        {
+                            model_outputs.outlier_scores_final[row] = workspace[tid].outlier_scores[row];
+                            model_outputs.outlier_clusters_final[row] = workspace[tid].outlier_clusters[row];
+                            model_outputs.outlier_trees_final[row] = workspace[tid].outlier_trees[row];
+                            model_outputs.outlier_depth_final[row] = workspace[tid].outlier_depth[row];
+                            model_outputs.outlier_columns_final[row] = col;
+                        }
                     }
+
                 }
+            }
+        }
 
+        catch(...) {
+            #pragma omp critical
+            {
+                if (!threw_exception) {
+                    threw_exception = true;
+                    ex = std::current_exception();
+                }
             }
         }
+    }
 
+    check_interrupt_switch(ss);
+    #if defined(DONT_THROW_ON_INTERRUPT)
+    if (interrupt_switch) return false;
+    #endif
 
-    }
+    if (threw_exception)
+        std::rethrow_exception(ex);
 
     /* once finished, determine how many decimals to report for numerical outliers */
     if (found_outliers)
@@ -443,21 +475,23 @@ void process_numeric_col(std::vector<Cluster> &cluster_root,
                          ModelParams &model_params,
                          ModelOutputs &model_outputs)
 {
+    if (interrupt_switch) return;
+
     /* discard NAs and infinites */
     workspace.target_col_num = target_col_num;
     workspace.target_numeric_col = input_data.numeric_data + target_col_num * input_data.nrows;
     workspace.orig_target_col = workspace.target_numeric_col;
     workspace.end = input_data.nrows - 1;
-    workspace.st = move_NAs_to_front(&workspace.ix_arr[0], workspace.target_numeric_col, 0, workspace.end, true);
+    workspace.st = move_NAs_to_front(workspace.ix_arr.data(), workspace.target_numeric_col, 0, workspace.end, true);
     workspace.col_has_outliers = false;
 
     /* check for problematic distributions - need to sort data first */
-    std::sort(&workspace.ix_arr[0] + workspace.st, &workspace.ix_arr[0] + workspace.end + 1,
+    std::sort(workspace.ix_arr.data() + workspace.st, workspace.ix_arr.data() + workspace.end + 1,
               [&workspace](const size_t a, const size_t b){return workspace.target_numeric_col[a] < workspace.target_numeric_col[b];});
 
     long double running_mean = 0;
-    long double mean_prev    = 0;
     long double running_ssq  = 0;
+    long double mean_prev    = workspace.target_numeric_col[workspace.ix_arr[workspace.st]];
     double xval;
     for (size_t row = workspace.st; row <= workspace.end; row++) {
         xval = workspace.target_numeric_col[workspace.ix_arr[row]];
@@ -466,10 +500,10 @@ void process_numeric_col(std::vector<Cluster> &cluster_root,
         mean_prev     = running_mean;
     }
     
-    check_for_tails(&workspace.ix_arr[0], workspace.st, workspace.end, workspace.target_numeric_col,
+    check_for_tails(workspace.ix_arr.data(), workspace.st, workspace.end, workspace.target_numeric_col,
                     model_params.z_norm, model_params.max_perc_outliers,
-                    &workspace.buffer_transf_y[0], (double)running_mean,
-                    (double)sqrtl(running_ssq / (long double)(workspace.end - workspace.st)),
+                    workspace.buffer_transf_y.data(), (double)running_mean,
+                    (double)std::sqrt(running_ssq / (long double)(workspace.end - workspace.st)),
                     &workspace.left_tail, &workspace.right_tail,
                     &workspace.exp_transf, &workspace.log_transf);
 
@@ -480,11 +514,11 @@ void process_numeric_col(std::vector<Cluster> &cluster_root,
     if (workspace.exp_transf) {
 
         workspace.orig_mean = (double) running_mean;
-        workspace.orig_sd   = (double) sqrtl(running_ssq / (long double)(workspace.end - workspace.st));
+        workspace.orig_sd   = (double) std::sqrt(running_ssq / (long double)(workspace.end - workspace.st));
         for (size_t row = workspace.st; row <= workspace.end; row++) {
             workspace.buffer_transf_y[workspace.ix_arr[row]] = exp(z_score(workspace.target_numeric_col[workspace.ix_arr[row]], workspace.orig_mean, workspace.orig_sd));
         }
-        workspace.target_numeric_col = &workspace.buffer_transf_y[0];
+        workspace.target_numeric_col = workspace.buffer_transf_y.data();
         model_outputs.col_transf[workspace.target_col_num] = Exp;
         model_outputs.transf_offset[workspace.target_col_num] = workspace.orig_mean;
         model_outputs.sd_div[workspace.target_col_num] = workspace.orig_sd;
@@ -501,7 +535,7 @@ void process_numeric_col(std::vector<Cluster> &cluster_root,
         for (size_t row = workspace.st; row <= workspace.end; row++) {
             workspace.buffer_transf_y[workspace.ix_arr[row]] = log(workspace.target_numeric_col[workspace.ix_arr[row]] - workspace.log_minval);
         }
-        workspace.target_numeric_col = &workspace.buffer_transf_y[0];
+        workspace.target_numeric_col = workspace.buffer_transf_y.data();
         model_outputs.col_transf[workspace.target_col_num] = Log;
         model_outputs.transf_offset[workspace.target_col_num] = workspace.log_minval;
 
@@ -514,9 +548,9 @@ void process_numeric_col(std::vector<Cluster> &cluster_root,
     workspace.tree->emplace_back(0, Root);
 
     workspace.clusters->emplace_back(NoType, Root);
-    workspace.col_has_outliers = define_numerical_cluster(workspace.target_numeric_col, &workspace.ix_arr[0], workspace.st,
-                                                          workspace.end, &workspace.outlier_scores[0],
-                                                          &workspace.outlier_clusters[0], &workspace.outlier_trees[0], &workspace.outlier_depth[0],
+    workspace.col_has_outliers = define_numerical_cluster(workspace.target_numeric_col, workspace.ix_arr.data(), workspace.st,
+                                                          workspace.end, workspace.outlier_scores.data(),
+                                                          workspace.outlier_clusters.data(), workspace.outlier_trees.data(), workspace.outlier_depth.data(),
                                                           workspace.clusters->back(), *(workspace.clusters), 0, 0, 0,
                                                           workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                           workspace.orig_mean, workspace.orig_sd,
@@ -526,16 +560,19 @@ void process_numeric_col(std::vector<Cluster> &cluster_root,
 
     /* remove outliers if any were found */
     if (workspace.has_outliers)
-        workspace.st = move_outliers_to_front(&workspace.ix_arr[0], &workspace.outlier_scores[0], workspace.st, workspace.end);
+        workspace.st = move_outliers_to_front(workspace.ix_arr.data(), workspace.outlier_scores.data(), workspace.st, workspace.end);
 
     /* update statistics if they've changed */
     if (workspace.has_outliers || workspace.exp_transf || workspace.log_transf)
-        workspace.sd_y = calc_sd(&workspace.ix_arr[0], workspace.target_numeric_col,
+        workspace.sd_y = calc_sd(workspace.ix_arr.data(), workspace.target_numeric_col,
                                  workspace.st, workspace.end, &workspace.mean_y);
     else
         workspace.sd_y = sqrtl(running_ssq / (long double)(workspace.end - workspace.st));
 
-    if (model_params.max_depth > 0) recursive_split_numeric(workspace, input_data, model_params, 0, false);
+    if (model_params.max_depth > 0 && workspace.sd_y > 0) {
+        workspace.exhausted_col_tracker.initialize(input_data.tot_cols, model_params.max_depth);
+        recursive_split_numeric(workspace, input_data, model_params, 0, false);
+    }
 }
 
 void recursive_split_numeric(Workspace &workspace,
@@ -543,19 +580,27 @@ void recursive_split_numeric(Workspace &workspace,
                              ModelParams &model_params,
                              size_t curr_depth, bool is_NA_branch)
 {
+    if (interrupt_switch) return;
+
     workspace.best_gain = -HUGE_VAL;
     workspace.column_type_best = NoType;
     workspace.lev_has_outliers = false;
-    if (curr_depth > 0) workspace.sd_y = calc_sd(&workspace.ix_arr[0], workspace.target_numeric_col,
-                                                 workspace.st, workspace.end, &workspace.mean_y);
 
     /* these are used to keep track of where to continue after calling a further recursion */
     size_t ix1, ix2, ix3;
     SplitType spl1, spl2;
     size_t tree_from = workspace.tree->size() - 1;
+    std::unique_ptr<RecursionState> state_backup;
+    ExhaustedColumnsLevel level_col_tracker;
+
+    if (curr_depth > 0) {
+        workspace.sd_y = calc_sd(workspace.ix_arr.data(), workspace.target_numeric_col,
+                                 workspace.st, workspace.end, &workspace.mean_y);
+        if (workspace.sd_y <= 0) goto abandon_column;
+    }
+    level_col_tracker.initialize(&workspace.exhausted_col_tracker);
 
     /* when using 'follow_all' need to keep track of a lot more things */
-    std::unique_ptr<RecursionState> state_backup;
     if (model_params.follow_all) state_backup = std::unique_ptr<RecursionState>(new RecursionState);
 
     
@@ -566,10 +611,16 @@ void recursive_split_numeric(Workspace &workspace,
 
         if (col == workspace.target_col_num) continue;
         if (input_data.skip_col[col]) continue;
-        split_numericx_numericy(&workspace.ix_arr[0], workspace.st, workspace.end, input_data.numeric_data + col * input_data.nrows,
+        if (workspace.exhausted_col_tracker.is_exhausted[col]) continue;
+        split_numericx_numericy(workspace.ix_arr.data(), workspace.st, workspace.end, input_data.numeric_data + col * input_data.nrows,
                                 workspace.target_numeric_col, workspace.sd_y, (bool)(input_data.has_NA[col]), model_params.min_size_numeric,
-                                model_params.take_mid, &workspace.buffer_sd[0], &(workspace.this_gain), &(workspace.this_split_point),
-                                &(workspace.this_split_ix), &(workspace.this_split_NA));
+                                model_params.take_mid, workspace.buffer_sd.data(), &(workspace.this_gain), &(workspace.this_split_point),
+                                &(workspace.this_split_ix), &(workspace.this_split_NA), &workspace.has_zero_variance);
+        if (workspace.has_zero_variance) {
+            workspace.has_zero_variance = false;
+            workspace.exhausted_col_tracker.push_col(col);
+            continue;
+        }
         if (model_params.gain_as_pct) workspace.this_gain /= workspace.sd_y;
 
         /* if the gain is not insignificant, check clusters created by this split */
@@ -581,9 +632,9 @@ void recursive_split_numeric(Workspace &workspace,
 
                 (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
                 workspace.clusters->emplace_back(Numeric, col, IsNa, -HUGE_VAL, true);
-                workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, &workspace.ix_arr[0], workspace.st,
-                                                                  workspace.this_split_NA - 1, &workspace.outlier_scores[0], &workspace.outlier_clusters[0],
-                                                                  &workspace.outlier_trees[0], &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+                workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, workspace.ix_arr.data(), workspace.st,
+                                                                  workspace.this_split_NA - 1, workspace.outlier_scores.data(), workspace.outlier_clusters.data(),
+                                                                  workspace.outlier_trees.data(), workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                                   workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                                   workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                                   workspace.orig_mean, workspace.orig_sd,
@@ -596,6 +647,9 @@ void recursive_split_numeric(Workspace &workspace,
                     workspace.tree->emplace_back(tree_from, col, HUGE_VAL, IsNa);
                     backup_recursion_state(workspace, *state_backup);
                     workspace.end = workspace.this_split_NA - 1;
+                    ExhaustedColumnsLevel level_col_tracker2;
+                    level_col_tracker2.initialize(&workspace.exhausted_col_tracker);
+                    workspace.exhausted_col_tracker.push_col(col);
                     recursive_split_numeric(workspace, input_data, model_params, curr_depth + 1, true);
                     restore_recursion_state(workspace, *state_backup);
                 }
@@ -605,9 +659,9 @@ void recursive_split_numeric(Workspace &workspace,
             /* left branch */
             (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
             workspace.clusters->emplace_back(Numeric, col, LessOrEqual, workspace.this_split_point, is_NA_branch);
-            workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, &workspace.ix_arr[0], workspace.this_split_NA,
-                                                              workspace.this_split_ix, &workspace.outlier_scores[0], &workspace.outlier_clusters[0],
-                                                              &workspace.outlier_trees[0], &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+            workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, workspace.ix_arr.data(), workspace.this_split_NA,
+                                                              workspace.this_split_ix, workspace.outlier_scores.data(), workspace.outlier_clusters.data(),
+                                                              workspace.outlier_trees.data(), workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                               workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                               workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                               workspace.orig_mean, workspace.orig_sd,
@@ -629,9 +683,9 @@ void recursive_split_numeric(Workspace &workspace,
             /* right branch */
             (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
             workspace.clusters->emplace_back(Numeric, col, Greater, workspace.this_split_point, is_NA_branch);
-            workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, &workspace.ix_arr[0], workspace.this_split_ix + 1,
-                                                              workspace.end, &workspace.outlier_scores[0], &workspace.outlier_clusters[0],
-                                                              &workspace.outlier_trees[0], &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+            workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, workspace.ix_arr.data(), workspace.this_split_ix + 1,
+                                                              workspace.end, workspace.outlier_scores.data(), workspace.outlier_clusters.data(),
+                                                              workspace.outlier_trees.data(), workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                               workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                               workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                               workspace.orig_mean, workspace.orig_sd,
@@ -665,29 +719,36 @@ void recursive_split_numeric(Workspace &workspace,
     for (size_t col = 0; col < input_data.ncols_categ; col++) {
 
         if (input_data.skip_col[col + input_data.ncols_numeric]) continue;
+        if (workspace.exhausted_col_tracker.is_exhausted[col + input_data.ncols_numeric]) continue;
 
-        split_categx_numericy(&workspace.ix_arr[0], workspace.st, workspace.end, input_data.categorical_data + col * input_data.nrows,
-                              workspace.target_numeric_col, workspace.sd_y, workspace.mean_y, false, input_data.ncat[col], &workspace.buffer_cat_cnt[0],
-                              &workspace.buffer_cat_sum[0], &workspace.buffer_cat_sum_sq[0], &workspace.buffer_cat_sorted[0],
+        split_categx_numericy(workspace.ix_arr.data(), workspace.st, workspace.end, input_data.categorical_data + col * input_data.nrows,
+                              workspace.target_numeric_col, workspace.sd_y, workspace.mean_y, false, input_data.ncat[col], workspace.buffer_cat_cnt.data(),
+                              workspace.buffer_cat_sum.data(), workspace.buffer_cat_sum_sq.data(), workspace.buffer_cat_sorted.data(),
                               (bool)(input_data.has_NA[col + input_data.ncols_numeric]), model_params.min_size_numeric,
-                              &(workspace.this_gain), &workspace.buffer_subset_categ[0], NULL);
+                              &(workspace.this_gain), workspace.buffer_subset_categ.data(), NULL,
+                              &workspace.has_zero_variance, &workspace.is_binary_split);
+        if (workspace.has_zero_variance) {
+            workspace.has_zero_variance = false;
+            workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric);
+            continue;
+        }
         if (model_params.gain_as_pct) workspace.this_gain /= workspace.sd_y;
 
         if (workspace.this_gain >= model_params.min_gain) {
 
             /* data is not arranged inside the splitting function, need to now assign to the branches as determined */
-            divide_subset_split(&workspace.ix_arr[0], input_data.categorical_data + col * input_data.nrows, workspace.st, workspace.end,
-                                &workspace.buffer_subset_categ[0], input_data.ncat[col], (bool)(workspace.buffer_cat_cnt[input_data.ncat[col]] > 0),
+            divide_subset_split(workspace.ix_arr.data(), input_data.categorical_data + col * input_data.nrows, workspace.st, workspace.end,
+                                workspace.buffer_subset_categ.data(), input_data.ncat[col], (bool)(workspace.buffer_cat_cnt[input_data.ncat[col]] > 0),
                                 &(workspace.this_split_NA), &(workspace.this_split_ix));
 
             /* NA branch */
             if ((workspace.this_split_NA - workspace.st) > model_params.min_size_numeric) {
 
                 (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
-                workspace.clusters->emplace_back(Categorical, col, IsNa, (char*)NULL, (int)0, true);
-                workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, &workspace.ix_arr[0], workspace.st,
-                                                                  workspace.this_split_NA - 1, &workspace.outlier_scores[0], &workspace.outlier_clusters[0],
-                                                                  &workspace.outlier_trees[0], &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+                workspace.clusters->emplace_back(Categorical, col, IsNa, (signed char*)NULL, (int)0, true);
+                workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, workspace.ix_arr.data(), workspace.st,
+                                                                  workspace.this_split_NA - 1, workspace.outlier_scores.data(), workspace.outlier_clusters.data(),
+                                                                  workspace.outlier_trees.data(), workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                                   workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                                   workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                                   workspace.orig_mean, workspace.orig_sd,
@@ -697,9 +758,12 @@ void recursive_split_numeric(Workspace &workspace,
 
                 if (model_params.follow_all && ((curr_depth + 1) < model_params.max_depth)) {
                     (*workspace.tree)[tree_from].all_branches.push_back(workspace.tree->size());
-                    workspace.tree->emplace_back(tree_from, col, IsNa, (char*)NULL, 0);
+                    workspace.tree->emplace_back(tree_from, col, IsNa, (signed char*)NULL, 0);
                     backup_recursion_state(workspace, *state_backup);
                     workspace.end = workspace.this_split_NA - 1;
+                    ExhaustedColumnsLevel level_col_tracker2;
+                    level_col_tracker2.initialize(&workspace.exhausted_col_tracker);
+                    workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric);
                     recursive_split_numeric(workspace, input_data, model_params, curr_depth + 1, true);
                     restore_recursion_state(workspace, *state_backup);
                 }
@@ -708,10 +772,10 @@ void recursive_split_numeric(Workspace &workspace,
 
             /* left branch */
             (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
-            workspace.clusters->emplace_back(Categorical, col, InSubset, &workspace.buffer_subset_categ[0], input_data.ncat[col], is_NA_branch);
-            workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, &workspace.ix_arr[0], workspace.this_split_NA,
-                                                              workspace.this_split_ix - 1, &workspace.outlier_scores[0], &workspace.outlier_clusters[0],
-                                                              &workspace.outlier_trees[0], &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+            workspace.clusters->emplace_back(Categorical, col, InSubset, workspace.buffer_subset_categ.data(), input_data.ncat[col], is_NA_branch);
+            workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, workspace.ix_arr.data(), workspace.this_split_NA,
+                                                              workspace.this_split_ix - 1, workspace.outlier_scores.data(), workspace.outlier_clusters.data(),
+                                                              workspace.outlier_trees.data(), workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                               workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                               workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                               workspace.orig_mean, workspace.orig_sd,
@@ -721,20 +785,25 @@ void recursive_split_numeric(Workspace &workspace,
 
             if (model_params.follow_all && ((curr_depth + 1) < model_params.max_depth)) {
                 (*workspace.tree)[tree_from].all_branches.push_back(workspace.tree->size());
-                workspace.tree->emplace_back(tree_from, col, InSubset, &workspace.buffer_subset_categ[0], input_data.ncat[col]);
+                workspace.tree->emplace_back(tree_from, col, InSubset, workspace.buffer_subset_categ.data(), input_data.ncat[col]);
                 backup_recursion_state(workspace, *state_backup);
                 workspace.st = workspace.this_split_NA;
                 workspace.end = workspace.this_split_ix - 1;
+                ExhaustedColumnsLevel level_col_tracker2;
+                if (workspace.is_binary_split) {
+                    level_col_tracker2.initialize(&workspace.exhausted_col_tracker);
+                    workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric);
+                }
                 recursive_split_numeric(workspace, input_data, model_params, curr_depth + 1, is_NA_branch);
                 restore_recursion_state(workspace, *state_backup);
             }
 
             /* right branch */
             (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
-            workspace.clusters->emplace_back(Categorical, col, NotInSubset, &workspace.buffer_subset_categ[0], input_data.ncat[col], is_NA_branch);
-            workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, &workspace.ix_arr[0], workspace.this_split_ix,
-                                                              workspace.end, &workspace.outlier_scores[0], &workspace.outlier_clusters[0],
-                                                              &workspace.outlier_trees[0], &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+            workspace.clusters->emplace_back(Categorical, col, NotInSubset, workspace.buffer_subset_categ.data(), input_data.ncat[col], is_NA_branch);
+            workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, workspace.ix_arr.data(), workspace.this_split_ix,
+                                                              workspace.end, workspace.outlier_scores.data(), workspace.outlier_clusters.data(),
+                                                              workspace.outlier_trees.data(), workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                               workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                               workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                               workspace.orig_mean, workspace.orig_sd,
@@ -744,9 +813,14 @@ void recursive_split_numeric(Workspace &workspace,
 
             if (model_params.follow_all && ((curr_depth + 1) < model_params.max_depth)) {
                 (*workspace.tree)[tree_from].all_branches.push_back(workspace.tree->size());
-                workspace.tree->emplace_back(tree_from, col, NotInSubset, &workspace.buffer_subset_categ[0], input_data.ncat[col]);
+                workspace.tree->emplace_back(tree_from, col, NotInSubset, workspace.buffer_subset_categ.data(), input_data.ncat[col]);
                 backup_recursion_state(workspace, *state_backup);
                 workspace.st = workspace.this_split_ix;
+                ExhaustedColumnsLevel level_col_tracker2;
+                if (workspace.is_binary_split) {
+                    level_col_tracker2.initialize(&workspace.exhausted_col_tracker);
+                    workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric);
+                }
                 recursive_split_numeric(workspace, input_data, model_params, curr_depth + 1, is_NA_branch);
                 restore_recursion_state(workspace, *state_backup);
             }
@@ -755,7 +829,8 @@ void recursive_split_numeric(Workspace &workspace,
                 workspace.best_gain = workspace.this_gain;
                 workspace.column_type_best = Categorical;
                 workspace.col_best = col;
-                memcpy(&workspace.buffer_subset_categ_best[0], &workspace.buffer_subset_categ[0], input_data.ncat[col] * sizeof(char));
+                workspace.best_cat_split_is_binary = workspace.is_binary_split;
+                memcpy(workspace.buffer_subset_categ_best.data(), workspace.buffer_subset_categ.data(), input_data.ncat[col] * sizeof(signed char));
             }
 
         }
@@ -766,18 +841,25 @@ void recursive_split_numeric(Workspace &workspace,
     for (size_t col = 0; col < input_data.ncols_ord; col++) {
 
         if (input_data.skip_col[col + input_data.ncols_numeric + input_data.ncols_categ]) continue;
+        if (workspace.exhausted_col_tracker.is_exhausted[col + input_data.ncols_numeric + input_data.ncols_categ]) continue;
 
         /* same code as for categorical, but this time with split level as int instead of boolean array as subset */
-        split_categx_numericy(&workspace.ix_arr[0], workspace.st, workspace.end, input_data.ordinal_data + col * input_data.nrows,
-                              workspace.target_numeric_col, workspace.sd_y, workspace.mean_y, true, input_data.ncat_ord[col], &workspace.buffer_cat_cnt[0],
-                              &workspace.buffer_cat_sum[0], &workspace.buffer_cat_sum_sq[0], &workspace.buffer_cat_sorted[0],
+        split_categx_numericy(workspace.ix_arr.data(), workspace.st, workspace.end, input_data.ordinal_data + col * input_data.nrows,
+                              workspace.target_numeric_col, workspace.sd_y, workspace.mean_y, true, input_data.ncat_ord[col], workspace.buffer_cat_cnt.data(),
+                              workspace.buffer_cat_sum.data(), workspace.buffer_cat_sum_sq.data(), workspace.buffer_cat_sorted.data(),
                               (bool)(input_data.has_NA[col + input_data.ncols_numeric + input_data.ncols_categ]), model_params.min_size_numeric,
-                              &(workspace.this_gain), &workspace.buffer_subset_categ[0], &(workspace.this_split_lev));
+                              &(workspace.this_gain), workspace.buffer_subset_categ.data(), &(workspace.this_split_lev),
+                              &workspace.has_zero_variance, &workspace.is_binary_split);
+        if (workspace.has_zero_variance) {
+            workspace.has_zero_variance = false;
+            workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric + input_data.ncols_categ);
+            continue;
+        }
         if (model_params.gain_as_pct) workspace.this_gain /= workspace.sd_y;
 
         if (workspace.this_gain >= model_params.min_gain) {
 
-            divide_subset_split(&workspace.ix_arr[0], input_data.ordinal_data + col * input_data.nrows, workspace.st, workspace.end,
+            divide_subset_split(workspace.ix_arr.data(), input_data.ordinal_data + col * input_data.nrows, workspace.st, workspace.end,
                                 workspace.this_split_lev, (bool)(workspace.buffer_cat_cnt[ input_data.ncat_ord[col] ] > 0),
                                 &(workspace.this_split_NA), &(workspace.this_split_ix) );
 
@@ -785,9 +867,9 @@ void recursive_split_numeric(Workspace &workspace,
 
                 (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
                 workspace.clusters->emplace_back(Ordinal, col, IsNa, (int)0, true);
-                workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, &workspace.ix_arr[0], workspace.st,
-                                                                  workspace.this_split_NA - 1, &workspace.outlier_scores[0], &workspace.outlier_clusters[0],
-                                                                  &workspace.outlier_trees[0], &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+                workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, workspace.ix_arr.data(), workspace.st,
+                                                                  workspace.this_split_NA - 1, workspace.outlier_scores.data(), workspace.outlier_clusters.data(),
+                                                                  workspace.outlier_trees.data(), workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                                   workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                                   workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                                   workspace.orig_mean, workspace.orig_sd,
@@ -800,6 +882,9 @@ void recursive_split_numeric(Workspace &workspace,
                     workspace.tree->emplace_back(tree_from, col, (int)-1, IsNa);
                     backup_recursion_state(workspace, *state_backup);
                     workspace.end = workspace.this_split_NA - 1;
+                    ExhaustedColumnsLevel level_col_tracker2;
+                    level_col_tracker2.initialize(&workspace.exhausted_col_tracker);
+                    workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric + input_data.ncols_ord);
                     recursive_split_numeric(workspace, input_data, model_params, curr_depth + 1, true);
                     restore_recursion_state(workspace, *state_backup);
                 }
@@ -809,9 +894,9 @@ void recursive_split_numeric(Workspace &workspace,
             /* left branch */
             (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
             workspace.clusters->emplace_back(Ordinal, col, LessOrEqual, workspace.this_split_lev, is_NA_branch);
-            workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, &workspace.ix_arr[0], workspace.this_split_NA,
-                                                              workspace.this_split_ix - 1, &workspace.outlier_scores[0], &workspace.outlier_clusters[0],
-                                                              &workspace.outlier_trees[0], &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+            workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, workspace.ix_arr.data(), workspace.this_split_NA,
+                                                              workspace.this_split_ix - 1, workspace.outlier_scores.data(), workspace.outlier_clusters.data(),
+                                                              workspace.outlier_trees.data(), &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
                                                               workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                               workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                               workspace.orig_mean, workspace.orig_sd,
@@ -825,6 +910,11 @@ void recursive_split_numeric(Workspace &workspace,
                 backup_recursion_state(workspace, *state_backup);
                 workspace.st = workspace.this_split_NA;
                 workspace.end = workspace.this_split_ix - 1;
+                ExhaustedColumnsLevel level_col_tracker2;
+                if (workspace.is_binary_split) {
+                    level_col_tracker2.initialize(&workspace.exhausted_col_tracker);
+                    workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric + input_data.ncols_ord);
+                }
                 recursive_split_numeric(workspace, input_data, model_params, curr_depth + 1, is_NA_branch);
                 restore_recursion_state(workspace, *state_backup);
             }
@@ -834,9 +924,9 @@ void recursive_split_numeric(Workspace &workspace,
             /* right branch */
             (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
             workspace.clusters->emplace_back(Ordinal, col, Greater, workspace.this_split_lev, is_NA_branch);
-            workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, &workspace.ix_arr[0], workspace.this_split_ix,
-                                                              workspace.end, &workspace.outlier_scores[0], &workspace.outlier_clusters[0],
-                                                              &workspace.outlier_trees[0], &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+            workspace.has_outliers = define_numerical_cluster(workspace.target_numeric_col, workspace.ix_arr.data(), workspace.this_split_ix,
+                                                              workspace.end, workspace.outlier_scores.data(), workspace.outlier_clusters.data(),
+                                                              workspace.outlier_trees.data(), workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                               workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                               workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                               workspace.orig_mean, workspace.orig_sd,
@@ -849,6 +939,11 @@ void recursive_split_numeric(Workspace &workspace,
                 workspace.tree->emplace_back(tree_from, col, workspace.this_split_lev, Greater);
                 backup_recursion_state(workspace, *state_backup);
                 workspace.st = workspace.this_split_ix;
+                ExhaustedColumnsLevel level_col_tracker2;
+                if (workspace.is_binary_split) {
+                    level_col_tracker2.initialize(&workspace.exhausted_col_tracker);
+                    workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric + input_data.ncols_ord);
+                }
                 recursive_split_numeric(workspace, input_data, model_params, curr_depth + 1, is_NA_branch);
                 restore_recursion_state(workspace, *state_backup);
             }
@@ -858,6 +953,7 @@ void recursive_split_numeric(Workspace &workspace,
                 workspace.column_type_best = Ordinal;
                 workspace.col_best = col;
                 workspace.split_lev_best = workspace.this_split_lev;
+                workspace.best_cat_split_is_binary = workspace.is_binary_split;
             }
 
         }
@@ -867,7 +963,7 @@ void recursive_split_numeric(Workspace &workspace,
     /* avoid unnecessary memory usage */
     workspace.col_has_outliers = workspace.lev_has_outliers? true : workspace.col_has_outliers;
     (*workspace.tree)[tree_from].clusters.shrink_to_fit();
-    if ((*workspace.tree)[tree_from].all_branches.size() > 0) (*workspace.tree)[tree_from].all_branches.shrink_to_fit();
+    if (!(*workspace.tree)[tree_from].all_branches.empty()) (*workspace.tree)[tree_from].all_branches.shrink_to_fit();
 
 
     /* continue splitting further if meeting threshold criteria */
@@ -879,13 +975,13 @@ void recursive_split_numeric(Workspace &workspace,
 
         /* discard outliers if any */
         if (workspace.lev_has_outliers)
-            workspace.st = move_outliers_to_front(&workspace.ix_arr[0], &workspace.outlier_scores[0], workspace.st, workspace.end);
+            workspace.st = move_outliers_to_front(workspace.ix_arr.data(), workspace.outlier_scores.data(), workspace.st, workspace.end);
 
         /* assign rows to their corresponding branch */
         switch(workspace.column_type_best) {
             case Numeric:
             {
-                divide_subset_split(&workspace.ix_arr[0], input_data.numeric_data + workspace.col_best * input_data.nrows,
+                divide_subset_split(workspace.ix_arr.data(), input_data.numeric_data + workspace.col_best * input_data.nrows,
                                     workspace.st, workspace.end, workspace.split_point_best,
                                     (bool)(input_data.has_NA[workspace.col_best]),
                                     &(workspace.this_split_NA), &(workspace.this_split_ix) );
@@ -896,28 +992,35 @@ void recursive_split_numeric(Workspace &workspace,
 
             case Categorical:
             {
-                divide_subset_split(&workspace.ix_arr[0], input_data.categorical_data + workspace.col_best * input_data.nrows,
-                                    workspace.st, workspace.end, &workspace.buffer_subset_categ_best[0], input_data.ncat[workspace.col_best],
+                divide_subset_split(workspace.ix_arr.data(), input_data.categorical_data + workspace.col_best * input_data.nrows,
+                                    workspace.st, workspace.end, workspace.buffer_subset_categ_best.data(), input_data.ncat[workspace.col_best],
                                     (bool)(input_data.has_NA[workspace.col_best + input_data.ncols_numeric]),
                                     &(workspace.this_split_NA), &(workspace.this_split_ix) );
                 spl1 = InSubset; spl2 = NotInSubset;
                 set_tree_as_categorical(workspace.tree->back(), input_data.ncat[workspace.col_best],
-                                        &workspace.buffer_subset_categ_best[0], workspace.col_best);
+                                        workspace.buffer_subset_categ_best.data(), workspace.col_best);
+                if (input_data.ncat[workspace.col_best] == 2 || workspace.best_cat_split_is_binary)
+                    workspace.exhausted_col_tracker.push_col(workspace.col_best + input_data.ncols_numeric);
                 break;
             }
 
             case Ordinal:
             {
-                divide_subset_split(&workspace.ix_arr[0], input_data.ordinal_data + workspace.col_best * input_data.nrows,
+                divide_subset_split(workspace.ix_arr.data(), input_data.ordinal_data + workspace.col_best * input_data.nrows,
                                     workspace.st, workspace.end, workspace.split_lev_best,
                                     (bool)(input_data.has_NA[workspace.col_best + input_data.ncols_numeric + input_data.ncols_categ]),
                                     &(workspace.this_split_NA), &(workspace.this_split_ix) );
                 spl1 = LessOrEqual; spl2 = Greater;
                 set_tree_as_ordinal(workspace.tree->back(), workspace.split_lev_best, workspace.col_best);
+                if (input_data.ncat_ord[workspace.col_best] == 2 || workspace.best_cat_split_is_binary)
+                    workspace.exhausted_col_tracker.push_col(workspace.col_best + input_data.ncols_numeric + input_data.ncols_categ);
                 break;
             }
 
-
+            default:
+            {
+                unexpected_error();
+            }
         }
 
         /* continue splitting recursively - need to remember from where */
@@ -956,11 +1059,12 @@ void recursive_split_numeric(Workspace &workspace,
     }
 
     /* if tree has no clusters and no subtrees, disconnect it from parent and then drop */
+    abandon_column:
     if (check_tree_is_not_needed((*workspace.tree)[tree_from])) {
 
         if (tree_from == 0) {
             workspace.tree->clear();
-        } else if ((*workspace.tree)[(*workspace.tree)[tree_from].parent].all_branches.size() > 0) {
+        } else if (!(*workspace.tree)[(*workspace.tree)[tree_from].parent].all_branches.empty()) {
             (*workspace.tree)[(*workspace.tree)[tree_from].parent].all_branches.pop_back();
             workspace.tree->pop_back();
         } else {
@@ -995,6 +1099,11 @@ void recursive_split_numeric(Workspace &workspace,
                     (*workspace.tree)[(*workspace.tree)[tree_from].parent].tree_right = 0;
                     break;
                 }
+
+                default:
+                {
+                    unexpected_error();
+                }
             }
             workspace.tree->pop_back();
         }
@@ -1010,6 +1119,8 @@ void process_categ_col(std::vector<Cluster> &cluster_root,
                        ModelParams &model_params,
                        ModelOutputs &model_outputs)
 {
+    if (interrupt_switch) return;
+
     if (model_params.max_depth <= 0) return;
 
     /* extract necesary info from column and discard NAs */
@@ -1024,10 +1135,10 @@ void process_categ_col(std::vector<Cluster> &cluster_root,
     }
     workspace.untransf_target_col = workspace.target_categ_col;
     workspace.end = input_data.nrows - 1;
-    workspace.st = move_NAs_to_front(&workspace.ix_arr[0], workspace.target_categ_col, 0, workspace.end);
+    workspace.st = move_NAs_to_front(workspace.ix_arr.data(), workspace.target_categ_col, 0, workspace.end);
     workspace.col_has_outliers = false;
     workspace.col_is_bin = workspace.ncat_this <= 2;
-    workspace.prop_small_this = &model_params.prop_small[ model_outputs.start_ix_cat_counts[workspace.target_col_num] ];
+    workspace.prop_small_this = model_params.prop_small.data() + model_outputs.start_ix_cat_counts[workspace.target_col_num];
     workspace.prior_prob = &model_outputs.prop_categ[ model_outputs.start_ix_cat_counts[workspace.target_col_num] ];
 
     /* create cluster root and reset outlier scores for this column */
@@ -1038,20 +1149,20 @@ void process_categ_col(std::vector<Cluster> &cluster_root,
 
 
     /* at first, see if there's a category with 1-2 observations among only categories with large counts */
-    workspace.col_has_outliers = find_outlier_categories_no_cond(&input_data.cat_counts[ model_outputs.start_ix_cat_counts[workspace.target_col_num] ],
+    workspace.col_has_outliers = find_outlier_categories_no_cond(input_data.cat_counts.data() + model_outputs.start_ix_cat_counts[workspace.target_col_num],
                                                                  workspace.ncat_this, workspace.end - workspace.st + 1,
-                                                                 &workspace.buffer_subset_categ[0], &(workspace.orig_mean));
+                                                                 workspace.buffer_subset_categ.data(), &(workspace.orig_mean));
 
     /* if there is any such case, create a cluster for them */
     if (workspace.col_has_outliers) {
         workspace.tree->back().clusters.push_back(0);
         workspace.clusters->emplace_back(NoType, Root);
-        define_categ_cluster_no_cond(workspace.untransf_target_col, &workspace.ix_arr[0], workspace.st, workspace.end, workspace.ncat_this,
-                                     &workspace.outlier_scores[0], &workspace.outlier_clusters[0], &workspace.outlier_trees[0],
-                                     &workspace.outlier_depth[0], workspace.clusters->back(),
-                                     &input_data.cat_counts[ model_outputs.start_ix_cat_counts[workspace.target_col_num] ],
-                                     &workspace.buffer_subset_categ[0], workspace.orig_mean);
-        workspace.st = move_outliers_to_front(&workspace.ix_arr[0], &workspace.outlier_scores[0], workspace.st, workspace.end);
+        define_categ_cluster_no_cond(workspace.untransf_target_col, workspace.ix_arr.data(), workspace.st, workspace.end, workspace.ncat_this,
+                                     workspace.outlier_scores.data(), workspace.outlier_clusters.data(), workspace.outlier_trees.data(),
+                                     workspace.outlier_depth.data(), workspace.clusters->back(),
+                                     input_data.cat_counts.data() + model_outputs.start_ix_cat_counts[workspace.target_col_num],
+                                     workspace.buffer_subset_categ.data(), workspace.orig_mean);
+        workspace.st = move_outliers_to_front(workspace.ix_arr.data(), workspace.outlier_scores.data(), workspace.st, workspace.end);
     }
 
     /* if no conditional outliers are required, stop there */
@@ -1069,6 +1180,8 @@ void process_categ_col(std::vector<Cluster> &cluster_root,
     }
     if (should_skip) return;
 
+    workspace.exhausted_col_tracker.initialize(input_data.tot_cols, model_params.max_depth);
+
 
     /* if the column is already binary, or if using multiple categories, or if there are no more categorical columns, split the data as-is */
     if (
@@ -1080,7 +1193,7 @@ void process_categ_col(std::vector<Cluster> &cluster_root,
     {
 
         /* calculate base information */
-        workspace.base_info = total_info(&input_data.cat_counts[ model_outputs.start_ix_cat_counts[workspace.target_col_num] ],
+        workspace.base_info = total_info(input_data.cat_counts.data() + model_outputs.start_ix_cat_counts[workspace.target_col_num],
                                          workspace.ncat_this, workspace.end - workspace.st + 1);
         workspace.base_info_orig = workspace.base_info;
 
@@ -1096,7 +1209,7 @@ void process_categ_col(std::vector<Cluster> &cluster_root,
         size_t cat_counts_bin[2];
         workspace.col_is_bin = true;
         workspace.already_split_main = false;
-        workspace.base_info_orig = total_info(&input_data.cat_counts[ model_outputs.start_ix_cat_counts[workspace.target_col_num] ],
+        workspace.base_info_orig = total_info(input_data.cat_counts.data() + model_outputs.start_ix_cat_counts[workspace.target_col_num],
                                               workspace.ncat_this, workspace.end - workspace.st + 1);
         workspace.tree->back().column_type = NoType;
 
@@ -1130,7 +1243,7 @@ void process_categ_col(std::vector<Cluster> &cluster_root,
             }
 
             if (cat_counts_bin[0] > 0 && cat_counts_bin[1] > 0) {
-                workspace.target_categ_col = &workspace.buffer_bin_y[0];
+                workspace.target_categ_col = workspace.buffer_bin_y.data();
                 workspace.base_info = total_info(cat_counts_bin, 2, workspace.end - workspace.st + 1);
                 (*workspace.tree)[0].binary_branches.push_back(workspace.tree->size());
                 workspace.tree->emplace_back(0, SubTrees);
@@ -1150,6 +1263,8 @@ void recursive_split_categ(Workspace &workspace,
                            ModelParams &model_params,
                            size_t curr_depth, bool is_NA_branch)
 {
+    if (interrupt_switch) return;
+    
     /*    idea is the same as its numeric counterpart, only splitting by another categorical
         is less clear how to do and offers different options */
     workspace.best_gain = -HUGE_VAL;
@@ -1158,14 +1273,15 @@ void recursive_split_categ(Workspace &workspace,
     size_t ix1, ix2, ix3;
     SplitType spl1, spl2;
     size_t tree_from = workspace.tree->size() - 1;
+    ExhaustedColumnsLevel level_col_tracker;
 
     /* when using 'follow_all' need to keep track of a lot more things */
     std::unique_ptr<RecursionState> state_backup;
     if (model_params.follow_all) state_backup = std::unique_ptr<RecursionState>(new RecursionState);
 
     if (curr_depth > 0) {
-        workspace.base_info_orig = total_info(&workspace.ix_arr[0], workspace.untransf_target_col, workspace.st, workspace.end,
-                                              workspace.ncat_this, &workspace.buffer_cat_cnt[0]);
+        workspace.base_info_orig = total_info(workspace.ix_arr.data(), workspace.untransf_target_col, workspace.st, workspace.end,
+                                              workspace.ncat_this, workspace.buffer_cat_cnt.data());
 
         /* check that there's still more than 1 category */
         size_t ncat_present = 0;
@@ -1175,14 +1291,16 @@ void recursive_split_categ(Workspace &workspace,
         }
         if (ncat_present < 2) goto drop_if_not_needed;
         if (workspace.col_is_bin && workspace.ncat_this > 2) {
-            workspace.base_info = total_info(&workspace.ix_arr[0], workspace.target_categ_col, workspace.st, workspace.end,
-                                             2, &workspace.buffer_cat_cnt[0]);
+            workspace.base_info = total_info(workspace.ix_arr.data(), workspace.target_categ_col, workspace.st, workspace.end,
+                                             2, workspace.buffer_cat_cnt.data());
             if (workspace.buffer_cat_cnt[0] < model_params.min_size_categ || workspace.buffer_cat_cnt[1] == model_params.min_size_categ) goto drop_if_not_needed;
         } else {
             workspace.base_info = workspace.base_info_orig;
         }
     }
 
+    level_col_tracker.initialize(&workspace.exhausted_col_tracker);
+
     /* split with each other column */
 
 
@@ -1191,11 +1309,17 @@ void recursive_split_categ(Workspace &workspace,
 
         if (curr_depth == 0 && workspace.col_is_bin && workspace.ncat_this > 2 && workspace.already_split_main) break;
         if (input_data.skip_col[col]) continue;
-        split_numericx_categy(&workspace.ix_arr[0], workspace.st, workspace.end, input_data.numeric_data + col * input_data.nrows,
+        if (workspace.exhausted_col_tracker.is_exhausted[col]) continue;
+        split_numericx_categy(workspace.ix_arr.data(), workspace.st, workspace.end, input_data.numeric_data + col * input_data.nrows,
                               workspace.untransf_target_col, workspace.ncat_this, workspace.base_info_orig,
-                              &workspace.buffer_cat_cnt[0], (bool)(input_data.has_NA[col]), model_params.min_size_categ,
-                              model_params.take_mid, &(workspace.this_gain), &(workspace.this_split_point),
-                              &(workspace.this_split_ix), &(workspace.this_split_NA));
+                              workspace.buffer_cat_cnt.data(), (bool)(input_data.has_NA[col]), model_params.min_size_categ,
+                              model_params.take_mid, &workspace.this_gain, &workspace.this_split_point,
+                              &workspace.this_split_ix, &workspace.this_split_NA, &workspace.has_zero_variance);
+        if (workspace.has_zero_variance) {
+            workspace.has_zero_variance = false;
+            workspace.exhausted_col_tracker.push_col(col);
+            continue;
+        }
         if (model_params.gain_as_pct) workspace.this_gain /= workspace.base_info_orig;
 
         if (workspace.this_gain >= model_params.min_gain) {
@@ -1207,15 +1331,15 @@ void recursive_split_categ(Workspace &workspace,
                 (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
                 workspace.clusters->emplace_back(Numeric, col, IsNa, -HUGE_VAL, true);
                 workspace.has_outliers = define_categ_cluster(workspace.untransf_target_col,
-                                                              &workspace.ix_arr[0], workspace.st, workspace.this_split_NA - 1,
+                                                              workspace.ix_arr.data(), workspace.st, workspace.this_split_NA - 1,
                                                               workspace.ncat_this, model_params.categ_from_maj,
-                                                              &workspace.outlier_scores[0], &workspace.outlier_clusters[0], &workspace.outlier_trees[0],
-                                                              &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+                                                              workspace.outlier_scores.data(), workspace.outlier_clusters.data(), workspace.outlier_trees.data(),
+                                                              workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                               workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                               model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
                                                               workspace.prop_small_this, workspace.prior_prob,
-                                                              &workspace.buffer_cat_cnt[0], &workspace.buffer_cat_sum[0],
-                                                              &workspace.buffer_crosstab[0], &workspace.buffer_subset_outlier[0], &(workspace.drop_cluster));
+                                                              workspace.buffer_cat_cnt.data(), workspace.buffer_cat_sum.data(),
+                                                              workspace.buffer_crosstab.data(), workspace.buffer_subset_outlier.data(), &(workspace.drop_cluster));
                 workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
                 if (workspace.drop_cluster) {
                     workspace.clusters->pop_back();
@@ -1227,6 +1351,9 @@ void recursive_split_categ(Workspace &workspace,
                     workspace.tree->emplace_back(tree_from, col, HUGE_VAL, IsNa);
                     backup_recursion_state(workspace, *state_backup);
                     workspace.end = workspace.this_split_NA - 1;
+                    ExhaustedColumnsLevel level_col_tracker2;
+                    level_col_tracker2.initialize(&workspace.exhausted_col_tracker);
+                    workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric);
                     recursive_split_categ(workspace, input_data, model_params, curr_depth + 1, true);
                     restore_recursion_state(workspace, *state_backup);
                 }
@@ -1237,15 +1364,15 @@ void recursive_split_categ(Workspace &workspace,
             (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
             workspace.clusters->emplace_back(Numeric, col, LessOrEqual, workspace.this_split_point, is_NA_branch);
             workspace.has_outliers = define_categ_cluster(workspace.untransf_target_col,
-                                                          &workspace.ix_arr[0], workspace.this_split_NA, workspace.this_split_ix,
+                                                          workspace.ix_arr.data(), workspace.this_split_NA, workspace.this_split_ix,
                                                           workspace.ncat_this, model_params.categ_from_maj,
-                                                          &workspace.outlier_scores[0], &workspace.outlier_clusters[0], &workspace.outlier_trees[0],
-                                                          &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+                                                          workspace.outlier_scores.data(), workspace.outlier_clusters.data(), workspace.outlier_trees.data(),
+                                                          workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                           workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                           model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
                                                           workspace.prop_small_this, workspace.prior_prob,
-                                                          &workspace.buffer_cat_cnt[0], &workspace.buffer_cat_sum[0],
-                                                          &workspace.buffer_crosstab[0], &workspace.buffer_subset_outlier[0], &(workspace.drop_cluster));
+                                                          workspace.buffer_cat_cnt.data(), workspace.buffer_cat_sum.data(),
+                                                          workspace.buffer_crosstab.data(), workspace.buffer_subset_outlier.data(), &(workspace.drop_cluster));
             workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
             if (workspace.drop_cluster) {
                 workspace.clusters->pop_back();
@@ -1267,15 +1394,15 @@ void recursive_split_categ(Workspace &workspace,
             (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
             workspace.clusters->emplace_back(Numeric, col, Greater, workspace.this_split_point, is_NA_branch);
             workspace.has_outliers = define_categ_cluster(workspace.untransf_target_col,
-                                                          &workspace.ix_arr[0], workspace.this_split_ix + 1, workspace.end,
+                                                          workspace.ix_arr.data(), workspace.this_split_ix + 1, workspace.end,
                                                           workspace.ncat_this, model_params.categ_from_maj,
-                                                          &workspace.outlier_scores[0], &workspace.outlier_clusters[0], &workspace.outlier_trees[0],
-                                                          &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+                                                          workspace.outlier_scores.data(), workspace.outlier_clusters.data(), workspace.outlier_trees.data(),
+                                                          workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                           workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                           model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
                                                           workspace.prop_small_this, workspace.prior_prob,
-                                                          &workspace.buffer_cat_cnt[0], &workspace.buffer_cat_sum[0],
-                                                          &workspace.buffer_crosstab[0], &workspace.buffer_subset_outlier[0], &(workspace.drop_cluster));
+                                                          workspace.buffer_cat_cnt.data(), workspace.buffer_cat_sum.data(),
+                                                          workspace.buffer_crosstab.data(), workspace.buffer_subset_outlier.data(), &(workspace.drop_cluster));
             workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
             if (workspace.drop_cluster) {
                 workspace.clusters->pop_back();
@@ -1313,15 +1440,23 @@ void recursive_split_categ(Workspace &workspace,
 
         if (col == workspace.target_col_num && !workspace.target_col_is_ord) continue;
         if (input_data.skip_col[col + input_data.ncols_numeric]) continue;
+        if (workspace.exhausted_col_tracker.is_exhausted[col + input_data.ncols_numeric]) continue;
+        workspace.is_binary_split = false;
 
         if (workspace.col_is_bin) {
             
-            split_categx_biny(&workspace.ix_arr[0], workspace.st, workspace.end,
+            split_categx_biny(workspace.ix_arr.data(), workspace.st, workspace.end,
                               input_data.categorical_data + col * input_data.nrows, workspace.target_categ_col,
-                              input_data.ncat[col], workspace.base_info, &workspace.buffer_cat_cnt[0],
-                              &workspace.buffer_crosstab[0], &workspace.buffer_cat_sorted[0],
+                              input_data.ncat[col], workspace.base_info, workspace.buffer_cat_cnt.data(),
+                              workspace.buffer_crosstab.data(), workspace.buffer_cat_sorted.data(),
                               (bool)(input_data.has_NA[col + input_data.ncols_numeric]), model_params.min_size_categ,
-                              &(workspace.this_gain), &workspace.buffer_subset_categ[0]);
+                              &(workspace.this_gain), workspace.buffer_subset_categ.data(),
+                              &workspace.has_zero_variance, &workspace.is_binary_split);
+            if (workspace.has_zero_variance) {
+                workspace.has_zero_variance = false;
+                workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric);
+                continue;
+            }
 
             /* If it was forcibly binarized, need to calculate the gain on the original categories to make it comparable */
             if (
@@ -1332,29 +1467,35 @@ void recursive_split_categ(Workspace &workspace,
                     )
                 )
             {
-                divide_subset_split(&workspace.ix_arr[0], input_data.categorical_data + col * input_data.nrows,
-                                    workspace.st, workspace.end, &workspace.buffer_subset_categ[0], input_data.ncat[col],
+                divide_subset_split(workspace.ix_arr.data(), input_data.categorical_data + col * input_data.nrows,
+                                    workspace.st, workspace.end, workspace.buffer_subset_categ.data(), input_data.ncat[col],
                                     (bool)input_data.has_NA[col + input_data.ncols_numeric],
                                     &(workspace.this_split_NA), &(workspace.this_split_ix) );
-                workspace.this_gain = categ_gain_from_split(&workspace.ix_arr[0], workspace.untransf_target_col, workspace.st,
+                workspace.this_gain = categ_gain_from_split(workspace.ix_arr.data(), workspace.untransf_target_col, workspace.st,
                                                             workspace.this_split_NA, workspace.this_split_ix, workspace.end,
-                                                            workspace.ncat_this, &workspace.buffer_cat_cnt[0], workspace.base_info_orig);
+                                                            workspace.ncat_this, workspace.buffer_cat_cnt.data(), workspace.base_info_orig);
             }
 
         } else {
 
             if (model_params.cat_bruteforce_subset && input_data.ncat[col] > 2) {
-                split_categx_categy_subset(&workspace.ix_arr[0], workspace.st, workspace.end,
+                split_categx_categy_subset(workspace.ix_arr.data(), workspace.st, workspace.end,
                                            input_data.categorical_data + col * input_data.nrows, workspace.target_categ_col,
                                            input_data.ncat[col], workspace.ncat_this, workspace.base_info_orig,
-                                           &workspace.buffer_cat_sorted[0], &workspace.buffer_crosstab[0], &workspace.buffer_cat_cnt[0],
+                                           workspace.buffer_cat_sorted.data(), workspace.buffer_crosstab.data(), workspace.buffer_cat_cnt.data(),
                                            (bool)(input_data.has_NA[col + input_data.ncols_numeric]), model_params.min_size_categ,
-                                           &(workspace.this_gain), &workspace.buffer_subset_categ[0]);
+                                           &(workspace.this_gain), workspace.buffer_subset_categ.data(),
+                                           &workspace.has_zero_variance, &workspace.is_binary_split);
+                if (workspace.has_zero_variance) {
+                    workspace.has_zero_variance = false;
+                    workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric);
+                    continue;
+                }
             } else {
-                split_categx_categy_separate(&workspace.ix_arr[0], workspace.st, workspace.end,
+                split_categx_categy_separate(workspace.ix_arr.data(), workspace.st, workspace.end,
                                              input_data.categorical_data + col * input_data.nrows, workspace.target_categ_col,
                                              input_data.ncat[col], workspace.ncat_this, workspace.base_info_orig,
-                                             &workspace.buffer_cat_cnt[0], &workspace.buffer_crosstab[0],
+                                             workspace.buffer_cat_cnt.data(), workspace.buffer_crosstab.data(),
                                              (bool)(input_data.has_NA[col + input_data.ncols_numeric]),
                                              model_params.min_size_categ, &(workspace.this_gain));
             }
@@ -1365,21 +1506,21 @@ void recursive_split_categ(Workspace &workspace,
         if (workspace.this_gain >= model_params.min_gain) {
             
             /* NA branch */
-            workspace.this_split_NA = move_NAs_to_front(&workspace.ix_arr[0], input_data.categorical_data + col * input_data.nrows, workspace.st, workspace.end);
+            workspace.this_split_NA = move_NAs_to_front(workspace.ix_arr.data(), input_data.categorical_data + col * input_data.nrows, workspace.st, workspace.end);
             if ((workspace.this_split_NA - workspace.st) > model_params.min_size_categ) {
 
                 (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
-                workspace.clusters->emplace_back(Categorical, col, IsNa, (char*)NULL, (int)0, true);
+                workspace.clusters->emplace_back(Categorical, col, IsNa, (signed char*)NULL, (int)0, true);
                 workspace.has_outliers = define_categ_cluster(workspace.untransf_target_col,
-                                                              &workspace.ix_arr[0], workspace.st, workspace.this_split_NA - 1,
+                                                              workspace.ix_arr.data(), workspace.st, workspace.this_split_NA - 1,
                                                               workspace.ncat_this, model_params.categ_from_maj,
-                                                              &workspace.outlier_scores[0], &workspace.outlier_clusters[0], &workspace.outlier_trees[0],
-                                                              &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+                                                              workspace.outlier_scores.data(), workspace.outlier_clusters.data(), workspace.outlier_trees.data(),
+                                                              workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                               workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                               model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
                                                               workspace.prop_small_this, workspace.prior_prob,
-                                                              &workspace.buffer_cat_cnt[0], &workspace.buffer_cat_sum[0],
-                                                              &workspace.buffer_crosstab[0], &workspace.buffer_subset_outlier[0], &(workspace.drop_cluster));
+                                                              workspace.buffer_cat_cnt.data(), workspace.buffer_cat_sum.data(),
+                                                              workspace.buffer_crosstab.data(), workspace.buffer_subset_outlier.data(), &(workspace.drop_cluster));
                 workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
                 if (workspace.drop_cluster) {
                     workspace.clusters->pop_back();
@@ -1388,9 +1529,12 @@ void recursive_split_categ(Workspace &workspace,
 
                 if (model_params.follow_all && ((curr_depth + 1) < model_params.max_depth)) {
                     (*workspace.tree)[tree_from].all_branches.push_back(workspace.tree->size());
-                    workspace.tree->emplace_back(tree_from, col, IsNa, (char*)NULL, 0);
+                    workspace.tree->emplace_back(tree_from, col, IsNa, (signed char*)NULL, 0);
                     backup_recursion_state(workspace, *state_backup);
                     workspace.end = workspace.this_split_NA - 1;
+                    ExhaustedColumnsLevel level_col_tracker2;
+                    level_col_tracker2.initialize(&workspace.exhausted_col_tracker);
+                    workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric);
                     recursive_split_categ(workspace, input_data, model_params, curr_depth + 1, true);
                     restore_recursion_state(workspace, *state_backup);
                 }
@@ -1401,7 +1545,7 @@ void recursive_split_categ(Workspace &workspace,
 
                 /* sort by the splitting variable and iterate over to determine the split points */
                 workspace.temp_ptr_x = input_data.categorical_data + col * input_data.nrows;
-                std::sort(&workspace.ix_arr[0] + workspace.this_split_NA, &workspace.ix_arr[0] + workspace.end + 1,
+                std::sort(workspace.ix_arr.data() + workspace.this_split_NA, workspace.ix_arr.data() + workspace.end + 1,
                           [&workspace](const size_t a, const size_t b){return workspace.temp_ptr_x[a] < workspace.temp_ptr_x[b];});
                 workspace.this_split_ix = workspace.this_split_NA;
 
@@ -1416,15 +1560,15 @@ void recursive_split_categ(Workspace &workspace,
                             (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
                             workspace.clusters->emplace_back(col, workspace.temp_ptr_x[workspace.ix_arr[row-1]], input_data.ncat[col], is_NA_branch);
                             workspace.has_outliers = define_categ_cluster(workspace.untransf_target_col,
-                                                                          &workspace.ix_arr[0], workspace.this_split_ix, row - 1,
+                                                                          workspace.ix_arr.data(), workspace.this_split_ix, row - 1,
                                                                           workspace.ncat_this, model_params.categ_from_maj,
-                                                                          &workspace.outlier_scores[0], &workspace.outlier_clusters[0], &workspace.outlier_trees[0],
-                                                                          &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+                                                                          workspace.outlier_scores.data(), workspace.outlier_clusters.data(), workspace.outlier_trees.data(),
+                                                                          workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                                           workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                                           model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
                                                                           workspace.prop_small_this, workspace.prior_prob,
-                                                                          &workspace.buffer_cat_cnt[0], &workspace.buffer_cat_sum[0],
-                                                                          &workspace.buffer_crosstab[0], &workspace.buffer_subset_outlier[0], &(workspace.drop_cluster));
+                                                                          workspace.buffer_cat_cnt.data(), workspace.buffer_cat_sum.data(),
+                                                                          workspace.buffer_crosstab.data(), workspace.buffer_subset_outlier.data(), &(workspace.drop_cluster));
                             workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
                             if (workspace.drop_cluster) {
                                 workspace.clusters->pop_back();
@@ -1436,6 +1580,9 @@ void recursive_split_categ(Workspace &workspace,
                                 backup_recursion_state(workspace, *state_backup);
                                 workspace.st = workspace.this_split_ix;
                                 workspace.end = row - 1;
+                                ExhaustedColumnsLevel level_col_tracker2;
+                                level_col_tracker2.initialize(&workspace.exhausted_col_tracker);
+                                workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric);
                                 recursive_split_categ(workspace, input_data, model_params, curr_depth + 1, is_NA_branch);
                                 restore_recursion_state(workspace, *state_backup);
                             }
@@ -1448,15 +1595,15 @@ void recursive_split_categ(Workspace &workspace,
                     (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
                     workspace.clusters->emplace_back(col, workspace.temp_ptr_x[workspace.ix_arr[workspace.end]], input_data.ncat[col], is_NA_branch);
                     workspace.has_outliers = define_categ_cluster(workspace.untransf_target_col,
-                                                                  &workspace.ix_arr[0], workspace.this_split_ix, workspace.end,
+                                                                  workspace.ix_arr.data(), workspace.this_split_ix, workspace.end,
                                                                   workspace.ncat_this, model_params.categ_from_maj,
-                                                                  &workspace.outlier_scores[0], &workspace.outlier_clusters[0], &workspace.outlier_trees[0],
-                                                                  &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+                                                                  workspace.outlier_scores.data(), workspace.outlier_clusters.data(), workspace.outlier_trees.data(),
+                                                                  workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                                   workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                                   model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
                                                                   workspace.prop_small_this, workspace.prior_prob,
-                                                                  &workspace.buffer_cat_cnt[0], &workspace.buffer_cat_sum[0],
-                                                                  &workspace.buffer_crosstab[0], &workspace.buffer_subset_outlier[0], &(workspace.drop_cluster));
+                                                                  workspace.buffer_cat_cnt.data(), workspace.buffer_cat_sum.data(),
+                                                                  workspace.buffer_crosstab.data(), workspace.buffer_subset_outlier.data(), &(workspace.drop_cluster));
                     workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
                     if (workspace.drop_cluster) {
                         workspace.clusters->pop_back();
@@ -1467,6 +1614,9 @@ void recursive_split_categ(Workspace &workspace,
                         workspace.tree->emplace_back(tree_from, col, workspace.temp_ptr_x[workspace.ix_arr[workspace.end]]);
                         backup_recursion_state(workspace, *state_backup);
                         workspace.st = workspace.this_split_ix;
+                        ExhaustedColumnsLevel level_col_tracker2;
+                        level_col_tracker2.initialize(&workspace.exhausted_col_tracker);
+                        workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric);
                         recursive_split_categ(workspace, input_data, model_params, curr_depth + 1, is_NA_branch);
                         restore_recursion_state(workspace, *state_backup);
                     }
@@ -1477,6 +1627,7 @@ void recursive_split_categ(Workspace &workspace,
                     workspace.best_gain = workspace.this_gain;
                     workspace.column_type_best = Categorical;
                     workspace.col_best = col;
+                    workspace.best_cat_split_is_binary = false;
                 }
 
 
@@ -1488,7 +1639,7 @@ void recursive_split_categ(Workspace &workspace,
 
                     workspace.buffer_subset_categ[0] = 1;
                     workspace.buffer_subset_categ[1] = 0;
-                    divide_subset_split(&workspace.ix_arr[0], input_data.categorical_data + col * input_data.nrows, workspace.this_split_NA, workspace.end,
+                    divide_subset_split(workspace.ix_arr.data(), input_data.categorical_data + col * input_data.nrows, workspace.this_split_NA, workspace.end,
                                         (int)0, false, &(workspace.this_split_NA), &(workspace.this_split_ix));
                     if (
                         (workspace.end - workspace.this_split_ix) < model_params.min_size_categ ||
@@ -1497,24 +1648,24 @@ void recursive_split_categ(Workspace &workspace,
 
                 } else {
 
-                    divide_subset_split(&workspace.ix_arr[0], input_data.categorical_data + col * input_data.nrows, workspace.this_split_NA, workspace.end,
-                                        &workspace.buffer_subset_categ[0], input_data.ncat[col], false,
+                    divide_subset_split(workspace.ix_arr.data(), input_data.categorical_data + col * input_data.nrows, workspace.this_split_NA, workspace.end,
+                                        workspace.buffer_subset_categ.data(), input_data.ncat[col], false,
                                         &(workspace.this_split_NA), &(workspace.this_split_ix));
                 }
 
                 /* left branch */
                 (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
-                workspace.clusters->emplace_back(Categorical, col, InSubset, &workspace.buffer_subset_categ[0], input_data.ncat[col], is_NA_branch);
+                workspace.clusters->emplace_back(Categorical, col, InSubset, workspace.buffer_subset_categ.data(), input_data.ncat[col], is_NA_branch);
                 workspace.has_outliers = define_categ_cluster(workspace.untransf_target_col,
-                                                              &workspace.ix_arr[0], workspace.this_split_NA, workspace.this_split_ix - 1,
+                                                              workspace.ix_arr.data(), workspace.this_split_NA, workspace.this_split_ix - 1,
                                                               workspace.ncat_this, model_params.categ_from_maj,
-                                                              &workspace.outlier_scores[0], &workspace.outlier_clusters[0], &workspace.outlier_trees[0],
-                                                              &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+                                                              workspace.outlier_scores.data(), workspace.outlier_clusters.data(), workspace.outlier_trees.data(),
+                                                              workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                               workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                               model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
                                                               workspace.prop_small_this, workspace.prior_prob,
-                                                              &workspace.buffer_cat_cnt[0], &workspace.buffer_cat_sum[0],
-                                                              &workspace.buffer_crosstab[0], &workspace.buffer_subset_outlier[0], &(workspace.drop_cluster));
+                                                              workspace.buffer_cat_cnt.data(), workspace.buffer_cat_sum.data(),
+                                                              workspace.buffer_crosstab.data(), workspace.buffer_subset_outlier.data(), &(workspace.drop_cluster));
                 workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
                 if (workspace.drop_cluster) {
                     workspace.clusters->pop_back();
@@ -1523,27 +1674,32 @@ void recursive_split_categ(Workspace &workspace,
 
                 if (model_params.follow_all && ((curr_depth + 1) < model_params.max_depth)) {
                     (*workspace.tree)[tree_from].all_branches.push_back(workspace.tree->size());
-                    workspace.tree->emplace_back(tree_from, col, InSubset, &workspace.buffer_subset_categ[0], input_data.ncat[col]);
+                    workspace.tree->emplace_back(tree_from, col, InSubset, workspace.buffer_subset_categ.data(), input_data.ncat[col]);
                     backup_recursion_state(workspace, *state_backup);
                     workspace.st = workspace.this_split_NA;
                     workspace.end = workspace.this_split_ix - 1;
+                    ExhaustedColumnsLevel level_col_tracker2;
+                    if (input_data.ncat[col] == 2 || workspace.is_binary_split) {
+                        level_col_tracker2.initialize(&workspace.exhausted_col_tracker);
+                        workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric);
+                    }
                     recursive_split_categ(workspace, input_data, model_params, curr_depth + 1, is_NA_branch);
                     restore_recursion_state(workspace, *state_backup);
                 }
 
                 /* right branch */
                 (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
-                workspace.clusters->emplace_back(Categorical, col, NotInSubset, &workspace.buffer_subset_categ[0], input_data.ncat[col], is_NA_branch);
+                workspace.clusters->emplace_back(Categorical, col, NotInSubset, workspace.buffer_subset_categ.data(), input_data.ncat[col], is_NA_branch);
                 workspace.has_outliers = define_categ_cluster(workspace.untransf_target_col,
-                                                              &workspace.ix_arr[0], workspace.this_split_ix, workspace.end,
+                                                              workspace.ix_arr.data(), workspace.this_split_ix, workspace.end,
                                                               workspace.ncat_this, model_params.categ_from_maj,
-                                                              &workspace.outlier_scores[0], &workspace.outlier_clusters[0], &workspace.outlier_trees[0],
-                                                              &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+                                                              workspace.outlier_scores.data(), workspace.outlier_clusters.data(), workspace.outlier_trees.data(),
+                                                              workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                               workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                               model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
                                                               workspace.prop_small_this, workspace.prior_prob,
-                                                              &workspace.buffer_cat_cnt[0], &workspace.buffer_cat_sum[0],
-                                                              &workspace.buffer_crosstab[0], &workspace.buffer_subset_outlier[0], &(workspace.drop_cluster));
+                                                              workspace.buffer_cat_cnt.data(), workspace.buffer_cat_sum.data(),
+                                                              workspace.buffer_crosstab.data(), workspace.buffer_subset_outlier.data(), &(workspace.drop_cluster));
                 workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
                 if (workspace.drop_cluster) {
                     workspace.clusters->pop_back();
@@ -1552,9 +1708,14 @@ void recursive_split_categ(Workspace &workspace,
 
                 if (model_params.follow_all && ((curr_depth + 1) < model_params.max_depth)) {
                     (*workspace.tree)[tree_from].all_branches.push_back(workspace.tree->size());
-                    workspace.tree->emplace_back(tree_from, col, NotInSubset, &workspace.buffer_subset_categ[0], input_data.ncat[col]);
+                    workspace.tree->emplace_back(tree_from, col, NotInSubset, workspace.buffer_subset_categ.data(), input_data.ncat[col]);
                     backup_recursion_state(workspace, *state_backup);
                     workspace.st = workspace.this_split_ix;
+                    ExhaustedColumnsLevel level_col_tracker2;
+                    if (input_data.ncat[col] == 2 || workspace.is_binary_split) {
+                        level_col_tracker2.initialize(&workspace.exhausted_col_tracker);
+                        workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric);
+                    }
                     recursive_split_categ(workspace, input_data, model_params, curr_depth + 1, is_NA_branch);
                     restore_recursion_state(workspace, *state_backup);
                 }
@@ -1563,7 +1724,8 @@ void recursive_split_categ(Workspace &workspace,
                     workspace.best_gain = workspace.this_gain;
                     workspace.column_type_best = Categorical;
                     workspace.col_best = col;
-                    memcpy(&workspace.buffer_subset_categ_best[0], &workspace.buffer_subset_categ[0], input_data.ncat[col] * sizeof(char));
+                    workspace.best_cat_split_is_binary = workspace.is_binary_split;
+                    memcpy(workspace.buffer_subset_categ_best.data(), workspace.buffer_subset_categ.data(), input_data.ncat[col] * sizeof(signed char));
                 }
 
             }
@@ -1579,18 +1741,25 @@ void recursive_split_categ(Workspace &workspace,
         if (curr_depth == 0 && workspace.col_is_bin && workspace.ncat_this > 2 && workspace.already_split_main) break;
         if (input_data.skip_col[col + input_data.ncols_numeric + input_data.ncols_categ]) continue;
         if (workspace.target_col_is_ord && col == (workspace.target_col_num - input_data.ncols_categ)) continue;
+        if (workspace.exhausted_col_tracker.is_exhausted[col + input_data.ncols_numeric + input_data.ncols_categ]) continue;
 
-        split_ordx_categy(&workspace.ix_arr[0], workspace.st, workspace.end,
+        split_ordx_categy(workspace.ix_arr.data(), workspace.st, workspace.end,
                           input_data.ordinal_data + col * input_data.nrows, workspace.untransf_target_col,
                           input_data.ncat_ord[col], workspace.ncat_this,
-                          workspace.base_info_orig, &workspace.buffer_cat_cnt[0], &workspace.buffer_crosstab[0], &workspace.buffer_cat_sorted[0],
+                          workspace.base_info_orig, workspace.buffer_cat_cnt.data(), workspace.buffer_crosstab.data(), workspace.buffer_cat_sorted.data(),
                           (bool)(input_data.has_NA[col + input_data.ncols_numeric + input_data.ncols_categ]),
-                          model_params.min_size_categ, &(workspace.this_gain), &(workspace.this_split_lev));
+                          model_params.min_size_categ, &(workspace.this_gain), &(workspace.this_split_lev),
+                          &workspace.has_zero_variance, &workspace.is_binary_split);
+        if (workspace.has_zero_variance) {
+            workspace.has_zero_variance = false;
+            workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric + input_data.ncols_categ);
+            continue;
+        }
         if (model_params.gain_as_pct) workspace.this_gain /= workspace.base_info_orig;
 
         if (workspace.this_gain >= model_params.min_gain) {
 
-            divide_subset_split(&workspace.ix_arr[0], input_data.ordinal_data + col * input_data.nrows, workspace.st, workspace.end,
+            divide_subset_split(workspace.ix_arr.data(), input_data.ordinal_data + col * input_data.nrows, workspace.st, workspace.end,
                                 workspace.this_split_lev, (bool)(workspace.buffer_cat_cnt[ input_data.ncat_ord[col] ] > 0),
                                 &(workspace.this_split_NA), &(workspace.this_split_ix) );
 
@@ -1600,15 +1769,15 @@ void recursive_split_categ(Workspace &workspace,
                 (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
                 workspace.clusters->emplace_back(Ordinal, col, IsNa, (int)0, true);
                 workspace.has_outliers = define_categ_cluster(workspace.untransf_target_col,
-                                                              &workspace.ix_arr[0], workspace.st, workspace.this_split_NA - 1,
+                                                              workspace.ix_arr.data(), workspace.st, workspace.this_split_NA - 1,
                                                               workspace.ncat_this, model_params.categ_from_maj,
-                                                              &workspace.outlier_scores[0], &workspace.outlier_clusters[0], &workspace.outlier_trees[0],
-                                                              &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+                                                              workspace.outlier_scores.data(), workspace.outlier_clusters.data(), workspace.outlier_trees.data(),
+                                                              workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                               workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                               model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
                                                               workspace.prop_small_this, workspace.prior_prob,
-                                                              &workspace.buffer_cat_cnt[0], &workspace.buffer_cat_sum[0],
-                                                              &workspace.buffer_crosstab[0], &workspace.buffer_subset_outlier[0], &(workspace.drop_cluster));
+                                                              workspace.buffer_cat_cnt.data(), workspace.buffer_cat_sum.data(),
+                                                              workspace.buffer_crosstab.data(), workspace.buffer_subset_outlier.data(), &(workspace.drop_cluster));
                 workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
                 if (workspace.drop_cluster) {
                     workspace.clusters->pop_back();
@@ -1620,6 +1789,9 @@ void recursive_split_categ(Workspace &workspace,
                     workspace.tree->emplace_back(tree_from, col, (int)-1, IsNa);
                     backup_recursion_state(workspace, *state_backup);
                     workspace.end = workspace.this_split_NA - 1;
+                    ExhaustedColumnsLevel level_col_tracker2;
+                    level_col_tracker2.initialize(&workspace.exhausted_col_tracker);
+                    workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric + input_data.ncols_categ);
                     recursive_split_categ(workspace, input_data, model_params, curr_depth + 1, true);
                     restore_recursion_state(workspace, *state_backup);
                 }
@@ -1630,15 +1802,15 @@ void recursive_split_categ(Workspace &workspace,
             (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
             workspace.clusters->emplace_back(Ordinal, col, LessOrEqual, workspace.this_split_lev, is_NA_branch);
             workspace.has_outliers = define_categ_cluster(workspace.untransf_target_col,
-                                                          &workspace.ix_arr[0], workspace.this_split_NA, workspace.this_split_ix - 1,
+                                                          workspace.ix_arr.data(), workspace.this_split_NA, workspace.this_split_ix - 1,
                                                           workspace.ncat_this, model_params.categ_from_maj,
-                                                          &workspace.outlier_scores[0], &workspace.outlier_clusters[0], &workspace.outlier_trees[0],
-                                                          &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+                                                          workspace.outlier_scores.data(), workspace.outlier_clusters.data(), workspace.outlier_trees.data(),
+                                                          workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                           workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                           model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
                                                           workspace.prop_small_this, workspace.prior_prob,
-                                                          &workspace.buffer_cat_cnt[0], &workspace.buffer_cat_sum[0],
-                                                          &workspace.buffer_crosstab[0], &workspace.buffer_subset_outlier[0], &(workspace.drop_cluster));
+                                                          workspace.buffer_cat_cnt.data(), workspace.buffer_cat_sum.data(),
+                                                          workspace.buffer_crosstab.data(), workspace.buffer_subset_outlier.data(), &(workspace.drop_cluster));
             workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
             if (workspace.drop_cluster) {
                 workspace.clusters->pop_back();
@@ -1651,6 +1823,11 @@ void recursive_split_categ(Workspace &workspace,
                 backup_recursion_state(workspace, *state_backup);
                 workspace.st = workspace.this_split_NA;
                 workspace.end = workspace.this_split_ix - 1;
+                ExhaustedColumnsLevel level_col_tracker2;
+                if (workspace.is_binary_split) {
+                    level_col_tracker2.initialize(&workspace.exhausted_col_tracker);
+                    workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric + input_data.ncols_categ);
+                }
                 recursive_split_categ(workspace, input_data, model_params, curr_depth + 1, is_NA_branch);
                 restore_recursion_state(workspace, *state_backup);
             }
@@ -1659,15 +1836,15 @@ void recursive_split_categ(Workspace &workspace,
             (*workspace.tree)[tree_from].clusters.push_back(workspace.clusters->size());
             workspace.clusters->emplace_back(Ordinal, col, Greater, workspace.this_split_lev, is_NA_branch);
             workspace.has_outliers = define_categ_cluster(workspace.untransf_target_col,
-                                                          &workspace.ix_arr[0], workspace.this_split_ix, workspace.end,
+                                                          workspace.ix_arr.data(), workspace.this_split_ix, workspace.end,
                                                           workspace.ncat_this, model_params.categ_from_maj,
-                                                          &workspace.outlier_scores[0], &workspace.outlier_clusters[0], &workspace.outlier_trees[0],
-                                                          &workspace.outlier_depth[0], workspace.clusters->back(), *(workspace.clusters),
+                                                          workspace.outlier_scores.data(), workspace.outlier_clusters.data(), workspace.outlier_trees.data(),
+                                                          workspace.outlier_depth.data(), workspace.clusters->back(), *(workspace.clusters),
                                                           workspace.clusters->size() - 1, tree_from, curr_depth + 1,
                                                           model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
                                                           workspace.prop_small_this, workspace.prior_prob,
-                                                          &workspace.buffer_cat_cnt[0], &workspace.buffer_cat_sum[0],
-                                                          &workspace.buffer_crosstab[0], &workspace.buffer_subset_outlier[0], &(workspace.drop_cluster));
+                                                          workspace.buffer_cat_cnt.data(), workspace.buffer_cat_sum.data(),
+                                                          workspace.buffer_crosstab.data(), workspace.buffer_subset_outlier.data(), &(workspace.drop_cluster));
             workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
             if (workspace.drop_cluster) {
                 workspace.clusters->pop_back();
@@ -1679,6 +1856,11 @@ void recursive_split_categ(Workspace &workspace,
                 workspace.tree->emplace_back(tree_from, col, workspace.this_split_lev, Greater);
                 backup_recursion_state(workspace, *state_backup);
                 workspace.st = workspace.this_split_ix;
+                ExhaustedColumnsLevel level_col_tracker2;
+                if (workspace.is_binary_split) {
+                    level_col_tracker2.initialize(&workspace.exhausted_col_tracker);
+                    workspace.exhausted_col_tracker.push_col(col + input_data.ncols_numeric + input_data.ncols_categ);
+                }
                 recursive_split_categ(workspace, input_data, model_params, curr_depth + 1, is_NA_branch);
                 restore_recursion_state(workspace, *state_backup);
             }
@@ -1689,6 +1871,7 @@ void recursive_split_categ(Workspace &workspace,
                 workspace.column_type_best = Ordinal;
                 workspace.col_best = col;
                 workspace.split_lev_best = workspace.this_split_lev;
+                workspace.best_cat_split_is_binary = workspace.is_binary_split;
             }
 
         }
@@ -1699,7 +1882,7 @@ void recursive_split_categ(Workspace &workspace,
     /* avoid unnecessary memory usage or repeats */
     workspace.col_has_outliers = workspace.lev_has_outliers? true : workspace.col_has_outliers;
     (*workspace.tree)[tree_from].clusters.shrink_to_fit();
-    if ((*workspace.tree)[tree_from].all_branches.size() > 0) (*workspace.tree)[tree_from].all_branches.shrink_to_fit();
+    if (!(*workspace.tree)[tree_from].all_branches.empty()) (*workspace.tree)[tree_from].all_branches.shrink_to_fit();
     if (curr_depth == 0 && workspace.col_is_bin && workspace.ncat_this > 2 && !workspace.already_split_main)
         workspace.already_split_main = true;
 
@@ -1712,13 +1895,13 @@ void recursive_split_categ(Workspace &workspace,
 
         /* discard outliers if any */
         if (workspace.lev_has_outliers)
-            workspace.st = move_outliers_to_front(&workspace.ix_arr[0], &workspace.outlier_scores[0], workspace.st, workspace.end);
+            workspace.st = move_outliers_to_front(workspace.ix_arr.data(), workspace.outlier_scores.data(), workspace.st, workspace.end);
 
         /* assign rows to their corresponding branch */
         switch(workspace.column_type_best) {
             case Numeric:
             {
-                divide_subset_split(&workspace.ix_arr[0], input_data.numeric_data + workspace.col_best * input_data.nrows,
+                divide_subset_split(workspace.ix_arr.data(), input_data.numeric_data + workspace.col_best * input_data.nrows,
                                     workspace.st, workspace.end, workspace.split_point_best,
                                     (bool)(input_data.has_NA[workspace.col_best]),
                                     &(workspace.this_split_NA), &(workspace.this_split_ix) );
@@ -1729,12 +1912,14 @@ void recursive_split_categ(Workspace &workspace,
 
             case Ordinal:
             {
-                divide_subset_split(&workspace.ix_arr[0], input_data.ordinal_data + workspace.col_best * input_data.nrows,
+                divide_subset_split(workspace.ix_arr.data(), input_data.ordinal_data + workspace.col_best * input_data.nrows,
                                     workspace.st, workspace.end, workspace.split_lev_best,
                                     (bool)(input_data.has_NA[workspace.col_best + input_data.ncols_numeric + input_data.ncols_categ]),
                                     &(workspace.this_split_NA), &(workspace.this_split_ix) );
                 spl1 = LessOrEqual; spl2 = Greater;
                 set_tree_as_ordinal(workspace.tree->back(), workspace.split_lev_best, workspace.col_best);
+                if (input_data.ncat_ord[workspace.col_best] == 2 || workspace.best_cat_split_is_binary)
+                    workspace.exhausted_col_tracker.push_col(workspace.col_best + input_data.ncols_numeric + input_data.ncols_categ);
                 break;
             }
 
@@ -1743,27 +1928,30 @@ void recursive_split_categ(Workspace &workspace,
 
                 if (input_data.ncat[workspace.col_best] == 2) {
 
-                    divide_subset_split(&workspace.ix_arr[0], input_data.categorical_data + workspace.col_best * input_data.nrows,
+                    divide_subset_split(workspace.ix_arr.data(), input_data.categorical_data + workspace.col_best * input_data.nrows,
                                         workspace.st, workspace.end, (int)0,
                                         (bool)(input_data.has_NA[workspace.col_best + input_data.ncols_numeric]),
                                         &(workspace.this_split_NA), &(workspace.this_split_ix) );
                     spl1 = InSubset; spl2 = NotInSubset;
                     set_tree_as_categorical(workspace.tree->back(), workspace.col_best);
+                    workspace.exhausted_col_tracker.push_col(workspace.col_best + input_data.ncols_numeric);
 
                 } else if (workspace.col_is_bin || model_params.cat_bruteforce_subset) {
 
-                    divide_subset_split(&workspace.ix_arr[0], input_data.categorical_data + workspace.col_best * input_data.nrows,
-                                        workspace.st, workspace.end, &workspace.buffer_subset_categ_best[0], input_data.ncat[workspace.col_best],
+                    divide_subset_split(workspace.ix_arr.data(), input_data.categorical_data + workspace.col_best * input_data.nrows,
+                                        workspace.st, workspace.end, workspace.buffer_subset_categ_best.data(), input_data.ncat[workspace.col_best],
                                         (bool)(input_data.has_NA[workspace.col_best + input_data.ncols_numeric]),
                                         &(workspace.this_split_NA), &(workspace.this_split_ix) );
                     spl1 = InSubset; spl2 = NotInSubset;
                     set_tree_as_categorical(workspace.tree->back(), input_data.ncat[workspace.col_best],
-                                            &workspace.buffer_subset_categ_best[0], workspace.col_best);
+                                            workspace.buffer_subset_categ_best.data(), workspace.col_best);
+                    if (workspace.best_cat_split_is_binary)
+                        workspace.exhausted_col_tracker.push_col(workspace.col_best + input_data.ncols_numeric);
 
                 } else {
                     spl1 = SingleCateg;
                     workspace.temp_ptr_x = input_data.categorical_data + workspace.col_best * input_data.nrows;
-                    std::sort(&workspace.ix_arr[0] + workspace.st, &workspace.ix_arr[0] + workspace.end + 1,
+                    std::sort(workspace.ix_arr.data() + workspace.st, workspace.ix_arr.data() + workspace.end + 1,
                               [&workspace](const size_t a, const size_t b){return workspace.temp_ptr_x[a] < workspace.temp_ptr_x[b];});
                     set_tree_as_categorical(workspace.tree->back(), workspace.col_best, input_data.ncat[workspace.col_best]);
 
@@ -1773,11 +1961,15 @@ void recursive_split_categ(Workspace &workspace,
                             break;
                         }
                     }
+                    workspace.exhausted_col_tracker.push_col(workspace.col_best + input_data.ncols_numeric);
                 }
                 break;
             }
 
-
+            default:
+            {
+                unexpected_error();
+            }
         }
 
 
@@ -1871,7 +2063,7 @@ void recursive_split_categ(Workspace &workspace,
 
             if (tree_from == 0) {
                 workspace.tree->clear();
-            } else if ((*workspace.tree)[(*workspace.tree)[tree_from].parent].all_branches.size() > 0) {
+            } else if (!(*workspace.tree)[(*workspace.tree)[tree_from].parent].all_branches.empty()) {
                 (*workspace.tree)[(*workspace.tree)[tree_from].parent].all_branches.pop_back();
                 workspace.tree->pop_back();
             } else {
@@ -1925,6 +2117,11 @@ void recursive_split_categ(Workspace &workspace,
                         workspace.tree->pop_back();
                         break;
                     }
+
+                    default:
+                    {
+                        unexpected_error();
+                    }
                 }
             }
         }