outliertree 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2851b4b56b23141bc9f1ef5b3c448fb75d785ce0e7b38580113001898ce18e2e
-  data.tar.gz: 817325392325bc61f1dea1363096678fe9fd578ec6026301e173447edc522752
+  metadata.gz: 8ed2332f581bd9cf68d32fe19bdb89c58f268c6ea6feb30e34e8422595920dc3
+  data.tar.gz: d7cc844317fc023bee7d461838ae3fad3567268845013d2fc4e761f325934534
 SHA512:
-  metadata.gz: e1bc84c131959bb7260100b4aa1e345ae09330600252299084efe5d40fbff8d8d9d9aadf78c6384a0b6a158a1b3bbcdeff9de3ce71fca90ce938003125b37898
-  data.tar.gz: cad988456c492f101bc71334997217a48d6588c4e2e5feee333bc074f3b14b62557d0e64429fca787705244b701eca7d685aa17f090dad94578fce172812e5a0
+  metadata.gz: 4afaa3d661d2d225dc55d708ba8d263b0a017fe2a5388d77cb881d5765f9e9cc9ef682b52ef541b706cf00fc0cc7d3834f537a7900c30d3783df1821ef7d432e
+  data.tar.gz: 6c0feea6f531277847d84c76cbf146ca3d3821f9dd9635c8f7bf1fe592b1905f02db2d288027600310609d817d891129b510f5dad377946e735364705d0949cd

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.3.1 (2023-12-19)
+
+- Updated OutlierTree to 1.8.2
+- Fixed error with Rice 4.1
+
 ## 0.3.0 (2022-06-13)
 
 - Updated OutlierTree to 1.8.1

data/ext/outliertree/ext.cpp

@@ -30,6 +30,29 @@ namespace Rice::detail
     }
   };
 
