datasketches 0.1.0

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

@@ -0,0 +1,235 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <iostream>
+
+#include <catch.hpp>
+#include <tuple_intersection.hpp>
+#include <theta_sketch_experimental.hpp>
+
+namespace datasketches {
+
+template<typename Summary>
+struct subtracting_intersection_policy {
+  void operator()(Summary& summary, const Summary& other) const {
+    summary -= other;
+  }
+};
+
+using tuple_intersection_float = tuple_intersection<float, subtracting_intersection_policy<float>>;
+
+TEST_CASE("tuple intersection: invalid", "[tuple_intersection]") {
+  tuple_intersection_float intersection;
+  REQUIRE_FALSE(intersection.has_result());
+  REQUIRE_THROWS_AS(intersection.get_result(), std::invalid_argument);
+}
+
+TEST_CASE("tuple intersection: empty", "[tuple_intersection]") {
+  auto sketch = update_tuple_sketch<float>::builder().build();
+  tuple_intersection_float intersection;
+  intersection.update(sketch);
+  auto result = intersection.get_result();
+  REQUIRE(result.get_num_retained() == 0);
+  REQUIRE(result.is_empty());
+  REQUIRE_FALSE(result.is_estimation_mode());
+  REQUIRE(result.get_estimate() == 0.0);
+
+  intersection.update(sketch);
+  result = intersection.get_result();
+  REQUIRE(result.get_num_retained() == 0);
+  REQUIRE(result.is_empty());
+  REQUIRE_FALSE(result.is_estimation_mode());
+  REQUIRE(result.get_estimate() == 0.0);
+}
+
+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);
+  tuple_intersection_float intersection;
+  intersection.update(sketch);
+  auto result = intersection.get_result();
+  REQUIRE(result.get_num_retained() == 0);
+  REQUIRE_FALSE(result.is_empty());
+  REQUIRE(result.is_estimation_mode());
+  REQUIRE(result.get_theta() == Approx(0.001).margin(1e-10));
+  REQUIRE(result.get_estimate() == 0.0);
+
+  intersection.update(sketch);
+  result = intersection.get_result();
+  REQUIRE(result.get_num_retained() == 0);
+  REQUIRE_FALSE(result.is_empty());
+  REQUIRE(result.is_estimation_mode());
+  REQUIRE(result.get_theta() == Approx(0.001).margin(1e-10));
+  REQUIRE(result.get_estimate() == 0.0);
+}
+
+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);
+
+  auto sketch2 = update_tuple_sketch<float>::builder().build();
+  value = 500;
+  for (int i = 0; i < 1000; i++) sketch2.update(value++, 1);
+
+  { // unordered
+    tuple_intersection_float intersection;
+    intersection.update(sketch1);
+    intersection.update(sketch2);
+    auto result = intersection.get_result();
+    REQUIRE_FALSE(result.is_empty());
+    REQUIRE_FALSE(result.is_estimation_mode());
+    REQUIRE(result.get_estimate() == 500.0);
+  }
+  { // ordered
+    tuple_intersection_float intersection;
+    intersection.update(sketch1.compact());
+    intersection.update(sketch2.compact());
+    auto result = intersection.get_result();
+    REQUIRE_FALSE(result.is_empty());
+    REQUIRE_FALSE(result.is_estimation_mode());
+    REQUIRE(result.get_estimate() == 500.0);
+  }
+}
+
+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);
+
+  auto sketch2 = update_tuple_sketch<float>::builder().build();
+  for (int i = 0; i < 1000; i++) sketch2.update(value++, 1);
+
+  { // unordered
+    tuple_intersection_float intersection;
+    intersection.update(sketch1);
+    intersection.update(sketch2);
+    auto result = intersection.get_result();
+    REQUIRE(result.is_empty());
+    REQUIRE_FALSE(result.is_estimation_mode());
+    REQUIRE(result.get_estimate() == 0.0);
+  }
+  { // ordered
+    tuple_intersection_float intersection;
+    intersection.update(sketch1.compact());
+    intersection.update(sketch2.compact());
+    auto result = intersection.get_result();
+    REQUIRE(result.is_empty());
+    REQUIRE_FALSE(result.is_estimation_mode());
+    REQUIRE(result.get_estimate() == 0.0);
+  }
+}
+
+// needed until promotion of experimental to replace existing theta sketch
+using update_theta_sketch = update_theta_sketch_experimental<>;
+
+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);
+
+  auto sketch2 = update_theta_sketch::builder().build();
+  value = 500;
+  for (int i = 0; i < 1000; i++) sketch2.update(value++);
+
+  { // unordered
+    tuple_intersection_float intersection;
+    intersection.update(sketch1);
+    intersection.update(compact_tuple_sketch<float>(sketch2, 1, false));
+    auto result = intersection.get_result();
+    REQUIRE_FALSE(result.is_empty());
+    REQUIRE_FALSE(result.is_estimation_mode());
+    REQUIRE(result.get_estimate() == 500.0);
+  }
+  { // ordered
+    tuple_intersection_float intersection;
+    intersection.update(sketch1.compact());
+    intersection.update(compact_tuple_sketch<float>(sketch2.compact(), 1));
+    auto result = intersection.get_result();
+    REQUIRE_FALSE(result.is_empty());
+    REQUIRE_FALSE(result.is_estimation_mode());
+    REQUIRE(result.get_estimate() == 500.0);
+  }
+}
+
+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);
+
+  auto sketch2 = update_tuple_sketch<float>::builder().build();
+  value = 5000;
+  for (int i = 0; i < 10000; i++) sketch2.update(value++, 1);
+
+  { // unordered
+    tuple_intersection_float intersection;
+    intersection.update(sketch1);
+    intersection.update(sketch2);
+    auto result = intersection.get_result();
+    REQUIRE_FALSE(result.is_empty());
+    REQUIRE(result.is_estimation_mode());
+    REQUIRE(result.get_estimate() == Approx(5000).margin(5000 * 0.02));
+  }
+  { // ordered
+    tuple_intersection_float intersection;
+    intersection.update(sketch1.compact());
+    intersection.update(sketch2.compact());
+    auto result = intersection.get_result();
+    REQUIRE_FALSE(result.is_empty());
+    REQUIRE(result.is_estimation_mode());
+    REQUIRE(result.get_estimate() == Approx(5000).margin(5000 * 0.02));
+  }
+}
+
+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);
+
+  auto sketch2 = update_tuple_sketch<float>::builder().build();
+  for (int i = 0; i < 10000; i++) sketch2.update(value++, 1);
+
+  { // unordered
+    tuple_intersection_float intersection;
+    intersection.update(sketch1);
+    intersection.update(sketch2);
+    auto result = intersection.get_result();
+    REQUIRE_FALSE(result.is_empty());
+    REQUIRE(result.is_estimation_mode());
+    REQUIRE(result.get_estimate() == 0.0);
+  }
+  { // ordered
+    tuple_intersection_float intersection;
+    intersection.update(sketch1.compact());
+    intersection.update(sketch2.compact());
+    auto result = intersection.get_result();
+    REQUIRE_FALSE(result.is_empty());
+    REQUIRE(result.is_estimation_mode());
+    REQUIRE(result.get_estimate() == 0.0);
+  }
+}
+
+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
+  tuple_intersection_float intersection(123);
+  REQUIRE_THROWS_AS(intersection.update(sketch), std::invalid_argument);
+}
+
+} /* namespace datasketches */

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

