outliertree 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ef23e1cd53c4dd31f3adc24d9f403d74d6d7f4680442b5e052b3c7c2d153658
-  data.tar.gz: 26e792c801de21a0f27f1a522d6fbf9ac03eb65dfb2fba91f4fbd268dffc570f
+  metadata.gz: 2851b4b56b23141bc9f1ef5b3c448fb75d785ce0e7b38580113001898ce18e2e
+  data.tar.gz: 817325392325bc61f1dea1363096678fe9fd578ec6026301e173447edc522752
 SHA512:
-  metadata.gz: 3bf9293f70824055367a2dc32b50c5a8b9bc49af09da7e2e7cbc4824c8764a454fb34fad1b0612b9aaf7b97a4ebb559a05caba247e7f1fc3cf8553fefedeb5c2
-  data.tar.gz: 7267d09d926458a1770904bb072b144a343950c1652a52f0df9f2e20b4b650a63e508acc75b43c369ada31998052b4719879fc45d1b08ba43c96570f0fff29bd
+  metadata.gz: e1bc84c131959bb7260100b4aa1e345ae09330600252299084efe5d40fbff8d8d9d9aadf78c6384a0b6a158a1b3bbcdeff9de3ce71fca90ce938003125b37898
+  data.tar.gz: cad988456c492f101bc71334997217a48d6588c4e2e5feee333bc074f3b14b62557d0e64429fca787705244b701eca7d685aa17f090dad94578fce172812e5a0

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 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/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.0"
 end

data/vendor/outliertree/README.md

@@ -1,47 +1,60 @@
 # 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] = [f]
+		[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:
+		[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:
@@ -54,18 +67,38 @@ install.packages("outliertree")
 ```
 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 --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:
+
+```
+export CFLAGS="-march=x86-64"
+export CXXFLAGS="-march=x86-64"
 pip install outliertree
 ```
-(Alternatively, can also pass argument `enable-omp` to the `setup.py` file: `python setup.py install enable-omp`)
 
+or for creating wheels:
+```
+export CFLAGS="-march=x86-64"
+export CXXFLAGS="-march=x86-64"
+python setup.py bwheel
+```
+** *
 
 * 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 +110,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)
@@ -113,17 +146,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 +171,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 +181,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,4 @@
+PKG_CPPFLAGS = -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

@@ -0,0 +1,4 @@
+PKG_CPPFLAGS = -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

@@ -5,14 +5,19 @@
 
 using namespace 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
+
 // deserialize_OutlierTree
-SEXP deserialize_OutlierTree(Rcpp::RawVector src);
-RcppExport SEXP _outliertree_deserialize_OutlierTree(SEXP srcSEXP) {
+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::RNGScope rcpp_rngScope_gen;
     Rcpp::traits::input_parameter< Rcpp::RawVector >::type src(srcSEXP);
-    rcpp_result_gen = Rcpp::wrap(deserialize_OutlierTree(src));
+    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
 }
@@ -21,7 +26,6 @@ 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;
@@ -32,7 +36,6 @@ Rcpp::List fit_OutlierTree(Rcpp::NumericVector arr_num, size_t ncols_numeric, Rc
 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 +78,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 +100,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,13 +108,23 @@ 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_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},
+    {"_outliertree_R_has_openmp", (DL_FUNC) &_outliertree_R_has_openmp, 0},
     {NULL, NULL, 0}
 };