datasketches 0.2.0 → 0.2.4

data/vendor/datasketches-cpp/python/src/hll_wrapper.cpp

@@ -56,9 +56,9 @@ void init_hll(py::module &m) {
     .export_values();
 
   py::class_<hll_sketch>(m, "hll_sketch")
-    .def(py::init<int>(), py::arg("lg_k"))
-    .def(py::init<int, target_hll_type>(), py::arg("lg_k"), py::arg("tgt_type"))
-    .def(py::init<int, target_hll_type, bool>(), py::arg("lg_k"), py::arg("tgt_type"), py::arg("start_max_size")=false)
+    .def(py::init<uint8_t>(), py::arg("lg_k"))
+    .def(py::init<uint8_t, target_hll_type>(), py::arg("lg_k"), py::arg("tgt_type"))
+    .def(py::init<uint8_t, target_hll_type, bool>(), py::arg("lg_k"), py::arg("tgt_type"), py::arg("start_max_size")=false)
     .def_static("deserialize", &dspy::hll_sketch_deserialize,
          "Reads a bytes object and returns the corresponding hll_sketch")
     .def("serialize_compact", &dspy::hll_sketch_serialize_compact,
@@ -104,7 +104,7 @@ void init_hll(py::module &m) {
     ;
 
   py::class_<hll_union>(m, "hll_union")
-    .def(py::init<int>(), py::arg("lg_max_k"))
+    .def(py::init<uint8_t>(), py::arg("lg_max_k"))
     .def_property_readonly("lg_config_k", &hll_union::get_lg_config_k, "Configured lg_k value for the union")
     .def_property_readonly("tgt_type", &hll_union::get_target_type, "Returns the HLL type (4, 6, or 8) when in estimation mode")
     .def("get_estimate", &hll_union::get_estimate,

data/vendor/datasketches-cpp/python/src/kll_wrapper.cpp

@@ -116,7 +116,7 @@ void bind_kll_sketch(py::module &m, const char* name) {
   using namespace datasketches;
 
   py::class_<kll_sketch<T>>(m, name)
-    .def(py::init<uint16_t>(), py::arg("k")=kll_sketch<T>::DEFAULT_K)
+    .def(py::init<uint16_t>(), py::arg("k")=kll_constants::DEFAULT_K)
     .def(py::init<const kll_sketch<T>&>())
     .def("update", (void (kll_sketch<T>::*)(const T&)) &kll_sketch<T>::update, py::arg("item"),
          "Updates the sketch with the given value")

data/vendor/datasketches-cpp/python/src/theta_wrapper.cpp

@@ -64,8 +64,8 @@ compact_theta_sketch compact_theta_sketch_deserialize(py::bytes skBytes, uint64_
   return compact_theta_sketch::deserialize(skStr.c_str(), skStr.length(), seed);
 }
 
-py::list theta_jaccard_sim_computation(const theta_sketch& sketch_a, const theta_sketch& sketch_b) {
-  return py::cast(theta_jaccard_similarity::jaccard(sketch_a, sketch_b));
+py::list theta_jaccard_sim_computation(const theta_sketch& sketch_a, const theta_sketch& sketch_b, uint64_t seed) {
+  return py::cast(theta_jaccard_similarity::jaccard(sketch_a, sketch_b, seed));
 }
 
 }
@@ -103,7 +103,7 @@ void init_theta(py::module &m) {
 
   py::class_<update_theta_sketch, theta_sketch>(m, "update_theta_sketch")
     .def(py::init(&dspy::update_theta_sketch_factory),
-         py::arg("lg_k")=update_theta_sketch::builder::DEFAULT_LG_K, py::arg("p")=1.0, py::arg("seed")=DEFAULT_SEED)
+         py::arg("lg_k")=theta_constants::DEFAULT_LG_K, py::arg("p")=1.0, py::arg("seed")=DEFAULT_SEED)
     .def(py::init<const update_theta_sketch&>())
     .def("update", (void (update_theta_sketch::*)(int64_t)) &update_theta_sketch::update, py::arg("datum"),
          "Updates the sketch with the given integral value")
@@ -127,7 +127,7 @@ void init_theta(py::module &m) {
 
   py::class_<theta_union>(m, "theta_union")
     .def(py::init(&dspy::theta_union_factory),
-         py::arg("lg_k")=update_theta_sketch::builder::DEFAULT_LG_K, py::arg("p")=1.0, py::arg("seed")=DEFAULT_SEED)
+         py::arg("lg_k")=theta_constants::DEFAULT_LG_K, py::arg("p")=1.0, py::arg("seed")=DEFAULT_SEED)
     .def("update", &theta_union::update<const theta_sketch&>, py::arg("sketch"),
          "Updates the union with the given sketch")
     .def("get_result", &theta_union::get_result, py::arg("ordered")=true,
@@ -153,18 +153,18 @@ void init_theta(py::module &m) {
   
   py::class_<theta_jaccard_similarity>(m, "theta_jaccard_similarity")
      .def_static("jaccard", &dspy::theta_jaccard_sim_computation,
-                 py::arg("sketch_a"), py::arg("sketch_b"),
+                 py::arg("sketch_a"), py::arg("sketch_b"), py::arg("seed")=DEFAULT_SEED,
                  "Returns a list with {lower_bound, estimate, upper_bound} of the Jaccard similarity between sketches")
      .def_static("exactly_equal", &theta_jaccard_similarity::exactly_equal<const theta_sketch&, const theta_sketch&>,
-                 py::arg("sketch_a"), py::arg("sketch_b"),
+                 py::arg("sketch_a"), py::arg("sketch_b"), py::arg("seed")=DEFAULT_SEED,
                  "Returns True if sketch_a and sketch_b are equivalent, otherwise False")
      .def_static("similarity_test", &theta_jaccard_similarity::similarity_test<const theta_sketch&, const theta_sketch&>,
-                 py::arg("actual"), py::arg("expected"), py::arg("threshold"),
+                 py::arg("actual"), py::arg("expected"), py::arg("threshold"), py::arg("seed")=DEFAULT_SEED,
                  "Tests similarity of an actual sketch against an expected sketch. Computers the lower bound of the Jaccard "
                  "index J_{LB} of the actual and expected sketches. If J_{LB} >= threshold, then the sketches are considered "
                  "to be similar sith a confidence of 97.7% and returns True, otherwise False.")
      .def_static("dissimilarity_test", &theta_jaccard_similarity::dissimilarity_test<const theta_sketch&, const theta_sketch&>,
-                 py::arg("actual"), py::arg("expected"), py::arg("threshold"),
+                 py::arg("actual"), py::arg("expected"), py::arg("threshold"), py::arg("seed")=DEFAULT_SEED,
                  "Tests dissimilarity of an actual sketch against an expected sketch. Computers the lower bound of the Jaccard "
                  "index J_{UB} of the actual and expected sketches. If J_{UB} <= threshold, then the sketches are considered "
                  "to be dissimilar sith a confidence of 97.7% and returns True, otherwise False.")            

data/vendor/datasketches-cpp/python/src/vector_of_kll.cpp

@@ -29,14 +29,20 @@ namespace py = pybind11;
 
 namespace datasketches {
 
+namespace vector_of_kll_constants {
+  static const uint32_t DEFAULT_K = kll_constants::DEFAULT_K;
+  static const uint32_t DEFAULT_D = 1;
+}
+
 // Wrapper class for Numpy compatibility
 template <typename T, typename C = std::less<T>, typename S = serde<T>>
 class vector_of_kll_sketches {
   public:
-    static const uint32_t DEFAULT_K = kll_sketch<T, C, S>::DEFAULT_K;
-    static const uint32_t DEFAULT_D = 1;
+    // TODO: Redundant and deprecated. Will be removed in next major version release.
+    static const uint32_t DEFAULT_K = vector_of_kll_constants::DEFAULT_K;
+    static const uint32_t DEFAULT_D = vector_of_kll_constants::DEFAULT_D;
 
-    explicit vector_of_kll_sketches(uint32_t k = DEFAULT_K, uint32_t d = DEFAULT_D);
+    explicit vector_of_kll_sketches(uint32_t k = vector_of_kll_constants::DEFAULT_K, uint32_t d = vector_of_kll_constants::DEFAULT_D);
     vector_of_kll_sketches(const vector_of_kll_sketches& other);
     vector_of_kll_sketches(vector_of_kll_sketches&& other) noexcept;
     vector_of_kll_sketches<T,C,S>& operator=(const vector_of_kll_sketches& other);
@@ -432,8 +438,8 @@ void bind_vector_of_kll_sketches(py::module &m, const char* name) {
   using namespace datasketches;
 
   py::class_<vector_of_kll_sketches<T>>(m, name)
-    .def(py::init<uint32_t, uint32_t>(), py::arg("k")=vector_of_kll_sketches<T>::DEFAULT_K, 
-                                         py::arg("d")=vector_of_kll_sketches<T>::DEFAULT_D)
+    .def(py::init<uint32_t, uint32_t>(), py::arg("k")=vector_of_kll_constants::DEFAULT_K, 
+                                         py::arg("d")=vector_of_kll_constants::DEFAULT_D)
     .def(py::init<const vector_of_kll_sketches<T>&>())
     // allow user to retrieve k or d, in case it's instantiated w/ defaults
     .def("get_k", &vector_of_kll_sketches<T>::get_k,

data/vendor/datasketches-cpp/python/src/vo_wrapper.cpp

@@ -32,7 +32,7 @@ namespace python {
 template<typename T>
 py::list vo_sketch_get_samples(const var_opt_sketch<T>& sk) {
   py::list list;
-  for (auto& item : sk) {
+  for (auto item : sk) {
     py::tuple t = py::make_tuple(item.first, item.second);
     list.append(t);
   }
@@ -57,7 +57,7 @@ std::string vo_sketch_to_string(const var_opt_sketch<T>& sk, bool print_items) {
     ss << sk.to_string();
     ss << "### VarOpt Sketch Items" << std::endl;
     int i = 0;
-    for (auto& item : sk) {
+    for (auto item : sk) {
       // item.second is always a double
       // item.first is an arbitrary py::object, so get the value by
       // using internal str() method then casting to C++ std::string

data/vendor/datasketches-cpp/python/tests/hll_test.py

@@ -58,7 +58,7 @@ class HllTest(unittest.TestCase):
         self.assertEqual(len(sk_bytes), result.get_compact_serialization_bytes())
         new_hll = hll_sketch.deserialize(sk_bytes)
 
-        # the sketch can self-report its configuation and status
+        # the sketch can self-report its configuration and status
         self.assertEqual(new_hll.lg_config_k, k)
         self.assertEqual(new_hll.tgt_type, tgt_hll_type.HLL_4)
         self.assertFalse(new_hll.is_empty())

data/vendor/datasketches-cpp/python/tests/kll_test.py

@@ -30,10 +30,10 @@ class KllTest(unittest.TestCase):
       kll.update(0.0)
 
       # 0 should be near the median
-      self.assertAlmostEqual(0.5, kll.get_rank(0.0), delta=0.025)
+      self.assertAlmostEqual(0.5, kll.get_rank(0.0), delta=0.035)
       
       # the median should be near 0
-      self.assertAlmostEqual(0.0, kll.get_quantile(0.5), delta=0.025)
+      self.assertAlmostEqual(0.0, kll.get_quantile(0.5), delta=0.035)
 
       # we also track the min/max independently from the rest of the data
       # which lets us know the full observed data range

data/vendor/datasketches-cpp/python/tests/req_test.py

@@ -30,10 +30,10 @@ class reqTest(unittest.TestCase):
       req.update(0.0)
 
       # 0 should be near the median
-      self.assertAlmostEqual(0.5, req.get_rank(0.0), delta=0.03)
+      self.assertAlmostEqual(0.5, req.get_rank(0.0), delta=0.045)
       
       # the median should be near 0
-      self.assertAlmostEqual(0.0, req.get_quantile(0.5), delta=0.03)
+      self.assertAlmostEqual(0.0, req.get_quantile(0.5), delta=0.045)
 
       # we also track the min/max independently from the rest of the data
       # which lets us know the full observed data range

data/vendor/datasketches-cpp/python/tests/vector_of_kll_test.py

@@ -39,9 +39,9 @@ class VectorOfKllSketchesTest(unittest.TestCase):
         kll.update(dat)
 
       # 0 should be near the median
-      np.testing.assert_allclose(0.5, kll.get_ranks(0.0), atol=0.025)
+      np.testing.assert_allclose(0.5, kll.get_ranks(0.0), atol=0.035)
       # the median should be near 0
-      np.testing.assert_allclose(0.0, kll.get_quantiles(0.5), atol=0.025)
+      np.testing.assert_allclose(0.0, kll.get_quantiles(0.5), atol=0.035)
       # we also track the min/max independently from the rest of the data
       # which lets us know the full observed data range
       np.testing.assert_allclose(kll.get_min_values(), smin)
@@ -118,9 +118,9 @@ class VectorOfKllSketchesTest(unittest.TestCase):
         kll.update(dat)
 
       # 0 should be near the median
-      np.testing.assert_allclose(0.5, kll.get_ranks(0.0), atol=0.025)
+      np.testing.assert_allclose(0.5, kll.get_ranks(0.0), atol=0.035)
       # the median should be near 0
-      np.testing.assert_allclose(0.0, kll.get_quantiles(0.5), atol=0.025)
+      np.testing.assert_allclose(0.0, kll.get_quantiles(0.5), atol=0.035)
       # we also track the min/max independently from the rest of the data
       # which lets us know the full observed data range
       np.testing.assert_allclose(kll.get_min_values(), smin)

data/vendor/datasketches-cpp/python/tests/vo_test.py

@@ -46,7 +46,7 @@ class VoTest(unittest.TestCase):
     self.assertEqual(len(items), k)
 
     # we can also apply a predicate to the sketch to get an estimate
-    # (with optimially minimal variance) of the subset sum of items
+    # (with optimally minimal variance) of the subset sum of items
     # matching that predicate among the entire population
 
     # we'll use a lambda here, but any function operating on a single
@@ -89,11 +89,11 @@ class VoTest(unittest.TestCase):
     # the union and a sketch.
     print(union)
 
-    # if we want to print the list of itmes, there must be a
+    # if we want to print the list of items, there must be a
     # __str__() method for each item (which need not be the same
     # type; they're all generic python objects when used from
     # python), otherwise you may trigger an exception.
-    # to_string() is provided as a convenince to avoid direct
+    # to_string() is provided as a convenience to avoid direct
     # calls to __str__() with parameters.
     print(result.to_string(True))
 

data/vendor/datasketches-cpp/req/CMakeLists.txt

@@ -32,29 +32,16 @@ target_include_directories(req
 target_link_libraries(req INTERFACE common)
 target_compile_features(req INTERFACE cxx_std_11)
 
-set(req_HEADERS "")
-list(APPEND req_HEADERS "include/req_common.hpp")
-list(APPEND req_HEADERS "include/req_sketch.hpp")
-list(APPEND req_HEADERS "include/req_sketch_impl.hpp")
-list(APPEND req_HEADERS "include/req_compactor.hpp")
-list(APPEND req_HEADERS "include/req_compactor_impl.hpp")
-list(APPEND req_HEADERS "include/req_quantile_calculator.hpp")
-list(APPEND req_HEADERS "include/req_quantile_calculator_impl.hpp")
-
 install(TARGETS req
   EXPORT ${PROJECT_NAME}
 )
 
-install(FILES ${req_HEADERS}
+install(FILES 
+		include/req_common.hpp
+		include/req_sketch.hpp
+		include/req_sketch_impl.hpp
+		include/req_compactor.hpp
+		include/req_compactor_impl.hpp
+		include/req_quantile_calculator.hpp
+		include/req_quantile_calculator_impl.hpp
   DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/DataSketches")
-
-target_sources(req
-  INTERFACE
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/req_common.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/req_sketch.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/req_sketch_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/req_compactor.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/req_compactor_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/req_quantile_calculator.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/req_quantile_calculator_impl.hpp
-)

data/vendor/datasketches-cpp/req/include/req_common.hpp

@@ -29,7 +29,8 @@
 namespace datasketches {
 
 // TODO: have a common random bit with KLL
-static std::independent_bits_engine<std::mt19937, 1, unsigned> req_random_bit(std::chrono::system_clock::now().time_since_epoch().count());
+static std::independent_bits_engine<std::mt19937, 1, unsigned>
+  req_random_bit(static_cast<unsigned>(std::chrono::system_clock::now().time_since_epoch().count()));
 
 namespace req_constants {
   static const uint16_t MIN_K = 4;

data/vendor/datasketches-cpp/req/include/req_compactor.hpp

@@ -110,8 +110,8 @@ private:
 
   bool ensure_enough_sections();
   std::pair<uint32_t, uint32_t> compute_compaction_range(uint32_t secs_to_compact) const;
-  void grow(size_t new_capacity);
-  void ensure_space(size_t num);
+  void grow(uint32_t new_capacity);
+  void ensure_space(uint32_t num);
 
   static uint32_t nearest_even(float value);
 
@@ -123,10 +123,10 @@ private:
   req_compactor(bool hra, uint8_t lg_weight, bool sorted, float section_size_raw, uint8_t num_sections, uint64_t state, std::unique_ptr<T, items_deleter> items, uint32_t num_items, const Allocator& allocator);
 
   template<typename S>
-  static std::unique_ptr<T, items_deleter> deserialize_items(std::istream& is, const S& serde, const Allocator& allocator, size_t num);
+  static std::unique_ptr<T, items_deleter> deserialize_items(std::istream& is, const S& serde, const Allocator& allocator, uint32_t num);
 
   template<typename S>
-  static std::pair<std::unique_ptr<T, items_deleter>, size_t> deserialize_items(const void* bytes, size_t size, const S& serde, const Allocator& allocator, size_t num);
+  static std::pair<std::unique_ptr<T, items_deleter>, size_t> deserialize_items(const void* bytes, size_t size, const S& serde, const Allocator& allocator, uint32_t num);
 
 };
 

data/vendor/datasketches-cpp/req/include/req_compactor_impl.hpp

@@ -38,7 +38,7 @@ lg_weight_(lg_weight),
 hra_(hra),
 coin_(false),
 sorted_(sorted),
-section_size_raw_(section_size),
+section_size_raw_(static_cast<float>(section_size)),
 section_size_(section_size),
 num_sections_(req_constants::INIT_NUM_SECTIONS),
 state_(0),
@@ -72,9 +72,9 @@ items_(nullptr)
 {
   if (other.items_ != nullptr) {
     items_ = allocator_.allocate(capacity_);
-    const size_t from = hra_ ? capacity_ - num_items_ : 0;
-    const size_t to = hra_ ? capacity_ : num_items_;
-    for (size_t i = from; i < to; ++i) new (items_ + i) T(other.items_[i]);
+    const uint32_t from = hra_ ? capacity_ - num_items_ : 0;
+    const uint32_t to = hra_ ? capacity_ : num_items_;
+    for (uint32_t i = from; i < to; ++i) new (items_ + i) T(other.items_[i]);
   }
 }
 
@@ -165,16 +165,16 @@ template<typename T, typename C, typename A>
 template<typename FwdT>
 void req_compactor<T, C, A>::append(FwdT&& item) {
   if (num_items_ == capacity_) grow(capacity_ + get_nom_capacity());
-  const size_t i = hra_ ? capacity_ - num_items_ - 1 : num_items_;
+  const uint32_t i = hra_ ? capacity_ - num_items_ - 1 : num_items_;
   new (items_ + i) T(std::forward<FwdT>(item));
   ++num_items_;
   if (num_items_ > 1) sorted_ = false;
 }
 
 template<typename T, typename C, typename A>
-void req_compactor<T, C, A>::grow(size_t new_capacity) {
+void req_compactor<T, C, A>::grow(uint32_t new_capacity) {
   T* new_items = allocator_.allocate(new_capacity);
-  size_t new_i = hra_ ? new_capacity - num_items_ : 0;
+  uint32_t new_i = hra_ ? new_capacity - num_items_ : 0;
   for (auto it = begin(); it != end(); ++it, ++new_i) {
     new (new_items + new_i) T(std::move(*it));
     (*it).~T();
@@ -185,7 +185,7 @@ void req_compactor<T, C, A>::grow(size_t new_capacity) {
 }
 
 template<typename T, typename C, typename A>
-void req_compactor<T, C, A>::ensure_space(size_t num) {
+void req_compactor<T, C, A>::ensure_space(uint32_t num) {
   if (num_items_ + num > capacity_) grow(num_items_ + num + get_nom_capacity());
 }
 
@@ -218,13 +218,13 @@ void req_compactor<T, C, A>::merge(FwdC&& other) {
   while (ensure_enough_sections()) {}
   ensure_space(other.get_num_items());
   sort();
-  auto middle = hra_ ? begin() : end();
+  auto offset = hra_ ? capacity_ - num_items_ : num_items_;
   auto from = hra_ ? begin() - other.get_num_items() : end();
   auto to = from + other.get_num_items();
   auto other_it = other.begin();
   for (auto it = from; it != to; ++it, ++other_it) new (it) T(conditional_forward<FwdC>(*other_it));
   if (!other.sorted_) std::sort(from, to, C());
-  if (num_items_ > 0) std::inplace_merge(hra_ ? from : begin(), middle, hra_ ? end() : to, C());
+  if (num_items_ > 0) std::inplace_merge(hra_ ? from : begin(), items_ + offset, hra_ ? end() : to, C());
   num_items_ += other.get_num_items();
 }
 
@@ -240,7 +240,7 @@ template<typename T, typename C, typename A>
 std::pair<uint32_t, uint32_t> req_compactor<T, C, A>::compact(req_compactor& next) {
   const uint32_t starting_nom_capacity = get_nom_capacity();
   // choose a part of the buffer to compact
-  const uint32_t secs_to_compact = std::min(static_cast<uint32_t>(count_trailing_zeros_in_u32(~state_) + 1), static_cast<uint32_t>(num_sections_));
+  const uint32_t secs_to_compact = std::min<uint32_t>(count_trailing_zeros_in_u64(~state_) + 1, num_sections_);
   auto compaction_range = compute_compaction_range(secs_to_compact);
   if (compaction_range.second - compaction_range.first < 2) throw std::logic_error("compaction range error");
 
@@ -267,9 +267,9 @@ std::pair<uint32_t, uint32_t> req_compactor<T, C, A>::compact(req_compactor& nex
 
 template<typename T, typename C, typename A>
 bool req_compactor<T, C, A>::ensure_enough_sections() {
-  const float ssr = section_size_raw_ / sqrt(2);
+  const float ssr = section_size_raw_ / sqrtf(2);
   const uint32_t ne = nearest_even(ssr);
-  if (state_ >= static_cast<uint64_t>(1 << (num_sections_ - 1)) && ne >= req_constants::MIN_K) {
+  if (state_ >= static_cast<uint64_t>(1ULL << (num_sections_ - 1)) && ne >= req_constants::MIN_K) {
     section_size_raw_ = ssr;
     section_size_ = ne;
     num_sections_ <<= 1;
@@ -284,8 +284,8 @@ std::pair<uint32_t, uint32_t> req_compactor<T, C, A>::compute_compaction_range(u
   uint32_t non_compact = get_nom_capacity() / 2 + (num_sections_ - secs_to_compact) * section_size_;
   // make compacted region even
   if (((num_items_ - non_compact) & 1) == 1) ++non_compact;
-  const size_t low = hra_ ? 0 : non_compact;
-  const size_t high = hra_ ? num_items_ - non_compact : num_items_;
+  const uint32_t low = hra_ ? 0 : non_compact;
+  const uint32_t high = hra_ ? num_items_ - non_compact : num_items_;
   return std::pair<uint32_t, uint32_t>(low, high);
 }
 
@@ -309,19 +309,6 @@ void req_compactor<T, C, A>::promote_evens_or_odds(InIter from, InIter to, bool
   }
 }
 
-// helpers for integral types
-template<typename T>
-static inline T read(std::istream& is) {
-  T value;
-  is.read(reinterpret_cast<char*>(&value), sizeof(T));
-  return value;
-}
-
-template<typename T>
-static inline void write(std::ostream& os, T value) {
-  os.write(reinterpret_cast<const char*>(&value), sizeof(T));
-}
-
 // implementation for fixed-size arithmetic types (integral and floating point)
 template<typename T, typename C, typename A>
 template<typename S, typename TT, typename std::enable_if<std::is_arithmetic<TT>::value, int>::type>
@@ -394,7 +381,7 @@ req_compactor<T, C, A> req_compactor<T, C, A>::deserialize(std::istream& is, con
 
 template<typename T, typename C, typename A>
 template<typename S>
-auto req_compactor<T, C, A>::deserialize_items(std::istream& is, const S& serde, const A& allocator, size_t num)
+auto req_compactor<T, C, A>::deserialize_items(std::istream& is, const S& serde, const A& allocator, uint32_t num)
 -> std::unique_ptr<T, items_deleter> {
   A alloc(allocator);
   std::unique_ptr<T, items_deleter> items(alloc.allocate(num), items_deleter(allocator, false, num));
@@ -402,7 +389,7 @@ auto req_compactor<T, C, A>::deserialize_items(std::istream& is, const S& serde,
   // serde did not throw, enable destructors
   items.get_deleter().set_destroy(true);
   if (!is.good()) throw std::runtime_error("error reading from std::istream");
-  return std::move(items);
+  return items;
 }
 
 template<typename T, typename C, typename A>
@@ -443,7 +430,7 @@ std::pair<req_compactor<T, C, A>, size_t> req_compactor<T, C, A>::deserialize(co
 
 template<typename T, typename C, typename A>
 template<typename S>
-auto req_compactor<T, C, A>::deserialize_items(const void* bytes, size_t size, const S& serde, const A& allocator, size_t num)
+auto req_compactor<T, C, A>::deserialize_items(const void* bytes, size_t size, const S& serde, const A& allocator, uint32_t num)
 -> std::pair<std::unique_ptr<T, items_deleter>, size_t> {
   const char* ptr = static_cast<const char*>(bytes);
   const char* end_ptr = static_cast<const char*>(bytes) + size;
@@ -478,22 +465,22 @@ items_(items.release())
 template<typename T, typename C, typename A>
 class req_compactor<T, C, A>::items_deleter {
   public:
-  items_deleter(const A& allocator, bool destroy, uint32_t num): allocator(allocator), destroy(destroy), num(num) {}
+  items_deleter(const A& allocator, bool destroy, size_t num): allocator_(allocator), destroy_(destroy), num_(num) {}
   void operator() (T* ptr) {
     if (ptr != nullptr) {
-      if (destroy) {
-        for (uint32_t i = 0; i < num; ++i) {
+      if (destroy_) {
+        for (size_t i = 0; i < num_; ++i) {
           ptr[i].~T();
         }
       }
-      allocator.deallocate(ptr, num);
+      allocator_.deallocate(ptr, num_);
     }
   }
-  void set_destroy(bool destroy) { this->destroy = destroy; }
+  void set_destroy(bool destroy) { destroy_ = destroy; }
   private:
-  A allocator;
-  bool destroy;
-  uint32_t num;
+  A allocator_;
+  bool destroy_;
+  size_t num_;
 };
 
 } /* namespace datasketches */

data/vendor/datasketches-cpp/req/include/req_sketch.hpp

@@ -319,7 +319,7 @@ private:
 
   // for deserialization
   class item_deleter;
-  req_sketch(uint32_t k, bool hra, uint64_t n, std::unique_ptr<T, item_deleter> min_value, std::unique_ptr<T, item_deleter> max_value, std::vector<Compactor, AllocCompactor>&& compactors);
+  req_sketch(uint16_t k, bool hra, uint64_t n, std::unique_ptr<T, item_deleter> min_value, std::unique_ptr<T, item_deleter> max_value, std::vector<Compactor, AllocCompactor>&& compactors);
 
   static void check_preamble_ints(uint8_t preamble_ints, uint8_t num_levels);
   static void check_serial_version(uint8_t serial_version);

data/vendor/datasketches-cpp/req/include/req_sketch_impl.hpp

@@ -28,7 +28,7 @@ namespace datasketches {
 template<typename T, typename C, typename S, typename A>
 req_sketch<T, C, S, A>::req_sketch(uint16_t k, bool hra, const A& allocator):
 allocator_(allocator),
-k_(std::max(static_cast<int>(k) & -2, static_cast<int>(req_constants::MIN_K))), //rounds down one if odd
+k_(std::max<uint8_t>(static_cast<int>(k) & -2, static_cast<int>(req_constants::MIN_K))), //rounds down one if odd
 hra_(hra),
 max_nom_size_(0),
 num_retained_(0),
@@ -401,7 +401,7 @@ void req_sketch<T, C, S, A>::serialize(std::ostream& os) const {
   write(os, k_);
   const uint8_t num_levels = is_empty() ? 0 : get_num_levels();
   write(os, num_levels);
-  const uint8_t num_raw_items = raw_items ? n_ : 0;
+  const uint8_t num_raw_items = raw_items ? static_cast<uint8_t>(n_) : 0;
   write(os, num_raw_items);
   if (is_empty()) return;
   if (is_estimation_mode()) {
@@ -440,7 +440,7 @@ auto req_sketch<T, C, S, A>::serialize(unsigned header_size_bytes) const -> vect
   ptr += copy_to_mem(k_, ptr);
   const uint8_t num_levels = is_empty() ? 0 : get_num_levels();
   ptr += copy_to_mem(num_levels, ptr);
-  const uint8_t num_raw_items = raw_items ? n_ : 0;
+  const uint8_t num_raw_items = raw_items ? static_cast<uint8_t>(n_) : 0;
   ptr += copy_to_mem(num_raw_items, ptr);
   if (!is_empty()) {
     if (is_estimation_mode()) {
@@ -620,7 +620,7 @@ void req_sketch<T, C, S, A>::grow() {
 
 template<typename T, typename C, typename S, typename A>
 uint8_t req_sketch<T, C, S, A>::get_num_levels() const {
-  return compactors_.size();
+  return static_cast<uint8_t>(compactors_.size());
 }
 
 template<typename T, typename C, typename S, typename A>
@@ -653,7 +653,9 @@ void req_sketch<T, C, S, A>::compress() {
 
 template<typename T, typename C, typename S, typename A>
 string<A> req_sketch<T, C, S, A>::to_string(bool print_levels, bool print_items) const {
-  std::basic_ostringstream<char, std::char_traits<char>, AllocChar<A>> os;
+  // Using a temporary stream for implementation here does not comply with AllocatorAwareContainer requirements.
+  // The stream does not support passing an allocator instance, and alternatives are complicated.
+  std::ostringstream os;
   os << "### REQ sketch summary:" << std::endl;
   os << "   K              : " << k_ << std::endl;
   os << "   High Rank Acc  : " << (hra_ ? "true" : "false") << std::endl;
@@ -693,7 +695,7 @@ string<A> req_sketch<T, C, S, A>::to_string(bool print_levels, bool print_items)
     }
     os << "### End sketch data" << std::endl;
   }
-  return os.str();
+  return string<A>(os.str().c_str(), allocator_);
 }
 
 template<typename T, typename C, typename S, typename A>
@@ -711,7 +713,7 @@ class req_sketch<T, C, S, A>::item_deleter {
 };
 
 template<typename T, typename C, typename S, typename A>
-req_sketch<T, C, S, A>::req_sketch(uint32_t k, bool hra, uint64_t n, std::unique_ptr<T, item_deleter> min_value, std::unique_ptr<T, item_deleter> max_value, std::vector<Compactor, AllocCompactor>&& compactors):
+req_sketch<T, C, S, A>::req_sketch(uint16_t k, bool hra, uint64_t n, std::unique_ptr<T, item_deleter> min_value, std::unique_ptr<T, item_deleter> max_value, std::vector<Compactor, AllocCompactor>&& compactors):
 allocator_(compactors.get_allocator()),
 k_(k),
 hra_(hra),
@@ -766,9 +768,9 @@ auto req_sketch<T, C, S, A>::end() const -> const_iterator {
 
 template<typename T, typename C, typename S, typename A>
 req_sketch<T, C, S, A>::const_iterator::const_iterator(LevelsIterator begin, LevelsIterator end):
-levels_it_(begin),
-levels_end_(end),
-compactor_it_((*levels_it_).begin())
+    levels_it_(begin),
+    levels_end_(end),
+    compactor_it_(begin == end ? nullptr : (*levels_it_).begin())
 {}
 
 template<typename T, typename C, typename S, typename A>
@@ -802,7 +804,7 @@ bool req_sketch<T, C, S, A>::const_iterator::operator!=(const const_iterator& ot
 
 template<typename T, typename C, typename S, typename A>
 std::pair<const T&, const uint64_t> req_sketch<T, C, S, A>::const_iterator::operator*() const {
-  return std::pair<const T&, const uint64_t>(*compactor_it_, 1 << (*levels_it_).get_lg_weight());
+  return std::pair<const T&, const uint64_t>(*compactor_it_, 1ULL << (*levels_it_).get_lg_weight());
 }
 
 } /* namespace datasketches */