isotree 0.3.0 → 0.3.1

data/vendor/isotree/src/robinmap/include/tsl/robin_hash.h

@@ -33,6 +33,7 @@
 #include <iterator>
 #include <limits>
 #include <memory>
+#include <new>
 #include <stdexcept>
 #include <tuple>
 #include <type_traits>
@@ -195,6 +196,7 @@ class bucket_entry : public bucket_entry_hash<StoreHash> {
           value_type(other.value());
       m_dist_from_ideal_bucket = other.m_dist_from_ideal_bucket;
     }
+    tsl_rh_assert(empty() == other.empty());
   }
 
   /**
@@ -212,6 +214,7 @@ class bucket_entry : public bucket_entry_hash<StoreHash> {
           value_type(std::move(other.value()));
       m_dist_from_ideal_bucket = other.m_dist_from_ideal_bucket;
     }
+    tsl_rh_assert(empty() == other.empty());
   }
 
   bucket_entry& operator=(const bucket_entry& other) noexcept(
@@ -249,12 +252,22 @@ class bucket_entry : public bucket_entry_hash<StoreHash> {
 
   value_type& value() noexcept {
     tsl_rh_assert(!empty());
+#if defined(__cplusplus) && __cplusplus >= 201703L
+    return *std::launder(
+        reinterpret_cast<value_type*>(std::addressof(m_value)));
+#else
     return *reinterpret_cast<value_type*>(std::addressof(m_value));
+#endif
   }
 
   const value_type& value() const noexcept {
     tsl_rh_assert(!empty());
+#if defined(__cplusplus) && __cplusplus >= 201703L
+    return *std::launder(
+        reinterpret_cast<const value_type*>(std::addressof(m_value)));
+#else
     return *reinterpret_cast<const value_type*>(std::addressof(m_value));
+#endif
   }
 
   distance_type dist_from_ideal_bucket() const noexcept {
@@ -283,6 +296,7 @@ class bucket_entry : public bucket_entry_hash<StoreHash> {
   void swap_with_value_in_bucket(distance_type& dist_from_ideal_bucket,
                                  truncated_hash_type& hash, value_type& value) {
     tsl_rh_assert(!empty());
+    tsl_rh_assert(dist_from_ideal_bucket > m_dist_from_ideal_bucket);
 
     using std::swap;
     swap(value, this->value());
@@ -310,19 +324,16 @@ class bucket_entry : public bucket_entry_hash<StoreHash> {
 
  public:
   static const distance_type EMPTY_MARKER_DIST_FROM_IDEAL_BUCKET = -1;
-  static const distance_type DIST_FROM_IDEAL_BUCKET_LIMIT = 4096;
+  static const distance_type DIST_FROM_IDEAL_BUCKET_LIMIT = 8192;
   static_assert(DIST_FROM_IDEAL_BUCKET_LIMIT <=
                     std::numeric_limits<distance_type>::max() - 1,
                 "DIST_FROM_IDEAL_BUCKET_LIMIT must be <= "
                 "std::numeric_limits<distance_type>::max() - 1.");
 
  private:
-  using storage = typename std::aligned_storage<sizeof(value_type),
-                                                alignof(value_type)>::type;
-
   distance_type m_dist_from_ideal_bucket;
   bool m_last_bucket;
-  storage m_value;
+  alignas(value_type) unsigned char m_value[sizeof(value_type)];
 };
 
 /**
@@ -659,7 +670,7 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
 
   robin_hash& operator=(robin_hash&& other) {
     other.swap(*this);
-    other.clear();
+    other.clear_and_shrink();
 
     return *this;
   }
@@ -1068,6 +1079,7 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
     m_max_load_factor = clamp(ml, float(MINIMUM_MAX_LOAD_FACTOR),
                               float(MAXIMUM_MAX_LOAD_FACTOR));
     m_load_threshold = size_type(float(bucket_count()) * m_max_load_factor);
+    tsl_rh_assert(bucket_count() == 0 || m_load_threshold < bucket_count());
   }
 
   void rehash(size_type count_) {
@@ -1219,7 +1231,7 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
       dist_from_ideal_bucket++;
     }
 
-    if (rehash_on_extreme_load()) {
+    while (rehash_on_extreme_load(dist_from_ideal_bucket)) {
       ibucket = bucket_for_hash(hash);
       dist_from_ideal_bucket = 0;
 
@@ -1271,6 +1283,8 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
   void insert_value_impl(std::size_t ibucket,
                          distance_type dist_from_ideal_bucket,
                          truncated_hash_type hash, value_type& value) {
+    tsl_rh_assert(dist_from_ideal_bucket >
+                  m_buckets[ibucket].dist_from_ideal_bucket());
     m_buckets[ibucket].swap_with_value_in_bucket(dist_from_ideal_bucket, hash,
                                                  value);
     ibucket = next_bucket(ibucket);
@@ -1279,7 +1293,7 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
     while (!m_buckets[ibucket].empty()) {
       if (dist_from_ideal_bucket >
           m_buckets[ibucket].dist_from_ideal_bucket()) {
-        if (dist_from_ideal_bucket >=
+        if (dist_from_ideal_bucket >
             bucket_entry::DIST_FROM_IDEAL_BUCKET_LIMIT) {
           /**
            * The number of probes is really high, rehash the map on the next
@@ -1304,6 +1318,7 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
     robin_hash new_table(count_, static_cast<Hash&>(*this),
                          static_cast<KeyEqual&>(*this), get_allocator(),
                          m_min_load_factor, m_max_load_factor);
+    tsl_rh_assert(size() <= new_table.m_load_threshold);
 
     const bool use_stored_hash =
         USE_STORED_HASH_ON_REHASH(new_table.bucket_count());
@@ -1364,8 +1379,11 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
    *
    * Return true if the table has been rehashed.
    */
