outliertree 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ef23e1cd53c4dd31f3adc24d9f403d74d6d7f4680442b5e052b3c7c2d153658
-  data.tar.gz: 26e792c801de21a0f27f1a522d6fbf9ac03eb65dfb2fba91f4fbd268dffc570f
+  metadata.gz: 8ed2332f581bd9cf68d32fe19bdb89c58f268c6ea6feb30e34e8422595920dc3
+  data.tar.gz: d7cc844317fc023bee7d461838ae3fad3567268845013d2fc4e761f325934534
 SHA512:
-  metadata.gz: 3bf9293f70824055367a2dc32b50c5a8b9bc49af09da7e2e7cbc4824c8764a454fb34fad1b0612b9aaf7b97a4ebb559a05caba247e7f1fc3cf8553fefedeb5c2
-  data.tar.gz: 7267d09d926458a1770904bb072b144a343950c1652a52f0df9f2e20b4b650a63e508acc75b43c369ada31998052b4719879fc45d1b08ba43c96570f0fff29bd
+  metadata.gz: 4afaa3d661d2d225dc55d708ba8d263b0a017fe2a5388d77cb881d5765f9e9cc9ef682b52ef541b706cf00fc0cc7d3834f537a7900c30d3783df1821ef7d432e
+  data.tar.gz: 6c0feea6f531277847d84c76cbf146ca3d3821f9dd9635c8f7bf1fe592b1905f02db2d288027600310609d817d891129b510f5dad377946e735364705d0949cd

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 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
+- Dropped support for Ruby < 2.7
+
 ## 0.2.1 (2021-05-23)
 
 - Improved performance

data/NOTICE.txt

@@ -1,5 +1,5 @@
 Copyright (C) 2019-2020 David Cortes
-Copyright (C) 2020-2021 Andrew Kane
+Copyright (C) 2020-2022 Andrew Kane
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by

data/README.md

