datasketches 0.3.2 → 0.4.0

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

@@ -23,10 +23,8 @@
 #include <array>
 
 #include <catch2/catch.hpp>
-#include <array_of_doubles_sketch.hpp>
-#include <array_of_doubles_union.hpp>
-#include <array_of_doubles_intersection.hpp>
-#include <array_of_doubles_a_not_b.hpp>
+
+#include "array_of_doubles_sketch.hpp"
 
 namespace datasketches {
 
@@ -47,130 +45,6 @@ TEST_CASE("aod sketch: reset", "[tuple_sketch]") {
   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());
-  REQUIRE(update_sketch.get_num_retained() == 0);
-  auto compact_sketch = update_sketch.compact();
-
-  // read binary sketch from Java
-  std::ifstream is;
-  is.exceptions(std::ios::failbit | std::ios::badbit);
-  is.open(inputPath + "aod_1_compact_empty_from_java.sk", std::ios::binary);
-  auto compact_sketch_from_java = compact_array_of_doubles_sketch::deserialize(is);
-  REQUIRE(compact_sketch.get_num_retained() == compact_sketch_from_java.get_num_retained());
-  REQUIRE(compact_sketch.get_theta() == Approx(compact_sketch_from_java.get_theta()).margin(1e-10));
-  REQUIRE(compact_sketch.get_estimate() == Approx(compact_sketch_from_java.get_estimate()).margin(1e-10));
-  REQUIRE(compact_sketch.get_lower_bound(1) == Approx(compact_sketch_from_java.get_lower_bound(1)).margin(1e-10));
-  REQUIRE(compact_sketch.get_upper_bound(1) == Approx(compact_sketch_from_java.get_upper_bound(1)).margin(1e-10));
-}
-
-TEST_CASE("aod sketch: serialization compatibility with java - empty configured for three values", "[tuple_sketch]") {
-  auto update_sketch = update_array_of_doubles_sketch::builder(3).build();
-  REQUIRE(update_sketch.is_empty());
-  REQUIRE(update_sketch.get_num_retained() == 0);
-  REQUIRE(update_sketch.get_num_values() == 3);
-  auto compact_sketch = update_sketch.compact();
-
-  // read binary sketch from Java
-  std::ifstream is;
-  is.exceptions(std::ios::failbit | std::ios::badbit);
-  is.open(inputPath + "aod_3_compact_empty_from_java.sk", std::ios::binary);
-  auto compact_sketch_from_java = compact_array_of_doubles_sketch::deserialize(is);
-  REQUIRE(compact_sketch.get_num_values() == compact_sketch_from_java.get_num_values());
-  REQUIRE(compact_sketch.get_num_retained() == compact_sketch_from_java.get_num_retained());
-  REQUIRE(compact_sketch.get_theta() == Approx(compact_sketch_from_java.get_theta()).margin(1e-10));
-  REQUIRE(compact_sketch.get_estimate() == Approx(compact_sketch_from_java.get_estimate()).margin(1e-10));
-  REQUIRE(compact_sketch.get_lower_bound(1) == Approx(compact_sketch_from_java.get_lower_bound(1)).margin(1e-10));
-  REQUIRE(compact_sketch.get_upper_bound(1) == Approx(compact_sketch_from_java.get_upper_bound(1)).margin(1e-10));
-}
-
-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.01f).build();
-  std::vector<double> a = {1};
-  update_sketch.update(1, a);
-  REQUIRE_FALSE(update_sketch.is_empty());
-  REQUIRE(update_sketch.get_num_retained() == 0);
-  auto compact_sketch = update_sketch.compact();
-
-  // read binary sketch from Java
-  std::ifstream is;
-  is.exceptions(std::ios::failbit | std::ios::badbit);
-  is.open(inputPath + "aod_1_compact_non_empty_no_entries_from_java.sk", std::ios::binary);
-  auto compact_sketch_from_java = compact_array_of_doubles_sketch::deserialize(is);
-  REQUIRE(compact_sketch.get_num_retained() == compact_sketch_from_java.get_num_retained());
-  REQUIRE(compact_sketch.get_theta() == Approx(compact_sketch_from_java.get_theta()).margin(1e-10));
-  REQUIRE(compact_sketch.get_estimate() == Approx(compact_sketch_from_java.get_estimate()).margin(1e-10));
-  REQUIRE(compact_sketch.get_lower_bound(1) == Approx(compact_sketch_from_java.get_lower_bound(1)).margin(1e-10));
-  REQUIRE(compact_sketch.get_upper_bound(1) == Approx(compact_sketch_from_java.get_upper_bound(1)).margin(1e-10));
-}
-
-TEST_CASE("aod sketch: serialization compatibility with java - estimation mode", "[tuple_sketch]") {
-  auto update_sketch = update_array_of_doubles_sketch::builder().build();
-  std::vector<double> a = {1};
-  for (int i = 0; i < 8192; ++i) update_sketch.update(i, a);
-  auto compact_sketch = update_sketch.compact();
-
-  // read binary sketch from Java
-  std::ifstream is;
-  is.exceptions(std::ios::failbit | std::ios::badbit);
-  is.open(inputPath + "aod_1_compact_estimation_from_java.sk", std::ios::binary);
-  auto compact_sketch_from_java = compact_array_of_doubles_sketch::deserialize(is);
-  REQUIRE(compact_sketch.get_num_retained() == compact_sketch_from_java.get_num_retained());
-  REQUIRE(compact_sketch.get_theta() == Approx(compact_sketch_from_java.get_theta()).margin(1e-10));
-  REQUIRE(compact_sketch.get_estimate() == Approx(compact_sketch_from_java.get_estimate()).margin(1e-10));
-  REQUIRE(compact_sketch.get_lower_bound(1) == Approx(compact_sketch_from_java.get_lower_bound(1)).margin(1e-10));
-  REQUIRE(compact_sketch.get_upper_bound(1) == Approx(compact_sketch_from_java.get_upper_bound(1)).margin(1e-10));
-  REQUIRE(compact_sketch.get_lower_bound(2) == Approx(compact_sketch_from_java.get_lower_bound(2)).margin(1e-10));
-  REQUIRE(compact_sketch.get_upper_bound(2) == Approx(compact_sketch_from_java.get_upper_bound(2)).margin(1e-10));
-  REQUIRE(compact_sketch.get_lower_bound(3) == Approx(compact_sketch_from_java.get_lower_bound(3)).margin(1e-10));
-  REQUIRE(compact_sketch.get_upper_bound(3) == Approx(compact_sketch_from_java.get_upper_bound(3)).margin(1e-10));
-
-  // sketch from Java is not ordered
-  // transform it to ordered so that iteration sequence would match exactly
-  compact_array_of_doubles_sketch ordered_sketch_from_java(compact_sketch_from_java, true);
-  auto it = ordered_sketch_from_java.begin();
-  for (const auto& entry: compact_sketch) {
-    REQUIRE(entry == *it);
-    ++it;
-  }
-}
-
-TEST_CASE("aod sketch: serialization compatibility with java - exact mode with two values", "[tuple_sketch]") {
-  auto update_sketch = update_array_of_doubles_sketch::builder(2).build();
-  std::vector<double> a = {1, 2};
-  for (int i = 0; i < 1000; ++i) update_sketch.update(i, a.data()); // pass vector as pointer
-  auto compact_sketch = update_sketch.compact();
-  REQUIRE_FALSE(compact_sketch.is_estimation_mode());
-
-  // read binary sketch from Java
-  std::ifstream is;
-  is.exceptions(std::ios::failbit | std::ios::badbit);
-  is.open(inputPath + "aod_2_compact_exact_from_java.sk", std::ios::binary);
-  auto compact_sketch_from_java = compact_array_of_doubles_sketch::deserialize(is);
-  REQUIRE(compact_sketch.get_num_retained() == compact_sketch_from_java.get_num_retained());
-  REQUIRE(compact_sketch.get_theta() == Approx(compact_sketch_from_java.get_theta()).margin(1e-10));
-  REQUIRE(compact_sketch.get_estimate() == Approx(compact_sketch_from_java.get_estimate()).margin(1e-10));
-  REQUIRE(compact_sketch.get_lower_bound(1) == Approx(compact_sketch_from_java.get_lower_bound(1)).margin(1e-10));
-  REQUIRE(compact_sketch.get_upper_bound(1) == Approx(compact_sketch_from_java.get_upper_bound(1)).margin(1e-10));
-  REQUIRE(compact_sketch.get_lower_bound(2) == Approx(compact_sketch_from_java.get_lower_bound(2)).margin(1e-10));
-  REQUIRE(compact_sketch.get_upper_bound(2) == Approx(compact_sketch_from_java.get_upper_bound(2)).margin(1e-10));
-  REQUIRE(compact_sketch.get_lower_bound(3) == Approx(compact_sketch_from_java.get_lower_bound(3)).margin(1e-10));
-  REQUIRE(compact_sketch.get_upper_bound(3) == Approx(compact_sketch_from_java.get_upper_bound(3)).margin(1e-10));
-
-  // sketch from Java is not ordered
-  // transform it to ordered so that iteration sequence would match exactly
-  compact_array_of_doubles_sketch ordered_sketch_from_java(compact_sketch_from_java, true);
-  auto it = ordered_sketch_from_java.begin();
-  for (const auto& entry: compact_sketch) {
-    REQUIRE(entry.first == (*it).first);
-    REQUIRE(entry.second.size() == 2);
-    REQUIRE(entry.second[0] == (*it).second[0]);
-    REQUIRE(entry.second[1] == (*it).second[1]);
-    ++it;
-  }
-}
-
 TEST_CASE("aod sketch: stream serialize deserialize - estimation mode", "[tuple_sketch]") {
   auto update_sketch = update_array_of_doubles_sketch::builder(2).build();
   std::vector<double> a = {1, 2};
@@ -290,7 +164,9 @@ TEST_CASE("aod intersection: half overlap", "[tuple_sketch]") {
   auto update_sketch2 = update_array_of_doubles_sketch::builder().build();
   for (int i = 500; i < 1500; ++i) update_sketch2.update(i, a);
 
-  array_of_doubles_intersection<array_of_doubles_union_policy> intersection;
+  // there is no default policy for intersection
+  // let's combine values the same way as in union for testing
+  array_of_doubles_intersection<default_array_of_doubles_union_policy> intersection;
   intersection.update(update_sketch1);
   intersection.update(update_sketch2);
   auto result = intersection.get_result();

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

@@ -42,11 +42,11 @@ class always_one_policy {
 public:
     always_one_policy(): initial_value(1) {}
     T create() const { return 1; }
-    void update(T&, const T&) const { }
+    void update(T&, const T&) const {}
 private:
     T initial_value;
 };
-using always_one_tuple_sketch = datasketches::update_tuple_sketch<int, int, always_one_policy<int>> ;
+using always_one_tuple_sketch = datasketches::update_tuple_sketch<int, int, always_one_policy<int>>;
 
 template<typename T>
 class update_sum_value_policy {
@@ -66,20 +66,20 @@ struct union_sum_value_policy {
     }
 };
 
-using sum_union_tuple_sketch = datasketches::tuple_union<int,  union_sum_value_policy<int>> ;
+using sum_union_tuple_sketch = datasketches::tuple_union<int, union_sum_value_policy<int>>;
 
 
-class EngagementTest{
+class EngagementTest {
 public:
-    int num_std_dev = 2 ;
-    void test_always_one_update(){
+    uint8_t num_std_dev = 2;
+    void test_always_one_update() {
         /*
          * Tests that updates into an update_tuple_sketch sketch only keeps a 1 in the column for stored values.
          */
-        int lgK = 8 ;
-        std::vector<datasketches::update_tuple_sketch<int, int, always_one_policy<int>>> sketch_array ;
+        uint8_t lgK = 8;
+        std::vector<datasketches::update_tuple_sketch<int, int, always_one_policy<int>>> sketch_array;
 
-        auto always_one_sketch = always_one_tuple_sketch::builder(always_one_policy<int>()).set_lg_k(lgK).build() ;
+        auto always_one_sketch = always_one_tuple_sketch::builder(always_one_policy<int>()).set_lg_k(lgK).build();
 
         always_one_sketch.update(1, 1);
         always_one_sketch.update(1, 2);
@@ -97,12 +97,12 @@ public:
         REQUIRE(sum == 3); // we only keep 1 for every stored key.
     }
 
-    void test_sum_update_policy(){
+    void test_sum_update_policy() {
         /*
         * Tests that updates into an sum_update_tuple_sketch sum the stored values on updates.
         */
-        int lgK = 8 ;
-        auto sum_sketch = sum_update_tuple_sketch::builder().set_lg_k(lgK).build() ;
+        uint8_t lgK = 8;
+        auto sum_sketch = sum_update_tuple_sketch::builder().set_lg_k(lgK).build();
 
         sum_sketch.update(1, 1);
         sum_sketch.update(1, 2);
@@ -124,8 +124,8 @@ public:
          * Tests that updates into two sketches of sum_update_tuple_sketch flavour, which have been unioned,
          * cause the stored values of two of the same keys to be summed.
          */
-        auto sketch1 = sum_update_tuple_sketch::builder().build() ;
-        auto sketch2 = sum_update_tuple_sketch::builder().build() ;
+        auto sketch1 = sum_update_tuple_sketch::builder().build();
+        auto sketch2 = sum_update_tuple_sketch::builder().build();
 
         sketch1.update(1, 1);
         sketch1.update(2, 1);
@@ -135,10 +135,10 @@ public:
         sketch2.update(2, 1);
         sketch2.update(3, 7);
 
-        auto union_sketch = sum_union_tuple_sketch::builder().build() ;
-        union_sketch.update(sketch1) ;
-        union_sketch.update(sketch2) ;
-        auto union_result = union_sketch.get_result() ;
+        auto union_sketch = sum_union_tuple_sketch::builder().build();
+        union_sketch.update(sketch1);
+        union_sketch.update(sketch2);
+        auto union_result = union_sketch.get_result();
 
         int num_retained = 0;
         int sum = 0;
@@ -150,95 +150,95 @@ public:
         REQUIRE(sum == 15); // 1:(1+2) + 2:(1+1) + 3:(3+7) = 15
     }
 
-    void compute_engagement_histogram(){
+    void compute_engagement_histogram() {
         /*
          * Returns the estimated histogram from the synthetic data.
          * On inspection one can verify this agrees with the
          * https://github.com/apache/datasketches-java/blob/master/src/test/java/org/apache/datasketches/tuple/aninteger/EngagementTest.java
          */
-        int lgK = 8 ;
-        const int days = 30 ;
-        int v = 0 ;
+        uint8_t lgK = 8;
+        const int days = 30;
+        int v = 0;
         std::set<int> set_array[days];
-        std::vector<datasketches::update_tuple_sketch<int, int, always_one_policy<int>>> sketch_array ;
+        std::vector<datasketches::update_tuple_sketch<int, int, always_one_policy<int>>> sketch_array;
 
 
-        for(int i=0; i<days ; i++){
-            auto builder = always_one_tuple_sketch::builder(always_one_policy<int>()) ;
-            builder.set_lg_k(lgK) ;
-            auto sketch = builder.build() ;
+        for (int i = 0; i < days; ++i) {
+            auto builder = always_one_tuple_sketch::builder(always_one_policy<int>());
+            builder.set_lg_k(lgK);
+            auto sketch = builder.build();
             sketch_array.push_back(sketch);
         }
-        REQUIRE(sketch_array.size() == days) ;
+        REQUIRE(sketch_array.size() == days);
 
-        for(int i=0; i<=days; i++){
-            int32_t num_ids = get_num_ids(days, i) ;
-            int32_t num_days = get_num_days(days, i) ;
+        for (int i = 0; i <= days; ++i) {
+            int32_t num_ids = get_num_ids(days, i);
+            int32_t num_days = get_num_days(days, i);
 
-            int my_v = v++ ;
-            for(int d=0 ; d<num_days; d++){
-                for(int id = 0; id < num_ids; id++){
-                    set_array[d].insert(my_v + id) ;
-                    sketch_array[d].update(my_v + id, 1) ;
+            int my_v = v++;
+            for (int d = 0; d < num_days; ++d) {
+                for (int id = 0; id < num_ids; ++id) {
+                    set_array[d].insert(my_v + id);
+                    sketch_array[d].update(my_v + id, 1);
                 }
             }
-            v += num_ids ;
+            v += num_ids;
         }
-        union_ops(lgK, sketch_array) ;
+        union_ops(lgK, sketch_array);
     }
 private:
-    int32_t get_num_ids(int total_days, int index){
+    int32_t get_num_ids(int total_days, int index) {
         /*
          * Generates power law distributed synthetic data
          */
-        double d = total_days ;
-        double i = index ;
-        return int(round(exp(i * log(d) / d))) ;
+        double d = total_days;
+        double i = index;
+        return int(round(exp(i * log(d) / d)));
     }
 
-    int32_t get_num_days(int total_days, int index){
-        double d = total_days ;
-        double i = index ;
-        return int(round(exp( (d-i) * log(d) / d ))) ;
+    int32_t get_num_days(int total_days, int index) {
+        double d = total_days;
+        double i = index;
+        return int(round(exp((d-i) * log(d) / d )));
     }
 
-    int32_t round_double_to_int(double x){
-        return int(std::round(x)) ;
+    int32_t round_double_to_int(double x) {
+        return int(std::round(x));
     }
 
-    void union_ops(int lgk, std::vector<datasketches::update_tuple_sketch<int, int, always_one_policy<int>>> sketches){
-        int num_sketches = sketches.size() ;
-        auto u = sum_union_tuple_sketch::builder().set_lg_k(lgk).build() ;
+    void union_ops(uint8_t lgk, std::vector<datasketches::update_tuple_sketch<int, int, always_one_policy<int>>> sketches) {
+        auto num_sketches = sketches.size();
+        auto u = sum_union_tuple_sketch::builder().set_lg_k(lgk).build();
 
-        for(auto sk:sketches){
-            u.update(sk) ;
+        for (auto sk: sketches) {
+            u.update(sk);
         }
-        auto union_result = u.get_result() ;
-        std::vector<uint64_t> num_days_arr(num_sketches+1) ;
+        auto union_result = u.get_result();
+        std::vector<uint64_t> num_days_arr(num_sketches+1);
 
         for (const auto& entry: union_result) {
-            int num_days_visited = entry.second ;
-            num_days_arr[num_days_visited]++;
+            int num_days_visited = entry.second;
+            ++num_days_arr[num_days_visited];
         }
 
-        int sum_visits = 0;
+        uint64_t sum_visits = 0;
         double theta = union_result.get_theta();
-        std::cout <<"\t\tEngagement Histogram.\t\t\t\n" ;
-        std::cout << "Number of Unique Visitors by Number of Days Visited" << std::endl ;
-        std::cout << "---------------------------------------------------" << std::endl ;
+        std::cout <<"\t\tEngagement Histogram.\t\t\t\n";
+        std::cout << "Number of Unique Visitors by Number of Days Visited" << std::endl;
+        std::cout << "---------------------------------------------------" << std::endl;
 
         std::cout << std::setw(12) << "Days Visited"
                   << std::setw(12) << "Estimate"
                   << std::setw(12) << "LB"
                   << std::setw(12) << "UB"
-                  << std:: endl ;
+                  << std:: endl;
 
-        for (uint64_t i = 0; i < num_days_arr.size(); i++) {
-            int visitors_at_days_visited = num_days_arr[i] ;
-            if(visitors_at_days_visited == 0){ continue; }
-            sum_visits += visitors_at_days_visited * i ;
+        for (size_t i = 0; i < num_days_arr.size(); ++i) {
+            auto visitors_at_days_visited = num_days_arr[i];
+            if (visitors_at_days_visited == 0) continue;
+            sum_visits += visitors_at_days_visited * i;
 
-            double est_visitors_at_days_visited = visitors_at_days_visited / theta ;
+            double est_visitors_at_days_visited = visitors_at_days_visited / theta;
             double lower_bound_at_days_visited =  union_result.get_lower_bound(num_std_dev, visitors_at_days_visited);
             double upper_bound_at_days_visited =  union_result.get_upper_bound(num_std_dev, visitors_at_days_visited);
 
@@ -246,27 +246,25 @@ private:
                       << std::setw(12) << est_visitors_at_days_visited
                       << std::setw(12) << lower_bound_at_days_visited
                       << std::setw(12) << upper_bound_at_days_visited
-                      << std:: endl ;
-
-    }
-        std::cout << std::endl << std::endl ;
+                      << std:: endl;
+        }
+        std::cout << std::endl << std::endl;
         std::cout << std::setw(12) << "Totals"
                   << std::setw(12) << "Estimate"
                   << std::setw(12) << "LB"
                   << std::setw(12) << "UB"
-                  << std:: endl ;
-        std::cout << "---------------------------------------------------" << std::endl ;
-
-        const double total_visitors = union_result.get_estimate() ;
-        const double lb_visitors = union_result.get_lower_bound(num_std_dev) ;
-        const double ub_visitors = union_result.get_upper_bound(num_std_dev) ;
+                  << std:: endl;
+        std::cout << "---------------------------------------------------" << std::endl;
 
+        const double total_visitors = union_result.get_estimate();
+        const double lb_visitors = union_result.get_lower_bound(num_std_dev);
+        const double ub_visitors = union_result.get_upper_bound(num_std_dev);
 
         std::cout << std::setw(12) << "Visitors"
                   << std::setw(12) << total_visitors
                   << std::setw(12) << lb_visitors
                   << std::setw(12) << ub_visitors
-                  << std:: endl ;
+                  << std:: endl;
 
         // The total number of visits, however, is a scaled metric and takes advantage of the fact that
         // the retained entries in the sketch is a uniform random sample of all unique visitors, and
@@ -275,25 +273,23 @@ private:
         const double lb_visits = est_visits * lb_visitors / total_visitors;
         const double ub_visits = est_visits * ub_visitors / total_visitors;
 
-
         std::cout << std::setw(12) << "Visits"
                   << std::setw(12) << est_visits
                   << std::setw(12) << lb_visits
                   << std::setw(12) << ub_visits
-                  << std:: endl ;
+                  << std:: endl;
     }
 
 };
 
 namespace datasketches {
 
-    TEST_CASE("engagement", "[engagement]") {
-    EngagementTest E ;
-    E.test_always_one_update() ;
-    E.test_sum_update_policy() ;
-    E.test_sum_union_policy() ;
-    E.compute_engagement_histogram() ;
-}
-
+  TEST_CASE("engagement", "[engagement]") {
+    EngagementTest E;
+    E.test_always_one_update();
+    E.test_sum_update_policy();
+    E.test_sum_union_policy();
+    E.compute_engagement_histogram();
+  }
 
-} /* namespace datasketches */
+} /* namespace datasketches */

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

@@ -25,7 +25,9 @@
 
 namespace datasketches {
 
-using tuple_jaccard_similarity_float = tuple_jaccard_similarity<float, default_union_policy<float>>;
+// there is no default policy for intersection
+// let's combine values the same way as in union for testing
+using tuple_jaccard_similarity_float = tuple_jaccard_similarity<float, default_tuple_union_policy<float>>;
 
 TEST_CASE("tuple jaccard: empty", "[tuple_sketch]") {
   auto sk_a = update_tuple_sketch<float>::builder().build();

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

@@ -0,0 +1,47 @@
+/*
+ * 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 <catch2/catch.hpp>
+#include <fstream>
+#include <tuple_sketch.hpp>
+
+namespace datasketches {
+
+// assume the binary sketches for this test have been generated by datasketches-java code
+// in the subdirectory called "java" in the root directory of this project
+static std::string testBinaryInputPath = std::string(TEST_BINARY_INPUT_PATH) + "../../java/";
+
+TEST_CASE("tuple sketch int", "[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 + "tuple_int_n" + std::to_string(n) + "_java.sk", std::ios::binary);
+    const auto sketch = compact_tuple_sketch<int>::deserialize(is);
+    REQUIRE(sketch.is_empty() == (n == 0));
+    REQUIRE(sketch.is_estimation_mode() == (n > 1000));
+    REQUIRE(sketch.get_estimate() == Approx(n).margin(n * 0.03));
+    for (const auto& entry: sketch) {
+      REQUIRE(entry.first < sketch.get_theta64());
+      REQUIRE(entry.second < static_cast<int>(n));
+    }
+  }
+}
+
+} /* namespace datasketches */

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

@@ -0,0 +1,38 @@
+/*
+ * 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 <catch2/catch.hpp>
+#include <fstream>
+#include <tuple_sketch.hpp>
+
+namespace datasketches {
+
+TEST_CASE("tuple sketch int generate", "[serialize_for_java]") {
+  const unsigned n_arr[] = {0, 1, 10, 100, 1000, 10000, 100000, 1000000};
+  for (const unsigned n: n_arr) {
+    auto sketch = update_tuple_sketch<int>::builder().build();
+    for (unsigned i = 0; i < n; ++i) sketch.update(i, i);
+    REQUIRE(sketch.is_empty() == (n == 0));
+    REQUIRE(sketch.get_estimate() == Approx(n).margin(n * 0.03));
+    std::ofstream os("tuple_int_n" + std::to_string(n) + "_cpp.sk", std::ios::binary);
+    sketch.compact().serialize(os);
+  }
+}
+
+} /* namespace datasketches */

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

@@ -86,7 +86,7 @@ TEST_CASE("tuple sketch float: empty", "[tuple_sketch]") {
   REQUIRE(update_sketch.compact(false).is_ordered());
 }
 
-TEST_CASE("tuple sketch: single item", "[theta_sketch]") {
+TEST_CASE("tuple sketch: single item", "[tuple_sketch]") {
   auto update_sketch = update_tuple_sketch<float>::builder().build();
   update_sketch.update(1, 1.0f);
   REQUIRE_FALSE(update_sketch.is_empty());

data/vendor/datasketches-cpp/version.cfg.in

@@ -1 +1 @@
-4.1.0
+5.0.0