datasketches 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d74bd4504918fd8217f9cf7d8c24442b5c196b2d874a042f6a2f30a24ae51db
-  data.tar.gz: 7521194ca0d05808b234c6cb1bb5150874c28f7e9536820f728b33b0aec8c52a
+  metadata.gz: e62d3e98b646fb074ae5bccf506a3ec9659bfde99d98721e2e3d7377ea68a3ce
+  data.tar.gz: ef7a1d11de9801e0d40d0071a46f695555a026a54c8e31d23624c01045faafe6
 SHA512:
-  metadata.gz: db41c21f18a51bf285e32556c52e06453810448d1d75d11cd1022576a98d5069977d65fe6bab7e5bd6425468531414fdd801a1bde1bfdf82fc05f455d97b80fd
-  data.tar.gz: 892e9f2c4b891194cfc1af8387494e78eb2e703b4a56f7c91e1b4784f0bd2439f35f8e25f92e954be44418d2964e804f892ab687df2acf8e9b64d43e0049cca0
+  metadata.gz: 8808ddf87374a66de48f0434f22b8813cd0170d40ce1dc518a480235f6bd359322fb1e354e224355911f5569a32dce99457515dfd6a8a591223ea6a1e834dfb8
+  data.tar.gz: 5fdeee4c5b69a495d90242e2a3e6157fbca0931bebeb77ba025840c15f14e571c9a672b527082324b2e72e17ae6e0d301b7978cf21be6ae77766cd1b4f18c3d0

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.2.0 (2021-05-17)
+
+- Updated DataSketches to 3.0.0
+- Updated to Rice 4
+
 ## 0.1.2 (2021-01-21)
 
 - Added `CpcUnion` and `UpdateThetaSketch`

data/ext/datasketches/cpc_wrapper.cpp

@@ -3,8 +3,7 @@
 #include <cpc_sketch.hpp>
 #include <cpc_union.hpp>
 
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
+#include "ext.h"
 
 using datasketches::cpc_sketch;
 using datasketches::cpc_union;