@@ -0,0 +1,98 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <iostream>
+
+#include <catch.hpp>
+#include <jaccard_similarity.hpp>
+
+namespace datasketches {
+
+using tuple_jaccard_similarity_float = tuple_jaccard_similarity<float, default_union_policy<float>>;
+
+TEST_CASE("tuple jaccard: empty", "[tuple_sketch]") {
+  auto sk_a = update_tuple_sketch<float>::builder().build();
+  auto sk_b = update_tuple_sketch<float>::builder().build();
+
+  // update sketches
+  auto jc = tuple_jaccard_similarity_float::jaccard(sk_a, sk_b);
+  REQUIRE(jc == std::array<double, 3>{1, 1, 1});
+
+  // compact sketches
+  jc = tuple_jaccard_similarity_float::jaccard(sk_a.compact(), sk_b.compact());
+  REQUIRE(jc == std::array<double, 3>{1, 1, 1});
+
+  REQUIRE(tuple_jaccard_similarity_float::exactly_equal(sk_a, sk_b));
+}
+
+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);
+
+  // update sketch
+  auto jc = tuple_jaccard_similarity_float::jaccard(sk, sk);
+  REQUIRE(jc == std::array<double, 3>{1, 1, 1});
+
+  // compact sketch
+  jc = tuple_jaccard_similarity_float::jaccard(sk.compact(), sk.compact());
+  REQUIRE(jc == std::array<double, 3>{1, 1, 1});
+
+  REQUIRE(tuple_jaccard_similarity_float::exactly_equal(sk, sk));
+}
+
+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);
+  }
+
+  // update sketches
+  auto jc = tuple_jaccard_similarity_float::jaccard(sk_a, sk_b);
+  REQUIRE(jc == std::array<double, 3>{1, 1, 1});
+
+  // compact sketches
+  jc = tuple_jaccard_similarity_float::jaccard(sk_a.compact(), sk_b.compact());
+  REQUIRE(jc == std::array<double, 3>{1, 1, 1});
+
+  REQUIRE(tuple_jaccard_similarity_float::exactly_equal(sk_a, sk_b));
+  REQUIRE(tuple_jaccard_similarity_float::exactly_equal(sk_a.compact(), sk_b));
+  REQUIRE(tuple_jaccard_similarity_float::exactly_equal(sk_a, sk_b.compact()));
+  REQUIRE(tuple_jaccard_similarity_float::exactly_equal(sk_a.compact(), sk_b.compact()));
+}
+
+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);
+  }
+
+  // update sketches
+  auto jc = tuple_jaccard_similarity_float::jaccard(sk_a, sk_b);
+  REQUIRE(jc == std::array<double, 3>{0, 0, 0});
+
+  // compact sketches
+  jc = tuple_jaccard_similarity_float::jaccard(sk_a.compact(), sk_b.compact());
+  REQUIRE(jc == std::array<double, 3>{0, 0, 0});
+}
+
+} /* namespace datasketches */

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

