datasketches 0.2.0 → 0.2.4

data/vendor/datasketches-cpp/tuple/include/tuple_union.hpp

@@ -80,11 +80,16 @@ public:
    */
   CompactSketch get_result(bool ordered = true) const;
 
+  /**
+   * Reset the union to the initial empty state
+   */
+  void reset();
+
 protected:
   State state_;
 
   // for builder
-  tuple_union(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, uint64_t theta, uint64_t seed, const Policy& policy, const Allocator& allocator);
+  tuple_union(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, float p, uint64_t theta, uint64_t seed, const Policy& policy, const Allocator& allocator);
 };
 
 template<typename S, typename P, typename A>

data/vendor/datasketches-cpp/tuple/include/tuple_union_impl.hpp

@@ -20,8 +20,8 @@
 namespace datasketches {
 
 template<typename S, typename P, typename A>
-tuple_union<S, P, A>::tuple_union(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, uint64_t theta, uint64_t seed, const P& policy, const A& allocator):
-state_(lg_cur_size, lg_nom_size, rf, theta, seed, internal_policy(policy), allocator)
+tuple_union<S, P, A>::tuple_union(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, float p, uint64_t theta, uint64_t seed, const P& policy, const A& allocator):
+state_(lg_cur_size, lg_nom_size, rf, p, theta, seed, internal_policy(policy), allocator)
 {}
 
 template<typename S, typename P, typename A>
@@ -35,13 +35,18 @@ auto tuple_union<S, P, A>::get_result(bool ordered) const -> CompactSketch {
   return state_.get_result(ordered);
 }
 
+template<typename S, typename P, typename A>
+void tuple_union<S, P, A>::reset() {
+  return state_.reset();
+}
+
 template<typename S, typename P, typename A>
 tuple_union<S, P, A>::builder::builder(const P& policy, const A& allocator):
 tuple_base_builder<builder, P, A>(policy, allocator) {}
 
 template<typename S, typename P, typename A>
 auto tuple_union<S, P, A>::builder::build() const -> tuple_union {
-  return tuple_union(this->starting_lg_size(), this->lg_k_, this->rf_, this->starting_theta(), this->seed_, this->policy_, this->allocator_);
+  return tuple_union(this->starting_lg_size(), this->lg_k_, this->rf_, this->p_, this->starting_theta(), this->seed_, this->policy_, this->allocator_);
 }
 
 } /* namespace datasketches */

data/vendor/datasketches-cpp/tuple/test/array_of_doubles_sketch_test.cpp

@@ -36,6 +36,17 @@ const std::string inputPath = TEST_BINARY_INPUT_PATH;
 const std::string inputPath = "test/";
 #endif
 