+  template<>
+  class To_Ruby<std::vector<signed char>>
+  {
+  public:
+    VALUE convert(std::vector<signed char> const & x)
+    {
+      auto a = rb_ary_new2(x.size());
+      for (const auto& v : x) {
+        rb_ary_push(a, To_Ruby<signed char>().convert(v));
+      }
+      return a;
+    }
+  };
+
+  template<>
+  struct Type<std::vector<signed char>>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
   template<>
   struct Type<ColType>
   {

data/lib/outliertree/version.rb

@@ -1,3 +1,3 @@
 module OutlierTree
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/vendor/outliertree/README.md

@@ -58,12 +58,18 @@ Procedure is described in more detail in [Explainable outlier detection through
 # Installation
 
 * For R:
+
+**Note:** This package benefits from extra optimizations that aren't enabled by default for R packages. See [this guide](https://github.com/david-cortes/installing-optimized-libraries) for instructions on how to enable them.
+
 ```r
 install.packages("outliertree")
 ```
 
 
 * For Python:
+
+**Note:** requires C/C++ compilers configured for Python. See [this guide](https://github.com/david-cortes/installing-optimized-libraries) for instructions.
+
 ```
 pip install outliertree
 ```
@@ -77,22 +83,21 @@ pip install --no-use-pep517 outliertree
 ```
 brew install libomp
 ```
-And then reinstall this package: `pip install --force-reinstall outliertree`.
+And then reinstall this package: `pip install --upgrade --no-deps --force-reinstall outliertree`.
 
 ** *
-**IMPORTANT:** the setup script will try to add compilation flag `-march=native`. This instructs the compiler to tune the package for the CPU in which it is being installed, but the result might not be usable in other computers. If building a binary wheel of this package or putting it into a docker image which will be used in different machines, this can be overriden by manually supplying compilation `CFLAGS` and `CXXFLAGS` as environment variables with something related to architecture. For maximum compatibility (but slowest speed), assuming `x86-64` computers, it's possible to do something like this:
+**IMPORTANT:** the setup script will try to add compilation flag `-march=native`. This instructs the compiler to tune the package for the CPU in which it is being installed (by e.g. using AVX instructions if available), but the result might not be usable in other computers. If building a binary wheel of this package or putting it into a docker image which will be used in different machines, this can be overriden either by (a) defining an environment variable `DONT_SET_MARCH=1`, or by (b) manually supplying compilation `CFLAGS` as an environment variable with something related to architecture. For maximum compatibility (but slowest speed), it's possible to do something like this:
 
 ```
-export CFLAGS="-march=x86-64"
-export CXXFLAGS="-march=x86-64"
+export DONT_SET_MARCH=1
 pip install outliertree
 ```
 
-or for creating wheels:
+or, by specifying some compilation flag for architecture:
 ```
 export CFLAGS="-march=x86-64"
 export CXXFLAGS="-march=x86-64"
-python setup.py bwheel
+pip install outliertree
 ```
 ** *
 
@@ -134,7 +139,7 @@ summary(new_outliers)
 ```
 (see documentation for more examples)
 
-Example [RMarkdown](http://htmlpreview.github.io/?https://github.com/david-cortes/outliertree/blob/master/example/titanic_outliertree_r.html) using the Titanic dataset.
+Example [RMarkdown](http://htmlpreview.github.io/?https://github.com/david-cortes/outliertree/blob/master/vignettes/Explainable_Outlier_Detection_in_Titanic_dataset.html) using the Titanic dataset.
 
 
 * For Python:

data/vendor/outliertree/src/Makevars.in

@@ -1,4 +1,3 @@
-PKG_CPPFLAGS = -D_FOR_R @SUPPORTS_RESTRICT@
+PKG_CPPFLAGS = -DRCPP_USE_UNWIND_PROTECT -D_FOR_R @SUPPORTS_RESTRICT@
 PKG_CXXFLAGS = $(SHLIB_OPENMP_CXXFLAGS) @FNE_FLAG@ @FNTP_FLAG@ $(CXX_VISIBILITY)
 PKG_LIBS = $(SHLIB_OPENMP_CXXFLAGS)
-CXX_STD = CXX11

data/vendor/outliertree/src/Makevars.win

@@ -1,4 +1,3 @@
-PKG_CPPFLAGS = -D_FOR_R
+PKG_CPPFLAGS = -DRCPP_USE_UNWIND_PROTECT -D_FOR_R
 PKG_CXXFLAGS = $(SHLIB_OPENMP_CXXFLAGS) -fno-trapping-math -fno-math-errno
 PKG_LIBS = $(SHLIB_OPENMP_CXXFLAGS)
-CXX_STD = CXX11

data/vendor/outliertree/src/RcppExports.cpp

@@ -10,27 +10,6 @@ Rcpp::Rostream<true>&  Rcpp::Rcout = Rcpp::Rcpp_cout_get();
 Rcpp::Rostream<false>& Rcpp::Rcerr = Rcpp::Rcpp_cerr_get();
 #endif
 
-// deserialize_OutlierTree
-SEXP deserialize_OutlierTree(Rcpp::RawVector src, SEXP ptr_obj);
-RcppExport SEXP _outliertree_deserialize_OutlierTree(SEXP srcSEXP, SEXP ptr_objSEXP) {
-BEGIN_RCPP
-    Rcpp::RObject rcpp_result_gen;
-    Rcpp::traits::input_parameter< Rcpp::RawVector >::type src(srcSEXP);
-    Rcpp::traits::input_parameter< SEXP >::type ptr_obj(ptr_objSEXP);
-    rcpp_result_gen = Rcpp::wrap(deserialize_OutlierTree(src, ptr_obj));
-    return rcpp_result_gen;
-END_RCPP
-}
-// check_null_ptr_model
-Rcpp::LogicalVector check_null_ptr_model(SEXP ptr_model);
-RcppExport SEXP _outliertree_check_null_ptr_model(SEXP ptr_modelSEXP) {
-BEGIN_RCPP
-    Rcpp::RObject rcpp_result_gen;
-    Rcpp::traits::input_parameter< SEXP >::type ptr_model(ptr_modelSEXP);
-    rcpp_result_gen = Rcpp::wrap(check_null_ptr_model(ptr_model));
-    return rcpp_result_gen;
-END_RCPP
-}
 // fit_OutlierTree
 Rcpp::List fit_OutlierTree(Rcpp::NumericVector arr_num, size_t ncols_numeric, Rcpp::IntegerVector arr_cat, size_t ncols_categ, Rcpp::IntegerVector ncat, Rcpp::IntegerVector arr_ord, size_t ncols_ord, Rcpp::IntegerVector ncat_ord, size_t nrows, Rcpp::LogicalVector cols_ignore_r, int nthreads, bool categ_as_bin, bool ord_as_bin, bool cat_bruteforce_subset, bool categ_from_maj, bool take_mid, size_t max_depth, double max_perc_outliers, size_t min_size_numeric, size_t min_size_categ, double min_gain, bool follow_all, bool gain_as_pct, double z_norm, double z_outlier, bool return_outliers, Rcpp::ListOf<Rcpp::StringVector> cat_levels, Rcpp::ListOf<Rcpp::StringVector> ord_levels, Rcpp::StringVector colnames_num, Rcpp::StringVector colnames_cat, Rcpp::StringVector colnames_ord, Rcpp::NumericVector min_date, Rcpp::NumericVector min_ts);
 RcppExport SEXP _outliertree_fit_OutlierTree(SEXP arr_numSEXP, SEXP ncols_numericSEXP, SEXP arr_catSEXP, SEXP ncols_categSEXP, SEXP ncatSEXP, SEXP arr_ordSEXP, SEXP ncols_ordSEXP, SEXP ncat_ordSEXP, SEXP nrowsSEXP, SEXP cols_ignore_rSEXP, SEXP nthreadsSEXP, SEXP categ_as_binSEXP, SEXP ord_as_binSEXP, SEXP cat_bruteforce_subsetSEXP, SEXP categ_from_majSEXP, SEXP take_midSEXP, SEXP max_depthSEXP, SEXP max_perc_outliersSEXP, SEXP min_size_numericSEXP, SEXP min_size_categSEXP, SEXP min_gainSEXP, SEXP follow_allSEXP, SEXP gain_as_pctSEXP, SEXP z_normSEXP, SEXP z_outlierSEXP, SEXP return_outliersSEXP, SEXP cat_levelsSEXP, SEXP ord_levelsSEXP, SEXP colnames_numSEXP, SEXP colnames_catSEXP, SEXP colnames_ordSEXP, SEXP min_dateSEXP, SEXP min_tsSEXP) {
@@ -119,8 +98,6 @@ END_RCPP
 }
 
 static const R_CallMethodDef CallEntries[] = {
-    {"_outliertree_deserialize_OutlierTree", (DL_FUNC) &_outliertree_deserialize_OutlierTree, 2},
-    {"_outliertree_check_null_ptr_model", (DL_FUNC) &_outliertree_check_null_ptr_model, 1},
     {"_outliertree_fit_OutlierTree", (DL_FUNC) &_outliertree_fit_OutlierTree, 33},
     {"_outliertree_predict_OutlierTree", (DL_FUNC) &_outliertree_predict_OutlierTree, 13},
     {"_outliertree_check_few_values", (DL_FUNC) &_outliertree_check_few_values, 4},
@@ -128,7 +105,9 @@ static const R_CallMethodDef CallEntries[] = {
     {NULL, NULL, 0}
 };
 
+void init_altrepped_class(DllInfo* dll);
 RcppExport void R_init_outliertree(DllInfo *dll) {
     R_registerRoutines(dll, NULL, CallEntries, NULL, NULL);
     R_useDynamicSymbols(dll, FALSE);
+    init_altrepped_class(dll);
 }

data/vendor/outliertree/src/Rwrapper.cpp

@@ -2,8 +2,8 @@
 
 #include <Rcpp.h>
 #include <Rcpp/unwindProtect.h>
+#include <R_ext/Altrep.h>
 // [[Rcpp::plugins(cpp11)]]
-// [[Rcpp::plugins(unwindProtect)]]
 
 /* This is to serialize the model objects */
 // [[Rcpp::depends(Rcereal)]]
@@ -16,18 +16,26 @@
 /* This is the package's header */
 #include "outlier_tree.hpp"
 
+void delete_model_from_R_ptr(SEXP R_ptr)
+{
+    ModelOutputs *model = static_cast<ModelOutputs*>(R_ExternalPtrAddr(R_ptr));
+    delete model;
+    R_SetExternalPtrAddr(R_ptr, nullptr);
+    R_ClearExternalPtr(R_ptr);
+}
+
 SEXP alloc_RawVec(void *data)
 {
     size_t vec_size = *(size_t*)data;
     if (vec_size > (size_t)std::numeric_limits<R_xlen_t>::max())
         Rcpp::stop("Resulting model is too large for R to handle.");
-    return Rcpp::RawVector((R_xlen_t)vec_size);
+    return Rf_allocVector(RAWSXP, vec_size);
 }
 
 /* for model serialization and re-usage in R */
 /* https://stackoverflow.com/questions/18474292/how-to-handle-c-internal-data-structure-in-r-in-order-to-allow-save-load */
 /* this extra comment below the link is a workaround for Rcpp issue 675 in GitHub, do not remove it */
-Rcpp::RawVector serialize_OutlierTree(ModelOutputs *model_outputs)
+SEXP serialize_OutlierTree(ModelOutputs *model_outputs)
 {
     std::stringstream ss;
     {
@@ -37,35 +45,20 @@ Rcpp::RawVector serialize_OutlierTree(ModelOutputs *model_outputs)
     ss.seekg(0, ss.end);
     std::stringstream::pos_type vec_size = ss.tellg();
     if (vec_size <= 0) {
-        Rcpp::Rcerr << "Error: model is too big to serialize, resulting object will not be usable.\n" << std::endl;
-        return Rcpp::RawVector();
+        Rf_error("Error: model is too big to serialize, resulting object will not be usable.\n");
     }
     size_t vec_size_ = (size_t)vec_size;
-    Rcpp::RawVector retval = Rcpp::unwindProtect(alloc_RawVec, (void*)&vec_size_);
-    if (!retval.size())
-        return retval;
+    SEXP retval = PROTECT(Rcpp::unwindProtect(alloc_RawVec, (void*)&vec_size_));
     ss.seekg(0, ss.beg);
-    ss.read(reinterpret_cast<char*>(RAW(retval)), retval.size());
+    ss.read(reinterpret_cast<char*>(RAW(retval)), vec_size_);
+    UNPROTECT(1);
     return retval;
 }
 
-SEXP safe_XPtr(void *model_ptr)
-{
-    return Rcpp::XPtr<ModelOutputs>((ModelOutputs*)model_ptr, true);
-}
-
-void R_delete_model(SEXP R_ptr)
-{
-    ModelOutputs *model = static_cast<ModelOutputs*>(R_ExternalPtrAddr(R_ptr));
-    delete model;
-    R_ClearExternalPtr(R_ptr);
-}
-
-// [[Rcpp::export(rng = false)]]
-SEXP deserialize_OutlierTree(Rcpp::RawVector src, SEXP ptr_obj)
+SEXP deserialize_OutlierTree(SEXP src, SEXP ptr_obj)
 {
     std::stringstream ss;
-    ss.write(reinterpret_cast<char*>(RAW(src)), src.size());
+    ss.write(reinterpret_cast<char*>(RAW(src)), Rf_xlength(src));
     ss.seekg(0, ss.beg);
     std::unique_ptr<ModelOutputs> model_outputs = std::unique_ptr<ModelOutputs>(new ModelOutputs());
     {
@@ -73,25 +66,134 @@ SEXP deserialize_OutlierTree(Rcpp::RawVector src, SEXP ptr_obj)
         iarchive(*model_outputs);
     }
     R_SetExternalPtrAddr(ptr_obj, model_outputs.get());
-    R_RegisterCFinalizerEx(ptr_obj, R_delete_model, TRUE);
+    R_RegisterCFinalizerEx(ptr_obj, delete_model_from_R_ptr, TRUE);
     model_outputs.release();
     return R_NilValue;
 }
 
-SEXP safe_int(void *x)
+static R_altrep_class_t otree_altrepped_pointer_class;
+
+R_xlen_t altrepped_pointer_length(SEXP obj)
 {
-    return Rcpp::wrap(*(int*)x);
+    return 1;
 }
 
-SEXP safe_bool(void *x)
+SEXP get_element_from_altrepped_ptr(SEXP R_altrepped_obj, R_xlen_t idx)
 {
-    return Rcpp::wrap(*(bool*)x);
+    return R_altrep_data1(R_altrepped_obj);
 }
 
-// [[Rcpp::export(rng = false)]]
-Rcpp::LogicalVector check_null_ptr_model(SEXP ptr_model)
+Rboolean inspect_altrepped_pointer(SEXP x, int pre, int deep, int pvec, void (*inspect_subtree)(SEXP, int, int, int))
+{
+    Rprintf("Altrepped pointer [address:%p]\n", R_ExternalPtrAddr(R_altrep_data1(x)));
+    return TRUE;
+}
+
+SEXP duplicate_altrepped_pointer(SEXP altrepped_obj, Rboolean deep)
+{
+    SEXP R_ptr_name = PROTECT(Rf_mkString("ptr"));
+    SEXP R_ptr_class = PROTECT(Rf_mkString("otree_altrepped_handle"));
+    SEXP out = PROTECT(R_new_altrep(otree_altrepped_pointer_class, R_NilValue, R_NilValue));
+
+    if (!deep) {
+        R_set_altrep_data1(out, R_altrep_data1(altrepped_obj));
+    }
+
+    else {
+
+        SEXP R_ptr = PROTECT(R_MakeExternalPtr(nullptr, R_NilValue, R_NilValue));
+
+        try {
+            std::unique_ptr<ModelOutputs> new_obj(new ModelOutputs());
+            ModelOutputs *cpp_ptr = (ModelOutputs*)R_ExternalPtrAddr(R_altrep_data1(altrepped_obj));
+            *new_obj = *cpp_ptr;
+
+            R_SetExternalPtrAddr(R_ptr, new_obj.get());
+            R_RegisterCFinalizerEx(R_ptr, delete_model_from_R_ptr, TRUE);
+            new_obj.release();
+        }
+
+        catch (const std::exception &ex) {
+            Rf_error("%s\n", ex.what());
+        }
+
+        R_set_altrep_data1(out, R_ptr);
+        UNPROTECT(1);
+    }
+
+    Rf_setAttrib(out, R_NamesSymbol, R_ptr_name);
+    Rf_setAttrib(out, R_NamesSymbol, R_ptr_class);
+    UNPROTECT(3);
+    return out;
+}
+
+SEXP serialize_altrepped_pointer(SEXP altrepped_obj)
 {
-    return Rcpp::LogicalVector(R_ExternalPtrAddr(ptr_model) == NULL);
+    return serialize_OutlierTree((ModelOutputs*)R_ExternalPtrAddr(R_altrep_data1(altrepped_obj)));
+}
+
+SEXP deserialize_altrepped_pointer(SEXP cls, SEXP R_state)
+{
+    SEXP R_ptr_name = PROTECT(Rf_mkString("ptr"));
+    SEXP R_ptr_class = PROTECT(Rf_mkString("otree_altrepped_handle"));
+    SEXP R_ptr = PROTECT(R_MakeExternalPtr(nullptr, R_NilValue, R_NilValue));
+    SEXP out = PROTECT(R_new_altrep(otree_altrepped_pointer_class, R_NilValue, R_NilValue));
+
+    try {
+        deserialize_OutlierTree(R_state, R_ptr);
+    }
+    catch (const std::exception &ex) {
+        Rf_error("%s\n", ex.what());
+    }
+
+    R_set_altrep_data1(out, R_ptr);
+    Rf_setAttrib(out, R_NamesSymbol, R_ptr_name);
+    Rf_setAttrib(out, R_ClassSymbol, R_ptr_class);
+
+    UNPROTECT(4);
+    return out;
+}
+
+SEXP get_altrepped_pointer(void *void_ptr)
+{
+    SEXP R_ptr_name = PROTECT(Rf_mkString("ptr"));
+    SEXP R_ptr_class = PROTECT(Rf_mkString("otree_altrepped_handle"));
+    SEXP R_ptr = PROTECT(R_MakeExternalPtr(nullptr, R_NilValue, R_NilValue));
+    SEXP out = PROTECT(R_new_altrep(otree_altrepped_pointer_class, R_NilValue, R_NilValue));
+
+    std::unique_ptr<ModelOutputs> *ptr = (std::unique_ptr<ModelOutputs>*)void_ptr;
+    R_SetExternalPtrAddr(R_ptr, ptr->get());
+    R_RegisterCFinalizerEx(R_ptr, delete_model_from_R_ptr, TRUE);
+    ptr->release();
+    
+    R_set_altrep_data1(out, R_ptr);
+    Rf_setAttrib(out, R_NamesSymbol, R_ptr_name);
+    Rf_setAttrib(out, R_ClassSymbol, R_ptr_class);
+
+    UNPROTECT(4);
+    return out;
+}
+
+// [[Rcpp::init]]
+void init_altrepped_class(DllInfo* dll)
+{
+    otree_altrepped_pointer_class = R_make_altlist_class("otree_altrepped_pointer_class", "outliertree", dll);
+    R_set_altrep_Length_method(otree_altrepped_pointer_class, altrepped_pointer_length);
+    R_set_altrep_Inspect_method(otree_altrepped_pointer_class, inspect_altrepped_pointer);
+    R_set_altrep_Serialized_state_method(otree_altrepped_pointer_class, serialize_altrepped_pointer);
+    R_set_altrep_Unserialize_method(otree_altrepped_pointer_class, deserialize_altrepped_pointer);
+    R_set_altrep_Duplicate_method(otree_altrepped_pointer_class, duplicate_altrepped_pointer);
+    R_set_altlist_Elt_method(otree_altrepped_pointer_class, get_element_from_altrepped_ptr);
+}
+
+SEXP safe_int(void *x)
+{
+    return Rf_ScalarInteger(*(int*)x);
+}
+
+SEXP safe_bool(void *x)
+{
+    return Rf_ScalarLogical(*(bool*)x);
 }
 
 double* set_R_nan_as_C_nan(double *restrict x_R, std::vector<double> &x_C, size_t n, int nthreads)
@@ -264,7 +366,7 @@ Rcpp::List describe_outliers(ModelOutputs &model_outputs,
             } else if (outl_col < (ncols_num + ncols_cat)) {
                 if (outl_col < (ncols_num + ncols_cat_cat)) {
                     tmp_bool = Rcpp::LogicalVector(model_outputs.all_clusters[outl_col][outl_clust].subset_common.size(), false);
-                    for (size_t cat = 0; cat < tmp_bool.size(); cat++) {
+                    for (size_t cat = 0; cat < (size_t)tmp_bool.size(); cat++) {
                         if (model_outputs.all_clusters[outl_col][outl_clust].subset_common[cat] == 0) {
                             tmp_bool[cat] = true;
                             }
@@ -308,7 +410,7 @@ Rcpp::List describe_outliers(ModelOutputs &model_outputs,
                 }
             } else {
                 tmp_bool = Rcpp::LogicalVector(model_outputs.all_clusters[outl_col][outl_clust].subset_common.size(), false);
-                for (size_t cat = 0; cat < tmp_bool.size(); cat++) {
+                for (size_t cat = 0; cat < (size_t)tmp_bool.size(); cat++) {
                     if (model_outputs.all_clusters[outl_col][outl_clust].subset_common[cat] == 0) {
                         tmp_bool[cat] = true;
                     }
@@ -1274,7 +1376,6 @@ Rcpp::List fit_OutlierTree(Rcpp::NumericVector arr_num, size_t ncols_numeric,
 {
     Rcpp::List outp = Rcpp::List::create(
         Rcpp::_["ptr_model"] = R_NilValue,
-        Rcpp::_["serialized_obj"] = R_NilValue,
         Rcpp::_["bounds"] = R_NilValue,
         Rcpp::_["outliers_info"] = R_NilValue,
         Rcpp::_["ntrees"] = R_NilValue,
@@ -1295,7 +1396,6 @@ Rcpp::List fit_OutlierTree(Rcpp::NumericVector arr_num, size_t ncols_numeric,
     double *arr_num_C = set_R_nan_as_C_nan(REAL(arr_num), Xcpp, arr_num.size(), nthreads);
 
     std::unique_ptr<ModelOutputs> model_outputs = std::unique_ptr<ModelOutputs>(new ModelOutputs());
-    try {
     found_outliers = fit_outliers_models(*model_outputs,
                                          arr_num_C, ncols_numeric,
                                          INTEGER(arr_cat), ncols_categ, INTEGER(ncat),
@@ -1313,13 +1413,7 @@ Rcpp::List fit_OutlierTree(Rcpp::NumericVector arr_num, size_t ncols_numeric,
         &min_ts
     };
     outp["bounds"] = Rcpp::unwindProtect(extract_outl_bounds_wrapper, (void*)&temp);
-    outp["serialized_obj"] = serialize_OutlierTree(model_outputs.get());
-    } catch(std::bad_alloc &e) {
-        Rcpp::stop("Insufficient memory.\n");
-    }
 
-    if (!Rf_xlength(outp["serialized_obj"]))
-        return outp;
     if (return_outliers) {
         args_describe_outliers temp = {
             model_outputs.get(),
@@ -1350,8 +1444,7 @@ Rcpp::List fit_OutlierTree(Rcpp::NumericVector arr_num, size_t ncols_numeric,
     outp["nclust"] = Rcpp::unwindProtect(safe_int, (void*)&nclust_int);
     outp["found_outliers"] = Rcpp::unwindProtect(safe_bool, (void*)&found_outliers);
     
-    outp["ptr_model"] = Rcpp::unwindProtect(safe_XPtr, model_outputs.get());
-    model_outputs.release();
+    outp["ptr_model"] = Rcpp::unwindProtect(get_altrepped_pointer, &model_outputs);
     return outp;
 }
 

data/vendor/outliertree/src/fit_model.cpp

@@ -190,9 +190,9 @@ bool fit_outliers_models(ModelOutputs &model_outputs,
     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.data(), input_data.ncat, input_data.ncols_categ,
-                                                          (bool*) input_data.skip_col.data() + ncols_numeric);
+                                                          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);
+                                                          input_data.skip_col.data() + input_data.ncols_numeric + input_data.ncols_categ, input_data.max_categ);
     } else {
         input_data.max_categ = 0;
     }
@@ -209,42 +209,39 @@ bool fit_outliers_models(ModelOutputs &model_outputs,
 
     /* calculate prior probabilities for categorical variables (in parallel), see if any is unsplittable */
     if (tot_cols > ncols_numeric) {
-        #pragma omp parallel
+        #pragma omp parallel sections if(nthreads > 1)
         {
-            #pragma omp sections
-            {
 
-                #pragma omp section
-                {
-                    if (ncols_categ > 0) {
-                        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.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.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.data() + input_data.ncols_numeric,
-                                                   std::min(input_data.ncols_categ, (size_t)std::max(1, nthreads - 1)));
-                    }
+            #pragma omp section
+            {
+                if (ncols_categ > 0) {
+                    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,
+                                             input_data.has_NA.data() + ncols_numeric, 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.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,
+                                               input_data.skip_col.data() + input_data.ncols_numeric,
+                                               std::min(input_data.ncols_categ, (size_t)std::max(1, nthreads - 1)));
+                }
 
 
-                }
+            }
 
-                #pragma omp section
-                {
-                    if (ncols_ord > 0) {
-                        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.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.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.data() + input_data.ncols_numeric + input_data.ncols_categ,
-                                                   std::max((int)1, nthreads - (int)input_data.ncols_categ));
-                    }
+            #pragma omp section
+            {
+                if (ncols_ord > 0) {
+                    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,
+                                             input_data.has_NA.data() + input_data.ncols_numeric + input_data.ncols_categ,
+                                             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.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,
+                                               input_data.skip_col.data() + input_data.ncols_numeric + input_data.ncols_categ,
+                                               std::max((int)1, nthreads - (int)input_data.ncols_categ));
                 }
             }
 
@@ -260,13 +257,13 @@ bool fit_outliers_models(ModelOutputs &model_outputs,
 
     /* 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.data(), (bool*) input_data.skip_col.data(),
+                              input_data.has_NA.data(), 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 */
     model_outputs.all_clusters.resize(tot_cols);
     model_outputs.all_trees.resize(tot_cols);
-    #pragma omp parallel for shared(model_outputs, input_data, model_params, tot_cols)
+    #pragma omp parallel for num_threads(nthreads) shared(model_outputs, input_data, model_params, tot_cols)
     for (size_t_for col = 0; col < tot_cols; col++) {
         if (input_data.skip_col[col]) continue;
         if (cols_ignore != NULL && cols_ignore[col]) continue;

data/vendor/outliertree/src/misc.cpp

@@ -39,7 +39,7 @@
 *    at which position will the counts for a given column start. Note that NAs are stored as the last index in each
 *    column, so each one needs one extra category
 */
-int calculate_category_indices(size_t start_ix_cat_counts[], int ncat[], size_t ncols, bool skip_col[], int max_categ)
+int calculate_category_indices(size_t start_ix_cat_counts[], int ncat[], size_t ncols, char skip_col[], int max_categ)
 {
     for (size_t col = 0; col < ncols; col++) {
         max_categ = std::max(ncat[col], max_categ);
@@ -53,7 +53,7 @@ int calculate_category_indices(size_t start_ix_cat_counts[], int ncat[], size_t
 /* Save the counts of each category for each column in the array determined above */
 void calculate_all_cat_counts(size_t start_ix_cat_counts[], size_t cat_counts[], int ncat[],
                               int categorical_data[], size_t ncols, size_t nrows,
-                              bool has_NA[], bool skip_col[], int nthreads)
+                              char has_NA[], char skip_col[], int nthreads)
 {
     size_t col_st_offset;
     size_t col_stop;
@@ -80,7 +80,7 @@ void calculate_all_cat_counts(size_t start_ix_cat_counts[], size_t cat_counts[],
 
 /* Check if some column has a large majority that would make any split fail to meet minimum sizes */
 void check_cat_col_unsplittable(size_t start_ix_cat_counts[], size_t cat_counts[], int ncat[],
-                                size_t ncols, size_t min_conditioned_size, size_t nrows, bool skip_col[], int nthreads)
+                                size_t ncols, size_t min_conditioned_size, size_t nrows, char skip_col[], int nthreads)
 {
     size_t largest_cnt;
     #pragma omp parallel for num_threads(nthreads) private(largest_cnt) shared(ncols, nrows, ncat, cat_counts, start_ix_cat_counts, min_conditioned_size, skip_col)
@@ -127,8 +127,8 @@ void calculate_lowerlim_proportion(long double *restrict prop_small, long double
 
 /* Check if a numerical column has no variance (i.e. will not be splittable).
    Along the way, also record the number of decimals to display for this column. */
-void check_missing_no_variance(double numeric_data[], size_t ncols, size_t nrows, bool has_NA[],
-                               bool skip_col[], int min_decimals[], int nthreads)
+void check_missing_no_variance(double numeric_data[], size_t ncols, size_t nrows, char has_NA[],
+                               char skip_col[], int min_decimals[], int nthreads)
 {
     long double running_mean;
     long double mean_prev;
@@ -680,18 +680,6 @@ int decimals_diff(double val1, double val2)
     return (int) res;
 }
 
-
-/* Reason behind this function: Cython (as of v0.29) will not auto-deallocate
-   structs which are part of a cdef'd class, which produces a memory leak
-   but can be force-destructed. Unfortunately, Cython itself doesn't even
-   allow calling destructors for structs, so it has to be done externally.
-   This function should otherwise have no reason to exist.
-*/
-void dealloc_ModelOutputs(ModelOutputs &model_outputs)
-{
-    model_outputs.~ModelOutputs();
-}
-
 ModelOutputs get_empty_ModelOutputs()
 {
     return ModelOutputs();

data/vendor/outliertree/src/outlier_tree.hpp

@@ -802,17 +802,17 @@ typedef struct {
 } RecursionState;
 
 
-int calculate_category_indices(size_t start_ix_cat_counts[], int ncat[], size_t ncols, bool skip_col[], int max_categ = 0);
+int calculate_category_indices(size_t start_ix_cat_counts[], int ncat[], size_t ncols, char skip_col[], int max_categ = 0);
 void calculate_all_cat_counts(size_t start_ix_cat_counts[], size_t cat_counts[], int ncat[],
                               int categorical_data[], size_t ncols, size_t nrows,
-                              bool has_NA[], bool skip_col[], int nthreads);
+                              char has_NA[], char skip_col[], int nthreads);
 void check_cat_col_unsplittable(size_t start_ix_cat_counts[], size_t cat_counts[], int ncat[],
-                                size_t ncols, size_t min_conditioned_size, size_t nrows, bool skip_col[], int nthreads);
+                                size_t ncols, size_t min_conditioned_size, size_t nrows, char skip_col[], int nthreads);
 void calculate_lowerlim_proportion(long double *restrict prop_small, long double *restrict prop,
                                    size_t start_ix_cat_counts[], size_t cat_counts[],
                                    size_t ncols, size_t nrows, double z_norm, double z_tail);
-void check_missing_no_variance(double numeric_data[], size_t ncols, size_t nrows, bool has_NA[],
-                               bool skip_col[], int min_decimals[], int nthreads);
+void check_missing_no_variance(double numeric_data[], size_t ncols, size_t nrows, char has_NA[],
+                               char skip_col[], int min_decimals[], int nthreads);
 void calc_central_mean_and_sd(size_t ix_arr[], size_t st, size_t end, double x[], size_t size_quarter, double *mean_central, double *sd_central);
 void check_for_tails(size_t ix_arr[], size_t st, size_t end, double *restrict x,
                      double z_norm, double max_perc_outliers,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: outliertree
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-13 00:00:00.000000000 Z
+date: 2023-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -75,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Explainable outlier/anomaly detection for Ruby