@@ -0,0 +1,102 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <iostream>
+
+#include <catch.hpp>
+#include <tuple_sketch.hpp>
+#include <test_allocator.hpp>
+#include <test_type.hpp>
+
+namespace datasketches {
+
+static const bool ALLOCATOR_TEST_DEBUG = false;
+
+struct test_type_replace_policy {
+  test_type create() const { return test_type(0); }
+  void update(test_type& summary, const test_type& update) const {
+    if (ALLOCATOR_TEST_DEBUG) std::cerr << "policy::update lvalue begin" << std::endl;
+    summary = update;
+    if (ALLOCATOR_TEST_DEBUG) std::cerr << "policy::update lvalue end" << std::endl;
+  }
+  void update(test_type& summary, test_type&& update) const {
+    if (ALLOCATOR_TEST_DEBUG) std::cerr << "policy::update rvalue begin" << std::endl;
+    summary = std::move(update);
+    if (ALLOCATOR_TEST_DEBUG) std::cerr << "policy::update rvalue end" << std::endl;
+  }
+};
+
+using update_tuple_sketch_test =
+    update_tuple_sketch<test_type, test_type, test_type_replace_policy, test_allocator<test_type>>;
+using compact_tuple_sketch_test =
+    compact_tuple_sketch<test_type, test_allocator<test_type>>;
+
+TEST_CASE("tuple sketch with test allocator: estimation mode", "[tuple_sketch]") {
+  test_allocator_total_bytes = 0;
+  test_allocator_net_allocations = 0;
+  {
+    auto update_sketch = update_tuple_sketch_test::builder().build();
+    for (int i = 0; i < 10000; ++i) update_sketch.update(i, 1);
+    for (int i = 0; i < 10000; ++i) update_sketch.update(i, 2);
+    REQUIRE(!update_sketch.is_empty());
+    REQUIRE(update_sketch.is_estimation_mode());
+    unsigned count = 0;
+    for (const auto& entry: update_sketch) {
+      REQUIRE(entry.second.get_value() == 2);
+      ++count;
+    }
+    REQUIRE(count == update_sketch.get_num_retained());
+
+    update_sketch.trim();
+    REQUIRE(update_sketch.get_num_retained() == (1 << update_sketch.get_lg_k()));
+
+    auto compact_sketch = update_sketch.compact();
+    REQUIRE(!compact_sketch.is_empty());
+    REQUIRE(compact_sketch.is_estimation_mode());
+    count = 0;
+    for (const auto& entry: compact_sketch) {
+      REQUIRE(entry.second.get_value() == 2);
+      ++count;
+    }
+    REQUIRE(count == update_sketch.get_num_retained());
+
+    auto bytes = compact_sketch.serialize(0, test_type_serde());
+    auto deserialized_sketch = compact_tuple_sketch_test::deserialize(bytes.data(), bytes.size(), DEFAULT_SEED, test_type_serde());
+    REQUIRE(deserialized_sketch.get_estimate() == compact_sketch.get_estimate());
+
+    // update sketch copy
+    if (ALLOCATOR_TEST_DEBUG) std::cout << update_sketch.to_string();
+    update_tuple_sketch_test update_sketch_copy(update_sketch);
+    update_sketch_copy = update_sketch;
+    // update sketch move
+    update_tuple_sketch_test update_sketch_moved(std::move(update_sketch_copy));
+    update_sketch_moved = std::move(update_sketch);
+
+    // compact sketch copy
+    compact_tuple_sketch_test compact_sketch_copy(compact_sketch);
+    compact_sketch_copy = compact_sketch;
+    // compact sketch move
+    compact_tuple_sketch_test compact_sketch_moved(std::move(compact_sketch_copy));
+    compact_sketch_moved = std::move(compact_sketch);
+  }
+  REQUIRE(test_allocator_total_bytes == 0);
+  REQUIRE(test_allocator_net_allocations == 0);
+}
+
+} /* namespace datasketches */

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

