isotree 0.2.2 → 0.3.0

data/vendor/isotree/src/{impute.cpp → impute.hpp}

@@ -18,11 +18,29 @@
 *     [5] https://sourceforge.net/projects/iforest/
 *     [6] https://math.stackexchange.com/questions/3388518/expected-number-of-paths-required-to-separate-elements-in-a-binary-tree
 *     [7] Quinlan, J. Ross. C4. 5: programs for machine learning. Elsevier, 2014.
-*     [8] Cortes, David. "Distance approximation using Isolation Forests." arXiv preprint arXiv:1910.12362 (2019).
-*     [9] Cortes, David. "Imputing missing values with unsupervised random trees." arXiv preprint arXiv:1911.06646 (2019).
+*     [8] Cortes, David.
+*         "Distance approximation using Isolation Forests."
+*         arXiv preprint arXiv:1910.12362 (2019).
+*     [9] Cortes, David.
+*         "Imputing missing values with unsupervised random trees."
+*         arXiv preprint arXiv:1911.06646 (2019).
+*     [10] https://math.stackexchange.com/questions/3333220/expected-average-depth-in-random-binary-tree-constructed-top-to-bottom
+*     [11] Cortes, David.
+*          "Revisiting randomized choices in isolation forests."
+*          arXiv preprint arXiv:2110.13402 (2021).
+*     [12] Guha, Sudipto, et al.
+*          "Robust random cut forest based anomaly detection on streams."
+*          International conference on machine learning. PMLR, 2016.
+*     [13] Cortes, David.
+*          "Isolation forests: looking beyond tree depth."
+*          arXiv preprint arXiv:2111.11639 (2021).
+*     [14] Ting, Kai Ming, Yue Zhu, and Zhi-Hua Zhou.
+*          "Isolation kernel and its effect on SVM"
+*          Proceedings of the 24th ACM SIGKDD
+*          International Conference on Knowledge Discovery & Data Mining. 2018.
 * 
 *     BSD 2-Clause License
-*     Copyright (c) 2020, David Cortes
+*     Copyright (c) 2019-2022, David Cortes
 *     All rights reserved.
 *     Redistribution and use in source and binary forms, with or without
 *     modification, are permitted provided that the following conditions are met:
@@ -52,18 +70,18 @@
 * Parameters
 * ==========
 * - numeric_data[nrows * ncols_numeric] (in, out)
-*       Pointer to numeric data in which missing values will be imputed. Must be ordered by columns like Fortran,
-*       not ordered by rows like C (i.e. entries 1..n contain column 0, n+1..2n column 1, etc.),
-*       and the column order must be the same as in the data that was used to fit the model.
+*       Pointer to numeric data in which missing values will be imputed. May be ordered by rows
+*       (i.e. entries 1..n contain row 0, n+1..2n row 1, etc.) - a.k.a. row-major - or by
+*       columns (i.e. entries 1..n contain column 0, n+1..2n column 1, etc.) - a.k.a. column-major
+*       (see parameter 'is_col_major').
 *       Pass NULL if there are no dense numeric columns.
 *       Can only pass one of 'numeric_data', 'Xr' + 'Xr_ind' + 'Xr_indptr'.
 *       Imputations will overwrite values in this same array.
-* - ncols_numeric
-*       Number of numeric columns in the data (whether they come in a sparse matrix or dense array).
 * - categ_data[nrows * ncols_categ]
-*       Pointer to categorical data in which missing values will be imputed. Must be ordered by columns like Fortran,
-*       not ordered by rows like C (i.e. entries 1..n contain column 0, n+1..2n column 1, etc.),
-*       and the column order must be the same as in the data that was used to fit the model.
+*       Pointer to categorical data in which missing values will be imputed. May be ordered by rows
+*       (i.e. entries 1..n contain row 0, n+1..2n row 1, etc.) - a.k.a. row-major - or by
+*       columns (i.e. entries 1..n contain column 0, n+1..2n column 1, etc.) - a.k.a. column-major
+*       (see parameter 'is_col_major').
 *       Pass NULL if there are no categorical columns.
 *       Each category should be represented as an integer, and these integers must start at zero and
 *       be in consecutive order - i.e. if category '3' is present, category '2' must have also been
@@ -71,6 +89,11 @@
 *       an encoding). Missing values should be encoded as negative numbers such as (-1). The encoding
 *       must be the same as was used in the data to which the model was fit.
 *       Imputations will overwrite values in this same array.
+* - is_col_major
+*       Whether 'numeric_data' and 'categ_data' come in column-major order, like the data to which the
+*       model was fit. If passing 'false', will assume they are in row-major order. Note that most of
+*       the functions in this library work only with column-major order, but here both are suitable
+*       and row-major is preferred. Both arrays must have the same orientation (row/column major).
 * - ncols_categ
 *       Number of categorical columns in the data.
 * - ncat[ncols_categ]
@@ -84,6 +107,7 @@
 *       Imputations will overwrite values in this same array.
 * - Xr_ind[nnz]
 *       Pointer to column indices to which each non-zero entry in 'Xr' corresponds.
+*       Must be in sorted order, otherwise results will be incorrect.
 *       Pass NULL if there are no sparse numeric columns in CSR format.
 * - Xr_indptr[nrows + 1]
 *       Pointer to row index pointers that tell at entry [row] where does row 'row'