+TEST_CASE("aod sketch: reset", "[tuple_sketch]") {
+  auto update_sketch = update_array_of_doubles_sketch::builder().build();
+  std::vector<double> a = {1};
+  update_sketch.update(1, a);
+  REQUIRE(!update_sketch.is_empty());
+  REQUIRE(update_sketch.get_num_retained() == 1);
+  update_sketch.reset();
+  REQUIRE(update_sketch.is_empty());
+  REQUIRE(update_sketch.get_num_retained() == 0);
+}
+
 TEST_CASE("aod sketch: serialization compatibility with java - empty", "[tuple_sketch]") {
   auto update_sketch = update_array_of_doubles_sketch::builder().build();
   REQUIRE(update_sketch.is_empty());
@@ -75,7 +86,7 @@ TEST_CASE("aod sketch: serialization compatibility with java - empty configured
 }
 
 TEST_CASE("aod sketch: serialization compatibility with java - non-empty no entries", "[tuple_sketch]") {
-  auto update_sketch = update_array_of_doubles_sketch::builder().set_p(0.01).build();
+  auto update_sketch = update_array_of_doubles_sketch::builder().set_p(0.01f).build();
   std::vector<double> a = {1};
   update_sketch.update(1, a);
   REQUIRE_FALSE(update_sketch.is_empty());
@@ -263,6 +274,11 @@ TEST_CASE("aod union: half overlap", "[tuple_sketch]") {
   u.update(update_sketch2);
   auto result = u.get_result();
   REQUIRE(result.get_estimate() == Approx(1500).margin(0.01));
+
+  u.reset();
+  result = u.get_result();
+  REQUIRE(result.is_empty());
+  REQUIRE(result.get_num_retained() == 0);
 }
 
 TEST_CASE("aod intersection: half overlap", "[tuple_sketch]") {

data/vendor/datasketches-cpp/tuple/test/tuple_a_not_b_test.cpp

@@ -38,8 +38,8 @@ TEST_CASE("tuple a-not-b: empty", "[tuple_a_not_b]") {
 
 TEST_CASE("tuple a-not-b: non empty no retained keys", "[tuple_a_not_b]") {
   auto a = update_tuple_sketch<float>::builder().build();
-  a.update(1, 1);
-  auto b = update_tuple_sketch<float>::builder().set_p(0.001).build();
+  a.update(1, 1.0f);
+  auto b = update_tuple_sketch<float>::builder().set_p(0.001f).build();
   tuple_a_not_b<float> a_not_b;
 
   // B is still empty
@@ -51,7 +51,7 @@ TEST_CASE("tuple a-not-b: non empty no retained keys", "[tuple_a_not_b]") {
   REQUIRE(result.get_estimate() == 1.0);
 
   // B is not empty in estimation mode and no entries
-  b.update(1, 1);
+  b.update(1, 1.0f);
   REQUIRE(b.get_num_retained() == 0);
 
   result = a_not_b.compute(a, b);
@@ -65,11 +65,11 @@ TEST_CASE("tuple a-not-b: non empty no retained keys", "[tuple_a_not_b]") {
 TEST_CASE("tuple a-not-b: exact mode half overlap", "[tuple_a_not_b]") {
   auto a = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 1000; i++) a.update(value++, 1);
+  for (int i = 0; i < 1000; i++) a.update(value++, 1.0f);
 
   auto b = update_tuple_sketch<float>::builder().build();
   value = 500;
-  for (int i = 0; i < 1000; i++) b.update(value++, 1);
+  for (int i = 0; i < 1000; i++) b.update(value++, 1.0f);
 
   tuple_a_not_b<float> a_not_b;
 
@@ -105,7 +105,7 @@ TEST_CASE("tuple a-not-b: exact mode half overlap", "[tuple_a_not_b]") {
 TEST_CASE("mixed a-not-b: exact mode half overlap", "[tuple_a_not_b]") {
   auto a = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 1000; i++) a.update(value++, 1);
+  for (int i = 0; i < 1000; i++) a.update(value++, 1.0f);
 
   auto b = update_theta_sketch::builder().build();
   value = 500;
@@ -145,10 +145,10 @@ TEST_CASE("mixed a-not-b: exact mode half overlap", "[tuple_a_not_b]") {
 TEST_CASE("tuple a-not-b: exact mode disjoint", "[tuple_a_not_b]") {
   auto a = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 1000; i++) a.update(value++, 1);
+  for (int i = 0; i < 1000; i++) a.update(value++, 1.0f);
 
   auto b = update_tuple_sketch<float>::builder().build();
-  for (int i = 0; i < 1000; i++) b.update(value++, 1);
+  for (int i = 0; i < 1000; i++) b.update(value++, 1.0f);
 
   tuple_a_not_b<float> a_not_b;
 
@@ -168,7 +168,7 @@ TEST_CASE("tuple a-not-b: exact mode disjoint", "[tuple_a_not_b]") {
 TEST_CASE("tuple a-not-b: exact mode full overlap", "[tuple_a_not_b]") {
   auto sketch = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 1000; i++) sketch.update(value++, 1);
+  for (int i = 0; i < 1000; i++) sketch.update(value++, 1.0f);
 
   tuple_a_not_b<float> a_not_b;
 
@@ -188,11 +188,11 @@ TEST_CASE("tuple a-not-b: exact mode full overlap", "[tuple_a_not_b]") {
 TEST_CASE("tuple a-not-b: estimation mode half overlap", "[tuple_a_not_b]") {
   auto a = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 10000; i++) a.update(value++, 1);
+  for (int i = 0; i < 10000; i++) a.update(value++, 1.0f);
 
   auto b = update_tuple_sketch<float>::builder().build();
   value = 5000;
-  for (int i = 0; i < 10000; i++) b.update(value++, 1);
+  for (int i = 0; i < 10000; i++) b.update(value++, 1.0f);
 
   tuple_a_not_b<float> a_not_b;
 
@@ -212,10 +212,10 @@ TEST_CASE("tuple a-not-b: estimation mode half overlap", "[tuple_a_not_b]") {
 TEST_CASE("tuple a-not-b: estimation mode disjoint", "[tuple_a_not_b]") {
   auto a = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 10000; i++) a.update(value++, 1);
+  for (int i = 0; i < 10000; i++) a.update(value++, 1.0f);
 
   auto b = update_tuple_sketch<float>::builder().build();
-  for (int i = 0; i < 10000; i++) b.update(value++, 1);
+  for (int i = 0; i < 10000; i++) b.update(value++, 1.0f);
 
   tuple_a_not_b<float> a_not_b;
 
@@ -235,7 +235,7 @@ TEST_CASE("tuple a-not-b: estimation mode disjoint", "[tuple_a_not_b]") {
 TEST_CASE("tuple a-not-b: estimation mode full overlap", "[tuple_a_not_b]") {
   auto sketch = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 10000; i++) sketch.update(value++, 1);
+  for (int i = 0; i < 10000; i++) sketch.update(value++, 1.0f);
 
   tuple_a_not_b<float> a_not_b;
 
@@ -254,7 +254,7 @@ TEST_CASE("tuple a-not-b: estimation mode full overlap", "[tuple_a_not_b]") {
 
 TEST_CASE("tuple a-not-b: seed mismatch", "[tuple_a_not_b]") {
   auto sketch = update_tuple_sketch<float>::builder().build();
-  sketch.update(1, 1); // non-empty should not be ignored
+  sketch.update(1, 1.0f); // non-empty should not be ignored
   tuple_a_not_b<float> a_not_b(123);
   REQUIRE_THROWS_AS(a_not_b.compute(sketch, sketch), std::invalid_argument);
 }
@@ -262,11 +262,11 @@ TEST_CASE("tuple a-not-b: seed mismatch", "[tuple_a_not_b]") {
 TEST_CASE("tuple a-not-b: issue #152", "[tuple_a_not_b]") {
   auto a = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 10000; i++) a.update(value++, 1);
+  for (int i = 0; i < 10000; i++) a.update(value++, 1.0f);
 
   auto b = update_tuple_sketch<float>::builder().build();
   value = 5000;
-  for (int i = 0; i < 25000; i++) b.update(value++, 1);
+  for (int i = 0; i < 25000; i++) b.update(value++, 1.0f);
 
   tuple_a_not_b<float> a_not_b;
 

data/vendor/datasketches-cpp/tuple/test/tuple_intersection_test.cpp

@@ -59,8 +59,8 @@ TEST_CASE("tuple intersection: empty", "[tuple_intersection]") {
 }
 
 TEST_CASE("tuple intersection: non empty no retained keys", "[tuple_intersection]") {
-  auto sketch = update_tuple_sketch<float>::builder().set_p(0.001).build();
-  sketch.update(1, 1);
+  auto sketch = update_tuple_sketch<float>::builder().set_p(0.001f).build();
+  sketch.update(1, 1.0f);
   tuple_intersection_float intersection;
   intersection.update(sketch);
   auto result = intersection.get_result();
@@ -82,11 +82,11 @@ TEST_CASE("tuple intersection: non empty no retained keys", "[tuple_intersection
 TEST_CASE("tuple intersection: exact mode half overlap", "[tuple_intersection]") {
   auto sketch1 = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 1000; i++) sketch1.update(value++, 1);
+  for (int i = 0; i < 1000; i++) sketch1.update(value++, 1.0f);
 
   auto sketch2 = update_tuple_sketch<float>::builder().build();
   value = 500;
-  for (int i = 0; i < 1000; i++) sketch2.update(value++, 1);
+  for (int i = 0; i < 1000; i++) sketch2.update(value++, 1.0f);
 
   { // unordered
     tuple_intersection_float intersection;
@@ -111,10 +111,10 @@ TEST_CASE("tuple intersection: exact mode half overlap", "[tuple_intersection]")
 TEST_CASE("tuple intersection: exact mode disjoint", "[tuple_intersection]") {
   auto sketch1 = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 1000; i++) sketch1.update(value++, 1);
+  for (int i = 0; i < 1000; i++) sketch1.update(value++, 1.0f);
 
   auto sketch2 = update_tuple_sketch<float>::builder().build();
-  for (int i = 0; i < 1000; i++) sketch2.update(value++, 1);
+  for (int i = 0; i < 1000; i++) sketch2.update(value++, 1.0f);
 
   { // unordered
     tuple_intersection_float intersection;
@@ -139,7 +139,7 @@ TEST_CASE("tuple intersection: exact mode disjoint", "[tuple_intersection]") {
 TEST_CASE("mixed intersection: exact mode half overlap", "[tuple_intersection]") {
   auto sketch1 = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 1000; i++) sketch1.update(value++, 1);
+  for (int i = 0; i < 1000; i++) sketch1.update(value++, 1.0f);
 
   auto sketch2 = update_theta_sketch::builder().build();
   value = 500;
@@ -168,11 +168,11 @@ TEST_CASE("mixed intersection: exact mode half overlap", "[tuple_intersection]")
 TEST_CASE("tuple intersection: estimation mode half overlap", "[tuple_intersection]") {
   auto sketch1 = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 10000; i++) sketch1.update(value++, 1);
+  for (int i = 0; i < 10000; i++) sketch1.update(value++, 1.0f);
 
   auto sketch2 = update_tuple_sketch<float>::builder().build();
   value = 5000;
-  for (int i = 0; i < 10000; i++) sketch2.update(value++, 1);
+  for (int i = 0; i < 10000; i++) sketch2.update(value++, 1.0f);
 
   { // unordered
     tuple_intersection_float intersection;
@@ -197,10 +197,10 @@ TEST_CASE("tuple intersection: estimation mode half overlap", "[tuple_intersecti
 TEST_CASE("tuple intersection: estimation mode disjoint", "[tuple_intersection]") {
   auto sketch1 = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 10000; i++) sketch1.update(value++, 1);
+  for (int i = 0; i < 10000; i++) sketch1.update(value++, 1.0f);
 
   auto sketch2 = update_tuple_sketch<float>::builder().build();
-  for (int i = 0; i < 10000; i++) sketch2.update(value++, 1);
+  for (int i = 0; i < 10000; i++) sketch2.update(value++, 1.0f);
 
   { // unordered
     tuple_intersection_float intersection;
@@ -224,7 +224,7 @@ TEST_CASE("tuple intersection: estimation mode disjoint", "[tuple_intersection]"
 
 TEST_CASE("tuple intersection: seed mismatch", "[tuple_intersection]") {
   auto sketch = update_tuple_sketch<float>::builder().build();
-  sketch.update(1, 1); // non-empty should not be ignored
+  sketch.update(1, 1.0f); // non-empty should not be ignored
   tuple_intersection_float intersection(123);
   REQUIRE_THROWS_AS(intersection.update(sketch), std::invalid_argument);
 }

data/vendor/datasketches-cpp/tuple/test/tuple_jaccard_similarity_test.cpp

@@ -44,7 +44,7 @@ TEST_CASE("tuple jaccard: empty", "[tuple_sketch]") {
 
 TEST_CASE("tuple jaccard: same sketch exact mode", "[tuple_sketch]") {
   auto sk = update_tuple_sketch<float>::builder().build();
-  for (int i = 0; i < 1000; ++i) sk.update(i, 1);
+  for (int i = 0; i < 1000; ++i) sk.update(i, 1.0f);
 
   // update sketch
   auto jc = tuple_jaccard_similarity_float::jaccard(sk, sk);
@@ -61,8 +61,8 @@ TEST_CASE("tuple jaccard: full overlap exact mode", "[tuple_sketch]") {
   auto sk_a = update_tuple_sketch<float>::builder().build();
   auto sk_b = update_tuple_sketch<float>::builder().build();
   for (int i = 0; i < 1000; ++i) {
-    sk_a.update(i, 1);
-    sk_b.update(i, 1);
+    sk_a.update(i, 1.0f);
+    sk_b.update(i, 1.0f);
   }
 
   // update sketches
@@ -83,8 +83,8 @@ TEST_CASE("tuple jaccard: disjoint exact mode", "[tuple_sketch]") {
   auto sk_a = update_tuple_sketch<float>::builder().build();
   auto sk_b = update_tuple_sketch<float>::builder().build();
   for (int i = 0; i < 1000; ++i) {
-    sk_a.update(i, 1);
-    sk_b.update(i + 1000, 1);
+    sk_a.update(i, 1.0f);
+    sk_b.update(i + 1000, 1.0f);
   }
 
   // update sketches

data/vendor/datasketches-cpp/tuple/test/tuple_sketch_allocation_test.cpp

@@ -64,7 +64,7 @@ TEST_CASE("tuple sketch with test allocator: estimation mode", "[tuple_sketch]")
     REQUIRE(count == update_sketch.get_num_retained());
 
     update_sketch.trim();
-    REQUIRE(update_sketch.get_num_retained() == (1 << update_sketch.get_lg_k()));
+    REQUIRE(update_sketch.get_num_retained() == (1U << update_sketch.get_lg_k()));
 
     auto compact_sketch = update_sketch.compact();
     REQUIRE(!compact_sketch.is_empty());

data/vendor/datasketches-cpp/tuple/test/tuple_sketch_test.cpp

@@ -34,18 +34,19 @@ std::ostream& operator<<(std::ostream& os, const three_doubles& tuple) {
 
 #include <catch.hpp>
 #include <tuple_sketch.hpp>
-//#include <test_type.hpp>
 
 namespace datasketches {
 
 TEST_CASE("tuple sketch float: builder", "[tuple_sketch]") {
   auto builder = update_tuple_sketch<float>::builder();
-  builder.set_lg_k(10).set_p(0.5).set_resize_factor(theta_constants::resize_factor::X2).set_seed(123);
+  builder.set_lg_k(10).set_p(0.5f).set_resize_factor(theta_constants::resize_factor::X2).set_seed(123);
   auto sketch = builder.build();
   REQUIRE(sketch.get_lg_k() == 10);
-  REQUIRE(sketch.get_theta() == 0.5);
+  REQUIRE(sketch.get_theta() == 1.0); // empty sketch should have theta 1.0
   REQUIRE(sketch.get_rf() == theta_constants::resize_factor::X2);
   REQUIRE(sketch.get_seed_hash() == compute_seed_hash(123));
+  sketch.update(1, 0);
+  REQUIRE(sketch.get_theta() == 0.5); // theta = p
 }
 
 TEST_CASE("tuple sketch float: empty", "[tuple_sketch]") {
@@ -58,7 +59,7 @@ TEST_CASE("tuple sketch float: empty", "[tuple_sketch]") {
   REQUIRE(update_sketch.get_upper_bound(1) == 0);
   REQUIRE(update_sketch.get_theta() == 1);
   REQUIRE(update_sketch.get_num_retained() == 0);
-  REQUIRE(!update_sketch.is_ordered());
+  REQUIRE(update_sketch.is_ordered());
 
   auto compact_sketch = update_sketch.compact();
   std::cout << "sizeof(compact_tuple_sketch<float>)=" << sizeof(compact_sketch) << std::endl;
@@ -70,22 +71,49 @@ TEST_CASE("tuple sketch float: empty", "[tuple_sketch]") {
   REQUIRE(compact_sketch.get_theta() == 1);
   REQUIRE(compact_sketch.get_num_retained() == 0);
   REQUIRE(compact_sketch.is_ordered());
+
+  // empty is forced to be ordered
+  REQUIRE(update_sketch.compact(false).is_ordered());
+}
+
+TEST_CASE("tuple sketch: single item", "[theta_sketch]") {
+  auto update_sketch = update_tuple_sketch<float>::builder().build();
+  update_sketch.update(1, 1.0f);
+  REQUIRE_FALSE(update_sketch.is_empty());
+  REQUIRE_FALSE(update_sketch.is_estimation_mode());
+  REQUIRE(update_sketch.get_theta() == 1.0);
+  REQUIRE(update_sketch.get_estimate() == 1.0);
+  REQUIRE(update_sketch.get_lower_bound(1) == 1.0);
+  REQUIRE(update_sketch.get_upper_bound(1) == 1.0);
+  REQUIRE(update_sketch.is_ordered()); // one item is ordered
+
+  auto compact_sketch = update_sketch.compact();
+  REQUIRE_FALSE(compact_sketch.is_empty());
+  REQUIRE_FALSE(compact_sketch.is_estimation_mode());
+  REQUIRE(compact_sketch.get_theta() == 1.0);
+  REQUIRE(compact_sketch.get_estimate() == 1.0);
+  REQUIRE(compact_sketch.get_lower_bound(1) == 1.0);
+  REQUIRE(compact_sketch.get_upper_bound(1) == 1.0);
+  REQUIRE(compact_sketch.is_ordered());
+
+  // single item is forced to be ordered
+  REQUIRE(update_sketch.compact(false).is_ordered());
 }
 
 TEST_CASE("tuple sketch float: exact mode", "[tuple_sketch]") {
   auto update_sketch = update_tuple_sketch<float>::builder().build();
-  update_sketch.update(1, 1);
-  update_sketch.update(2, 2);
-  update_sketch.update(1, 1);
+  update_sketch.update(1, 1.0f);
+  update_sketch.update(2, 2.0f);
+  update_sketch.update(1, 1.0f);
 //  std::cout << update_sketch.to_string(true);
-  REQUIRE(!update_sketch.is_empty());
-  REQUIRE(!update_sketch.is_estimation_mode());
+  REQUIRE_FALSE(update_sketch.is_empty());
+  REQUIRE_FALSE(update_sketch.is_estimation_mode());
   REQUIRE(update_sketch.get_estimate() == 2);
   REQUIRE(update_sketch.get_lower_bound(1) == 2);
   REQUIRE(update_sketch.get_upper_bound(1) == 2);
   REQUIRE(update_sketch.get_theta() == 1);
   REQUIRE(update_sketch.get_num_retained() == 2);
-  REQUIRE(!update_sketch.is_ordered());
+  REQUIRE_FALSE(update_sketch.is_ordered());
   int count = 0;
   for (const auto& entry: update_sketch) {
     REQUIRE(entry.second == 2);
@@ -95,8 +123,8 @@ TEST_CASE("tuple sketch float: exact mode", "[tuple_sketch]") {
 
   auto compact_sketch = update_sketch.compact();
 //  std::cout << compact_sketch.to_string(true);
-  REQUIRE(!compact_sketch.is_empty());
-  REQUIRE(!compact_sketch.is_estimation_mode());
+  REQUIRE_FALSE(compact_sketch.is_empty());
+  REQUIRE_FALSE(compact_sketch.is_estimation_mode());
   REQUIRE(compact_sketch.get_estimate() == 2);
   REQUIRE(compact_sketch.get_lower_bound(1) == 2);
   REQUIRE(compact_sketch.get_upper_bound(1) == 2);
@@ -151,6 +179,16 @@ TEST_CASE("tuple sketch float: exact mode", "[tuple_sketch]") {
       ++it;
     }
   }
+
+  update_sketch.reset();
+  REQUIRE(update_sketch.is_empty());
+  REQUIRE_FALSE(update_sketch.is_estimation_mode());
+  REQUIRE(update_sketch.get_estimate() == 0);
+  REQUIRE(update_sketch.get_lower_bound(1) == 0);
+  REQUIRE(update_sketch.get_upper_bound(1) == 0);
+  REQUIRE(update_sketch.get_theta() == 1);
+  REQUIRE(update_sketch.get_num_retained() == 0);
+  REQUIRE(update_sketch.is_ordered());
 }
 
 template<typename T>
@@ -167,11 +205,11 @@ using max_float_update_tuple_sketch = update_tuple_sketch<float, float, max_valu
 
 TEST_CASE("tuple sketch: float, custom policy", "[tuple_sketch]") {
   auto update_sketch = max_float_update_tuple_sketch::builder(max_value_policy<float>(5)).build();
-  update_sketch.update(1, 1);
-  update_sketch.update(1, 2);
-  update_sketch.update(2, 10);
-  update_sketch.update(3, 3);
-  update_sketch.update(3, 7);
+  update_sketch.update(1, 1.0f);
+  update_sketch.update(1, 2.0f);
+  update_sketch.update(2, 10.0f);
+  update_sketch.update(3, 3.0f);
+  update_sketch.update(3, 7.0f);
 //  std::cout << update_sketch.to_string(true);
   int count = 0;
   float sum = 0;
@@ -212,37 +250,37 @@ TEST_CASE("tuple sketch: tuple of doubles", "[tuple_sketch]") {
 TEST_CASE("tuple sketch: float, update with different types of keys", "[tuple_sketch]") {
   auto sketch = update_tuple_sketch<float>::builder().build();
 
-  sketch.update(static_cast<uint64_t>(1), 1);
+  sketch.update(static_cast<uint64_t>(1), 1.0f);
   REQUIRE(sketch.get_num_retained() == 1);
 
-  sketch.update(static_cast<int64_t>(1), 1);
+  sketch.update(static_cast<int64_t>(1), 1.0f);
   REQUIRE(sketch.get_num_retained() == 1);
 
-  sketch.update(static_cast<uint32_t>(1), 1);
+  sketch.update(static_cast<uint32_t>(1), 1.0f);
   REQUIRE(sketch.get_num_retained() == 1);
 
-  sketch.update(static_cast<int32_t>(1), 1);
+  sketch.update(static_cast<int32_t>(1), 1.0f);
   REQUIRE(sketch.get_num_retained() == 1);
 
-  sketch.update(static_cast<uint16_t>(1), 1);
+  sketch.update(static_cast<uint16_t>(1), 1.0f);
   REQUIRE(sketch.get_num_retained() == 1);
 
-  sketch.update(static_cast<int16_t>(1), 1);
+  sketch.update(static_cast<int16_t>(1), 1.0f);
   REQUIRE(sketch.get_num_retained() == 1);
 
-  sketch.update(static_cast<uint8_t>(1), 1);
+  sketch.update(static_cast<uint8_t>(1), 1.0f);
   REQUIRE(sketch.get_num_retained() == 1);
 
-  sketch.update(static_cast<int8_t>(1), 1);
+  sketch.update(static_cast<int8_t>(1), 1.0f);
   REQUIRE(sketch.get_num_retained() == 1);
 
-  sketch.update(1.0, 1);
+  sketch.update(1.0, 1.0f);
   REQUIRE(sketch.get_num_retained() == 2);
 
-  sketch.update(static_cast<float>(1), 1);
+  sketch.update(static_cast<float>(1), 1.0f);
   REQUIRE(sketch.get_num_retained() == 2);
 
-  sketch.update("a", 1);
+  sketch.update("a", 1.0f);
   REQUIRE(sketch.get_num_retained() == 3);
 }
 

data/vendor/datasketches-cpp/tuple/test/tuple_union_test.cpp

@@ -51,9 +51,9 @@ TEST_CASE("tupe_union float: empty theta sketch", "[tuple union]") {
 }
 
 TEST_CASE("tuple_union float: non-empty no retained entries", "[tuple union]") {
-  auto update_sketch = update_tuple_sketch<float>::builder().set_p(0.001).build();
+  auto update_sketch = update_tuple_sketch<float>::builder().set_p(0.001f).build();
 //  std::cout << update_sketch.to_string();
-  update_sketch.update(1, 1);
+  update_sketch.update(1, 1.0f);
   REQUIRE(!update_sketch.is_empty());
   REQUIRE(update_sketch.get_num_retained() == 0);
   auto u = tuple_union<float>::builder().build();
@@ -69,28 +69,35 @@ TEST_CASE("tuple_union float: non-empty no retained entries", "[tuple union]") {
 
 TEST_CASE("tuple_union float: simple case", "[tuple union]") {
   auto update_sketch1 = update_tuple_sketch<float>::builder().build();
-  update_sketch1.update(1, 1);
-  update_sketch1.update(2, 1);
+  update_sketch1.update(1, 1.0f);
+  update_sketch1.update(2, 1.0f);
 
   auto update_sketch2 = update_tuple_sketch<float>::builder().build();
-  update_sketch2.update(1, 1);
-  update_sketch2.update(3, 1);
+  update_sketch2.update(1, 1.0f);
+  update_sketch2.update(3, 1.0f);
 
   auto u = tuple_union<float>::builder().build();
   u.update(update_sketch1);
   u.update(update_sketch2);
   auto result = u.get_result();
   REQUIRE(result.get_num_retained() == 3);
+
+  u.reset();
+  result = u.get_result();
+  REQUIRE(result.is_empty());
+  REQUIRE(result.get_num_retained() == 0);
+  REQUIRE(!result.is_estimation_mode());
+  REQUIRE(result.get_estimate() == 0);
 }
 
 TEST_CASE("tuple_union float: exact mode half overlap", "[tuple union]") {
   auto update_sketch1 = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 1000; ++i) update_sketch1.update(value++, 1);
+  for (int i = 0; i < 1000; ++i) update_sketch1.update(value++, 1.0f);
 
   auto update_sketch2 = update_tuple_sketch<float>::builder().build();
   value = 500;
-  for (int i = 0; i < 1000; ++i) update_sketch2.update(value++, 1);
+  for (int i = 0; i < 1000; ++i) update_sketch2.update(value++, 1.0f);
 
   { // unordered
     auto u = tuple_union<float>::builder().build();
@@ -115,11 +122,11 @@ TEST_CASE("tuple_union float: exact mode half overlap", "[tuple union]") {
 TEST_CASE("tuple_union float: estimation mode half overlap", "[tuple union]") {
   auto update_sketch1 = update_tuple_sketch<float>::builder().build();
   int value = 0;
-  for (int i = 0; i < 10000; ++i) update_sketch1.update(value++, 1);
+  for (int i = 0; i < 10000; ++i) update_sketch1.update(value++, 1.0f);
 
   auto update_sketch2 = update_tuple_sketch<float>::builder().build();
   value = 5000;
-  for (int i = 0; i < 10000; ++i) update_sketch2.update(value++, 1);
+  for (int i = 0; i < 10000; ++i) update_sketch2.update(value++, 1.0f);
 
   { // unordered
     auto u = tuple_union<float>::builder().build();
@@ -143,7 +150,7 @@ TEST_CASE("tuple_union float: estimation mode half overlap", "[tuple union]") {
 
 TEST_CASE("tuple_union float: seed mismatch", "[tuple union]") {
   auto update_sketch = update_tuple_sketch<float>::builder().build();
-  update_sketch.update(1, 1); // non-empty should not be ignored
+  update_sketch.update(1, 1.0f); // non-empty should not be ignored
 
   auto u = tuple_union<float>::builder().set_seed(123).build();
   REQUIRE_THROWS_AS(u.update(update_sketch), std::invalid_argument);
@@ -154,7 +161,7 @@ TEST_CASE("tuple_union float: full overlap with theta sketch", "[tuple union]")
 
   // tuple update
   auto update_tuple = update_tuple_sketch<float>::builder().build();
-  for (unsigned i = 0; i < 10; ++i) update_tuple.update(i, 1);
+  for (unsigned i = 0; i < 10; ++i) update_tuple.update(i, 1.0f);
   u.update(update_tuple);
 
   // tuple compact