@@ -0,0 +1,249 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <iostream>
+#include <tuple>
+
+namespace datasketches {
+
+using three_doubles = std::tuple<double, double, double>;
+
+// this is needed for a test below, but should be defined here
+std::ostream& operator<<(std::ostream& os, const three_doubles& tuple) {
+  os << std::get<0>(tuple) << ", " << std::get<1>(tuple) << ", " << std::get<2>(tuple);
+  return os;
+}
+
+}
+
+#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);
+  auto sketch = builder.build();
+  REQUIRE(sketch.get_lg_k() == 10);
+  REQUIRE(sketch.get_theta() == 0.5);
+  REQUIRE(sketch.get_rf() == theta_constants::resize_factor::X2);
+  REQUIRE(sketch.get_seed_hash() == compute_seed_hash(123));
+}
+
+TEST_CASE("tuple sketch float: empty", "[tuple_sketch]") {
+  auto update_sketch = update_tuple_sketch<float>::builder().build();
+  std::cout << "sizeof(update_tuple_sketch<float>)=" << sizeof(update_sketch) << std::endl;
+  REQUIRE(update_sketch.is_empty());
+  REQUIRE(!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());
+
+  auto compact_sketch = update_sketch.compact();
+  std::cout << "sizeof(compact_tuple_sketch<float>)=" << sizeof(compact_sketch) << std::endl;
+  REQUIRE(compact_sketch.is_empty());
+  REQUIRE(!compact_sketch.is_estimation_mode());
+  REQUIRE(compact_sketch.get_estimate() == 0);
+  REQUIRE(compact_sketch.get_lower_bound(1) == 0);
+  REQUIRE(compact_sketch.get_upper_bound(1) == 0);
+  REQUIRE(compact_sketch.get_theta() == 1);
+  REQUIRE(compact_sketch.get_num_retained() == 0);
+  REQUIRE(compact_sketch.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);
+//  std::cout << update_sketch.to_string(true);
+  REQUIRE(!update_sketch.is_empty());
+  REQUIRE(!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());
+  int count = 0;
+  for (const auto& entry: update_sketch) {
+    REQUIRE(entry.second == 2);
+    ++count;
+  }
+  REQUIRE(count == 2);
+
+  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(compact_sketch.get_estimate() == 2);
+  REQUIRE(compact_sketch.get_lower_bound(1) == 2);
+  REQUIRE(compact_sketch.get_upper_bound(1) == 2);
+  REQUIRE(compact_sketch.get_theta() == 1);
+  REQUIRE(compact_sketch.get_num_retained() == 2);
+  REQUIRE(compact_sketch.is_ordered());
+  count = 0;
+  for (const auto& entry: compact_sketch) {
+    REQUIRE(entry.second == 2);
+    ++count;
+  }
+  REQUIRE(count == 2);
+
+  { // stream
+    std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
+    compact_sketch.serialize(s);
+    auto deserialized_sketch = compact_tuple_sketch<float>::deserialize(s);
+    REQUIRE(!deserialized_sketch.is_empty());
+    REQUIRE(!deserialized_sketch.is_estimation_mode());
+    REQUIRE(deserialized_sketch.get_estimate() == 2);
+    REQUIRE(deserialized_sketch.get_lower_bound(1) == 2);
+    REQUIRE(deserialized_sketch.get_upper_bound(1) == 2);
+    REQUIRE(deserialized_sketch.get_theta() == 1);
+    REQUIRE(deserialized_sketch.get_num_retained() == 2);
+    REQUIRE(deserialized_sketch.is_ordered());
+//    std::cout << "deserialized sketch:" << std::endl;
+//    std::cout << deserialized_sketch.to_string(true);
+  }
+  { // bytes
+    auto bytes = compact_sketch.serialize();
+    auto deserialized_sketch = compact_tuple_sketch<float>::deserialize(bytes.data(), bytes.size());
+    REQUIRE(!deserialized_sketch.is_empty());
+    REQUIRE(!deserialized_sketch.is_estimation_mode());
+    REQUIRE(deserialized_sketch.get_estimate() == 2);
+    REQUIRE(deserialized_sketch.get_lower_bound(1) == 2);
+    REQUIRE(deserialized_sketch.get_upper_bound(1) == 2);
+    REQUIRE(deserialized_sketch.get_theta() == 1);
+    REQUIRE(deserialized_sketch.get_num_retained() == 2);
+    REQUIRE(deserialized_sketch.is_ordered());
+//    std::cout << deserialized_sketch.to_string(true);
+  }
+  // mixed
+  {
+    auto bytes = compact_sketch.serialize();
+    std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
+    s.write(reinterpret_cast<const char*>(bytes.data()), bytes.size());
+    auto deserialized_sketch = compact_tuple_sketch<float>::deserialize(s);
+    auto it = deserialized_sketch.begin();
+    for (const auto& entry: compact_sketch) {
+      REQUIRE(entry.first == (*it).first);
+      REQUIRE(entry.second == (*it).second);
+      ++it;
+    }
+  }
+}
+
+template<typename T>
+class max_value_policy {
+public:
+  max_value_policy(const T& initial_value): initial_value(initial_value) {}
+  T create() const { return initial_value; }
+  void update(T& summary, const T& update) const { summary = std::max(summary, update); }
+private:
+  T initial_value;
+};
+
+using max_float_update_tuple_sketch = update_tuple_sketch<float, float, max_value_policy<float>>;
+
+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);
+//  std::cout << update_sketch.to_string(true);
+  int count = 0;
+  float sum = 0;
+  for (const auto& entry: update_sketch) {
+    sum += entry.second;
+    ++count;
+  }
+  REQUIRE(count == 3);
+  REQUIRE(sum == 22); // 5 + 10 + 7
+}
+
+struct three_doubles_update_policy {
+  std::tuple<double, double, double> create() const {
+    return std::tuple<double, double, double>(0, 0, 0);
+  }
+  void update(std::tuple<double, double, double>& summary, const std::tuple<double, double, double>& update) const {
+    std::get<0>(summary) += std::get<0>(update);
+    std::get<1>(summary) += std::get<1>(update);
+    std::get<2>(summary) += std::get<2>(update);
+  }
+};
+
+TEST_CASE("tuple sketch: tuple of doubles", "[tuple_sketch]") {
+  using three_doubles_update_tuple_sketch = update_tuple_sketch<three_doubles, three_doubles, three_doubles_update_policy>;
+  auto update_sketch = three_doubles_update_tuple_sketch::builder().build();
+  update_sketch.update(1, three_doubles(1, 2, 3));
+//  std::cout << update_sketch.to_string(true);
+  const auto& entry = *update_sketch.begin();
+  REQUIRE(std::get<0>(entry.second) == 1.0);
+  REQUIRE(std::get<1>(entry.second) == 2.0);
+  REQUIRE(std::get<2>(entry.second) == 3.0);
+
+  auto compact_sketch = update_sketch.compact();
+//  std::cout << compact_sketch.to_string(true);
+  REQUIRE(compact_sketch.get_num_retained() == 1);
+}
+
+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);
+  REQUIRE(sketch.get_num_retained() == 1);
+
+  sketch.update(static_cast<int64_t>(1), 1);
+  REQUIRE(sketch.get_num_retained() == 1);
+
+  sketch.update(static_cast<uint32_t>(1), 1);
+  REQUIRE(sketch.get_num_retained() == 1);
+
+  sketch.update(static_cast<int32_t>(1), 1);
+  REQUIRE(sketch.get_num_retained() == 1);
+
+  sketch.update(static_cast<uint16_t>(1), 1);
+  REQUIRE(sketch.get_num_retained() == 1);
+
+  sketch.update(static_cast<int16_t>(1), 1);
+  REQUIRE(sketch.get_num_retained() == 1);
+
+  sketch.update(static_cast<uint8_t>(1), 1);
+  REQUIRE(sketch.get_num_retained() == 1);
+
+  sketch.update(static_cast<int8_t>(1), 1);
+  REQUIRE(sketch.get_num_retained() == 1);
+
+  sketch.update(1.0, 1);
+  REQUIRE(sketch.get_num_retained() == 2);
+
+  sketch.update(static_cast<float>(1), 1);
+  REQUIRE(sketch.get_num_retained() == 2);
+
+  sketch.update("a", 1);
+  REQUIRE(sketch.get_num_retained() == 3);
+}
+
+} /* namespace datasketches */