@@ -16,30 +15,30 @@ using Rice::Arg;
 
 void init_cpc(Rice::Module& m) {
   Rice::define_class_under<cpc_sketch>(m, "CpcSketch")
-    .define_constructor(Rice::Constructor<cpc_sketch, uint8_t, uint64_t>(), (Rice::Arg("lg_k")=CPC_DEFAULT_LG_K, Rice::Arg("seed")=DEFAULT_SEED))
+    .define_constructor(Rice::Constructor<cpc_sketch, uint8_t, uint64_t>(), Rice::Arg("lg_k")=CPC_DEFAULT_LG_K, Rice::Arg("seed")=DEFAULT_SEED)
     .define_method("lg_k", &cpc_sketch::get_lg_k)
     .define_method("empty?", &cpc_sketch::is_empty)
     .define_method("lower_bound", &cpc_sketch::get_lower_bound)
     .define_method("upper_bound", &cpc_sketch::get_upper_bound)
     .define_method(
       "update",
-      *[](cpc_sketch& self, Rice::Object datum) {
+      [](cpc_sketch& self, Rice::Object datum) {
         if (FIXNUM_P(datum.value())) {
-          return self.update(from_ruby<int64_t>(datum));
+          return self.update(Rice::detail::From_Ruby<int64_t>().convert(datum));
         } else if (datum.is_a(rb_cNumeric)) {
-          return self.update(from_ruby<double>(datum));
+          return self.update(Rice::detail::From_Ruby<double>().convert(datum));
         } else {
           return self.update(datum.to_s().str());
         }
       })
     .define_method(
       "estimate",
-      *[](cpc_sketch& self) {
+      [](cpc_sketch& self) {
         return self.get_estimate();
       })
     .define_method(
       "serialize",
-      *[](cpc_sketch& self) {
+      [](cpc_sketch& self) {
         std::ostringstream oss;
         self.serialize(oss);
         return oss.str();
@@ -47,22 +46,22 @@ void init_cpc(Rice::Module& m) {
     // TODO change to summary?
     .define_method(
       "to_string",
-      *[](cpc_sketch& self) {
+      [](cpc_sketch& self) {
         return self.to_string();
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "deserialize",
-      *[](std::string& is) {
+      [](const std::string& is) {
         std::istringstream iss(is);
         return cpc_sketch::deserialize(iss);
       });
 
   Rice::define_class_under<cpc_union>(m, "CpcUnion")
-    .define_constructor(Rice::Constructor<cpc_union, uint8_t, uint64_t>(), (Rice::Arg("lg_k"), Rice::Arg("seed")=DEFAULT_SEED))
+    .define_constructor(Rice::Constructor<cpc_union, uint8_t, uint64_t>(), Rice::Arg("lg_k"), Rice::Arg("seed")=DEFAULT_SEED)
     .define_method("result", &cpc_union::get_result)
     .define_method(
       "update",
-      *[](cpc_union& self, cpc_sketch& sketch) {
+      [](cpc_union& self, cpc_sketch& sketch) {
         self.update(sketch);
       });
 }

data/ext/datasketches/ext.cpp

@@ -1,4 +1,4 @@
-#include <rice/Module.hpp>
+#include "ext.h"
 
 void init_cpc(Rice::Module& m);
 void init_fi(Rice::Module& m);

data/ext/datasketches/ext.h

@@ -0,0 +1,4 @@
+#pragma once
+
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>

data/ext/datasketches/extconf.rb

@@ -1,6 +1,6 @@
 require "mkmf-rice"
 
-$CXXFLAGS += " -std=c++11"
+$CXXFLAGS += " -std=c++17"
 
 ext = File.expand_path(".", __dir__)
 datasketches = File.expand_path("../../vendor/datasketches-cpp", __dir__)

data/ext/datasketches/fi_wrapper.cpp

@@ -2,8 +2,7 @@
 
 #include <frequent_items_sketch.hpp>
 
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
+#include "ext.h"
 
 template<typename T>
 void bind_fi_sketch(Rice::Module& m, const char* name) {
@@ -18,12 +17,12 @@ void bind_fi_sketch(Rice::Module& m, const char* name) {
     .define_method("maximum_error", &datasketches::frequent_items_sketch<T>::get_maximum_error)
     .define_method(
       "update",
-      *[](datasketches::frequent_items_sketch<T>& self, const T item) {
+      [](datasketches::frequent_items_sketch<T>& self, const T item) {
         self.update(item);
       })
     .define_method(
       "serialize",
-      *[](datasketches::frequent_items_sketch<T>& self) {
+      [](datasketches::frequent_items_sketch<T>& self) {
         std::ostringstream oss;
         self.serialize(oss);
         return oss.str();
@@ -31,13 +30,12 @@ void bind_fi_sketch(Rice::Module& m, const char* name) {
     // TODO change to summary?
     .define_method(
       "to_string",
-      *[](datasketches::frequent_items_sketch<T>& self) {
+      [](datasketches::frequent_items_sketch<T>& self) {
         return self.to_string();
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "deserialize",
-      // TODO figure out segfault
-      *[](std::string is) {
+      [](const std::string& is) {
         std::istringstream iss(is);
         return datasketches::frequent_items_sketch<T>::deserialize(iss);
       });

data/ext/datasketches/hll_wrapper.cpp

@@ -2,8 +2,7 @@
 
 #include <hll.hpp>
 
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
+#include "ext.h"
 
 using datasketches::hll_sketch;
 using datasketches::hll_union;
@@ -17,30 +16,30 @@ void init_hll(Rice::Module& m) {
     .define_method("composite_estimate", &hll_sketch::get_composite_estimate)
     .define_method(
       "update",
-      *[](hll_sketch& self, Rice::Object datum) {
+      [](hll_sketch& self, Rice::Object datum) {
         if (FIXNUM_P(datum.value())) {
-          return self.update(from_ruby<int64_t>(datum));
+          return self.update(Rice::detail::From_Ruby<int64_t>().convert(datum));
         } else if (datum.is_a(rb_cNumeric)) {
-          return self.update(from_ruby<double>(datum));
+          return self.update(Rice::detail::From_Ruby<double>().convert(datum));
         } else {
           return self.update(datum.to_s().str());
         }
       })
     .define_method(
       "estimate",
-      *[](hll_sketch& self) {
+      [](hll_sketch& self) {
         return self.get_estimate();
       })
     .define_method(
       "serialize_compact",
-      *[](hll_sketch& self) {
+      [](hll_sketch& self) {
         std::ostringstream oss;
         self.serialize_compact(oss);
         return oss.str();
       })
     .define_method(
       "serialize_updatable",
-      *[](hll_sketch& self) {
+      [](hll_sketch& self) {
         std::ostringstream oss;
         self.serialize_updatable(oss);
         return oss.str();
@@ -48,12 +47,12 @@ void init_hll(Rice::Module& m) {
     // TODO change to summary?
     .define_method(
       "to_string",
-      *[](hll_sketch& self) {
+      [](hll_sketch& self) {
         return self.to_string();
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "deserialize",
-      *[](std::string& is) {
+      [](const std::string& is) {
         std::istringstream iss(is);
         return hll_sketch::deserialize(iss);
       });
@@ -62,17 +61,17 @@ void init_hll(Rice::Module& m) {
     .define_constructor(Rice::Constructor<hll_union, int>())
     .define_method(
       "update",
-      *[](hll_union& self, hll_sketch& sketch) {
+      [](hll_union& self, hll_sketch& sketch) {
         self.update(sketch);
       })
     .define_method(
       "estimate",
-      *[](hll_union& self) {
+      [](hll_union& self) {
         return self.get_estimate();
       })
     .define_method(
       "result",
-      *[](hll_union& self) {
+      [](hll_union& self) {
         return self.get_result();
       });
 }

data/ext/datasketches/kll_wrapper.cpp

@@ -2,79 +2,31 @@
 
 #include <kll_sketch.hpp>
 
-#include <rice/Array.hpp>
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
+#include "ext.h"
 
 using datasketches::kll_sketch;
 
-template<>
-std::vector<int> from_ruby<std::vector<int>>(Rice::Object x)
+namespace Rice::detail
 {
-  auto a = Rice::Array(x);
-  std::vector<int> vec(a.size());
-  for (long i = 0; i < a.size(); i++) {
-    vec[i] = from_ruby<int>(a[i]);
-  }
-  return vec;
-}
-
-template<>
-std::vector<float> from_ruby<std::vector<float>>(Rice::Object x)
-{
-  auto a = Rice::Array(x);
-  std::vector<float> vec(a.size());
-  for (long i = 0; i < a.size(); i++) {
-    vec[i] = from_ruby<float>(a[i]);
-  }
-  return vec;
-}
-
-template<>
-std::vector<double> from_ruby<std::vector<double>>(Rice::Object x)
-{
-  auto a = Rice::Array(x);
-  std::vector<double> vec(a.size());
-  for (long i = 0; i < a.size(); i++) {
-    vec[i] = from_ruby<double>(a[i]);
-  }
-  return vec;
-}
-
-template<>
-Rice::Object to_ruby<std::vector<int>>(std::vector<int> const & x)
-{
-  auto a = Rice::Array();
-  for (size_t i = 0; i < x.size(); i++) {
-    a.push(x[i]);
-  }
-  return a;
-}
-
-template<>
-Rice::Object to_ruby<std::vector<float>>(std::vector<float> const & x)
-{
-  auto a = Rice::Array();
-  for (size_t i = 0; i < x.size(); i++) {
-    a.push(x[i]);
-  }
-  return a;
-}
-
-template<>
-Rice::Object to_ruby<std::vector<double>>(std::vector<double> const & x)
-{
-  auto a = Rice::Array();
-  for (size_t i = 0; i < x.size(); i++) {
-    a.push(x[i]);
-  }
-  return a;
+  template<typename T>
+  class To_Ruby<std::vector<T>>
+  {
+  public:
+    VALUE convert(std::vector<T> const & x)
+    {
+      auto a = rb_ary_new2(x.size());
+      for (const auto& v : x) {
+        detail::protect(rb_ary_push, a, To_Ruby<T>().convert(v));
+      }
+      return a;
+    }
+  };
 }
 
 template<typename T>
 void bind_kll_sketch(Rice::Module& m, const char* name) {
   Rice::define_class_under<kll_sketch<T>>(m, name)
-    .define_constructor(Rice::Constructor<kll_sketch<T>, uint16_t>(), (Rice::Arg("k")=kll_sketch<T>::DEFAULT_K))
+    .define_constructor(Rice::Constructor<kll_sketch<T>, uint16_t>(), Rice::Arg("k")=kll_sketch<T>::DEFAULT_K)
     .define_method("empty?", &kll_sketch<T>::is_empty)
     .define_method("n", &kll_sketch<T>::get_n)
     .define_method("num_retained", &kll_sketch<T>::get_num_retained)
@@ -84,42 +36,42 @@ void bind_kll_sketch(Rice::Module& m, const char* name) {
     .define_method("quantile", &kll_sketch<T>::get_quantile)
     .define_method(
       "quantiles",
-      *[](kll_sketch<T>& self, Rice::Object obj) {
+      [](kll_sketch<T>& self, Rice::Object obj) {
         if (obj.is_a(rb_cArray)) {
-          auto fractions = from_ruby<std::vector<double>>(obj);
+          auto fractions = Rice::detail::From_Ruby<std::vector<double>>().convert(obj);
           return self.get_quantiles(&fractions[0], fractions.size());
         } else {
-          return self.get_quantiles(from_ruby<size_t>(obj));
+          return self.get_quantiles(Rice::detail::From_Ruby<size_t>().convert(obj));
         }
       })
     .define_method(
       "rank",
-      *[](kll_sketch<T>& self, const T item) {
+      [](kll_sketch<T>& self, const T item) {
         return self.get_rank(item);
       })
     .define_method(
       "pmf",
-      *[](kll_sketch<T>& self, std::vector<T> split_points) {
+      [](kll_sketch<T>& self, std::vector<T> split_points) {
         return self.get_PMF(&split_points[0], split_points.size());
       })
     .define_method(
       "cdf",
-      *[](kll_sketch<T>& self, std::vector<T> split_points) {
+      [](kll_sketch<T>& self, std::vector<T> split_points) {
         return self.get_CDF(&split_points[0], split_points.size());
       })
     .define_method(
       "merge",
-      *[](kll_sketch<T>& self, const kll_sketch<T>& other) {
+      [](kll_sketch<T>& self, const kll_sketch<T>& other) {
         self.merge(other);
       })
     .define_method(
       "update",
-      *[](kll_sketch<T>& self, const T item) {
+      [](kll_sketch<T>& self, const T item) {
         self.update(item);
       })
     .define_method(
       "serialize",
-      *[](kll_sketch<T>& self) {
+      [](kll_sketch<T>& self) {
         std::ostringstream oss;
         self.serialize(oss);
         return oss.str();
@@ -127,12 +79,12 @@ void bind_kll_sketch(Rice::Module& m, const char* name) {
     // TODO change to summary?
     .define_method(
       "to_string",
-      *[](kll_sketch<T>& self) {
+      [](kll_sketch<T>& self) {
         return self.to_string();
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "deserialize",
-      *[](std::string& is) {
+      [](const std::string& is) {
         std::istringstream iss(is);
         return kll_sketch<T>::deserialize(iss);
       });

data/ext/datasketches/theta_wrapper.cpp

@@ -5,8 +5,7 @@
 #include <theta_intersection.hpp>
 #include <theta_a_not_b.hpp>
 
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
+#include "ext.h"
 
 using datasketches::theta_sketch;
 using datasketches::update_theta_sketch;
@@ -24,79 +23,66 @@ void init_theta(Rice::Module& m) {
     .define_method("empty?", &theta_sketch::is_empty)
     .define_method("estimate", &theta_sketch::get_estimate)
     .define_method("lower_bound", &theta_sketch::get_lower_bound)
-    .define_method("upper_bound", &theta_sketch::get_upper_bound)
-    .define_method(
-      "serialize",
-      *[](theta_sketch& self) {
-        std::ostringstream oss;
-        self.serialize(oss);
-        return oss.str();
+    .define_method("upper_bound", &theta_sketch::get_upper_bound);
+
+  Rice::define_class_under<compact_theta_sketch, theta_sketch>(m, "CompactThetaSketch")
+    .define_singleton_function(
+      "deserialize",
+      [](const std::string& is) {
+        std::istringstream iss(is);
+        return compact_theta_sketch::deserialize(iss);
       });
 
   Rice::define_class_under<update_theta_sketch, theta_sketch>(m, "UpdateThetaSketch")
-    .define_singleton_method(
+    .define_singleton_function(
       "new",
-      *[](uint8_t lg_k, double p, uint64_t seed) {
+      [](uint8_t lg_k, double p, uint64_t seed) {
         update_theta_sketch::builder builder;
         builder.set_lg_k(lg_k);
         builder.set_p(p);
         builder.set_seed(seed);
         return builder.build();
       },
-      (Arg("lg_k")=update_theta_sketch::builder::DEFAULT_LG_K, Arg("p")=1.0, Arg("seed")=DEFAULT_SEED))
-    .define_method("compact", &update_theta_sketch::compact, (Arg("ordered")=true))
+      Arg("lg_k")=update_theta_sketch::builder::DEFAULT_LG_K, Arg("p")=1.0, Arg("seed")=DEFAULT_SEED)
+    .define_method("compact", &update_theta_sketch::compact, Arg("ordered")=true)
     .define_method(
       "update",
-      *[](update_theta_sketch& self, Rice::Object datum) {
+      [](update_theta_sketch& self, Rice::Object datum) {
         if (FIXNUM_P(datum.value())) {
-          return self.update(from_ruby<int64_t>(datum));
+          return self.update(Rice::detail::From_Ruby<int64_t>().convert(datum));
         } else if (datum.is_a(rb_cNumeric)) {
-          return self.update(from_ruby<double>(datum));
+          return self.update(Rice::detail::From_Ruby<double>().convert(datum));
         } else {
           return self.update(datum.to_s().str());
         }
       })
     .define_method(
       "estimate",
-      *[](update_theta_sketch& self) {
+      [](update_theta_sketch& self) {
         return self.get_estimate();
-      })
-    .define_singleton_method(
-      "deserialize",
-      *[](std::string& is) {
-        std::istringstream iss(is);
-        return update_theta_sketch::deserialize(iss);
-      });
-
-  Rice::define_class_under<compact_theta_sketch, theta_sketch>(m, "CompactThetaSketch")
-    .define_singleton_method(
-      "deserialize",
-      *[](std::string& is) {
-        std::istringstream iss(is);
-        return compact_theta_sketch::deserialize(iss);
       });
 
   Rice::define_class_under<theta_union>(m, "ThetaUnion")
-    .define_singleton_method(
+    .define_singleton_function(
       "new",
-      *[](uint8_t lg_k, double p, uint64_t seed) {
+      [](uint8_t lg_k, double p, uint64_t seed) {
         theta_union::builder builder;
         builder.set_lg_k(lg_k);
         builder.set_p(p);
         builder.set_seed(seed);
         return builder.build();
       },
-      (Arg("lg_k")=update_theta_sketch::builder::DEFAULT_LG_K, Arg("p")=1.0, Arg("seed")=DEFAULT_SEED))
-    .define_method("update", &theta_union::update)
-    .define_method("result", &theta_union::get_result, (Arg("ordered")=true));
+      Arg("lg_k")=update_theta_sketch::builder::DEFAULT_LG_K, Arg("p")=1.0, Arg("seed")=DEFAULT_SEED)
+    .define_method("update", &theta_union::update<const theta_sketch&>)
+    .define_method("result", &theta_union::get_result, Arg("ordered")=true);
 
   Rice::define_class_under<theta_intersection>(m, "ThetaIntersection")
-    .define_constructor(Rice::Constructor<theta_intersection, uint64_t>(), (Arg("seed")=DEFAULT_SEED))
-    .define_method("update", &theta_intersection::update)
-    .define_method("result", &theta_intersection::get_result, (Arg("ordered")=true))
+    .define_constructor(Rice::Constructor<theta_intersection, uint64_t>(), Arg("seed")=DEFAULT_SEED)
+    .define_method("update", &theta_intersection::update<const theta_sketch&>)
+    .define_method("result", &theta_intersection::get_result, Arg("ordered")=true)
     .define_method("result?", &theta_intersection::has_result);
 
   Rice::define_class_under<theta_a_not_b>(m, "ThetaANotB")
-    .define_constructor(Rice::Constructor<theta_a_not_b, uint64_t>(), (Arg("seed")=DEFAULT_SEED))
-    .define_method("compute", &theta_a_not_b::compute, (Arg("a"), Arg("b"), Arg("ordered")=true));
+    .define_constructor(Rice::Constructor<theta_a_not_b, uint64_t>(), Arg("seed")=DEFAULT_SEED)
+    .define_method("compute", &theta_a_not_b::compute<const theta_sketch&, const theta_sketch&>, Arg("a"), Arg("b"), Arg("ordered")=true);
 }