outliertree 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2851b4b56b23141bc9f1ef5b3c448fb75d785ce0e7b38580113001898ce18e2e
-  data.tar.gz: 817325392325bc61f1dea1363096678fe9fd578ec6026301e173447edc522752
+  metadata.gz: 107a39daf1b8743880c65c0c9bd20f6b2430687a843aa3394e4f57ba38b58766
+  data.tar.gz: 81e5e13612dd119624a6ec12652b048002c0c2103ee6389709682fb6bcb27e5e
 SHA512:
-  metadata.gz: e1bc84c131959bb7260100b4aa1e345ae09330600252299084efe5d40fbff8d8d9d9aadf78c6384a0b6a158a1b3bbcdeff9de3ce71fca90ce938003125b37898
-  data.tar.gz: cad988456c492f101bc71334997217a48d6588c4e2e5feee333bc074f3b14b62557d0e64429fca787705244b701eca7d685aa17f090dad94578fce172812e5a0
+  metadata.gz: 2a8c6276389a465d548b7b06e7933e64094059960301b4393015bd906dd8deed361887876c152017bc2427fe54b81271e076de24f3e1df801f8f0c330a6c0f76
+  data.tar.gz: 27b9eb4c42adc7abf6c905ec3c787f6947aae6475ecb37283c9b00e560ebb49a8a6bd7ebacfce2c636ba289f014b6dd87821d65311cd3a8640700a4dae44464d

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 0.4.0 (2024-06-11)
+
+- Updated OutlierTree to 1.9.0
+- Dropped support for Ruby < 3.1
+
+## 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/README.md

