datasketches 0.2.1 → 0.2.2

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/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));
 }
 
 }
@@ -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/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/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/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>
@@ -711,7 +711,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 +766,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 +802,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 */

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

@@ -55,15 +55,15 @@ TEST_CASE("req sketch: empty", "[req_sketch]") {
 
 TEST_CASE("req sketch: single value, lra", "[req_sketch]") {
   req_sketch<float> sketch(12, false);
-  sketch.update(1);
+  sketch.update(1.0f);
   REQUIRE_FALSE(sketch.is_HRA());
   REQUIRE_FALSE(sketch.is_empty());
   REQUIRE_FALSE(sketch.is_estimation_mode());
   REQUIRE(sketch.get_n() == 1);
   REQUIRE(sketch.get_num_retained() == 1);
-  REQUIRE(sketch.get_rank(1) == 0);
-  REQUIRE(sketch.get_rank<true>(1) == 1);
-  REQUIRE(sketch.get_rank(1.1) == 1);
+  REQUIRE(sketch.get_rank(1.0f) == 0);
+  REQUIRE(sketch.get_rank<true>(1.0f) == 1);
+  REQUIRE(sketch.get_rank(1.1f) == 1);
   REQUIRE(sketch.get_rank(std::numeric_limits<float>::infinity()) == 1);
   REQUIRE(sketch.get_quantile(0) == 1);
   REQUIRE(sketch.get_quantile(0.5) == 1);
@@ -86,43 +86,43 @@ TEST_CASE("req sketch: single value, lra", "[req_sketch]") {
 
 TEST_CASE("req sketch: repeated values", "[req_sketch]") {
   req_sketch<float> sketch(12);
-  sketch.update(1);
-  sketch.update(1);
-  sketch.update(1);
-  sketch.update(2);
-  sketch.update(2);
-  sketch.update(2);
+  sketch.update(1.0f);
+  sketch.update(1.0f);
+  sketch.update(1.0f);
+  sketch.update(2.0f);
+  sketch.update(2.0f);
+  sketch.update(2.0f);
   REQUIRE_FALSE(sketch.is_empty());
   REQUIRE_FALSE(sketch.is_estimation_mode());
   REQUIRE(sketch.get_n() == 6);
   REQUIRE(sketch.get_num_retained() == 6);
-  REQUIRE(sketch.get_rank(1) == 0);
-  REQUIRE(sketch.get_rank<true>(1) == 0.5);
-  REQUIRE(sketch.get_rank(2) == 0.5);
-  REQUIRE(sketch.get_rank<true>(2) == 1);
+  REQUIRE(sketch.get_rank(1.0f) == 0);
+  REQUIRE(sketch.get_rank<true>(1.0f) == 0.5);
+  REQUIRE(sketch.get_rank(2.0f) == 0.5);
+  REQUIRE(sketch.get_rank<true>(2.0f) == 1);
 }
 
 TEST_CASE("req sketch: exact mode", "[req_sketch]") {
   req_sketch<float> sketch(12);
-  for (size_t i = 1; i <= 10; ++i) sketch.update(i);
+  for (size_t i = 1; i <= 10; ++i) sketch.update(static_cast<float>(i));
   REQUIRE_FALSE(sketch.is_empty());
   REQUIRE_FALSE(sketch.is_estimation_mode());
   REQUIRE(sketch.get_n() == 10);
   REQUIRE(sketch.get_num_retained() == 10);
 
   // like KLL
-  REQUIRE(sketch.get_rank(1) == 0);
-  REQUIRE(sketch.get_rank(2) == 0.1);
-  REQUIRE(sketch.get_rank(6) == 0.5);
-  REQUIRE(sketch.get_rank(9) == 0.8);
-  REQUIRE(sketch.get_rank(10) == 0.9);
+  REQUIRE(sketch.get_rank(1.0f) == 0);
+  REQUIRE(sketch.get_rank(2.0f) == 0.1);
+  REQUIRE(sketch.get_rank(6.0f) == 0.5);
+  REQUIRE(sketch.get_rank(9.0f) == 0.8);
+  REQUIRE(sketch.get_rank(10.0f) == 0.9);
 
   // inclusive
-  REQUIRE(sketch.get_rank<true>(1) == 0.1);
-  REQUIRE(sketch.get_rank<true>(2) == 0.2);
-  REQUIRE(sketch.get_rank<true>(5) == 0.5);
-  REQUIRE(sketch.get_rank<true>(9) == 0.9);
-  REQUIRE(sketch.get_rank<true>(10) == 1);
+  REQUIRE(sketch.get_rank<true>(1.0f) == 0.1);
+  REQUIRE(sketch.get_rank<true>(2.0f) == 0.2);
+  REQUIRE(sketch.get_rank<true>(5.0f) == 0.5);
+  REQUIRE(sketch.get_rank<true>(9.0f) == 0.9);
+  REQUIRE(sketch.get_rank<true>(10.0f) == 1);
 
   // like KLL
   REQUIRE(sketch.get_quantile(0) == 1);
@@ -164,16 +164,16 @@ TEST_CASE("req sketch: exact mode", "[req_sketch]") {
 TEST_CASE("req sketch: estimation mode", "[req_sketch]") {
   req_sketch<float> sketch(12);
   const size_t n = 100000;
-  for (size_t i = 0; i < n; ++i) sketch.update(i);
+  for (size_t i = 0; i < n; ++i) sketch.update(static_cast<float>(i));
   REQUIRE_FALSE(sketch.is_empty());
   REQUIRE(sketch.is_estimation_mode());
   REQUIRE(sketch.get_n() == n);
 //  std::cout << sketch.to_string(true);
   REQUIRE(sketch.get_num_retained() < n);
   REQUIRE(sketch.get_rank(0) == 0);
-  REQUIRE(sketch.get_rank(n) == 1);
-  REQUIRE(sketch.get_rank(n / 2) == Approx(0.5).margin(0.01));
-  REQUIRE(sketch.get_rank(n - 1) == Approx(1).margin(0.01));
+  REQUIRE(sketch.get_rank(static_cast<float>(n)) == 1);
+  REQUIRE(sketch.get_rank(n / 2.0f) == Approx(0.5).margin(0.01));
+  REQUIRE(sketch.get_rank(n - 1.0f) == Approx(1).margin(0.01));
   REQUIRE(sketch.get_min_value() == 0);
   REQUIRE(sketch.get_max_value() == n - 1);
   REQUIRE(sketch.get_rank_lower_bound(0.5, 1) < 0.5);
@@ -219,7 +219,7 @@ TEST_CASE("req sketch: byte serialize-deserialize empty", "[req_sketch]") {
 
 TEST_CASE("req sketch: stream serialize-deserialize single item", "[req_sketch]") {
   req_sketch<float> sketch(12);
-  sketch.update(1);
+  sketch.update(1.0f);
 
   std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
   sketch.serialize(s);
@@ -235,7 +235,7 @@ TEST_CASE("req sketch: stream serialize-deserialize single item", "[req_sketch]"
 
 TEST_CASE("req sketch: byte serialize-deserialize single item", "[req_sketch]") {
   req_sketch<float> sketch(12);
-  sketch.update(1);
+  sketch.update(1.0f);
 
   auto bytes = sketch.serialize();
   REQUIRE(bytes.size() == sketch.get_serialized_size_bytes());
@@ -253,7 +253,7 @@ TEST_CASE("req sketch: byte serialize-deserialize single item", "[req_sketch]")
 TEST_CASE("req sketch: stream serialize-deserialize exact mode", "[req_sketch]") {
   req_sketch<float> sketch(12);
   const size_t n = 50;
-  for (size_t i = 0; i < n; ++i) sketch.update(i);
+  for (size_t i = 0; i < n; ++i) sketch.update(static_cast<float>(i));
   REQUIRE_FALSE(sketch.is_estimation_mode());
 
   std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
@@ -271,7 +271,7 @@ TEST_CASE("req sketch: stream serialize-deserialize exact mode", "[req_sketch]")
 TEST_CASE("req sketch: byte serialize-deserialize exact mode", "[req_sketch]") {
   req_sketch<float> sketch(12);
   const size_t n = 50;
-  for (size_t i = 0; i < n; ++i) sketch.update(i);
+  for (size_t i = 0; i < n; ++i) sketch.update(static_cast<float>(i));
   REQUIRE_FALSE(sketch.is_estimation_mode());
 
   auto bytes = sketch.serialize();
@@ -290,7 +290,7 @@ TEST_CASE("req sketch: byte serialize-deserialize exact mode", "[req_sketch]") {
 TEST_CASE("req sketch: stream serialize-deserialize estimation mode", "[req_sketch]") {
   req_sketch<float> sketch(12);
   const size_t n = 100000;
-  for (size_t i = 0; i < n; ++i) sketch.update(i);
+  for (size_t i = 0; i < n; ++i) sketch.update(static_cast<float>(i));
   REQUIRE(sketch.is_estimation_mode());
 
   std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
@@ -308,7 +308,7 @@ TEST_CASE("req sketch: stream serialize-deserialize estimation mode", "[req_sket
 TEST_CASE("req sketch: byte serialize-deserialize estimation mode", "[req_sketch]") {
   req_sketch<float> sketch(12);
   const size_t n = 100000;
-  for (size_t i = 0; i < n; ++i) sketch.update(i);
+  for (size_t i = 0; i < n; ++i) sketch.update(static_cast<float>(i));
   REQUIRE(sketch.is_estimation_mode());
 
   auto bytes = sketch.serialize();
@@ -326,7 +326,7 @@ TEST_CASE("req sketch: byte serialize-deserialize estimation mode", "[req_sketch
 TEST_CASE("req sketch: serialize deserialize stream and bytes equivalence", "[req_sketch]") {
   req_sketch<float> sketch(12);
   const size_t n = 100000;
-  for (size_t i = 0; i < n; ++i) sketch.update(i);
+  for (size_t i = 0; i < n; ++i) sketch.update(static_cast<float>(i));
   REQUIRE(sketch.is_estimation_mode());
 
   std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
@@ -373,8 +373,8 @@ TEST_CASE("req sketch: stream deserialize from Java - single item", "[req_sketch
   REQUIRE(sketch.get_num_retained() == 1);
   REQUIRE(sketch.get_min_value() == 1);
   REQUIRE(sketch.get_max_value() == 1);
-  REQUIRE(sketch.get_rank(1) == 0);
-  REQUIRE(sketch.get_rank<true>(1) == 1);
+  REQUIRE(sketch.get_rank(1.0f) == 0);
+  REQUIRE(sketch.get_rank<true>(1.0f) == 1);
 }
 
 TEST_CASE("req sketch: stream deserialize from Java - raw items", "[req_sketch]") {
@@ -388,7 +388,7 @@ TEST_CASE("req sketch: stream deserialize from Java - raw items", "[req_sketch]"
   REQUIRE(sketch.get_num_retained() == 4);
   REQUIRE(sketch.get_min_value() == 0);
   REQUIRE(sketch.get_max_value() == 3);
-  REQUIRE(sketch.get_rank(2) == 0.5);
+  REQUIRE(sketch.get_rank(2.0f) == 0.5);
 }
 
 TEST_CASE("req sketch: stream deserialize from Java - exact mode", "[req_sketch]") {
@@ -402,7 +402,7 @@ TEST_CASE("req sketch: stream deserialize from Java - exact mode", "[req_sketch]
   REQUIRE(sketch.get_num_retained() == 100);
   REQUIRE(sketch.get_min_value() == 0);
   REQUIRE(sketch.get_max_value() == 99);
-  REQUIRE(sketch.get_rank(50) == 0.5);
+  REQUIRE(sketch.get_rank(50.0f) == 0.5);
 }
 
 TEST_CASE("req sketch: stream deserialize from Java - estimation mode", "[req_sketch]") {
@@ -416,14 +416,14 @@ TEST_CASE("req sketch: stream deserialize from Java - estimation mode", "[req_sk
   REQUIRE(sketch.get_num_retained() == 2942);
   REQUIRE(sketch.get_min_value() == 0);
   REQUIRE(sketch.get_max_value() == 9999);
-  REQUIRE(sketch.get_rank(5000) == 0.5);
+  REQUIRE(sketch.get_rank(5000.0f) == 0.5);
 }
 
 TEST_CASE("req sketch: merge into empty", "[req_sketch]") {
   req_sketch<float> sketch1(40);
 
   req_sketch<float> sketch2(40);
-  for (size_t i = 0; i < 1000; ++i) sketch2.update(i);
+  for (size_t i = 0; i < 1000; ++i) sketch2.update(static_cast<float>(i));
 
   sketch1.merge(sketch2);
   REQUIRE(sketch1.get_min_value() == 0);
@@ -431,15 +431,15 @@ TEST_CASE("req sketch: merge into empty", "[req_sketch]") {
   REQUIRE(sketch1.get_quantile(0.25) == Approx(250).margin(3));
   REQUIRE(sketch1.get_quantile(0.5) == Approx(500).margin(3));
   REQUIRE(sketch1.get_quantile(0.75) == Approx(750).margin(3));
-  REQUIRE(sketch1.get_rank(500) == Approx(0.5).margin(0.01));
+  REQUIRE(sketch1.get_rank(500.0f) == Approx(0.5).margin(0.01));
 }
 
 TEST_CASE("req sketch: merge", "[req_sketch]") {
   req_sketch<float> sketch1(100);
-  for (size_t i = 0; i < 1000; ++i) sketch1.update(i);
+  for (size_t i = 0; i < 1000; ++i) sketch1.update(static_cast<float>(i));
 
   req_sketch<float> sketch2(100);
-  for (size_t i = 1000; i < 2000; ++i) sketch2.update(i);
+  for (size_t i = 1000; i < 2000; ++i) sketch2.update(static_cast<float>(i));
 
   sketch1.merge(sketch2);
   REQUIRE(sketch1.get_min_value() == 0);
@@ -447,18 +447,18 @@ TEST_CASE("req sketch: merge", "[req_sketch]") {
   REQUIRE(sketch1.get_quantile(0.25) == Approx(500).margin(3));
   REQUIRE(sketch1.get_quantile(0.5) == Approx(1000).margin(1));
   REQUIRE(sketch1.get_quantile(0.75) == Approx(1500).margin(1));
-  REQUIRE(sketch1.get_rank(1000) == Approx(0.5).margin(0.01));
+  REQUIRE(sketch1.get_rank(1000.0f) == Approx(0.5).margin(0.01));
 }
 
 TEST_CASE("req sketch: merge multiple", "[req_sketch]") {
   req_sketch<float> sketch1(12);
-  for (size_t i = 0; i < 40; ++i) sketch1.update(i);
+  for (size_t i = 0; i < 40; ++i) sketch1.update(static_cast<float>(i));
 
   req_sketch<float> sketch2(12);
-  for (size_t i = 40; i < 80; ++i) sketch2.update(i);
+  for (size_t i = 40; i < 80; ++i) sketch2.update(static_cast<float>(i));
 
   req_sketch<float> sketch3(12);
-  for (size_t i = 80; i < 120; ++i) sketch3.update(i);
+  for (size_t i = 80; i < 120; ++i) sketch3.update(static_cast<float>(i));
 
   req_sketch<float> sketch(12);
   sketch.merge(sketch1);
@@ -467,15 +467,15 @@ TEST_CASE("req sketch: merge multiple", "[req_sketch]") {
   REQUIRE(sketch.get_min_value() == 0);
   REQUIRE(sketch.get_max_value() == 119);
   REQUIRE(sketch.get_quantile(0.5) == Approx(60).margin(3));
-  REQUIRE(sketch.get_rank(60) == Approx(0.5).margin(0.01));
+  REQUIRE(sketch.get_rank(60.0f) == Approx(0.5).margin(0.01));
 }
 
 TEST_CASE("req sketch: merge incompatible HRA and LRA", "[req_sketch]") {
   req_sketch<float> sketch1(12);
-  sketch1.update(1);
+  sketch1.update(1.0f);
 
   req_sketch<float> sketch2(12, false);
-  sketch2.update(1);
+  sketch2.update(1.0f);
 
   REQUIRE_THROWS_AS(sketch1.merge(sketch2), std::invalid_argument);
 }