@@ -1,4 +1,4 @@
-# OutlierTree
+# OutlierTree Ruby
 
 :deciduous_tree: [OutlierTree](https://github.com/david-cortes/outliertree) - explainable outlier/anomaly detection - for Ruby
 
@@ -8,16 +8,16 @@ Produces human-readable explanations for why values are detected as outliers
 Price (2.50) looks low given Department is Books and Sale is false
 ```
 
-:evergreen_tree: Check out [IsoTree](https://github.com/ankane/isotree) for an alternative approach that uses Isolation Forest
+: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/workflows/build/badge.svg?branch=master)](https://github.com/ankane/outliertree/actions)
+[![Build Status](https://github.com/ankane/outliertree-ruby/workflows/build/badge.svg?branch=master)](https://github.com/ankane/outliertree-ruby/actions)
 
 ## Installation
 
 Add this line to your application’s Gemfile:
 
 ```ruby
-gem 'outliertree'
+gem "outliertree"
 ```
 
 ## Getting Started
@@ -28,7 +28,8 @@ Prep your data
 data = [
   {department: "Books",  sale: false, price: 2.50},
   {department: "Books",  sale: true,  price: 3.00},
-  {department: "Movies", sale: false, price: 5.00}
+  {department: "Movies", sale: false, price: 5.00},
+  # ...
 ]
 ```
 
@@ -108,22 +109,22 @@ bundle install
 
 ## History
 
-View the [changelog](https://github.com/ankane/outliertree/blob/master/CHANGELOG.md)
+View the [changelog](https://github.com/ankane/outliertree-ruby/blob/master/CHANGELOG.md)
 
 ## Contributing
 
 Everyone is encouraged to help improve this project. Here are a few ways you can help:
 
-- [Report bugs](https://github.com/ankane/outliertree/issues)
-- Fix bugs and [submit pull requests](https://github.com/ankane/outliertree/pulls)
+- [Report bugs](https://github.com/ankane/outliertree-ruby/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/outliertree-ruby/pulls)
 - Write, clarify, or fix documentation
 - Suggest or add new features
 
 To get started with development:
 
 ```sh
-git clone --recursive https://github.com/ankane/outliertree.git
-cd outliertree
+git clone --recursive https://github.com/ankane/outliertree-ruby.git
+cd outliertree-ruby
 bundle install
 bundle exec rake compile
 bundle exec rake test

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/ext/outliertree/extconf.rb

@@ -1,6 +1,6 @@
 require "mkmf-rice"
 
-$CXXFLAGS += " -std=c++17 $(optflags)"
+$CXXFLAGS += " -std=c++17 $(optflags) -DDONT_THROW_ON_INTERRUPT"
 
 apple_clang = RbConfig::CONFIG["CC_VERSION_MESSAGE"] =~ /apple clang/i
 

data/lib/outliertree/result.rb

@@ -22,7 +22,7 @@ module OutlierTree
           if outl_col < @numeric_columns.size
             column = @numeric_columns[outl_col]
             value = df[column][row]
-            decimals = model_outputs.outlier_decimals_distr[row]
+            _decimals = model_outputs.outlier_decimals_distr[row]
           else
             column = @categorical_columns[outl_col - @numeric_columns.size]
             value = df[column][row]
@@ -94,11 +94,11 @@ module OutlierTree
     private
 
     def add_condition(row, split_type, cluster)
-      coldecim = 0
+      _coldecim = 0
       case cluster.column_type
       when :numeric
         cond_col = @numeric_columns[cluster.col_num]
-        coldecim = model_outputs.min_decimals_col[cluster.col_num]
+        _coldecim = model_outputs.min_decimals_col[cluster.col_num]
       else
         cond_col = @categorical_columns[cluster.col_num]
       end

data/lib/outliertree/version.rb

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

data/vendor/outliertree/README.md

@@ -1,71 +1,109 @@
 # OutlierTree
 
-Explainable outlier/anomaly detection based on smart decision tree grouping, similar in spirit to the GritBot software developed by RuleQuest research. Written in C++ with interfaces for R and Python. Supports columns of types numeric, categorical, binary/boolean, and ordinal, and can handle missing values in all of them. Ideal as a sanity checker in exploratory data analysis.
-
-# How it works
-
-Will try to fit decision trees that try to "predict" values for each column based on the values of each other column. Along the way, each time a split is evaluated, it will take the observations that fall into each branch as a homogeneous cluster in which it will search for outliers in the 1-d distribution of the column being predicted. Outliers are determined according to confidence intervals on this 1-d distribution, and need to have a large gap with respect to the next observation in sorted order to be flagged as outliers. Since outliers are searched for in a decision tree branch, it will know the conditions that make it a rare observation compared to others that meet the same conditions, and the conditions will always be correlated with the target variable (as it's being predicted from them).
-
-As such, it will only be able to detect outliers that can be described through a decision tree logic, and unlike other methods such as [Isolation Forests](https://github.com/david-cortes/isotree), will not be able to assign an outlier score to each observation, nor to detect outliers that are just overall rare, but will always provide a human-readable justification when it flags an outlier.
-
-Procedure is described in more detail in [Explainable outlier detection through decision tree conditioning](http://arxiv.org/abs/2001.00636).
+Explainable outlier/anomaly detection based on smart decision tree grouping, similar in spirit to the GritBot software developed by RuleQuest research. Written in C++ with interfaces for R and Python (additional Ruby wrapper can be found [here](https://github.com/ankane/outliertree/)). Supports columns of types numeric, categorical, binary/boolean, and ordinal, and can handle missing values in all of them. Ideal as a sanity checker in exploratory data analysis.
 
 # Example outputs
 
-Example outliers from [hypothyroid dataset](http://archive.ics.uci.edu/ml/datasets/thyroid+disease):
+Example outliers from the [hypothyroid dataset](http://archive.ics.uci.edu/ml/datasets/thyroid+disease):
 ```
-row [1137] - suspicious column: [age] - suspicious value: [75.000]
-	distribution: 95.122% <= 42.000 - [mean: 31.462] - [sd: 5.281] - [norm. obs: 39]
+row [1138] - suspicious column: [age] - suspicious value: [75.00]
+	distribution: 95.122% <= 42.00 - [mean: 31.46] - [sd: 5.28] - [norm. obs: 39]
 	given:
-		[pregnant] = [t]
+		[pregnant] = [TRUE]
 
 
-row [2229] - suspicious column: [T3] - suspicious vale: [10.600]
-	distribution: 99.951% <= 7.100 - [mean: 1.984] - [sd: 0.750] - [norm. obs: 2050]
+row [2230] - suspicious column: [T3] - suspicious value: [10.60]
+	distribution: 99.951% <= 7.10 - [mean: 1.98] - [sd: 0.75] - [norm. obs: 2050]
+	given:
+		[query.hyperthyroid] = [FALSE]
+
+row [745] - suspicious column: [TT4] - suspicious value: [239.00]
+	distribution: 98.571% <= 177.00 - [mean: 135.23] - [sd: 12.57] - [norm. obs: 69]
 	given:
-		[query hyperthyroid] = [f]
+		[FTI] between (97.96, 128.12] (value: 112.74)
+		[T4U] > [1.12] (value: 2.12)
+		[age] > [55.00] (value: 87.00)
 ```
 (i.e. it's saying that it's abnormal to be pregnant at the age of 75, or to not be classified as hyperthyroidal when having very high thyroid hormone levels)
 (this dataset is also bundled into the R package - e.g. `data(hypothyroid)`)
 
 
-Example outlier from [Titanic dataset](https://www.kaggle.com/c/titanic):
+Example outliers from the [Titanic dataset](https://www.kaggle.com/c/titanic):
 ```
-row [885] - suspicious column: [Fare] - suspicious value: [29.125]
-	distribution: 97.849% <= 15.500 - [mean: 7.887] - [sd: 1.173] - [norm. obs: 91]
+row [1147] - suspicious column: [Fare] - suspicious value: [29.12]
+	distribution: 97.849% <= 15.50 - [mean: 7.89] - [sd: 1.17] - [norm. obs: 91]
 	given:
 		[Pclass] = [3]
 		[SibSp] = [0]
 		[Embarked] = [Q]
+
+row [897] - suspicious column: [Fare] - suspicious value: [0.00]
+	distribution: 99.216% >= 3.17 - [mean: 9.68] - [sd: 6.98] - [norm. obs: 506]
+	given:
+		[Pclass] = [3]
+		[SibSp] = [0]
 ```
-(i.e. it's saying that the this person paid too much for the kind of accomodation he had)
+(i.e. it's saying that the the first person paid too much for the kind of accomodation he had, and the second person should not have gotten it for free)
 
 _Note that it can also produce other types of conditions such as 'between' (for numeric intervals) or 'in' (for categorical subsets)_
 
+# How it works
+
+Will try to fit decision trees that try to "predict" values for each column based on the values of each other column. Along the way, each time a split is evaluated, it will take the observations that fall into each branch as a homogeneous cluster in which it will search for outliers in the 1-d distribution of the column being predicted. Outliers are determined according to confidence intervals on this 1-d distribution, and need to have a large gap with respect to the next observation in sorted order to be flagged as outliers. Since outliers are searched for in a decision tree branch, it will know the conditions that make it a rare observation compared to others that meet the same conditions, and the conditions will always be correlated with the target variable (as it's being predicted from them).
+
+As such, it will only be able to detect outliers that can be described through a decision tree logic, and unlike other methods such as [Isolation Forests](https://github.com/david-cortes/isotree), will not be able to assign an outlier score to each observation, nor to detect outliers that are just overall rare, but will always provide a human-readable justification when it flags an outlier.
+
+Procedure is described in more detail in [Explainable outlier detection through decision tree conditioning](http://arxiv.org/abs/2001.00636).
+
 # 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
 ```
-(Package has only been tested in Python 3)
+or if that fails:
+```
+pip install --no-use-pep517 outliertree
+```
+** *
 
-**Note for macOS users:** on macOS, the Python version of this package will compile **without** multi-threading capabilities. This is due to default apple's redistribution of `clang` not providing OpenMP modules, and aliasing it to `gcc` which causes confusions in build scripts. If you have a non-apple version of `clang` with the OpenMP modules, or if you have `gcc` installed, you can compile this package with multi-threading enabled by setting up an environment variable `ENABLE_OMP=1`:
+**Note for macOS users:** on macOS, the Python version of this package might compile **without** multi-threading capabilities. In order to enable multi-threading support, first install OpenMP:
 ```
-export ENABLE_OMP=1
+brew install libomp
+```
+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 (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 DONT_SET_MARCH=1
 pip install outliertree
 ```
-(Alternatively, can also pass argument `enable-omp` to the `setup.py` file: `python setup.py install enable-omp`)
 
+or, by specifying some compilation flag for architecture:
+```
+export CFLAGS="-march=x86-64"
+export CXXFLAGS="-march=x86-64"
+pip install outliertree
+```
+** *
 
 * For C++: package doesn't have a build system, nor a `main` function that can produce an executable, but can be built as a shared object and wrapped into other languages with any C++11-compliant compiler (`std=c++11` in most compilers, `/std:c++14` in MSVC). For parallelization, needs OpenMP linkage (`-fopenmp` in most compilers, `/openmp` in MSVC). Package should *not* be built with optimization higher than `O3` (i.e. don't use `-Ofast`). Needs linkage to the `math` library, which should be enabled by default in most C++ compilers, but otherwise would require `-lm` argument. No external dependencies are required.
 
+* For Ruby: see [external repository with wrapper](https://github.com/ankane/outliertree/).
 
 # Sample usage
 
@@ -77,18 +115,18 @@ library(outliertree)
 nrows = 100
 set.seed(1)
 df = data.frame(
-	numeric_col1 = c(rnorm(nrows - 1), 1e6),
-	numeric_col2 = rgamma(nrows, 1),
-	categ_col    = sample(c('categA', 'categB', 'categC'), size = nrows, replace = TRUE)
-	)
+    numeric_col1 = c(rnorm(nrows - 1), 1e6),
+    numeric_col2 = rgamma(nrows, 1),
+    categ_col    = sample(c('categA', 'categB', 'categC'), size = nrows, replace = TRUE)
+)
 
 ### test data frame with another obvious outlier
 nrows_test = 50
 df_test = data.frame(
-	numeric_col1 = rnorm(nrows_test),
-	numeric_col2 = c(-1e6, rgamma(nrows_test - 1, 1)),
-	categ_col    = sample(c('categA', 'categB', 'categC'), size = nrows_test, replace = TRUE)
-	)
+    numeric_col1 = rnorm(nrows_test),
+    numeric_col2 = c(-1e6, rgamma(nrows_test - 1, 1)),
+    categ_col    = sample(c('categA', 'categB', 'categC'), size = nrows_test, replace = TRUE)
+)
 
 ### fit model
 outliers_model = outliertree::outlier.tree(df, outliers_print = 10, save_outliers = TRUE)
@@ -101,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:
@@ -113,17 +151,17 @@ from outliertree import OutlierTree
 nrows = 100
 np.random.seed(1)
 df = pd.DataFrame({
-	"numeric_col1" : np.r_[np.random.normal(size = nrows - 1), np.array([float(1e6)])],
-	"numeric_col2" : np.random.gamma(1, 1, size = nrows),
-	"categ_col"    : np.random.choice(['categA', 'categB', 'categC'], size = nrows)
-	})
+    "numeric_col1" : np.r_[np.random.normal(size = nrows - 1), np.array([float(1e6)])],
+    "numeric_col2" : np.random.gamma(1, 1, size = nrows),
+    "categ_col"    : np.random.choice(['categA', 'categB', 'categC'], size = nrows)
+})
 
 ### test data frame with another obvious outlier
 df_test = pd.DataFrame({
-	"numeric_col1" : np.random.normal(size = nrows),
-	"numeric_col2" : np.r_[np.array([float(-1e6)]), np.random.gamma(1, 1, size = nrows - 1)],
-	"categ_col"    : np.random.choice(['categA', 'categB', 'categC'], size = nrows)
-	})
+    "numeric_col1" : np.random.normal(size = nrows),
+    "numeric_col2" : np.r_[np.array([float(-1e6)]), np.random.gamma(1, 1, size = nrows - 1)],
+    "categ_col"    : np.random.choice(['categA', 'categB', 'categC'], size = nrows)
+})
 
 ### fit model
 outliers_model = OutlierTree()
@@ -138,6 +176,8 @@ outliers_model.print_outliers(new_outliers)
 
 Example [IPython notebook](http://nbviewer.ipython.org/github/david-cortes/outliertree/blob/master/example/titanic_outliertree_python.ipynb) using the Titanic dataset.
 
+* For Ruby: see the [external repository](https://github.com/ankane/outliertree/).
+
 * For C++: see functions `fit_outliers_models` and `find_new_outliers` in header `outlier_tree.hpp`.
 
 # Documentation
@@ -146,6 +186,8 @@ Example [IPython notebook](http://nbviewer.ipython.org/github/david-cortes/outli
 
 * For Python: documentation is available at [ReadTheDocs](http://outliertree.readthedocs.io/en/latest/) (and it's also built-in in the package as docstrings, e.g. `help(outliertree.OutlierTree.fit)`).
 
+* For Ruby: see the [external repository](https://github.com/ankane/outliertree/) and the [Python documentation](http://outliertree.readthedocs.io/en/latest/).
+
 * For C++: documentation is available in the source files (not in the header).
 
 # References

data/vendor/outliertree/src/Makevars.in

@@ -0,0 +1,3 @@
+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)

data/vendor/outliertree/src/Makevars.win

@@ -0,0 +1,3 @@
+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)

data/vendor/outliertree/src/RcppExports.cpp

@@ -5,34 +5,16 @@
 
 using namespace Rcpp;
 
-// deserialize_OutlierTree
-SEXP deserialize_OutlierTree(Rcpp::RawVector src);
-RcppExport SEXP _outliertree_deserialize_OutlierTree(SEXP srcSEXP) {
-BEGIN_RCPP
-    Rcpp::RObject rcpp_result_gen;
-    Rcpp::RNGScope rcpp_rngScope_gen;
-    Rcpp::traits::input_parameter< Rcpp::RawVector >::type src(srcSEXP);
-    rcpp_result_gen = Rcpp::wrap(deserialize_OutlierTree(src));
-    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::RNGScope rcpp_rngScope_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
-}
+#ifdef RCPP_USE_GLOBAL_ROSTREAM
+Rcpp::Rostream<true>&  Rcpp::Rcout = Rcpp::Rcpp_cout_get();
+Rcpp::Rostream<false>& Rcpp::Rcerr = Rcpp::Rcpp_cerr_get();
+#endif
+
 // 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) {
 BEGIN_RCPP
     Rcpp::RObject rcpp_result_gen;
-    Rcpp::RNGScope rcpp_rngScope_gen;
     Rcpp::traits::input_parameter< Rcpp::NumericVector >::type arr_num(arr_numSEXP);
     Rcpp::traits::input_parameter< size_t >::type ncols_numeric(ncols_numericSEXP);
     Rcpp::traits::input_parameter< Rcpp::IntegerVector >::type arr_cat(arr_catSEXP);
@@ -75,7 +57,6 @@ Rcpp::List predict_OutlierTree(SEXP ptr_model, size_t nrows, int nthreads, Rcpp:
 RcppExport SEXP _outliertree_predict_OutlierTree(SEXP ptr_modelSEXP, SEXP nrowsSEXP, SEXP nthreadsSEXP, SEXP arr_numSEXP, SEXP arr_catSEXP, SEXP arr_ordSEXP, SEXP cat_levelsSEXP, SEXP ord_levelsSEXP, SEXP colnames_numSEXP, SEXP colnames_catSEXP, SEXP colnames_ordSEXP, SEXP min_dateSEXP, SEXP min_tsSEXP) {
 BEGIN_RCPP
     Rcpp::RObject rcpp_result_gen;
-    Rcpp::RNGScope rcpp_rngScope_gen;
     Rcpp::traits::input_parameter< SEXP >::type ptr_model(ptr_modelSEXP);
     Rcpp::traits::input_parameter< size_t >::type nrows(nrowsSEXP);
     Rcpp::traits::input_parameter< int >::type nthreads(nthreadsSEXP);
@@ -98,7 +79,6 @@ Rcpp::LogicalVector check_few_values(Rcpp::NumericVector arr_num, size_t nrows,
 RcppExport SEXP _outliertree_check_few_values(SEXP arr_numSEXP, SEXP nrowsSEXP, SEXP ncolsSEXP, SEXP nthreadsSEXP) {
 BEGIN_RCPP
     Rcpp::RObject rcpp_result_gen;
-    Rcpp::RNGScope rcpp_rngScope_gen;
     Rcpp::traits::input_parameter< Rcpp::NumericVector >::type arr_num(arr_numSEXP);
     Rcpp::traits::input_parameter< size_t >::type nrows(nrowsSEXP);
     Rcpp::traits::input_parameter< size_t >::type ncols(ncolsSEXP);
@@ -107,17 +87,27 @@ BEGIN_RCPP
     return rcpp_result_gen;
 END_RCPP
 }
+// R_has_openmp
+bool R_has_openmp();
+RcppExport SEXP _outliertree_R_has_openmp() {
+BEGIN_RCPP
+    Rcpp::RObject rcpp_result_gen;
+    rcpp_result_gen = Rcpp::wrap(R_has_openmp());
+    return rcpp_result_gen;
+END_RCPP
+}
 
 static const R_CallMethodDef CallEntries[] = {
-    {"_outliertree_deserialize_OutlierTree", (DL_FUNC) &_outliertree_deserialize_OutlierTree, 1},
-    {"_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},
+    {"_outliertree_R_has_openmp", (DL_FUNC) &_outliertree_R_has_openmp, 0},
     {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);
 }