datasketches 0.5.2 → 0.5.3

data/vendor/datasketches-cpp/kll/include/kll_sketch.hpp

@@ -46,6 +46,11 @@ namespace kll_constants {
  * and nearly optimal accuracy per retained item.
  * See <a href="https://arxiv.org/abs/1603.05346v2">Optimal Quantile Approximation in Streams</a>.
  *
+ * Sketch that may retain string values.
+ * For sketches containing strings, cross-language portability depends on
+ * using compatible string encodings. This class does not by itself enforce
+ * UTF-8 validity for all string inputs.
+ *
  * <p>This is a stochastic streaming sketch that enables near real-time analysis of the
  * approximate distribution of items from a very large stream in a single pass, requiring only
  * that the items are comparable.
@@ -56,7 +61,7 @@ namespace kll_constants {
  * <p>As of May 2020, this implementation produces serialized sketches which are binary-compatible
  * with the equivalent Java implementation only when template parameter T = float
  * (32-bit single precision values).
- * 
+ *
  * <p>Given an input stream of <i>N</i> items, the <i>natural rank</i> of any specific
  * item is defined as its index <i>(1 to N)</i> in inclusive mode
  * or <i>(0 to N-1)</i> in exclusive mode
@@ -225,6 +230,8 @@ class kll_sketch {
 
     /**
      * Updates this sketch with the given data item.
+     * If cross-language portability is required, callers should ensure that
+     * the input string uses a compatible encoding (valid UTF-8).
      * @param item from a stream of items
      */
     template<typename FwdT>
@@ -232,6 +239,8 @@ class kll_sketch {
 
     /**
      * Merges another sketch into this one.
+     * If sketches contain strings, callers are responsible for ensuring that
+     * both sketches were built using compatible string encodings.
      * @param other sketch to merge into this one
      */
     template<typename FwdSk>

data/vendor/datasketches-cpp/kll/include/kll_sketch_impl.hpp

@@ -24,6 +24,7 @@
 #include <iomanip>
 #include <sstream>
 #include <stdexcept>
+#include <type_traits>
 
 #include "conditional_forward.hpp"
 #include "count_zeros.hpp"
@@ -198,7 +199,7 @@ void kll_sketch<T, C, A>::update_min_max(const T& item) {
 
 template<typename T, typename C, typename A>
 uint32_t kll_sketch<T, C, A>::internal_update() {
-  if (levels_[0] == 0) compress_while_updating();
+  if (levels_[0] == 0) { compress_while_updating(); }
   n_++;
   is_level_zero_sorted_ = false;
   return --levels_[0];
@@ -207,7 +208,7 @@ uint32_t kll_sketch<T, C, A>::internal_update() {
 template<typename T, typename C, typename A>
 template<typename FwdSk>
 void kll_sketch<T, C, A>::merge(FwdSk&& other) {
-  if (other.is_empty()) return;
+  if (other.is_empty()) { return; }
   if (m_ != other.m_) {
     throw std::invalid_argument("incompatible M: " + std::to_string(m_) + " and " + std::to_string(other.m_));
   }
@@ -223,9 +224,9 @@ void kll_sketch<T, C, A>::merge(FwdSk&& other) {
     const uint32_t index = internal_update();
     new (&items_[index]) T(conditional_forward<FwdSk>(other.items_[i]));
   }
-  if (other.num_levels_ >= 2) merge_higher_levels(other, final_n);
+  if (other.num_levels_ >= 2) { merge_higher_levels(other, final_n); }
   n_ = final_n;
-  if (other.is_estimation_mode()) min_k_ = std::min(min_k_, other.min_k_);
+  if (other.is_estimation_mode()) { min_k_ = std::min(min_k_, other.min_k_); }
   assert_correct_total_weight();
   reset_sorted_view();
 }
@@ -257,13 +258,13 @@ bool kll_sketch<T, C, A>::is_estimation_mode() const {
 
 template<typename T, typename C, typename A>
 T kll_sketch<T, C, A>::get_min_item() const {
-  if (is_empty()) throw std::runtime_error("operation is undefined for an empty sketch");
+  if (is_empty()) { throw std::runtime_error("operation is undefined for an empty sketch"); }
   return *min_item_;
 }
 
 template<typename T, typename C, typename A>
 T kll_sketch<T, C, A>::get_max_item() const {
-  if (is_empty()) throw std::runtime_error("operation is undefined for an empty sketch");
+  if (is_empty()) { throw std::runtime_error("operation is undefined for an empty sketch"); }
   return *max_item_;
 }
 
@@ -279,28 +280,28 @@ A kll_sketch<T, C, A>::get_allocator() const {
 
 template<typename T, typename C, typename A>
 double kll_sketch<T, C, A>::get_rank(const T& item, bool inclusive) const {
-  if (is_empty()) throw std::runtime_error("operation is undefined for an empty sketch");
+  if (is_empty()) { throw std::runtime_error("operation is undefined for an empty sketch"); }
   setup_sorted_view();
   return sorted_view_->get_rank(item, inclusive);
 }
 
 template<typename T, typename C, typename A>
 auto kll_sketch<T, C, A>::get_PMF(const T* split_points, uint32_t size, bool inclusive) const -> vector_double {
-  if (is_empty()) throw std::runtime_error("operation is undefined for an empty sketch");
+  if (is_empty()) { throw std::runtime_error("operation is undefined for an empty sketch"); }
   setup_sorted_view();
   return sorted_view_->get_PMF(split_points, size, inclusive);
 }
 
 template<typename T, typename C, typename A>
 auto kll_sketch<T, C, A>::get_CDF(const T* split_points, uint32_t size, bool inclusive) const -> vector_double {
-  if (is_empty()) throw std::runtime_error("operation is undefined for an empty sketch");
+  if (is_empty()) { throw std::runtime_error("operation is undefined for an empty sketch"); }
   setup_sorted_view();
   return sorted_view_->get_CDF(split_points, size, inclusive);
 }
 
 template<typename T, typename C, typename A>
 auto kll_sketch<T, C, A>::get_quantile(double rank, bool inclusive) const -> quantile_return_type {
-  if (is_empty()) throw std::runtime_error("operation is undefined for an empty sketch");
+  if (is_empty()) { throw std::runtime_error("operation is undefined for an empty sketch"); }
   if ((rank < 0.0) || (rank > 1.0)) {
     throw std::invalid_argument("normalized rank cannot be less than zero or greater than 1.0");
   }
@@ -481,18 +482,22 @@ kll_sketch<T, C, A> kll_sketch<T, C, A>::deserialize(std::istream& is, const Ser
     read(is, levels.data(), sizeof(levels[0]) * num_levels);
   }
   levels[num_levels] = capacity;
-  optional<T> tmp; // space to deserialize min and max
   optional<T> min_item;
   optional<T> max_item;
   if (!is_single_item) {
-    sd.deserialize(is, &*tmp, 1);
+    // Space to deserialize min and max.
+    // serde::deserialize expects allocated but not initialized storage.
+    typename std::aligned_storage<sizeof(T), alignof(T)>::type tmp_storage;
+    T* tmp = reinterpret_cast<T*>(&tmp_storage);
+
+    sd.deserialize(is, tmp, 1);
     // serde call did not throw, repackage and cleanup
-    min_item.emplace(*tmp);
-    (*tmp).~T();
-    sd.deserialize(is, &*tmp, 1);
+    min_item.emplace(std::move(*tmp));
+    tmp->~T();
+    sd.deserialize(is, tmp, 1);
     // serde call did not throw, repackage and cleanup
-    max_item.emplace(*tmp);
-    (*tmp).~T();
+    max_item.emplace(std::move(*tmp));
+    tmp->~T();
   }
   A alloc(allocator);
   auto items_buffer_deleter = [capacity, &alloc](T* ptr) { alloc.deallocate(ptr, capacity); };
@@ -565,18 +570,22 @@ kll_sketch<T, C, A> kll_sketch<T, C, A>::deserialize(const void* bytes, size_t s
     ptr += copy_from_mem(ptr, levels.data(), sizeof(levels[0]) * num_levels);
   }
   levels[num_levels] = capacity;
-  optional<T> tmp; // space to deserialize min and max
   optional<T> min_item;
   optional<T> max_item;
   if (!is_single_item) {
-    ptr += sd.deserialize(ptr, end_ptr - ptr, &*tmp, 1);
+    // Space to deserialize min and max.
+    // serde::deserialize expects allocated but not initialized storage.
+    typename std::aligned_storage<sizeof(T), alignof(T)>::type tmp_storage;
+    T* tmp = reinterpret_cast<T*>(&tmp_storage);
+
+    ptr += sd.deserialize(ptr, end_ptr - ptr, tmp, 1);
     // serde call did not throw, repackage and cleanup
-    min_item.emplace(*tmp);
-    (*tmp).~T();
-    ptr += sd.deserialize(ptr, end_ptr - ptr, &*tmp, 1);
+    min_item.emplace(std::move(*tmp));
+    tmp->~T();
+    ptr += sd.deserialize(ptr, end_ptr - ptr, tmp, 1);
     // serde call did not throw, repackage and cleanup
-    max_item.emplace(*tmp);
-    (*tmp).~T();
+    max_item.emplace(std::move(*tmp));
+    tmp->~T();
   }
   A alloc(allocator);
   auto items_buffer_deleter = [capacity, &alloc](T* ptr) { alloc.deallocate(ptr, capacity); };

data/vendor/datasketches-cpp/kll/test/kll_sketch_deserialize_from_java_test.cpp

@@ -100,4 +100,28 @@ TEST_CASE("kll string", "[serde_compat]") {
   }
 }
 
+TEST_CASE("kll long", "[serde_compat]") {
+  const unsigned n_arr[] = {0, 1, 10, 100, 1000, 10000, 100000, 1000000};
+  for (const unsigned n: n_arr) {
+    std::ifstream is;
+    is.exceptions(std::ios::failbit | std::ios::badbit);
+    is.open(testBinaryInputPath + "kll_long_n" + std::to_string(n) + "_java.sk", std::ios::binary);
+    const auto sketch = kll_sketch<long>::deserialize(is);
+    REQUIRE(sketch.is_empty() == (n == 0));
+    REQUIRE(sketch.is_estimation_mode() == (n > kll_constants::DEFAULT_K));
+    REQUIRE(sketch.get_n() == n);
+    if (n > 0) {
+      REQUIRE(sketch.get_min_item() == 1);
+      REQUIRE(sketch.get_max_item() == static_cast<long>(n));
+      uint64_t weight = 0;
+      for (const auto pair: sketch) {
+        REQUIRE(pair.first >= sketch.get_min_item());
+        REQUIRE(pair.first <= sketch.get_max_item());
+        weight += pair.second;
+      }
+      REQUIRE(weight == sketch.get_n());
+    }
+  }
+}
+
 } /* namespace datasketches */

data/vendor/datasketches-cpp/kll/test/kll_sketch_serialize_for_java.cpp

@@ -43,6 +43,16 @@ TEST_CASE("kll sketch double generate", "[serialize_for_java]") {
   }
 }
 
+TEST_CASE("kll sketch long generate", "[serialize_for_java]") {
+  const unsigned n_arr[] = {0, 1, 10, 100, 1000, 10000, 100000, 1000000};
+  for (const unsigned n: n_arr) {
+    kll_sketch<long> sketch;
+    for (unsigned i = 1; i <= n; ++i) sketch.update(i);
+    std::ofstream os("kll_long_n" + std::to_string(n) + "_cpp.sk", std::ios::binary);
+    sketch.serialize(os);
+  }
+}
+
 struct compare_as_number {
   bool operator()(const std::string& a, const std::string& b) const {
     return std::stoi(a) < std::stoi(b);

data/vendor/datasketches-cpp/quantiles/include/quantiles_sketch.hpp

@@ -47,6 +47,11 @@ namespace quantiles_constants {
  * The analysis is obtained using get_rank() and get_quantile() functions,
  * the Probability Mass Function from get_PMF() and the Cumulative Distribution Function from get_CDF().
  *
+ * Sketch that may retain string values.
+ * For sketches containing strings, cross-language portability depends on
+ * using compatible string encodings. This class does not by itself enforce
+ * UTF-8 validity for all string inputs.
+ *
  * <p>Consider a large stream of one million values such as packet sizes coming into a network node.
  * The natural rank of any specific size value is its index in the hypothetical sorted
  * array of values.
@@ -206,6 +211,8 @@ public:
 
   /**
    * Updates this sketch with the given data item.
+   * If cross-language portability is required, callers should ensure that
+   * the input string uses a compatible encoding (valid UTF-8).
    * @param item from a stream of items
    */
   template<typename FwdT>
@@ -213,6 +220,8 @@ public:
 
   /**
    * Merges another sketch into this one.
+   * If sketches contain strings, callers are responsible for ensuring that
+   * both sketches were built using compatible string encodings.
    * @param other sketch to merge into this one
    */
   template<typename FwdSk>
@@ -537,10 +546,10 @@ private:
   static void merge_two_size_k_buffers(Level& arr_in_1, Level& arr_in_2, Level& arr_out, const Comparator& comparator);
 
   template<typename SerDe>
-  static Level deserialize_array(std::istream& is, uint32_t num_items, uint32_t capcacity, const SerDe& serde, const Allocator& allocator);
+  static Level deserialize_array(std::istream& is, uint32_t num_items, uint32_t capacity, const SerDe& serde, const Allocator& allocator);
   
   template<typename SerDe>
-  static std::pair<Level, size_t> deserialize_array(const void* bytes, size_t size, uint32_t num_items, uint32_t capcacity, const SerDe& serde, const Allocator& allocator);
+  static std::pair<Level, size_t> deserialize_array(const void* bytes, size_t size, uint32_t num_items, uint32_t capacity, const SerDe& serde, const Allocator& allocator);
 
   static void check_k(uint16_t k);
   static void check_serial_version(uint8_t serial_version);

data/vendor/datasketches-cpp/quantiles/include/quantiles_sketch_impl.hpp

@@ -25,6 +25,7 @@
 #include <stdexcept>
 #include <iomanip>
 #include <sstream>
+#include <type_traits>
 
 #include "count_zeros.hpp"
 #include "conditional_forward.hpp"
@@ -393,18 +394,22 @@ auto quantiles_sketch<T, C, A>::deserialize(std::istream &is, const SerDe& serde
   const bool is_compact = (serial_version == 2) | ((flags_byte & (1 << flags::IS_COMPACT)) > 0);
   const bool is_sorted = (flags_byte & (1 << flags::IS_SORTED)) > 0;
 
-  optional<T> tmp; // space to deserialize min and max
   optional<T> min_item;
   optional<T> max_item;
 
-  serde.deserialize(is, &*tmp, 1);
+  // Space to deserialize min and max.
+  // serde::deserialize expects allocated but not initialized storage.
+  typename std::aligned_storage<sizeof(T), alignof(T)>::type tmp_storage;
+  T* tmp = reinterpret_cast<T*>(&tmp_storage);
+
+  serde.deserialize(is, tmp, 1);
   // serde call did not throw, repackage and cleanup
-  min_item.emplace(*tmp);
-  (*tmp).~T();
-  serde.deserialize(is, &*tmp, 1);
+  min_item.emplace(std::move(*tmp));
+  tmp->~T();
+  serde.deserialize(is, tmp, 1);
   // serde call did not throw, repackage and cleanup
-  max_item.emplace(*tmp);
-  (*tmp).~T();
+  max_item.emplace(std::move(*tmp));
+  tmp->~T();
 
   if (serial_version == 1) {
     read<uint64_t>(is); // no longer used
@@ -507,18 +512,22 @@ auto quantiles_sketch<T, C, A>::deserialize(const void* bytes, size_t size, cons
   const bool is_compact = (serial_version == 2) | ((flags_byte & (1 << flags::IS_COMPACT)) > 0);
   const bool is_sorted = (flags_byte & (1 << flags::IS_SORTED)) > 0;
 
-  optional<T> tmp; // space to deserialize min and max
   optional<T> min_item;
   optional<T> max_item;
 
-  ptr += serde.deserialize(ptr, end_ptr - ptr, &*tmp, 1);
+  // Space to deserialize min and max.
+  // serde::deserialize expects allocated but not initialized storage.
+  typename std::aligned_storage<sizeof(T), alignof(T)>::type tmp_storage;
+  T* tmp = reinterpret_cast<T*>(&tmp_storage);
+
+  ptr += serde.deserialize(ptr, end_ptr - ptr, tmp, 1);
   // serde call did not throw, repackage and cleanup
-  min_item.emplace(*tmp);
-  (*tmp).~T();
-  ptr += serde.deserialize(ptr, end_ptr - ptr, &*tmp, 1);
+  min_item.emplace(std::move(*tmp));
+  tmp->~T();
+  ptr += serde.deserialize(ptr, end_ptr - ptr, tmp, 1);
   // serde call did not throw, repackage and cleanup
-  max_item.emplace(*tmp);
-  (*tmp).~T();
+  max_item.emplace(std::move(*tmp));
+  tmp->~T();
 
   if (serial_version == 1) {
     uint64_t unused_long;
@@ -581,7 +590,7 @@ auto quantiles_sketch<T, C, A>::deserialize_array(const void* bytes, size_t size
   // serde did not throw, enable destructors
   items.get_deleter().set_destroy(true);
   
-  // succesfully read, now put into a Level
+  // successfully read, now put into a Level
   Level level(allocator);
   level.reserve(capacity);
   level.insert(level.begin(),

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

@@ -35,6 +35,11 @@ namespace datasketches {
  * "Relative Error Streaming Quantiles" by Graham Cormode, Zohar Karnin, Edo Liberty,
  * Justin Thaler, Pavel Veselý, and loosely derived from a Python prototype written by Pavel Veselý.
  *
+ * Sketch that may retain string values.
+ * For sketches containing strings, cross-language portability depends on
+ * using compatible string encodings. This class does not by itself enforce
+ * UTF-8 validity for all string inputs.
+ *
  * <p>Reference: https://arxiv.org/abs/2004.01668</p>
  *
  * <p>This implementation differs from the algorithm described in the paper in the following:</p>
@@ -179,6 +184,8 @@ public:
 
   /**
    * Updates this sketch with the given data item.
+   * If cross-language portability is required, callers should ensure that
+   * the input string uses a compatible encoding (valid UTF-8).
    * @param item from a stream of items
    */
   template<typename FwdT>
@@ -186,6 +193,8 @@ public:
 
   /**
    * Merges another sketch into this one.
+   * If sketches contain strings, callers are responsible for ensuring that
+   * both sketches were built using compatible string encodings.
    * @param other sketch to merge into this one
    */
   template<typename FwdSk>

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

@@ -22,6 +22,7 @@
 
 #include <sstream>
 #include <stdexcept>
+#include <type_traits>
 
 namespace datasketches {
 
@@ -292,7 +293,7 @@ double req_sketch<T, C, A>::get_rank_upper_bound(double rank, uint8_t num_std_de
 
 template<typename T, typename C, typename A>
 double req_sketch<T, C, A>::get_RSE(uint16_t k, double rank, bool hra, uint64_t n) {
-  return get_rank_lb(k, 2, rank, 1, n, hra);
+  return get_rank_ub(k, 2, rank, 1, n, hra) - rank;
 }
 
 template<typename T, typename C, typename A>
@@ -461,7 +462,6 @@ req_sketch<T, C, A> req_sketch<T, C, A>::deserialize(std::istream& is, const Ser
   const bool hra = flags_byte & (1 << flags::IS_HIGH_RANK);
   if (is_empty) return req_sketch(k, hra, comparator, allocator);
 
-  optional<T> tmp; // space to deserialize min and max
   optional<T> min_item;
   optional<T> max_item;
 
@@ -472,14 +472,19 @@ req_sketch<T, C, A> req_sketch<T, C, A>::deserialize(std::istream& is, const Ser
   uint64_t n = 1;
   if (num_levels > 1) {
     n = read<uint64_t>(is);
-    sd.deserialize(is, &*tmp, 1);
+    // Space to deserialize min and max.
+    // serde::deserialize expects allocated but not initialized storage.
+    typename std::aligned_storage<sizeof(T), alignof(T)>::type tmp_storage;
+    T* tmp = reinterpret_cast<T*>(&tmp_storage);
+
+    sd.deserialize(is, tmp, 1);
     // serde call did not throw, repackage and cleanup
-    min_item.emplace(*tmp);
-    (*tmp).~T();
-    sd.deserialize(is, &*tmp, 1);
+    min_item.emplace(std::move(*tmp));
+    tmp->~T();
+    sd.deserialize(is, tmp, 1);
     // serde call did not throw, repackage and cleanup
-    max_item.emplace(*tmp);
-    (*tmp).~T();
+    max_item.emplace(std::move(*tmp));
+    tmp->~T();
   }
 
   if (raw_items) {
@@ -537,7 +542,6 @@ req_sketch<T, C, A> req_sketch<T, C, A>::deserialize(const void* bytes, size_t s
   const bool hra = flags_byte & (1 << flags::IS_HIGH_RANK);
   if (is_empty) return req_sketch(k, hra, comparator, allocator);
 
-  optional<T> tmp; // space to deserialize min and max
   optional<T> min_item;
   optional<T> max_item;
 
@@ -549,14 +553,19 @@ req_sketch<T, C, A> req_sketch<T, C, A>::deserialize(const void* bytes, size_t s
   if (num_levels > 1) {
     ensure_minimum_memory(end_ptr - ptr, sizeof(n));
     ptr += copy_from_mem(ptr, n);
-    ptr += sd.deserialize(ptr, end_ptr - ptr, &*tmp, 1);
+    // Space to deserialize min and max.
+    // serde::deserialize expects allocated but not initialized storage.
+    typename std::aligned_storage<sizeof(T), alignof(T)>::type tmp_storage;
+    T* tmp = reinterpret_cast<T*>(&tmp_storage);
+
+    ptr += sd.deserialize(ptr, end_ptr - ptr, tmp, 1);
     // serde call did not throw, repackage and cleanup
-    min_item.emplace(*tmp);
-    (*tmp).~T();
-    ptr += sd.deserialize(ptr, end_ptr - ptr, &*tmp, 1);
+    min_item.emplace(std::move(*tmp));
+    tmp->~T();
+    ptr += sd.deserialize(ptr, end_ptr - ptr, tmp, 1);
     // serde call did not throw, repackage and cleanup
-    max_item.emplace(*tmp);
-    (*tmp).~T();
+    max_item.emplace(std::move(*tmp));
+    tmp->~T();
   }
 
   if (raw_items) {

data/vendor/datasketches-cpp/req/test/req_sketch_deserialize_from_java_test.cpp

@@ -52,4 +52,50 @@ TEST_CASE("req float", "[serde_compat]") {
   }
 }
 
+TEST_CASE("req float negative", "[serde_compat]") {
+  const unsigned n_arr[] = {1, 10};
+  for (const unsigned n: n_arr) {
+    std::ifstream is;
+    is.exceptions(std::ios::failbit | std::ios::badbit);
+    is.open(testBinaryInputPath + "req_float_negative_n" + std::to_string(n) + "_java.sk", std::ios::binary);
+    const auto sketch = req_sketch<float>::deserialize(is);
+    REQUIRE(sketch.is_HRA());
+    REQUIRE_FALSE(sketch.is_empty());
+    REQUIRE_FALSE(sketch.is_estimation_mode());
+    REQUIRE(sketch.get_n() == n);
+    REQUIRE(sketch.get_min_item() == -static_cast<float>(n));
+    REQUIRE(sketch.get_max_item() == -1.0f);
+    uint64_t weight = 0;
+    for (const auto pair: sketch) {
+      REQUIRE(pair.first >= sketch.get_min_item());
+      REQUIRE(pair.first <= sketch.get_max_item());
+      weight += pair.second;
+    }
+    REQUIRE(weight == sketch.get_n());
+  }
+}
+
+TEST_CASE("req float mixed", "[serde_compat]") {
+  const unsigned n_arr[] = {1, 10};
+  for (const unsigned n: n_arr) {
+    std::ifstream is;
+    is.exceptions(std::ios::failbit | std::ios::badbit);
+    is.open(testBinaryInputPath + "req_float_mixed_n" + std::to_string(n) + "_java.sk", std::ios::binary);
+    const auto sketch = req_sketch<float>::deserialize(is);
+    REQUIRE(sketch.is_HRA());
+    REQUIRE_FALSE(sketch.is_empty());
+    REQUIRE_FALSE(sketch.is_estimation_mode());
+    REQUIRE(sketch.get_n() == 2 * n + 1);
+    REQUIRE(sketch.get_min_item() == -static_cast<float>(n));
+    REQUIRE(sketch.get_max_item() == static_cast<float>(n));
+    uint64_t weight = 0;
+    for (const auto pair: sketch) {
+      REQUIRE(pair.first >= sketch.get_min_item());
+      REQUIRE(pair.first <= sketch.get_max_item());
+      weight += pair.second;
+    }
+    REQUIRE(weight == sketch.get_n());
+  }
+}
+
 } /* namespace datasketches */

data/vendor/datasketches-cpp/req/test/req_sketch_serialize_for_java.cpp

@@ -33,4 +33,24 @@ TEST_CASE("req sketch float generate", "[serialize_for_java]") {
   }
 }
 
+TEST_CASE("req sketch float negative generate", "[serialize_for_java]") {
+  const unsigned n_arr[] = {1, 10};
+  for (const unsigned n: n_arr) {
+    req_sketch<float> sketch(12);
+    for (unsigned i = 1; i <= n; ++i) sketch.update(-static_cast<float>(i));
+    std::ofstream os("req_float_negative_n" + std::to_string(n) + "_cpp.sk", std::ios::binary);
+    sketch.serialize(os);
+  }
+}
+
+TEST_CASE("req sketch float mixed generate", "[serialize_for_java]") {
+  const unsigned n_arr[] = {1, 10};
+  for (const unsigned n: n_arr) {
+    req_sketch<float> sketch(12);
+    for (int i = -static_cast<int>(n); i <= static_cast<int>(n); ++i) sketch.update(static_cast<float>(i));
+    std::ofstream os("req_float_mixed_n" + std::to_string(n) + "_cpp.sk", std::ios::binary);
+    sketch.serialize(os);
+  }
+}
+
 } /* namespace datasketches */

data/vendor/datasketches-cpp/req/test/req_sketch_test.cpp

@@ -43,6 +43,7 @@ TEST_CASE("req sketch: empty", "[req_sketch]") {
   REQUIRE_FALSE(sketch.is_estimation_mode());
   REQUIRE(sketch.get_n() == 0);
   REQUIRE(sketch.get_num_retained() == 0);
+  REQUIRE(sketch.get_RSE(sketch.get_k(), 0.5, true, 0) == 0);
   REQUIRE_THROWS_AS(sketch.get_min_item(), std::runtime_error);
   REQUIRE_THROWS_AS(sketch.get_max_item(), std::runtime_error);
   REQUIRE_THROWS_AS(sketch.get_rank(0), std::runtime_error);
@@ -61,6 +62,7 @@ TEST_CASE("req sketch: single value, lra", "[req_sketch]") {
   REQUIRE_FALSE(sketch.is_estimation_mode());
   REQUIRE(sketch.get_n() == 1);
   REQUIRE(sketch.get_num_retained() == 1);
+  REQUIRE(sketch.get_RSE(sketch.get_k(), 0.5, false, sketch.get_n()) == 0);
   REQUIRE(sketch.get_rank(1.0f, false) == 0);
   REQUIRE(sketch.get_rank(1.0f) == 1);
   REQUIRE(sketch.get_rank(1.1f, false) == 1);
@@ -314,6 +316,74 @@ TEST_CASE("req sketch: byte serialize-deserialize estimation mode", "[req_sketch
   REQUIRE(sketch2.get_max_item() == sketch.get_max_item());
 }
 
+TEST_CASE("req sketch: stream serialize-deserialize negative values", "[req_sketch]") {
+  req_sketch<float> sketch(12);
+  const size_t n = 50;
+  for (size_t i = 1; i <= n; ++i) sketch.update(-static_cast<float>(i));
+
+  std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
+  sketch.serialize(s);
+  auto sketch2 = req_sketch<float>::deserialize(s);
+  REQUIRE(s.tellg() == s.tellp());
+  REQUIRE(sketch2.is_empty() == sketch.is_empty());
+  REQUIRE(sketch2.is_estimation_mode() == sketch.is_estimation_mode());
+  REQUIRE(sketch2.get_num_retained() == sketch.get_num_retained());
+  REQUIRE(sketch2.get_n() == sketch.get_n());
+  REQUIRE(sketch2.get_min_item() == -static_cast<float>(n));
+  REQUIRE(sketch2.get_max_item() == -1.0f);
+}
+
+TEST_CASE("req sketch: byte serialize-deserialize negative values", "[req_sketch]") {
+  req_sketch<float> sketch(12);
+  const size_t n = 50;
+  for (size_t i = 1; i <= n; ++i) sketch.update(-static_cast<float>(i));
+
+  auto bytes = sketch.serialize();
+  REQUIRE(bytes.size() == sketch.get_serialized_size_bytes());
+  auto sketch2 = req_sketch<float>::deserialize(bytes.data(), bytes.size());
+  REQUIRE(bytes.size() == sketch2.get_serialized_size_bytes());
+  REQUIRE(sketch2.is_empty() == sketch.is_empty());
+  REQUIRE(sketch2.is_estimation_mode() == sketch.is_estimation_mode());
+  REQUIRE(sketch2.get_num_retained() == sketch.get_num_retained());
+  REQUIRE(sketch2.get_n() == sketch.get_n());
+  REQUIRE(sketch2.get_min_item() == -static_cast<float>(n));
+  REQUIRE(sketch2.get_max_item() == -1.0f);
+}
+
+TEST_CASE("req sketch: stream serialize-deserialize mixed values", "[req_sketch]") {
+  req_sketch<float> sketch(12);
+  const int half = 25;
+  for (int i = -half; i < half; ++i) sketch.update(static_cast<float>(i));
+
+  std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
+  sketch.serialize(s);
+  auto sketch2 = req_sketch<float>::deserialize(s);
+  REQUIRE(s.tellg() == s.tellp());
+  REQUIRE(sketch2.is_empty() == sketch.is_empty());
+  REQUIRE(sketch2.is_estimation_mode() == sketch.is_estimation_mode());
+  REQUIRE(sketch2.get_num_retained() == sketch.get_num_retained());
+  REQUIRE(sketch2.get_n() == sketch.get_n());
+  REQUIRE(sketch2.get_min_item() == static_cast<float>(-half));
+  REQUIRE(sketch2.get_max_item() == static_cast<float>(half - 1));
+}
+
+TEST_CASE("req sketch: byte serialize-deserialize mixed values", "[req_sketch]") {
+  req_sketch<float> sketch(12);
+  const int half = 25;
+  for (int i = -half; i < half; ++i) sketch.update(static_cast<float>(i));
+
+  auto bytes = sketch.serialize();
+  REQUIRE(bytes.size() == sketch.get_serialized_size_bytes());
+  auto sketch2 = req_sketch<float>::deserialize(bytes.data(), bytes.size());
+  REQUIRE(bytes.size() == sketch2.get_serialized_size_bytes());
+  REQUIRE(sketch2.is_empty() == sketch.is_empty());
+  REQUIRE(sketch2.is_estimation_mode() == sketch.is_estimation_mode());
+  REQUIRE(sketch2.get_num_retained() == sketch.get_num_retained());
+  REQUIRE(sketch2.get_n() == sketch.get_n());
+  REQUIRE(sketch2.get_min_item() == static_cast<float>(-half));
+  REQUIRE(sketch2.get_max_item() == static_cast<float>(half - 1));
+}
+
 TEST_CASE("req sketch: serialize deserialize stream and bytes equivalence", "[req_sketch]") {
   req_sketch<float> sketch(12);
   const size_t n = 100000;