@@ -91,6 +115,11 @@
 *       Pass NULL if there are no sparse numeric columns in CSR format.
 * - nrows
 *       Number of rows in 'numeric_data', 'Xc', 'Xr, 'categ_data'.
+* - use_long_double
+*       Whether to use 'long double' (extended precision) type for the calculations. This makes them
+*       more accurate (provided that the compiler used has wider long doubles than doubles), but
+*       slower - especially in platforms in which 'long double' is a software-emulated type (e.g.
+*       Power8 platforms).
 * - nthreads
 *       Number of parallel threads to use. Note that, the more threads, the more memory will be
 *       allocated, even if the thread does not end up being used. Ignored when not building with
@@ -107,13 +136,50 @@
 *       Pointer to fitted imputation node obects for the same trees as in 'model_outputs' or 'model_outputs_ext',
 *       as produced from function 'fit_iforest',
 */
-void impute_missing_values(double numeric_data[], int categ_data[],
-                           double Xr[], sparse_ix Xr_ind[], sparse_ix Xr_indptr[],
+template <class real_t, class sparse_ix>
+void impute_missing_values(real_t numeric_data[], int categ_data[], bool is_col_major,
+                           real_t Xr[], sparse_ix Xr_ind[], sparse_ix Xr_indptr[],
+                           size_t nrows, bool use_long_double, int nthreads,
+                           IsoForest *model_outputs, ExtIsoForest *model_outputs_ext,
+                           Imputer &imputer)
+{
+    if (use_long_double && !has_long_double()) {
+        use_long_double = false;
+        fprintf(stderr, "Passed 'use_long_double=true', but library was compiled without long double support.\n");
+    }
+    #ifndef NO_LONG_DOUBLE
+    if (likely(!use_long_double))
+    #endif
+        impute_missing_values_internal<real_t, sparse_ix, double>(
+            numeric_data, categ_data, is_col_major,
+            Xr, Xr_ind, Xr_indptr,
+            nrows, nthreads,
+            model_outputs, model_outputs_ext,
+            imputer
+        );
+    #ifndef NO_LONG_DOUBLE
+    else
+        impute_missing_values_internal<real_t, sparse_ix, long double>(
+            numeric_data, categ_data, is_col_major,
+            Xr, Xr_ind, Xr_indptr,
+            nrows, nthreads,
+            model_outputs, model_outputs_ext,
+            imputer
+        );
+    #endif
+}
+
+template <class real_t, class sparse_ix, class ldouble_safe>
+void impute_missing_values_internal(
+                           real_t numeric_data[], int categ_data[], bool is_col_major,
+                           real_t Xr[], sparse_ix Xr_ind[], sparse_ix Xr_indptr[],
                            size_t nrows, int nthreads,
                            IsoForest *model_outputs, ExtIsoForest *model_outputs_ext,
                            Imputer &imputer)
 {
-    PredictionData prediction_data = {numeric_data, categ_data, nrows,
+    PredictionData<real_t, sparse_ix>
+                   prediction_data = {numeric_data, categ_data, nrows,
+                                      is_col_major, imputer.ncols_numeric, imputer.ncols_categ,
                                       NULL, NULL, NULL,
                                       Xr, Xr_ind, Xr_indptr};
 
@@ -128,34 +194,53 @@ void impute_missing_values(double numeric_data[], int categ_data[],
     if ((size_t)nthreads > end)
         nthreads = (int)end;
     #ifdef _OPENMP
-        std::vector<ImputedData> imp_memory(nthreads);
+        std::vector<ImputedData<sparse_ix, ldouble_safe>> imp_memory(nthreads);
     #else
-        std::vector<ImputedData> imp_memory(1);
+        std::vector<ImputedData<sparse_ix, ldouble_safe>> imp_memory(1);
     #endif
 
+    bool threw_exception = false;
+    std::exception_ptr ex = NULL;
 
     if (model_outputs != NULL)
     {
         #pragma omp parallel for schedule(dynamic) num_threads(nthreads) \
-                shared(end, imp_memory, prediction_data, model_outputs, ix_arr, imputer)
-        for (size_t_for row = 0; row < end; row++)
+                shared(end, imp_memory, prediction_data, model_outputs, ix_arr, imputer, ex, threw_exception)
+        for (size_t_for row = 0; row < (decltype(row))end; row++)
         {
-            initialize_impute_calc(imp_memory[omp_get_thread_num()], prediction_data, imputer, ix_arr[row]);
-
-            for (std::vector<IsoTree> &tree : model_outputs->trees)
+            if (threw_exception) continue;
+            try
             {
-                traverse_itree(tree,
-                               *model_outputs,
-                               prediction_data,
-                               &imputer.imputer_tree[&tree - &(model_outputs->trees[0])],
-                               &imp_memory[omp_get_thread_num()],
-                               (double) 1,
-                               ix_arr[row],
-                               NULL,
-                               (size_t) 0);
+                initialize_impute_calc(imp_memory[omp_get_thread_num()], prediction_data, imputer, ix_arr[row]);
+
+                for (std::vector<IsoTree> &tree : model_outputs->trees)
+                {
+                    traverse_itree(tree,
+                                   *model_outputs,
+                                   prediction_data,
+                                   &imputer.imputer_tree[&tree - &(model_outputs->trees[0])],
+                                   &imp_memory[omp_get_thread_num()],
+                                   (double) 1,
+                                   ix_arr[row],
+                                   (sparse_ix*)NULL,
+                                   (double*)NULL,
+                                   (size_t) 0);
+                }
+
+                apply_imputation_results(prediction_data, imp_memory[omp_get_thread_num()], imputer, (size_t) ix_arr[row]);
             }
 
-            apply_imputation_results(prediction_data, imp_memory[omp_get_thread_num()], imputer, (size_t) ix_arr[row]);
+            catch(...)
+            {
+                #pragma omp critical
+                {
+                    if (!threw_exception)
+                    {
+                        threw_exception = true;
+                        ex = std::current_exception();
+                    }
+                }
+            }
 
         }
     }
@@ -164,31 +249,51 @@ void impute_missing_values(double numeric_data[], int categ_data[],
     {
         double temp;
         #pragma omp parallel for schedule(dynamic) num_threads(nthreads) \
-                shared(end, imp_memory, prediction_data, model_outputs_ext, ix_arr, imputer) \
+                shared(end, imp_memory, prediction_data, model_outputs_ext, ix_arr, imputer, ex, threw_exception) \
                 private(temp)
-        for (size_t_for row = 0; row < end; row++)
+        for (size_t_for row = 0; row < (decltype(row))end; row++)
         {
-            initialize_impute_calc(imp_memory[omp_get_thread_num()], prediction_data, imputer, ix_arr[row]);
-
-            for (std::vector<IsoHPlane> &hplane : model_outputs_ext->hplanes)
+            if (threw_exception) continue;
+            try
             {
-                traverse_hplane(hplane,
-                                *model_outputs_ext,
-                                prediction_data,
-                                temp,
-                                &imputer.imputer_tree[&hplane - &(model_outputs_ext->hplanes[0])],
-                                &imp_memory[omp_get_thread_num()],
-                                NULL,
-                                ix_arr[row]);
+                initialize_impute_calc(imp_memory[omp_get_thread_num()], prediction_data, imputer, ix_arr[row]);
+
+                for (std::vector<IsoHPlane> &hplane : model_outputs_ext->hplanes)
+                {
+                    traverse_hplane(hplane,
+                                    *model_outputs_ext,
+                                    prediction_data,
+                                    temp,
+                                    &imputer.imputer_tree[&hplane - &(model_outputs_ext->hplanes[0])],
+                                    &imp_memory[omp_get_thread_num()],
+                                    (sparse_ix*)NULL,
+                                    (double*)NULL,
+                                    ix_arr[row]);
+                }
+
+                apply_imputation_results(prediction_data, imp_memory[omp_get_thread_num()], imputer, (size_t) ix_arr[row]);
             }
 
-            apply_imputation_results(prediction_data, imp_memory[omp_get_thread_num()], imputer, (size_t) ix_arr[row]);
+            catch (...)
+            {
+                #pragma omp critical
+                {
+                    if (!threw_exception)
+                    {
+                        threw_exception = true;
+                        ex = std::current_exception();
+                    }
+                }
+            }
 
         }
     }
 
+    if (threw_exception)
+        std::rethrow_exception(ex);
 }
 
+template <class InputData, class ldouble_safe>
 void initialize_imputer(Imputer &imputer, InputData &input_data, size_t ntrees, int nthreads)
 {
     imputer.ncols_numeric  =  input_data.ncols_numeric;
@@ -212,7 +317,7 @@ void initialize_imputer(Imputer &imputer, InputData &input_data, size_t ntrees,
     if (input_data.numeric_data != NULL)
     {
         #pragma omp parallel for schedule(static) num_threads(nthreads) private(cnt, offset) shared(input_data, imputer)
-        for (size_t_for col = 0; col < input_data.ncols_numeric; col++)
+        for (size_t_for col = 0; col < (decltype(col))input_data.ncols_numeric; col++)
         {
             cnt    = input_data.nrows;
             offset = col * input_data.nrows;
@@ -222,23 +327,23 @@ void initialize_imputer(Imputer &imputer, InputData &input_data, size_t ntrees,
                                            input_data.numeric_data[row + offset] : 0;
                 cnt -= is_na_or_inf(input_data.numeric_data[row + offset]);
             }
-            imputer.col_means[col] /= (long double) cnt;
+            imputer.col_means[col] /= (ldouble_safe) cnt;
         }
     }
 
     else if (input_data.Xc_indptr != NULL)
     {
         #pragma omp parallel for schedule(dynamic) num_threads(nthreads) private(cnt) shared(input_data, imputer)
-        for (size_t_for col = 0; col < input_data.ncols_numeric; col++)
+        for (size_t_for col = 0; col < (decltype(col))input_data.ncols_numeric; col++)
         {
             cnt = input_data.nrows;
-            for (size_t ix = input_data.Xc_indptr[col]; ix < input_data.Xc_indptr[col + 1]; ix++)
+            for (auto ix = input_data.Xc_indptr[col]; ix < input_data.Xc_indptr[col + 1]; ix++)
             {
                 imputer.col_means[col] += (!is_na_or_inf(input_data.Xc[ix]))?
                                            input_data.Xc[ix] : 0;
                 cnt -= is_na_or_inf(input_data.Xc[ix]);
             }
-            imputer.col_means[col] /= (long double) cnt;
+            imputer.col_means[col] /= (ldouble_safe) cnt;
         }
     }
 
@@ -246,7 +351,7 @@ void initialize_imputer(Imputer &imputer, InputData &input_data, size_t ntrees,
     {
         std::vector<size_t> cat_counts(input_data.max_categ);
         #pragma omp parallel for schedule(static) num_threads(nthreads) firstprivate(cat_counts) private(offset) shared(input_data, imputer)
-        for (size_t_for col = 0; col < input_data.ncols_categ; col++)
+        for (size_t_for col = 0; col < (decltype(col))input_data.ncols_categ; col++)
         {
             std::fill(cat_counts.begin(), cat_counts.end(), 0);
             offset = col * input_data.nrows;
@@ -264,6 +369,7 @@ void initialize_imputer(Imputer &imputer, InputData &input_data, size_t ntrees,
 
 
 /* https://en.wikipedia.org/wiki/Kahan_summation_algorithm */
+template <class InputData, class WorkerMemory, class ldouble_safe>
 void build_impute_node(ImputeNode &imputer,    WorkerMemory &workspace,
                        InputData  &input_data, ModelParams  &model_params,
                        std::vector<ImputeNode> &imputer_tree,
@@ -274,7 +380,8 @@ void build_impute_node(ImputeNode &imputer,    WorkerMemory &workspace,
     if (!has_weights)
         wsum = (double)(workspace.end - workspace.st + 1);
     else
-        wsum = calculate_sum_weights(workspace.ix_arr, workspace.st, workspace.end, curr_depth,
+        wsum = calculate_sum_weights<ldouble_safe>(
+                                     workspace.ix_arr, workspace.st, workspace.end, curr_depth,
                                      workspace.weights_arr, workspace.weights_map);
 
     imputer.num_sum.resize(input_data.ncols_numeric, 0);
@@ -320,7 +427,7 @@ void build_impute_node(ImputeNode &imputer,    WorkerMemory &workspace,
                         if (!is_na_or_inf(xnum))
                         {
                             cnt++;
-                            imputer.num_sum[col] += (xnum - imputer.num_sum[col]) / (long double)cnt;
+                            imputer.num_sum[col] += (xnum - imputer.num_sum[col]) / (ldouble_safe)cnt;
                         }
                     }
                     imputer.num_weight[col] = (double) cnt;
@@ -349,7 +456,7 @@ void build_impute_node(ImputeNode &imputer,    WorkerMemory &workspace,
 
         else
         {
-            long double prod_sum, corr, val, diff;
+            ldouble_safe prod_sum, corr, val, diff;
             if (input_data.numeric_data != NULL)
             {
                  for (size_t col = 0; col < input_data.ncols_numeric; col++)
@@ -417,7 +524,7 @@ void build_impute_node(ImputeNode &imputer,    WorkerMemory &workspace,
                  row != ix_arr + workspace.end + 1 && curr_pos != end_col + 1 && ind_end_col >= *row;
                 )
             {
-                if (input_data.Xc_ind[curr_pos] == *row)
+                if (input_data.Xc_ind[curr_pos] == static_cast<typename std::remove_pointer<decltype(input_data.Xc_ind)>::type>(*row))
                 {
                     xnum = input_data.Xc[curr_pos];
                     if (workspace.weights_arr.size())
@@ -443,7 +550,7 @@ void build_impute_node(ImputeNode &imputer,    WorkerMemory &workspace,
 
                 else
                 {
-                    if (input_data.Xc_ind[curr_pos] > *row)
+                    if (input_data.Xc_ind[curr_pos] > static_cast<typename std::remove_pointer<decltype(input_data.Xc_ind)>::type>(*row))
                         row = std::lower_bound(row + 1, ix_arr + workspace.end + 1, input_data.Xc_ind[curr_pos]);
                     else
                         curr_pos = std::lower_bound(input_data.Xc_ind + curr_pos + 1, input_data.Xc_ind + end_col + 1, *row) - input_data.Xc_ind;
@@ -514,7 +621,10 @@ void build_impute_node(ImputeNode &imputer,    WorkerMemory &workspace,
                     {
                         for (int cat = 0; cat < input_data.ncat[col]; cat++)
                         {
-                            imputer.cat_sum[col][cat] += imputer_tree[curr_tree].cat_sum[col][cat] / imputer.cat_weight[col];
+                            imputer.cat_sum[col][cat]
+                                +=
+                            (imputer_tree[curr_tree].cat_sum[col][cat] > 0)?
+                                (imputer_tree[curr_tree].cat_sum[col][cat] / imputer.cat_weight[col]) : 0.;
                             imputer.cat_weight[col]    =  wsum / (double)(2 * look_aboves);
                         }
                         break;
@@ -544,7 +654,7 @@ void build_impute_node(ImputeNode &imputer,    WorkerMemory &workspace,
     {
         case Inverse:
         {
-            double wsum_div = wsum * sqrt(wsum);
+            double wsum_div = wsum * std::sqrt(wsum);
             for (double &w : imputer.num_weight)
                 w /= wsum_div;
 
@@ -562,6 +672,8 @@ void build_impute_node(ImputeNode &imputer,    WorkerMemory &workspace,
             break;
         }
 
+        default: {}
+
         /* TODO: maybe divide by nrows for prop */
     }
 
@@ -585,6 +697,8 @@ void build_impute_node(ImputeNode &imputer,    WorkerMemory &workspace,
                 w *= curr_depth_dbl;
             break;
         }
+
+        default: {}
     }
 
     /* now re-adjust sums */
@@ -621,7 +735,7 @@ void drop_nonterminal_imp_node(std::vector<ImputeNode>  &imputer_tree,
     {
         for (size_t tr = 0; tr < trees->size(); tr++)
         {
-            if ((*trees)[tr].score <= 0)
+            if ((*trees)[tr].tree_left != 0)
             {
                 shrink_impute_node(imputer_tree[tr]);
             }
@@ -639,7 +753,7 @@ void drop_nonterminal_imp_node(std::vector<ImputeNode>  &imputer_tree,
     {
         for (size_t tr = 0; tr < hplanes->size(); tr++)
         {
-            if ((*hplanes)[tr].score <= 0)
+            if ((*hplanes)[tr].hplane_left != 0)
             {
                 shrink_impute_node(imputer_tree[tr]);
             }
@@ -656,7 +770,8 @@ void drop_nonterminal_imp_node(std::vector<ImputeNode>  &imputer_tree,
     imputer_tree.shrink_to_fit();
 }
 
-void combine_imp_single(ImputedData &imp_addfrom, ImputedData &imp_addto)
+template <class ImputedData>
+void combine_imp_single(ImputedData &restrict imp_addfrom, ImputedData &restrict imp_addto)
 {
     size_t col;
     for (size_t ix = 0; ix < imp_addfrom.n_missing_num; ix++)
@@ -681,16 +796,17 @@ void combine_imp_single(ImputedData &imp_addfrom, ImputedData &imp_addto)
     }
 }
 
+template <class ImputedData, class WorkerMemory>
 void combine_tree_imputations(WorkerMemory &workspace,
                               std::vector<ImputedData> &impute_vec,
-                              std::unordered_map<size_t, ImputedData> &impute_map,
+                              hashed_map<size_t, ImputedData> &impute_map,
                               std::vector<char> &has_missing,
                               int nthreads)
 {
     if (workspace.impute_vec.size())
     {
         #pragma omp parallel for schedule(dynamic) num_threads(nthreads) shared(has_missing, workspace, impute_vec)
-        for (size_t_for row = 0; row < has_missing.size(); row++)
+        for (size_t_for row = 0; row < (decltype(row))has_missing.size(); row++)
             if (has_missing[row])
                 combine_imp_single(workspace.impute_vec[row], impute_vec[row]);
     }
@@ -698,13 +814,14 @@ void combine_tree_imputations(WorkerMemory &workspace,
     else if (workspace.impute_map.size())
     {
         #pragma omp parallel for schedule(dynamic) num_threads(nthreads) shared(has_missing, workspace, impute_map)
-        for (size_t_for row = 0; row < has_missing.size(); row++)
+        for (size_t_for row = 0; row < (decltype(row))has_missing.size(); row++)
             if (has_missing[row])
                 combine_imp_single(workspace.impute_map[row], impute_map[row]);
     }
 }
 
 
+template <class ImputedData>
 void add_from_impute_node(ImputeNode &imputer, ImputedData &imputed_data, double w)
 {
     size_t col;
@@ -731,6 +848,7 @@ void add_from_impute_node(ImputeNode &imputer, ImputedData &imputed_data, double
 }
 
 
+template <class InputData, class WorkerMemory>
 void add_from_impute_node(ImputeNode &imputer, WorkerMemory &workspace, InputData &input_data)
 {
     if (workspace.impute_vec.size())
@@ -794,7 +912,7 @@ void add_from_impute_node(ImputeNode &imputer, WorkerMemory &workspace, InputDat
     }
 }
 
-template <class imp_arr>
+template <class imp_arr, class InputData>
 void apply_imputation_results(imp_arr    &impute_vec,
                               Imputer    &imputer,
                               InputData  &input_data,
@@ -809,7 +927,7 @@ void apply_imputation_results(imp_arr    &impute_vec,
 
         for (size_t col = 0; col < input_data.ncols_numeric; col++)
         {
-            for (sparse_ix ix = input_data.Xc_indptr[col]; ix < input_data.Xc_indptr[col + 1]; ix++)
+            for (auto ix = input_data.Xc_indptr[col]; ix < input_data.Xc_indptr[col + 1]; ix++)
             {
                 if (is_na_or_inf(input_data.Xc[ix]))
                 {
@@ -832,7 +950,7 @@ void apply_imputation_results(imp_arr    &impute_vec,
     }
 
     #pragma omp parallel for schedule(dynamic) num_threads(nthreads) shared(input_data, impute_vec, imputer) private(col)
-    for (size_t_for row = 0; row < input_data.nrows; row++)
+    for (size_t_for row = 0; row < (decltype(row))input_data.nrows; row++)
     {
         if (input_data.has_missing[row])
         {
@@ -867,8 +985,9 @@ void apply_imputation_results(imp_arr    &impute_vec,
     }
 }
 
+template <class ImputedData, class InputData>
 void apply_imputation_results(std::vector<ImputedData> &impute_vec,
-                              std::unordered_map<size_t, ImputedData> &impute_map,
+                              hashed_map<size_t, ImputedData> &impute_map,
                               Imputer   &imputer,
                               InputData &input_data,
                               int nthreads)
@@ -880,6 +999,7 @@ void apply_imputation_results(std::vector<ImputedData> &impute_vec,
 }
 
 
+template <class PredictionData, class ImputedData>
 void apply_imputation_results(PredictionData  &prediction_data,
                               ImputedData     &imp,
                               Imputer         &imputer,
@@ -887,21 +1007,40 @@ void apply_imputation_results(PredictionData  &prediction_data,
 {
     size_t col;
     size_t pos = 0;
-    for (size_t ix = 0; ix < imp.n_missing_num; ix++)
+    if (prediction_data.is_col_major)
     {
-        col = imp.missing_num[ix];
-        if (imp.num_weight[ix] > 0 && !is_na_or_inf(imp.num_sum[ix]))
-            prediction_data.numeric_data[row + col * prediction_data.nrows]
-                =
-            imp.num_sum[ix] / imp.num_weight[ix];
-        else
-            prediction_data.numeric_data[row + col * prediction_data.nrows]
-                =
-            imputer.col_means[col];
+        for (size_t ix = 0; ix < imp.n_missing_num; ix++)
+        {
+            col = imp.missing_num[ix];
+            if (imp.num_weight[ix] > 0 && !is_na_or_inf(imp.num_sum[ix]))
+                prediction_data.numeric_data[row + col * prediction_data.nrows]
+                    =
+                imp.num_sum[ix] / imp.num_weight[ix];
+            else
+                prediction_data.numeric_data[row + col * prediction_data.nrows]
+                    =
+                imputer.col_means[col];
+        }
+    }
+
+    else
+    {
+        for (size_t ix = 0; ix < imp.n_missing_num; ix++)
+        {
+            col = imp.missing_num[ix];
+            if (imp.num_weight[ix] > 0 && !is_na_or_inf(imp.num_sum[ix]))
+                prediction_data.numeric_data[col + row * imputer.ncols_numeric]
+                    =
+                imp.num_sum[ix] / imp.num_weight[ix];
+            else
+                prediction_data.numeric_data[col + row * imputer.ncols_numeric]
+                    =
+                imputer.col_means[col];
+        }
     }
 
     if (prediction_data.Xr != NULL)
-        for (size_t ix = prediction_data.Xr_indptr[row]; ix < prediction_data.Xr_indptr[row + 1]; ix++)
+        for (auto ix = prediction_data.Xr_indptr[row]; ix < prediction_data.Xr_indptr[row + 1]; ix++)
         {
             if (is_na_or_inf(prediction_data.Xr[ix]))
             {
@@ -917,22 +1056,43 @@ void apply_imputation_results(PredictionData  &prediction_data,
             }
         }
 
-    for (size_t ix = 0; ix < imp.n_missing_cat; ix++)
+    if (prediction_data.is_col_major)
     {
-        col = imp.missing_cat[ix];
-        prediction_data.categ_data[row + col * prediction_data.nrows]
+        for (size_t ix = 0; ix < imp.n_missing_cat; ix++)
+        {
+            col = imp.missing_cat[ix];
+            prediction_data.categ_data[row + col * prediction_data.nrows]
+                        =
+            std::distance(imp.cat_sum[col].begin(),
+                          std::max_element(imp.cat_sum[col].begin(), imp.cat_sum[col].end()));
+
+            if (prediction_data.categ_data[row + col * prediction_data.nrows] == 0 && imp.cat_sum[col][0] <= 0)
+                prediction_data.categ_data[row + col * prediction_data.nrows]
                     =
-        std::distance(imp.cat_sum[col].begin(),
-                      std::max_element(imp.cat_sum[col].begin(), imp.cat_sum[col].end()));
+                imputer.col_modes[col];
+        }
+    }
 
-        if (prediction_data.categ_data[row + col * prediction_data.nrows] == 0 && imp.cat_sum[col][0] <= 0)
-            prediction_data.categ_data[row + col * prediction_data.nrows]
-                =
-            imputer.col_modes[col];
+    else
+    {
+        for (size_t ix = 0; ix < imp.n_missing_cat; ix++)
+        {
+            col = imp.missing_cat[ix];
+            prediction_data.categ_data[col + row * imputer.ncols_categ]
+                        =
+            std::distance(imp.cat_sum[col].begin(),
+                          std::max_element(imp.cat_sum[col].begin(), imp.cat_sum[col].end()));
+
+            if (prediction_data.categ_data[col + row * imputer.ncols_categ] == 0 && imp.cat_sum[col][0] <= 0)
+                prediction_data.categ_data[col + row * imputer.ncols_categ]
+                    =
+                imputer.col_modes[col];
+        }
     }
 }
 
 
+template <class ImputedData, class InputData>
 void initialize_impute_calc(ImputedData &imp, InputData &input_data, size_t row)
 {
     imp.n_missing_num = 0;
@@ -953,15 +1113,15 @@ void initialize_impute_calc(ImputedData &imp, InputData &input_data, size_t row)
     else if (input_data.Xc_indptr != NULL)
     {
         imp.missing_sp.resize(input_data.ncols_numeric);
-        sparse_ix *res;
+        decltype(input_data.Xc_indptr) res;
         for (size_t col = 0; col < input_data.ncols_numeric; col++)
         {
             res = std::lower_bound(input_data.Xc_ind + input_data.Xc_indptr[col],
                                    input_data.Xc_ind + input_data.Xc_indptr[col + 1],
-                                   (sparse_ix) row);
+                                   row);
             if (
                 res != input_data.Xc_ind + input_data.Xc_indptr[col + 1] && 
-                *res == row && 
+                *res == static_cast<typename std::remove_pointer<decltype(res)>::type>(row) && 
                 is_na_or_inf(input_data.Xc[res - input_data.Xc_ind])
                 )
             {
@@ -986,6 +1146,7 @@ void initialize_impute_calc(ImputedData &imp, InputData &input_data, size_t row)
     }
 }
 
+template <class ImputedData, class PredictionData>
 void initialize_impute_calc(ImputedData &imp, PredictionData &prediction_data, Imputer &imputer, size_t row)
 {
     imp.n_missing_num = 0;
@@ -996,9 +1157,20 @@ void initialize_impute_calc(ImputedData &imp, PredictionData &prediction_data, I
     {
         if (!imp.missing_num.size())
             imp.missing_num.resize(imputer.ncols_numeric);
-        for (size_t col = 0; col < imputer.ncols_numeric; col++)
-            if (is_na_or_inf(prediction_data.numeric_data[row + col * prediction_data.nrows]))
-                imp.missing_num[imp.n_missing_num++] = col;
+
+        if (prediction_data.is_col_major)
+        {
+            for (size_t col = 0; col < imputer.ncols_numeric; col++)
+                if (is_na_or_inf(prediction_data.numeric_data[row + col * prediction_data.nrows]))
+                    imp.missing_num[imp.n_missing_num++] = col;
+        }
+
+        else
+        {
+            for (size_t col = 0; col < imputer.ncols_numeric; col++)
+                if (is_na_or_inf(prediction_data.numeric_data[col + row * imputer.ncols_numeric]))
+                    imp.missing_num[imp.n_missing_num++] = col;
+        }
 
         if (!imp.num_sum.size())
         {
@@ -1017,7 +1189,7 @@ void initialize_impute_calc(ImputedData &imp, PredictionData &prediction_data, I
     {
         if (!imp.missing_sp.size())
             imp.missing_sp.resize(imputer.ncols_numeric);
-        for (size_t ix = prediction_data.Xr_indptr[row]; ix < prediction_data.Xr_indptr[row + 1]; ix++)
+        for (auto ix = prediction_data.Xr_indptr[row]; ix < prediction_data.Xr_indptr[row + 1]; ix++)
             if (is_na_or_inf(prediction_data.Xr[ix]))
                 imp.missing_sp[imp.n_missing_sp++] = prediction_data.Xr_ind[ix];
 
@@ -1038,10 +1210,23 @@ void initialize_impute_calc(ImputedData &imp, PredictionData &prediction_data, I
     {
         if (!imp.missing_cat.size())
             imp.missing_cat.resize(imputer.ncols_categ);
-        for (size_t col = 0; col < imputer.ncols_categ; col++)
+
+        if (prediction_data.is_col_major)
         {
-            if (prediction_data.categ_data[row + col * prediction_data.nrows] < 0)
-                imp.missing_cat[imp.n_missing_cat++] = col;
+            for (size_t col = 0; col < imputer.ncols_categ; col++)
+            {
+                if (prediction_data.categ_data[row + col * prediction_data.nrows] < 0)
+                    imp.missing_cat[imp.n_missing_cat++] = col;
+            }
+        }
+
+        else
+        {
+            for (size_t col = 0; col < imputer.ncols_categ; col++)
+            {
+                if (prediction_data.categ_data[col + row * imputer.ncols_categ] < 0)
+                    imp.missing_cat[imp.n_missing_cat++] = col;
+            }
         }
 
         if (!imp.cat_weight.size())
@@ -1063,31 +1248,35 @@ void initialize_impute_calc(ImputedData &imp, PredictionData &prediction_data, I
     }
 }
 
-ImputedData::ImputedData(InputData &input_data, size_t row)
-{
-    initialize_impute_calc(*this, input_data, row);
-}
+// template class ImputedData <class InputData>
+// ImputedData::ImputedData(InputData &input_data, size_t row)
+// {
+//     initialize_impute_calc(*this, input_data, row);
+// }
 
+template <class ImputedData, class InputData>
 void allocate_imp_vec(std::vector<ImputedData> &impute_vec, InputData &input_data, int nthreads)
 {
     impute_vec.resize(input_data.nrows);
     #pragma omp parallel for schedule(dynamic) num_threads(nthreads) shared(impute_vec, input_data)
-    for (size_t_for row = 0; row < input_data.nrows; row++)
+    for (size_t_for row = 0; row < (decltype(row))input_data.nrows; row++)
         if (input_data.has_missing[row])
             initialize_impute_calc(impute_vec[row], input_data, row);
 }
 
 
-void allocate_imp_map(std::unordered_map<size_t, ImputedData> &impute_map, InputData &input_data)
+template <class ImputedData, class InputData>
+void allocate_imp_map(hashed_map<size_t, ImputedData> &impute_map, InputData &input_data)
 {
     for (size_t row = 0; row < input_data.nrows; row++)
         if (input_data.has_missing[row])
             impute_map[row] = ImputedData(input_data, row);
 }
 
+template <class ImputedData, class InputData>
 void allocate_imp(InputData &input_data,
                   std::vector<ImputedData> &impute_vec,
-                  std::unordered_map<size_t, ImputedData> &impute_map,
+                  hashed_map<size_t, ImputedData> &impute_map,
                   int nthreads)
 {
     if (input_data.n_missing == 0)
@@ -1098,9 +1287,10 @@ void allocate_imp(InputData &input_data,
         allocate_imp_vec(impute_vec, input_data, nthreads);
 }
 
+template <class ImputedData, class InputData>
 void check_for_missing(InputData &input_data,
                        std::vector<ImputedData> &impute_vec,
-                       std::unordered_map<size_t, ImputedData> &impute_map,
+                       hashed_map<size_t, ImputedData> &impute_map,
                        int nthreads)
 {
     input_data.has_missing.assign(input_data.nrows, false);
@@ -1109,7 +1299,7 @@ void check_for_missing(InputData &input_data,
     {
         for (size_t col = 0; col < input_data.ncols_numeric; col++)
             #pragma omp parallel for schedule(static) num_threads(nthreads) shared(col, input_data)
-            for (size_t_for ix = input_data.Xc_indptr[col]; ix < input_data.Xc_indptr[col + 1]; ix++)
+            for (size_t_for ix = input_data.Xc_indptr[col]; ix < (decltype(ix))input_data.Xc_indptr[col + 1]; ix++)
                 if (is_na_or_inf(input_data.Xc[ix]))
                     input_data.has_missing[input_data.Xc_ind[ix]] = true;
             #pragma omp barrier
@@ -1118,14 +1308,17 @@ void check_for_missing(InputData &input_data,
     if (input_data.numeric_data != NULL || input_data.categ_data != NULL)
     {
         #pragma omp parallel for schedule(static) num_threads(nthreads) shared(input_data)
-        for (size_t_for row = 0; row < input_data.nrows; row++)
+        for (size_t_for row = 0; row < (decltype(row))input_data.nrows; row++)
         {
-            for (size_t col = 0; col < input_data.ncols_numeric; col++)
+            if (input_data.Xc_indptr == NULL)
             {
-                if (is_na_or_inf(input_data.numeric_data[row + col * input_data.nrows]))
+                for (size_t col = 0; col < input_data.ncols_numeric; col++)
                 {
-                    input_data.has_missing[row] = true;
-                    break;
+                    if (is_na_or_inf(input_data.numeric_data[row + col * input_data.nrows]))
+                    {
+                        input_data.has_missing[row] = true;
+                        break;
+                    }
                 }
             }
 
@@ -1145,6 +1338,7 @@ void check_for_missing(InputData &input_data,
     allocate_imp(input_data, impute_vec, impute_map, nthreads);
 }
 
+template <class PredictionData>
 size_t check_for_missing(PredictionData  &prediction_data,
                          Imputer         &imputer,
                          size_t          ix_arr[],
@@ -1153,19 +1347,38 @@ size_t check_for_missing(PredictionData  &prediction_data,
     std::vector<char> has_missing(prediction_data.nrows, false);
 
     #pragma omp parallel for schedule(static) num_threads(nthreads) shared(has_missing, prediction_data, imputer)
-    for (size_t_for row = 0; row < prediction_data.nrows; row++)
+    for (size_t_for row = 0; row < (decltype(row))prediction_data.nrows; row++)
     {
         if (prediction_data.numeric_data != NULL)
-            for (size_t col = 0; col < imputer.ncols_numeric; col++)
+        {
+            if (prediction_data.is_col_major)
             {
-                if (is_na_or_inf(prediction_data.numeric_data[row + col * prediction_data.nrows]))
+                for (size_t col = 0; col < imputer.ncols_numeric; col++)
                 {
-                    has_missing[row] = true;
-                    break;
+                    if (is_na_or_inf(prediction_data.numeric_data[row + col * prediction_data.nrows]))
+                    {
+                        has_missing[row] = true;
+                        break;
+                    }
                 }
             }
+
+            else
+            {
+                for (size_t col = 0; col < imputer.ncols_numeric; col++)
+                {
+                    if (is_na_or_inf(prediction_data.numeric_data[col + row * imputer.ncols_numeric]))
+                    {
+                        has_missing[row] = true;
+                        break;
+                    }
+                }
+            }
+        }
+
         else if (prediction_data.Xr != NULL)
-            for (size_t ix = prediction_data.Xr_indptr[row]; ix < prediction_data.Xr_indptr[row + 1]; ix++)
+        {
+            for (auto ix = prediction_data.Xr_indptr[row]; ix < prediction_data.Xr_indptr[row + 1]; ix++)
             {
                 if (is_na_or_inf(prediction_data.Xr[ix]))
                 {
@@ -1173,16 +1386,34 @@ size_t check_for_missing(PredictionData  &prediction_data,
                     break;
                 }
             }
+        }
 
         if (!has_missing[row])
-            for (size_t col = 0; col < imputer.ncols_categ; col++)
+        {
+            if (prediction_data.is_col_major)
             {
-                if (prediction_data.categ_data[row + col * prediction_data.nrows] < 0)
+                for (size_t col = 0; col < imputer.ncols_categ; col++)
                 {
-                    has_missing[row] = true;
-                    break;
+                    if (prediction_data.categ_data[row + col * prediction_data.nrows] < 0)
+                    {
+                        has_missing[row] = true;
+                        break;
+                    }
+                }
+            }
+
+            else
+            {
+                for (size_t col = 0; col < imputer.ncols_categ; col++)
+                {
+                    if (prediction_data.categ_data[col + row * imputer.ncols_categ] < 0)
+                    {
+                        has_missing[row] = true;
+                        break;
+                    }
                 }
             }
+        }
     }
 
     size_t st = 0;