-  bool rehash_on_extreme_load() {
-    if (m_grow_on_next_insert || size() >= m_load_threshold) {
+  bool rehash_on_extreme_load(distance_type curr_dist_from_ideal_bucket) {
+    if (m_grow_on_next_insert ||
+        curr_dist_from_ideal_bucket >
+            bucket_entry::DIST_FROM_IDEAL_BUCKET_LIMIT ||
+        size() >= m_load_threshold) {
       rehash_impl(GrowthPolicy::next_bucket_count());
       m_grow_on_next_insert = false;
 
@@ -1571,6 +1589,7 @@ class robin_hash : private Hash, private KeyEqual, private GrowthPolicy {
    */
   bucket_entry* static_empty_bucket_ptr() noexcept {
     static bucket_entry empty_bucket(true);
+    tsl_rh_assert(empty_bucket.empty());
     return &empty_bucket;
   }
 

data/vendor/isotree/src/serialize.cpp

@@ -1847,13 +1847,13 @@ void check_setup_info
     }
 
     if (setup_info[4] == (uint8_t)IsAbnormalDouble)
-        fprintf(stderr, "Warning: input model uses non-standard numeric type, might read correctly.\n");
+        print_errmsg("Warning: input model uses non-standard numeric type, might read correctly.\n");
     
     switch(setup_info[6])
     {
-        case 16: {saved_int_t = Is16Bit; break;}
-        case 32: {saved_int_t = Is32Bit; break;}
-        case 64: {saved_int_t = Is64Bit; break;}
+        case 2: {saved_int_t = Is16Bit; break;}
+        case 4: {saved_int_t = Is32Bit; break;}
+        case 8: {saved_int_t = Is64Bit; break;}
         default: {saved_int_t = IsOther; break;}
     }
     if ((uint8_t)sizeof(int) != setup_info[6]) {
@@ -3844,7 +3844,7 @@ void serialize_combined
     {
         if (memcmp(curr_setup.get(), serialized_model, get_size_setup_info()))
         {
-            fprintf(stderr, "Warning: 'model' was serialized in a different setup, will need to convert.\n");
+            print_errmsg("Warning: 'model' was serialized in a different setup, will need to convert.\n");
             IsoForest model;
             deserialization_pipeline(model, serialized_model);
             new_model = std::unique_ptr<char[]>(new char[get_size_model(model)]);
@@ -3862,7 +3862,7 @@ void serialize_combined
     {
         if (memcmp(curr_setup.get(), serialized_model_ext, get_size_setup_info()))
         {
-            fprintf(stderr, "Warning: 'model_ext' was serialized in a different setup, will need to convert.\n");
+            print_errmsg("Warning: 'model_ext' was serialized in a different setup, will need to convert.\n");
             ExtIsoForest model;
             deserialization_pipeline(model, serialized_model_ext);
             new_model = std::unique_ptr<char[]>(new char[get_size_model(model)]);
@@ -3884,7 +3884,7 @@ void serialize_combined
     {
         if (memcmp(curr_setup.get(), serialized_imputer, get_size_setup_info()))
         {
-            fprintf(stderr, "Warning: 'imputer' was serialized in a different setup, will need to convert.\n");
+            print_errmsg("Warning: 'imputer' was serialized in a different setup, will need to convert.\n");
             Imputer model;
             deserialization_pipeline(model, serialized_imputer);
             new_model = std::unique_ptr<char[]>(new char[get_size_model(model)]);
@@ -3907,7 +3907,7 @@ void serialize_combined
     {
         if (memcmp(curr_setup.get(), serialized_indexer, get_size_setup_info()))
         {
-            fprintf(stderr, "Warning: 'indexer' was serialized in a different setup, will need to convert.\n");
+            print_errmsg("Warning: 'indexer' was serialized in a different setup, will need to convert.\n");
             TreesIndexer model;
             deserialization_pipeline(model, serialized_indexer);
             new_model = std::unique_ptr<char[]>(new char[get_size_model(model)]);
@@ -4211,7 +4211,9 @@ void deserialize_combined
         {
             deserialize_model(*model, in, has_same_endianness, has_same_int_size, has_same_size_t_size, saved_int_t, saved_size_t, lacks_range_penalty, lacks_scoring_metric);
             check_interrupt_switch(ss);
-            read_bytes<char>((void*)optional_metadata, size_metadata, in);
+            if (optional_metadata) {
+                read_bytes<char>((void*)optional_metadata, size_metadata, in);
+            }
             break;
         }
         case HasSingleVarModelPlusIndexerPlusMetadataNext:
@@ -4220,14 +4222,18 @@ void deserialize_combined
             check_interrupt_switch(ss);
             deserialize_model(*indexer, in, has_same_endianness, has_same_int_size, has_same_size_t_size, saved_int_t, saved_size_t, lacks_range_penalty, lacks_scoring_metric);
             check_interrupt_switch(ss);
-            read_bytes<char>((void*)optional_metadata, size_metadata, in);
+            if (optional_metadata) {
+                read_bytes<char>((void*)optional_metadata, size_metadata, in);
+            }
             break;
         }
         case HasExtModelPlusMetadataNext:
         {
             deserialize_model(*model_ext, in, has_same_endianness, has_same_int_size, has_same_size_t_size, saved_int_t, saved_size_t, lacks_range_penalty, lacks_scoring_metric);
             check_interrupt_switch(ss);
-            read_bytes<char>((void*)optional_metadata, size_metadata, in);
+            if (optional_metadata) {
+                read_bytes<char>((void*)optional_metadata, size_metadata, in);
+            }
             break;
         }
         case HasExtModelPlusIndexerPlusMetadataNext:
@@ -4236,7 +4242,9 @@ void deserialize_combined
             check_interrupt_switch(ss);
             deserialize_model(*indexer, in, has_same_endianness, has_same_int_size, has_same_size_t_size, saved_int_t, saved_size_t, lacks_range_penalty, lacks_scoring_metric);
             check_interrupt_switch(ss);
-            read_bytes<char>((void*)optional_metadata, size_metadata, in);
+            if (optional_metadata) {
+                read_bytes<char>((void*)optional_metadata, size_metadata, in);
+            }
             break;
         }
         case HasSingleVarModelPlusImputerPlusMetadataNext:
@@ -4245,7 +4253,9 @@ void deserialize_combined
             check_interrupt_switch(ss);
             deserialize_model(*imputer, in, has_same_endianness, has_same_int_size, has_same_size_t_size, saved_int_t, saved_size_t, lacks_range_penalty, lacks_scoring_metric);
             check_interrupt_switch(ss);
-            read_bytes<char>((void*)optional_metadata, size_metadata, in);
+            if (optional_metadata) {
+                read_bytes<char>((void*)optional_metadata, size_metadata, in);
+            }
             break;
         }
         case HasSingleVarModelPlusImputerPlusIndexerPlusMetadataNext:
@@ -4256,7 +4266,9 @@ void deserialize_combined
             check_interrupt_switch(ss);
             deserialize_model(*indexer, in, has_same_endianness, has_same_int_size, has_same_size_t_size, saved_int_t, saved_size_t, lacks_range_penalty, lacks_scoring_metric);
             check_interrupt_switch(ss);
-            read_bytes<char>((void*)optional_metadata, size_metadata, in);
+            if (optional_metadata) {
+                read_bytes<char>((void*)optional_metadata, size_metadata, in);
+            }
             break;
         }
         case HasExtModelPlusImputerPlusMetadataNext:
@@ -4265,7 +4277,9 @@ void deserialize_combined
             check_interrupt_switch(ss);
             deserialize_model(*imputer, in, has_same_endianness, has_same_int_size, has_same_size_t_size, saved_int_t, saved_size_t, lacks_range_penalty, lacks_scoring_metric);
             check_interrupt_switch(ss);
-            read_bytes<char>((void*)optional_metadata, size_metadata, in);
+            if (optional_metadata) {
+                read_bytes<char>((void*)optional_metadata, size_metadata, in);
+            }
             break;
         }
         case HasExtModelPlusImputerPlusIndexerPlusMetadataNext:
@@ -4276,7 +4290,9 @@ void deserialize_combined
             check_interrupt_switch(ss);
             deserialize_model(*indexer, in, has_same_endianness, has_same_int_size, has_same_size_t_size, saved_int_t, saved_size_t, lacks_range_penalty, lacks_scoring_metric);
             check_interrupt_switch(ss);
-            read_bytes<char>((void*)optional_metadata, size_metadata, in);
+            if (optional_metadata) {
+                read_bytes<char>((void*)optional_metadata, size_metadata, in);
+            }
             break;
         }
         

data/vendor/isotree/src/sql.cpp

@@ -593,14 +593,14 @@ void extract_cond_ext_isotree(ExtIsoForest &model, IsoHPlane &hplane,
                     case SubSet:
                     {
                         hplane_conds += std::string("CASE ") + categ_colnames[hplane.col_num[ix]];
-                        for (size_t categ = 0; categ < hplane.cat_coef[hplane.col_num[ix]].size(); categ++)
+                        for (size_t categ = 0; categ < hplane.cat_coef[n_visited_categ].size(); categ++)
                         {
                             hplane_conds
                                 +=
                               std::string(" WHEN '")
                             + categ_levels[hplane.col_num[ix]][categ]
                             + std::string("' THEN ")
-                            + std::to_string( hplane.cat_coef[hplane.col_num[ix]][categ]);
+                            + std::to_string( hplane.cat_coef[n_visited_categ][categ]);
                         }
                         if (model.new_cat_action == Smallest)
                             hplane_conds += std::string(" ELSE ") + std::to_string(hplane.fill_new[n_visited_categ]);

data/vendor/isotree/src/utils.hpp

@@ -130,34 +130,7 @@
 
 /* adapted from cephes */
 #define EULERS_GAMMA 0.577215664901532860606512
-double digamma(double x)
-{
-    double y, z, z2;
-
-    /* check for positive integer up to 128 */
-    if (unlikely((x <= 64) && (x == std::floor(x)))) {
-        return harmonic_recursive(1.0, (double)x) - EULERS_GAMMA;
-    }
-
-    if (likely(x < 1.0e17 ))
-    {
-        z = 1.0/(x * x);
-        z2 = square(z);
-        y = z * ( 8.33333333333333333333E-2
-                 -8.33333333333333333333E-3*z
-                 +3.96825396825396825397E-3*z2
-                 -4.16666666666666666667E-3*z2*z
-                 +7.57575757575757575758E-3*square(z2)
-                 -2.10927960927960927961E-2*square(z2)*z
-                 +8.33333333333333333333E-2*square(z2)*z2);
-    }
-    else {
-        y = 0.0;
-    }
-
-    y = ((-0.5/x) - y) + std::log(x);
-    return y;
-}
+#include "digamma.hpp"
 
 /* http://fredrik-j.blogspot.com/2009/02/how-not-to-compute-harmonic-numbers.html
    https://en.wikipedia.org/wiki/Harmonic_number
@@ -434,7 +407,7 @@ void build_btree_sampler(std::vector<double> &btree_weights, real_t *restrict sa
     
     if (std::isnan(btree_weights[0]) || btree_weights[0] <= 0)
     {
-        fprintf(stderr, "Numeric precision error with sample weights, will not use them.\n");
+        print_errmsg("Numeric precision error with sample weights, will not use them.\n");
         log2_n = 0;
         btree_weights.clear();
         btree_weights.shrink_to_fit();
@@ -672,16 +645,21 @@ void weighted_shuffle(size_t *restrict outp, size_t n, real_t *restrict weights,
     }
 }
 
+/* Goualard, Frédéric. "Drawing random floating-point numbers from an interval."
+   ACM Transactions on Modeling and Computer Simulation (TOMACS) 32.3 (2022): 1-24. */
+[[gnu::flatten]]
 double sample_random_uniform(double xmin, double xmax, RNG_engine &rng) noexcept
 {
-    double out;
-    std::uniform_real_distribution<double> runif(xmin, xmax);
-    for (int attempt = 0; attempt < 100; attempt++)
-    {
-        out = runif(rng);
-        if (likely(out < xmax)) return out;
+    const double random_unit = UniformUnitInterval(0, 1)(rng);
+    const double half_min = 0.5 * xmin;
+    const double half_max = 0.5 * xmax;
+    double out = 2. * (half_min + random_unit * (half_max - half_min));
+    if (unlikely(out >= xmax)) {
+        if (unlikely(xmax == xmin)) return xmin;
+        out = std::nextafter(xmax, xmin);
     }
-    return xmin;
+    out = std::fmax(out, xmin);
+    return out;
 }
 
 template <class ldouble_safe>
@@ -3721,7 +3699,7 @@ void check_interrupt_switch(SignalSwitcher &ss)
     if (interrupt_switch)
     {
         ss.restore_handle();
-        fprintf(stderr, "Error: procedure was interrupted\n");
+        print_errmsg("Error: procedure was interrupted\n");
         raise(SIGINT);
         #ifdef _FOR_R
         Rcpp::checkUserInterrupt();

data/vendor/isotree/src/xoshiro.hpp

@@ -285,13 +285,9 @@ static inline bool get_is_little_endian() noexcept
 static const bool is_little_endian = get_is_little_endian();
 
 /* ~Uniform([0,1))
-   Be aware that the compilers headers may:
-   - Produce a non-uniform distribution as they divide
-     by the maximum value of the generator (not all numbers
-     between zero and one are representable).
-   - Draw from a closed interval [0,1] (infinitesimal chance
-     that something will go wrong, but better not take it).
-   (For example, GCC4 had bugs like those)
+   Be aware that the compilers headers may produce a non-uniform
+   distribution as they divide by the maximum value of the generator
+   (not all numbers between zero and one are representable).
    Hence this replacement. It is not too much slower
    than what the compiler's header use. */
 class UniformUnitInterval

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: isotree
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-14 00:00:00.000000000 Z
+date: 2023-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -49,6 +49,7 @@ files:
 - vendor/isotree/src/Rwrapper.cpp
 - vendor/isotree/src/c_interface.cpp
 - vendor/isotree/src/crit.hpp
+- vendor/isotree/src/digamma.hpp
 - vendor/isotree/src/dist.hpp
 - vendor/isotree/src/exp_depth_table.hpp
 - vendor/isotree/src/extended.hpp
@@ -102,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Outlier/anomaly detection for Ruby using Isolation Forest