datasketches 0.2.7 → 0.3.1

data/vendor/datasketches-cpp/theta/include/theta_sketch_impl.hpp

@@ -341,8 +341,7 @@ void compact_theta_sketch_alloc<A>::print_specifics(std::ostringstream&) const {
 
 template<typename A>
 void compact_theta_sketch_alloc<A>::serialize(std::ostream& os) const {
-  const bool is_single_item = entries_.size() == 1 && !this->is_estimation_mode();
-  const uint8_t preamble_longs = this->is_empty() || is_single_item ? 1 : this->is_estimation_mode() ? 3 : 2;
+  const uint8_t preamble_longs = this->is_estimation_mode() ? 3 : this->is_empty() || entries_.size() == 1 ? 1 : 2;
   write(os, preamble_longs);
   const uint8_t serial_version = SERIAL_VERSION;
   write(os, serial_version);
@@ -359,24 +358,19 @@ void compact_theta_sketch_alloc<A>::serialize(std::ostream& os) const {
   write(os, flags_byte);
   const uint16_t seed_hash = get_seed_hash();
   write(os, seed_hash);
-  if (!this->is_empty()) {
-    if (!is_single_item) {
-      const uint32_t num_entries = static_cast<uint32_t>(entries_.size());
-      write(os, num_entries);
-      const uint32_t unused32 = 0;
-      write(os, unused32);
-      if (this->is_estimation_mode()) {
-        write(os, this->theta_);
-      }
-    }
-    write(os, entries_.data(), entries_.size() * sizeof(uint64_t));
+  if (preamble_longs > 1) {
+    const uint32_t num_entries = static_cast<uint32_t>(entries_.size());
+    write(os, num_entries);
+    const uint32_t unused32 = 0;
+    write(os, unused32);
   }
+  if (this->is_estimation_mode()) write(os, this->theta_);
+  if (entries_.size() > 0) write(os, entries_.data(), entries_.size() * sizeof(uint64_t));
 }
 
 template<typename A>
 auto compact_theta_sketch_alloc<A>::serialize(unsigned header_size_bytes) const -> vector_bytes {
-  const bool is_single_item = entries_.size() == 1 && !this->is_estimation_mode();
-  const uint8_t preamble_longs = this->is_empty() || is_single_item ? 1 : this->is_estimation_mode() ? 3 : 2;
+  const uint8_t preamble_longs = this->is_estimation_mode() ? 3 : this->is_empty() || entries_.size() == 1 ? 1 : 2;
   const size_t size = header_size_bytes + sizeof(uint64_t) * preamble_longs
       + sizeof(uint64_t) * entries_.size();
   vector_bytes bytes(size, 0, entries_.get_allocator());
@@ -397,17 +391,13 @@ auto compact_theta_sketch_alloc<A>::serialize(unsigned header_size_bytes) const
   ptr += copy_to_mem(flags_byte, ptr);
   const uint16_t seed_hash = get_seed_hash();
   ptr += copy_to_mem(seed_hash, ptr);
-  if (!this->is_empty()) {
-    if (!is_single_item) {
-      const uint32_t num_entries = static_cast<uint32_t>(entries_.size());
-      ptr += copy_to_mem(num_entries, ptr);
-      ptr += sizeof(uint32_t);
-      if (this->is_estimation_mode()) {
-        ptr += copy_to_mem(theta_, ptr);
-      }
-    }
-    ptr += copy_to_mem(entries_.data(), ptr, entries_.size() * sizeof(uint64_t));
+  if (preamble_longs > 1) {
+    const uint32_t num_entries = static_cast<uint32_t>(entries_.size());
+    ptr += copy_to_mem(num_entries, ptr);
+    ptr += sizeof(uint32_t); // unused
   }
+  if (this->is_estimation_mode()) ptr += copy_to_mem(theta_, ptr);
+  if (entries_.size() > 0) ptr += copy_to_mem(entries_.data(), ptr, entries_.size() * sizeof(uint64_t));
   return bytes;
 }
 

data/vendor/datasketches-cpp/theta/include/theta_update_sketch_base.hpp

@@ -96,15 +96,6 @@ struct theta_update_sketch_base {
 template<typename Derived, typename Allocator>
 class theta_base_builder {
 public:
-  // TODO: Redundant and deprecated. Will be removed in next major version release.
-  using resize_factor = theta_constants::resize_factor;
-  static const uint8_t MIN_LG_K = theta_constants::MIN_LG_K;
-  static const uint8_t MAX_LG_K = theta_constants::MAX_LG_K;
-  // TODO: The following defaults are redundant and deprecated. Will be removed in the
-  //       next major version release
-  static const uint8_t DEFAULT_LG_K = theta_constants::DEFAULT_LG_K;
-  static const resize_factor DEFAULT_RESIZE_FACTOR = theta_constants::DEFAULT_RESIZE_FACTOR;
-
   /**
    * Creates and instance of the builder with default parameters.
    */

data/vendor/datasketches-cpp/theta/include/theta_update_sketch_base_impl.hpp

@@ -310,11 +310,11 @@ seed_(DEFAULT_SEED) {}
 
 template<typename Derived, typename Allocator>
 Derived& theta_base_builder<Derived, Allocator>::set_lg_k(uint8_t lg_k) {
-  if (lg_k < MIN_LG_K) {
-    throw std::invalid_argument("lg_k must not be less than " + std::to_string(MIN_LG_K) + ": " + std::to_string(lg_k));
+  if (lg_k < theta_constants::MIN_LG_K) {
+    throw std::invalid_argument("lg_k must not be less than " + std::to_string(theta_constants::MIN_LG_K) + ": " + std::to_string(lg_k));
   }
-  if (lg_k > MAX_LG_K) {
-    throw std::invalid_argument("lg_k must not be greater than " + std::to_string(MAX_LG_K) + ": " + std::to_string(lg_k));
+  if (lg_k > theta_constants::MAX_LG_K) {
+    throw std::invalid_argument("lg_k must not be greater than " + std::to_string(theta_constants::MAX_LG_K) + ": " + std::to_string(lg_k));
   }
   lg_k_ = lg_k;
   return static_cast<Derived&>(*this);
@@ -346,7 +346,7 @@ uint64_t theta_base_builder<Derived, Allocator>::starting_theta() const {
 
 template<typename Derived, typename Allocator>
 uint8_t theta_base_builder<Derived, Allocator>::starting_lg_size() const {
-  return theta_build_helper<true>::starting_sub_multiple(lg_k_ + 1, MIN_LG_K, static_cast<uint8_t>(rf_));
+  return theta_build_helper<true>::starting_sub_multiple(lg_k_ + 1, theta_constants::MIN_LG_K, static_cast<uint8_t>(rf_));
 }
 
 // iterator

data/vendor/datasketches-cpp/theta/test/CMakeLists.txt

@@ -17,7 +17,7 @@
 
 add_executable(theta_test)
 
-target_link_libraries(theta_test theta common_test)
+target_link_libraries(theta_test theta common_test_lib)
 
 set_target_properties(theta_test PROPERTIES
   CXX_STANDARD 11

data/vendor/datasketches-cpp/theta/test/theta_sketch_test.cpp

@@ -152,7 +152,7 @@ TEST_CASE("theta sketch: estimation", "[theta_sketch]") {
   REQUIRE(update_sketch.get_lower_bound(1) < n);
   REQUIRE(update_sketch.get_upper_bound(1) > n);
 
-  const uint32_t k = 1 << update_theta_sketch::builder::DEFAULT_LG_K;
+  const uint32_t k = 1 << theta_constants::DEFAULT_LG_K;
   REQUIRE(update_sketch.get_num_retained() >= k);
   update_sketch.trim();
   REQUIRE(update_sketch.get_num_retained() == k);
@@ -398,6 +398,7 @@ TEST_CASE("theta sketch: serialize deserialize stream and bytes equivalence", "[
 TEST_CASE("theta sketch: deserialize empty buffer overrun", "[theta_sketch]") {
   update_theta_sketch update_sketch = update_theta_sketch::builder().build();
   auto bytes = update_sketch.compact().serialize();
+  REQUIRE(bytes.size() == 8);
   REQUIRE_THROWS_AS(compact_theta_sketch::deserialize(bytes.data(), bytes.size() - 1), std::out_of_range);
 }
 

data/vendor/datasketches-cpp/tox.ini

@@ -0,0 +1,26 @@
+# 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.
+
+[tox]
+envlist = py3
+isolated_build = true
+
+[testenv]
+deps = pytest
+       numpy
+changedir = python/tests
+commands = pytest

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

@@ -72,21 +72,45 @@ public:
   double get_estimate() const;
 
   /**
-   * Returns the approximate lower error bound given a number of standard deviations.
-   * This parameter is similar to the number of standard deviations of the normal distribution
-   * and corresponds to approximately 67%, 95% and 99% confidence intervals.
-   * @param num_std_devs number of Standard Deviations (1, 2 or 3)
-   * @return the lower bound
-   */
+  * Returns the approximate lower error bound given a number of standard deviations over an arbitrary number of
+  * items stored in the sketch.
+  * This parameter is similar to the number of standard deviations of the normal distribution
+  * and corresponds to approximately 67%, 95% and 99% confidence intervals.
+  * @param num_std_devs number of Standard Deviations (1, 2 or 3)
+  * @param num_subset_entries number of items from {0, 1, ..., get_num_retained()} over which to estimate the bound
+  * @return the lower bound
+  */
+  double get_lower_bound(uint8_t num_std_devs, uint32_t num_subset_entries) const ;
+
+  /**
+  * Returns the approximate lower error bound given a number of standard deviations.
+  * This parameter is similar to the number of standard deviations of the normal distribution
+  * and corresponds to approximately 67%, 95% and 99% confidence intervals.
+  * @param num_std_devs number of Standard Deviations (1, 2 or 3)
+  * @return the lower bound
+  */
   double get_lower_bound(uint8_t num_std_devs) const;
 
+
   /**
-   * Returns the approximate upper error bound given a number of standard deviations.
-   * This parameter is similar to the number of standard deviations of the normal distribution
-   * and corresponds to approximately 67%, 95% and 99% confidence intervals.
-   * @param num_std_devs number of Standard Deviations (1, 2 or 3)
-   * @return the upper bound
-   */
+  * Returns the approximate upper error bound given a number of standard deviations over an arbitrary number of
+  * items stored in the sketch.
+  * This parameter is similar to the number of standard deviations of the normal distribution
+  * and corresponds to approximately 67%, 95% and 99% confidence intervals.
+  * @param num_std_devs number of Standard Deviations (1, 2 or 3)
+  * @param num_subset_entries number of items from {0, 1, ..., get_num_retained()} over which to estimate the bound
+  * @return the lower bound
+  */
+  double get_upper_bound(uint8_t num_std_devs, uint32_t num_subset_entries) const ;
+
+
+  /**
+  * Returns the approximate upper error bound given a number of standard deviations.
+  * This parameter is similar to the number of standard deviations of the normal distribution
+  * and corresponds to approximately 67%, 95% and 99% confidence intervals.
+  * @param num_std_devs number of Standard Deviations (1, 2 or 3)
+  * @return the upper bound
+  */
   double get_upper_bound(uint8_t num_std_devs) const;
 
   /**

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

@@ -40,16 +40,28 @@ double tuple_sketch<S, A>::get_estimate() const {
   return get_num_retained() / get_theta();
 }
 
+template<typename S, typename A>
+double tuple_sketch<S, A>::get_lower_bound(uint8_t num_std_devs, uint32_t num_subset_entries) const {
+    num_subset_entries = std::min(num_subset_entries, get_num_retained()) ;
+    if (!is_estimation_mode()) return num_subset_entries;
+    return binomial_bounds::get_lower_bound(num_subset_entries, get_theta(), num_std_devs);
+}
+
 template<typename S, typename A>
 double tuple_sketch<S, A>::get_lower_bound(uint8_t num_std_devs) const {
-  if (!is_estimation_mode()) return get_num_retained();
-  return binomial_bounds::get_lower_bound(get_num_retained(), get_theta(), num_std_devs);
+  return get_lower_bound(num_std_devs, get_num_retained()) ;
+}
+
+template<typename S, typename A>
+double tuple_sketch<S, A>::get_upper_bound(uint8_t num_std_devs, uint32_t num_subset_entries) const {
+    num_subset_entries = std::min(num_subset_entries, get_num_retained()) ;
+    if (!is_estimation_mode()) return num_subset_entries;
+    return binomial_bounds::get_upper_bound(num_subset_entries, get_theta(), num_std_devs);
 }
 
 template<typename S, typename A>
 double tuple_sketch<S, A>::get_upper_bound(uint8_t num_std_devs) const {
-  if (!is_estimation_mode()) return get_num_retained();
-  return binomial_bounds::get_upper_bound(get_num_retained(), get_theta(), num_std_devs);
+    return get_upper_bound(num_std_devs, get_num_retained()) ;
 }
 
 template<typename S, typename A>

data/vendor/datasketches-cpp/tuple/test/CMakeLists.txt

@@ -17,7 +17,7 @@
 
 add_executable(tuple_test)
 
-target_link_libraries(tuple_test tuple common_test)
+target_link_libraries(tuple_test tuple common_test_lib)
 
 set_target_properties(tuple_test PROPERTIES
   CXX_STANDARD 11
@@ -45,4 +45,5 @@ target_sources(tuple_test
     tuple_a_not_b_test.cpp
     tuple_jaccard_similarity_test.cpp
     array_of_doubles_sketch_test.cpp
+    engagement_test.cpp
 )

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

@@ -0,0 +1,299 @@
+/*
+ * 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 <iomanip>
+#include <set>
+#include <catch2/catch.hpp>
+#include <tuple_sketch.hpp>
+#include <tuple_union.hpp>
+#include <stdexcept>
+
+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 = datasketches::update_tuple_sketch<float, float, max_value_policy<float>>;
+
+template<typename T>
+class always_one_policy {
+public:
+    always_one_policy(): initial_value(1) {}
+    T create() const { return 1; }
+    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>> ;
+
+template<typename T>
+class update_sum_value_policy {
+public:
+    update_sum_value_policy(): initial_value(0) {}
+    T create() const { return initial_value; }
+    void update(T& summary, const T& update) const { summary += update; }
+private:
+    T initial_value;
+};
+using sum_update_tuple_sketch = datasketches::update_tuple_sketch<int, int, update_sum_value_policy<int>>;
+
+template<typename Summary>
+struct union_sum_value_policy {
+    void operator()(Summary& summary, const Summary& other) const {
+        summary += other;
+    }
+};
+
+using sum_union_tuple_sketch = datasketches::tuple_union<int,  union_sum_value_policy<int>> ;
+
+
+class EngagementTest{
+public:
+    int 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 ;
+
+        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);
+        always_one_sketch.update(2, 1);
+        always_one_sketch.update(3, 3);
+        always_one_sketch.update(3, 7);
+
+        int num_retained = 0;
+        int sum = 0;
+        for (const auto& entry: always_one_sketch) {
+            sum += entry.second;
+            ++num_retained;
+        }
+        REQUIRE(num_retained == 3);
+        REQUIRE(sum == 3); // we only keep 1 for every stored key.
+    }
+
+    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() ;
+
+        sum_sketch.update(1, 1);
+        sum_sketch.update(1, 2);
+        sum_sketch.update(2, 1);
+        sum_sketch.update(3, 3);
+        sum_sketch.update(3, 7);
+        int num_retained = 0;
+        int sum = 0;
+        for (const auto& entry: sum_sketch) {
+            sum += entry.second;
+            ++num_retained;
+        }
+        REQUIRE(num_retained == 3);
+        REQUIRE(sum == 14); // (1+2) + 1 + (3 + 7) = 14
+    }
+
+    void test_sum_union_policy(){
+        /*
+         * 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() ;
+
+        sketch1.update(1, 1);
+        sketch1.update(2, 1);
+        sketch1.update(3, 3);
+
+        sketch2.update(1, 2);
+        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() ;
+
+        int num_retained = 0;
+        int sum = 0;
+        for (const auto& entry: union_result) {
+            sum += entry.second;
+            ++num_retained;
+        }
+        REQUIRE(num_retained == 3);
+        REQUIRE(sum == 15); // 1:(1+2) + 2:(1+1) + 3:(3+7) = 15
+    }
+
+    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 ;
+        std::set<int> set_array[days];
+        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() ;
+            sketch_array.push_back(sketch);
+        }
+        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) ;
+
+            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 ;
+        }
+        union_ops(lgK, sketch_array) ;
+    }
+private:
+    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))) ;
+    }
+
+    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)) ;
+    }
+
+    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() ;
+
+        for(auto sk:sketches){
+            u.update(sk) ;
+        }
+        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 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 << std::setw(12) << "Days Visited"
+                  << std::setw(12) << "Estimate"
+                  << std::setw(12) << "LB"
+                  << std::setw(12) << "UB"
+                  << 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 ;
+
+            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);
+
+            std::cout << std::setw(12) << i
+                      << 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::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::cout << std::setw(12) << "Visitors"
+                  << std::setw(12) << total_visitors
+                  << std::setw(12) << lb_visitors
+                  << std::setw(12) << ub_visitors
+                  << 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
+        // the  rest of the unique users will likely behave in the same way.
+        const double est_visits = sum_visits / theta;
+        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 ;
+    }
+
+};
+
+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() ;
+}
+
+
+} /* namespace datasketches */

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

@@ -56,7 +56,13 @@ TEST_CASE("tuple sketch float: empty", "[tuple_sketch]") {
   REQUIRE(!update_sketch.is_estimation_mode());
   REQUIRE(update_sketch.get_estimate() == 0);
   REQUIRE(update_sketch.get_lower_bound(1) == 0);
+  REQUIRE(update_sketch.get_lower_bound(1, 1) == 0);
+  REQUIRE(update_sketch.get_lower_bound(1, update_sketch.get_num_retained()) == 0);
+  REQUIRE(update_sketch.get_lower_bound(1, update_sketch.get_num_retained()+1) == 0);
   REQUIRE(update_sketch.get_upper_bound(1) == 0);
+  REQUIRE(update_sketch.get_upper_bound(1, 1) == 0);
+  REQUIRE(update_sketch.get_upper_bound(1, update_sketch.get_num_retained()) == 0);
+  REQUIRE(update_sketch.get_upper_bound(1, update_sketch.get_num_retained()+1) == 0);
   REQUIRE(update_sketch.get_theta() == 1);
   REQUIRE(update_sketch.get_num_retained() == 0);
   REQUIRE(update_sketch.is_ordered());
@@ -67,7 +73,11 @@ TEST_CASE("tuple sketch float: empty", "[tuple_sketch]") {
   REQUIRE(!compact_sketch.is_estimation_mode());
   REQUIRE(compact_sketch.get_estimate() == 0);
   REQUIRE(compact_sketch.get_lower_bound(1) == 0);
+  REQUIRE(compact_sketch.get_lower_bound(1, 1) == 0);
+  REQUIRE(compact_sketch.get_lower_bound(1, update_sketch.get_num_retained()) == 0);
   REQUIRE(compact_sketch.get_upper_bound(1) == 0);
+  REQUIRE(compact_sketch.get_upper_bound(1, 1) == 0);
+  REQUIRE(compact_sketch.get_upper_bound(1, update_sketch.get_num_retained()) == 0);
   REQUIRE(compact_sketch.get_theta() == 1);
   REQUIRE(compact_sketch.get_num_retained() == 0);
   REQUIRE(compact_sketch.is_ordered());
@@ -110,7 +120,11 @@ TEST_CASE("tuple sketch float: exact mode", "[tuple_sketch]") {
   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_lower_bound(1, 1) == 1);
+  REQUIRE(update_sketch.get_lower_bound(1, update_sketch.get_num_retained()) == 2);
   REQUIRE(update_sketch.get_upper_bound(1) == 2);
+  REQUIRE(update_sketch.get_upper_bound(1, 1) == 1);
+  REQUIRE(update_sketch.get_upper_bound(1, update_sketch.get_num_retained()) == 2);
   REQUIRE(update_sketch.get_theta() == 1);
   REQUIRE(update_sketch.get_num_retained() == 2);
   REQUIRE_FALSE(update_sketch.is_ordered());
@@ -127,7 +141,11 @@ TEST_CASE("tuple sketch float: exact mode", "[tuple_sketch]") {
   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_lower_bound(1, 1) == 1);
+  REQUIRE(compact_sketch.get_lower_bound(1, compact_sketch.get_num_retained()) == 2);
   REQUIRE(compact_sketch.get_upper_bound(1) == 2);
+  REQUIRE(compact_sketch.get_upper_bound(1, 1) == 1);
+  REQUIRE(compact_sketch.get_upper_bound(1, compact_sketch.get_num_retained()) == 2);
   REQUIRE(compact_sketch.get_theta() == 1);
   REQUIRE(compact_sketch.get_num_retained() == 2);
   REQUIRE(compact_sketch.is_ordered());
@@ -146,7 +164,11 @@ TEST_CASE("tuple sketch float: exact mode", "[tuple_sketch]") {
     REQUIRE(!deserialized_sketch.is_estimation_mode());
     REQUIRE(deserialized_sketch.get_estimate() == 2);
     REQUIRE(deserialized_sketch.get_lower_bound(1) == 2);
+    REQUIRE(deserialized_sketch.get_lower_bound(1, 1) == 1);
+    REQUIRE(deserialized_sketch.get_lower_bound(1, deserialized_sketch.get_num_retained()) == 2);
     REQUIRE(deserialized_sketch.get_upper_bound(1) == 2);
+    REQUIRE(deserialized_sketch.get_upper_bound(1, 1) == 1);
+    REQUIRE(deserialized_sketch.get_upper_bound(1, deserialized_sketch.get_num_retained()) == 2);
     REQUIRE(deserialized_sketch.get_theta() == 1);
     REQUIRE(deserialized_sketch.get_num_retained() == 2);
     REQUIRE(deserialized_sketch.is_ordered());
@@ -160,7 +182,11 @@ TEST_CASE("tuple sketch float: exact mode", "[tuple_sketch]") {
     REQUIRE(!deserialized_sketch.is_estimation_mode());
     REQUIRE(deserialized_sketch.get_estimate() == 2);
     REQUIRE(deserialized_sketch.get_lower_bound(1) == 2);
+    REQUIRE(deserialized_sketch.get_lower_bound(1, 1) == 1);
+    REQUIRE(deserialized_sketch.get_lower_bound(1, deserialized_sketch.get_num_retained()) == 2);
     REQUIRE(deserialized_sketch.get_upper_bound(1) == 2);
+    REQUIRE(deserialized_sketch.get_upper_bound(1, 1) == 1);
+    REQUIRE(deserialized_sketch.get_upper_bound(1, deserialized_sketch.get_num_retained()) == 2);
     REQUIRE(deserialized_sketch.get_theta() == 1);
     REQUIRE(deserialized_sketch.get_num_retained() == 2);
     REQUIRE(deserialized_sketch.is_ordered());

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

@@ -0,0 +1 @@
+4.0.1