@@ -10,7 +10,7 @@ Price (2.50) looks low given Department is Books and Sale is false
 
 :evergreen_tree: Check out [IsoTree](https://github.com/ankane/isotree-ruby) for an alternative approach that uses Isolation Forest
 
-[![Build Status](https://github.com/ankane/outliertree-ruby/workflows/build/badge.svg?branch=master)](https://github.com/ankane/outliertree-ruby/actions)
+[![Build Status](https://github.com/ankane/outliertree-ruby/actions/workflows/build.yml/badge.svg)](https://github.com/ankane/outliertree-ruby/actions)
 
 ## Installation
 

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.4.0"
 end

data/lib/outliertree.rb

@@ -5,10 +5,10 @@ require "outliertree/ext"
 require "etc"
 
 # modules
-require "outliertree/dataset"
-require "outliertree/model"
-require "outliertree/result"
-require "outliertree/version"
+require_relative "outliertree/dataset"
+require_relative "outliertree/model"
+require_relative "outliertree/result"
+require_relative "outliertree/version"
 
 module OutlierTree
   def self.new(**options)

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/clusters.cpp

@@ -11,7 +11,7 @@
 *      arXiv preprint arXiv:2001.00636 (2020).
 *    
 *    
-*    Copyright 2020 David Cortes.
+*    Copyright 2020-2024 David Cortes.
 *    
 *    Written for C++11 standard and OpenMP 2.0 or later. Code is meant to be wrapped into scripting languages
 *    such as R or Python.
@@ -97,6 +97,10 @@
 *        Model parameter. Default is 2.67.
 *    - z_outlier (in)
 *        Model parameter. Default is 8.0. Must be greater than z_norm.
+*    - check_nonneg_outliers (in)
+*        Whether to add an extra check for possible outliers defined as having negative values while all
+*        the rest have positive values, regardless of how many standard deviations away they are.
+*        This is currently only done on the first cluster (no conditions on any variable).
 *    
 *    Returns:
 *        - Whether there were any outliers detected.
@@ -107,7 +111,8 @@ bool define_numerical_cluster(double *restrict x, size_t *restrict ix_arr, size_
                               size_t cluster_num, size_t tree_num, size_t tree_depth,
                               bool is_log_transf, double log_minval, bool is_exp_transf, double orig_mean, double orig_sd,
                               double left_tail, double right_tail, double *restrict orig_x,
-                              double max_perc_outliers, double z_norm, double z_outlier)
+                              double max_perc_outliers, double z_norm, double z_outlier,
+                              bool check_nonneg_outliers)
 {
 
     /*  TODO: this function could try to determine if the distribution is multimodal, and if so,
@@ -120,6 +125,7 @@ bool define_numerical_cluster(double *restrict x, size_t *restrict ix_arr, size_
     /* NAs and Inf should have already been removed, and outliers with fewer conditionals already discarded */
     bool has_low_values  = false;
     bool has_high_values = false;
+    bool has_outlier_neg_values = false;
     long double running_mean = 0;
     long double running_ssq  = 0;
     long double mean_prev    = 0;
@@ -127,14 +133,15 @@ bool define_numerical_cluster(double *restrict x, size_t *restrict ix_arr, size_
     double mean;
     double sd;
     size_t cnt;
-    size_t tail_size     = (size_t) calculate_max_outliers((long double)(end - st + 1), max_perc_outliers);
+    size_t tot           = end - st + 1;
+    size_t tail_size     = (size_t) calculate_max_outliers((long double)tot, max_perc_outliers);
     size_t st_non_tail   = st  + tail_size;
     size_t end_non_tail  = end - tail_size;
     size_t st_normals    = 0;
     size_t end_normals   = 0;
     double min_gap = z_outlier - z_norm;
 
-    double curr_gap, next_gap, eps, lim_by_orig;
+    double curr_gap, next_gap, lim_by_orig;
 
     /* Note: there is no good reason and no theory behind these numbers.
        TODO: find a better way of setting this */
@@ -166,9 +173,8 @@ bool define_numerical_cluster(double *restrict x, size_t *restrict ix_arr, size_
     if ((!isinf(left_tail) || !isinf(right_tail)) && !is_log_transf && !is_exp_transf) {
         sd *= 0.5;
     }
-    sd = std::fmax(sd, 1e-15);
     while (std::numeric_limits<double>::epsilon() > sd*std::fmin(min_gap, z_norm))
-        sd *= 4;
+        sd = std::nextafter(sd, std::numeric_limits<double>::infinity());
     cluster.cluster_mean = mean;
     cluster.cluster_sd = sd;
     cnt = end - st + 1;
@@ -212,10 +218,8 @@ bool define_numerical_cluster(double *restrict x, size_t *restrict ix_arr, size_
                 cluster.display_lim_low = orig_x[ix_arr[row + 1]];
                 cluster.perc_above = (long double)(end - st_normals + 1) / (long double)(end - st + 1);
 
-                eps = 1e-15;
                 while (cluster.display_lim_low <= cluster.lower_lim) {
-                    cluster.lower_lim -= eps;
-                    eps *= 4;
+                    cluster.lower_lim = std::nextafter(cluster.lower_lim, -std::numeric_limits<double>::infinity());
                 }
                 break;
             }
@@ -225,6 +229,7 @@ bool define_numerical_cluster(double *restrict x, size_t *restrict ix_arr, size_
         if (st_normals == 0) {
             has_low_values = false;
         } else {
+            assign_low_outliers:
             for (size_t row = st; row < st_normals; row++) {
 
                 /* assign outlier if it's a better cluster than previously assigned */
@@ -254,7 +259,23 @@ bool define_numerical_cluster(double *restrict x, size_t *restrict ix_arr, size_
             }
         }
     }
-    if (!has_low_values) {
+    /* special type of outliers not based on standard deviations */
+    if (check_nonneg_outliers && st_normals == 0 && tot >= 500 && orig_x[ix_arr[st]] < 0. && orig_x[ix_arr[end]] >= 2.) {
+        size_t max_neg_outliers = (tot < 10000)? 1 : ((tot < 100000)? 2 : 3);
+        if (orig_x[ix_arr[st + max_neg_outliers]] > 0.) {
+            size_t num_neg = 0;
+            for (size_t row = st; row < st + max_neg_outliers; row++) {
+                num_neg += orig_x[ix_arr[row]] < 0.;
+            }
+            st_normals = st + num_neg;
+            cluster.lower_lim = 0.;
+            cluster.display_lim_low = orig_x[ix_arr[st + st_normals]];
+            cluster.perc_above = (long double)(end - st_normals + 1) / (long double)(end - st + 1);
+            has_outlier_neg_values = true;
+            goto assign_low_outliers;
+        }
+    }
+    if (!has_low_values && !has_outlier_neg_values) {
         cluster.perc_above = 1.0;
         if (!is_log_transf && !is_exp_transf) {
 
@@ -271,10 +292,8 @@ bool define_numerical_cluster(double *restrict x, size_t *restrict ix_arr, size_
         }
 
         if (cluster.lower_lim > -HUGE_VAL) {
-            eps = 1e-15;
             while (cluster.lower_lim >= orig_x[ix_arr[st]]) {
-                cluster.lower_lim -= eps;
-                eps *= 4.;
+                cluster.lower_lim = std::nextafter(cluster.lower_lim, -std::numeric_limits<double>::infinity());
             }
         }
 
@@ -324,10 +343,8 @@ bool define_numerical_cluster(double *restrict x, size_t *restrict ix_arr, size_
                 cluster.display_lim_high = orig_x[ix_arr[row - 1]];
                 cluster.perc_below = (long double)(end_normals - st + 1) / (long double)(end - st + 1);
 
-                eps = 1e-15;
                 while (cluster.display_lim_high >= cluster.upper_lim) {
-                    cluster.upper_lim += eps;
-                    eps *= 4;
+                    cluster.upper_lim = std::nextafter(cluster.upper_lim, std::numeric_limits<double>::infinity());
                 }
                 break;
             }
@@ -384,10 +401,8 @@ bool define_numerical_cluster(double *restrict x, size_t *restrict ix_arr, size_
         }
 
         if (cluster.upper_lim < HUGE_VAL) {
-            eps = 1e-15;
             while (cluster.upper_lim <= orig_x[ix_arr[end]]) {
-                cluster.upper_lim += eps;
-                eps *= 4.;
+                cluster.upper_lim = std::nextafter(cluster.upper_lim, std::numeric_limits<double>::infinity());
             }
         }
 
@@ -406,8 +421,8 @@ bool define_numerical_cluster(double *restrict x, size_t *restrict ix_arr, size_
     }
 
     /* save displayed statistics for cluster */
-    if (has_high_values || has_low_values || is_log_transf || is_exp_transf) {
-        size_t st_disp  = has_low_values?  st_normals  : st;
+    if (has_high_values || has_low_values || is_log_transf || is_exp_transf || has_outlier_neg_values) {
+        size_t st_disp  = (has_low_values || has_outlier_neg_values)?  st_normals  : st;
         size_t end_disp = has_high_values? end_normals : end;
         running_mean = 0;
         running_ssq  = 0;
@@ -428,7 +443,7 @@ bool define_numerical_cluster(double *restrict x, size_t *restrict ix_arr, size_
     }
 
     /* report whether outliers were found or not */
-    return has_low_values || has_high_values;
+    return has_low_values || has_high_values || has_outlier_neg_values;
 }
 
 

data/vendor/outliertree/src/fit_model.cpp

@@ -11,7 +11,7 @@
 *      arXiv preprint arXiv:2001.00636 (2020).
 *    
 *    
-*    Copyright 2020 David Cortes.
+*    Copyright 2020-2024 David Cortes.
 *    
 *    Written for C++11 standard and OpenMP 2.0 or later. Code is meant to be wrapped into scripting languages
 *    such as R or Python.
@@ -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;
@@ -555,7 +552,8 @@ void process_numeric_col(std::vector<Cluster> &cluster_root,
                                                           workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                           workspace.orig_mean, workspace.orig_sd,
                                                           workspace.left_tail, workspace.right_tail, workspace.orig_target_col,
-                                                          model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier);
+                                                          model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
+                                                          true);
     workspace.tree->back().clusters.push_back(0);
 
     /* remove outliers if any were found */
@@ -639,7 +637,8 @@ void recursive_split_numeric(Workspace &workspace,
                                                                   workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                                   workspace.orig_mean, workspace.orig_sd,
                                                                   workspace.left_tail, workspace.right_tail, workspace.orig_target_col,
-                                                                  model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier);
+                                                                  model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
+                                                                  false);
                 workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
 
                 if (model_params.follow_all && ((curr_depth + 1) < model_params.max_depth)) {
@@ -666,7 +665,8 @@ void recursive_split_numeric(Workspace &workspace,
                                                               workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                               workspace.orig_mean, workspace.orig_sd,
                                                               workspace.left_tail, workspace.right_tail, workspace.orig_target_col,
-                                                              model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier);
+                                                              model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
+                                                              false);
             workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
 
             if (model_params.follow_all && ((curr_depth + 1) < model_params.max_depth)) {
@@ -690,7 +690,8 @@ void recursive_split_numeric(Workspace &workspace,
                                                               workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                               workspace.orig_mean, workspace.orig_sd,
                                                               workspace.left_tail, workspace.right_tail, workspace.orig_target_col,
-                                                              model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier);
+                                                              model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
+                                                              false);
             workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
 
             if (model_params.follow_all && ((curr_depth + 1) < model_params.max_depth)) {
@@ -753,7 +754,8 @@ void recursive_split_numeric(Workspace &workspace,
                                                                   workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                                   workspace.orig_mean, workspace.orig_sd,
                                                                   workspace.left_tail, workspace.right_tail, workspace.orig_target_col,
-                                                                  model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier);
+                                                                  model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
+                                                                  false);
                 workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
 
                 if (model_params.follow_all && ((curr_depth + 1) < model_params.max_depth)) {
@@ -780,7 +782,8 @@ void recursive_split_numeric(Workspace &workspace,
                                                               workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                               workspace.orig_mean, workspace.orig_sd,
                                                               workspace.left_tail, workspace.right_tail, workspace.orig_target_col,
-                                                              model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier);
+                                                              model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
+                                                              false);
             workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
 
             if (model_params.follow_all && ((curr_depth + 1) < model_params.max_depth)) {
@@ -808,7 +811,8 @@ void recursive_split_numeric(Workspace &workspace,
                                                               workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                               workspace.orig_mean, workspace.orig_sd,
                                                               workspace.left_tail, workspace.right_tail, workspace.orig_target_col,
-                                                              model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier);
+                                                              model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
+                                                              false);
             workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
 
             if (model_params.follow_all && ((curr_depth + 1) < model_params.max_depth)) {
@@ -874,7 +878,8 @@ void recursive_split_numeric(Workspace &workspace,
                                                                   workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                                   workspace.orig_mean, workspace.orig_sd,
                                                                   workspace.left_tail, workspace.right_tail, workspace.orig_target_col,
-                                                                  model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier);
+                                                                  model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
+                                                                  false);
                 workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
 
                 if (model_params.follow_all && ((curr_depth + 1) < model_params.max_depth)) {
@@ -901,7 +906,8 @@ void recursive_split_numeric(Workspace &workspace,
                                                               workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                               workspace.orig_mean, workspace.orig_sd,
                                                               workspace.left_tail, workspace.right_tail, workspace.orig_target_col,
-                                                              model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier);
+                                                              model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
+                                                              false);
             workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
 
             if (model_params.follow_all && ((curr_depth + 1) < model_params.max_depth)) {
@@ -931,7 +937,8 @@ void recursive_split_numeric(Workspace &workspace,
                                                               workspace.log_transf, workspace.log_minval, workspace.exp_transf,
                                                               workspace.orig_mean, workspace.orig_sd,
                                                               workspace.left_tail, workspace.right_tail, workspace.orig_target_col,
-                                                              model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier);
+                                                              model_params.max_perc_outliers, model_params.z_norm, model_params.z_outlier,
+                                                              false);
             workspace.lev_has_outliers = workspace.has_outliers? true : workspace.lev_has_outliers;
 
             if (model_params.follow_all && ((curr_depth + 1) < model_params.max_depth)) {

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

@@ -733,7 +733,8 @@ bool define_numerical_cluster(double *restrict x, size_t *restrict ix_arr, size_
                               size_t *restrict outlier_depth, Cluster &cluster, std::vector<Cluster> &clusters, size_t cluster_num, size_t tree_num, size_t tree_depth,
                               bool is_log_transf, double log_minval, bool is_exp_transf, double orig_mean, double orig_sd,
                               double left_tail, double right_tail, double *restrict orig_x,
-                              double max_perc_outliers, double z_norm, double z_outlier);
+                              double max_perc_outliers, double z_norm, double z_outlier,
+                              bool check_nonneg_outliers);
 void define_categ_cluster_no_cond(int *restrict x, size_t *restrict ix_arr, size_t st, size_t end, size_t ncateg,
                                   double *restrict outlier_scores, size_t *restrict outlier_clusters, size_t *restrict outlier_trees,
                                   size_t *restrict outlier_depth, Cluster &cluster,
@@ -802,17 +803,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.4.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-13 00:00:00.000000000 Z
+date: 2024-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.2
+        version: '4.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.2
+        version: '4.3'
 description:
 email: andrew@ankane.org
 executables: []
@@ -68,14 +68,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: Explainable outlier/anomaly detection for Ruby