datasketches 0.3.1 → 0.4.0

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

@@ -167,20 +167,6 @@ TEST_CASE("theta sketch: estimation", "[theta_sketch]") {
   REQUIRE(compact_sketch.get_upper_bound(1) > n);
 }
 
-TEST_CASE("theta sketch: deserialize compact empty from java", "[theta_sketch]") {
-  std::ifstream is;
-  is.exceptions(std::ios::failbit | std::ios::badbit);
-  is.open(inputPath + "theta_compact_empty_from_java.sk", std::ios::binary);
-  auto sketch = compact_theta_sketch::deserialize(is);
-  REQUIRE(sketch.is_empty());
-  REQUIRE_FALSE(sketch.is_estimation_mode());
-  REQUIRE(sketch.get_num_retained() == 0);
-  REQUIRE(sketch.get_theta() == 1.0);
-  REQUIRE(sketch.get_estimate() == 0.0);
-  REQUIRE(sketch.get_lower_bound(1) == 0.0);
-  REQUIRE(sketch.get_upper_bound(1) == 0.0);
-}
-
 TEST_CASE("theta sketch: deserialize compact v1 empty from java", "[theta_sketch]") {
   std::ifstream is;
   is.exceptions(std::ios::failbit | std::ios::badbit);
@@ -209,88 +195,6 @@ TEST_CASE("theta sketch: deserialize compact v2 empty from java", "[theta_sketch
   REQUIRE(sketch.get_upper_bound(1) == 0.0);
 }
 
-TEST_CASE("theta sketch: deserialize single item from java", "[theta_sketch]") {
-  std::ifstream is;
-  is.exceptions(std::ios::failbit | std::ios::badbit);
-  is.open(inputPath + "theta_compact_single_item_from_java.sk", std::ios::binary);
-  auto sketch = compact_theta_sketch::deserialize(is);
-  REQUIRE_FALSE(sketch.is_empty());
-  REQUIRE_FALSE(sketch.is_estimation_mode());
-  REQUIRE(sketch.get_num_retained() == 1);
-  REQUIRE(sketch.get_theta() == 1.0);
-  REQUIRE(sketch.get_estimate() == 1.0);
-  REQUIRE(sketch.get_lower_bound(1) == 1.0);
-  REQUIRE(sketch.get_upper_bound(1) == 1.0);
-}
-
-TEST_CASE("theta sketch: deserialize compact exact from java", "[theta_sketch]") {
-  std::ifstream is;
-  is.exceptions(std::ios::failbit | std::ios::badbit);
-  is.open(inputPath + "theta_compact_exact_from_java.sk", std::ios::binary);
-  auto sketch = compact_theta_sketch::deserialize(is);
-  REQUIRE_FALSE(sketch.is_empty());
-  REQUIRE_FALSE(sketch.is_estimation_mode());
-  REQUIRE(sketch.is_ordered());
-  REQUIRE(sketch.get_num_retained() == 100);
-
-  // the same construction process in Java must have produced exactly the same sketch
-  auto update_sketch = update_theta_sketch::builder().build();
-  const int n = 100;
-  for (int i = 0; i < n; i++) update_sketch.update(i);
-  REQUIRE(sketch.get_num_retained() == update_sketch.get_num_retained());
-  REQUIRE(sketch.get_theta() == Approx(update_sketch.get_theta()).margin(1e-10));
-  REQUIRE(sketch.get_estimate() == Approx(update_sketch.get_estimate()).margin(1e-10));
-  REQUIRE(sketch.get_lower_bound(1) == Approx(update_sketch.get_lower_bound(1)).margin(1e-10));
-  REQUIRE(sketch.get_upper_bound(1) == Approx(update_sketch.get_upper_bound(1)).margin(1e-10));
-  REQUIRE(sketch.get_lower_bound(2) == Approx(update_sketch.get_lower_bound(2)).margin(1e-10));
-  REQUIRE(sketch.get_upper_bound(2) == Approx(update_sketch.get_upper_bound(2)).margin(1e-10));
-  REQUIRE(sketch.get_lower_bound(3) == Approx(update_sketch.get_lower_bound(3)).margin(1e-10));
-  REQUIRE(sketch.get_upper_bound(3) == Approx(update_sketch.get_upper_bound(3)).margin(1e-10));
-  compact_theta_sketch compact_sketch = update_sketch.compact();
-  // the sketches are ordered, so the iteration sequence must match exactly
-  auto iter = sketch.begin();
-  for (const auto& key: compact_sketch) {
-    REQUIRE(*iter == key);
-    ++iter;
-  }
-}
-
-TEST_CASE("theta sketch: deserialize compact estimation from java", "[theta_sketch]") {
-  std::ifstream is;
-  is.exceptions(std::ios::failbit | std::ios::badbit);
-  is.open(inputPath + "theta_compact_estimation_from_java.sk", std::ios::binary);
-  auto sketch = compact_theta_sketch::deserialize(is);
-  REQUIRE_FALSE(sketch.is_empty());
-  REQUIRE(sketch.is_estimation_mode());
-  REQUIRE(sketch.is_ordered());
-  REQUIRE(sketch.get_num_retained() == 4342);
-  REQUIRE(sketch.get_theta() == Approx(0.531700444213199).margin(1e-10));
-  REQUIRE(sketch.get_estimate() == Approx(8166.25234614053).margin(1e-10));
-  REQUIRE(sketch.get_lower_bound(2) == Approx(7996.956955317471).margin(1e-10));
-  REQUIRE(sketch.get_upper_bound(2) == Approx(8339.090301078124).margin(1e-10));
-
-  // the same construction process in Java must have produced exactly the same sketch
-  update_theta_sketch update_sketch = update_theta_sketch::builder().build();
-  const int n = 8192;
-  for (int i = 0; i < n; i++) update_sketch.update(i);
-  REQUIRE(sketch.get_num_retained() == update_sketch.get_num_retained());
-  REQUIRE(sketch.get_theta() == Approx(update_sketch.get_theta()).margin(1e-10));
-  REQUIRE(sketch.get_estimate() == Approx(update_sketch.get_estimate()).margin(1e-10));
-  REQUIRE(sketch.get_lower_bound(1) == Approx(update_sketch.get_lower_bound(1)).margin(1e-10));
-  REQUIRE(sketch.get_upper_bound(1) == Approx(update_sketch.get_upper_bound(1)).margin(1e-10));
-  REQUIRE(sketch.get_lower_bound(2) == Approx(update_sketch.get_lower_bound(2)).margin(1e-10));
-  REQUIRE(sketch.get_upper_bound(2) == Approx(update_sketch.get_upper_bound(2)).margin(1e-10));
-  REQUIRE(sketch.get_lower_bound(3) == Approx(update_sketch.get_lower_bound(3)).margin(1e-10));
-  REQUIRE(sketch.get_upper_bound(3) == Approx(update_sketch.get_upper_bound(3)).margin(1e-10));
-  compact_theta_sketch compact_sketch = update_sketch.compact();
-  // the sketches are ordered, so the iteration sequence must match exactly
-  auto iter = sketch.begin();
-  for (const auto& key: compact_sketch) {
-    REQUIRE(*iter == key);
-    ++iter;
-  }
-}
-
 TEST_CASE("theta sketch: deserialize compact v1 estimation from java", "[theta_sketch]") {
   std::ifstream is;
   is.exceptions(std::ios::failbit | std::ios::badbit);
@@ -473,30 +377,6 @@ TEST_CASE("theta sketch: conversion constructor and wrapped compact", "[theta_sk
   REQUIRE_THROWS_AS(wrapped_compact_theta_sketch::wrap(bytes.data(), bytes.size(), 0), std::invalid_argument);
 }
 
-TEST_CASE("theta sketch: wrap compact empty from java", "[theta_sketch]") {
-  std::ifstream is;
-  is.exceptions(std::ios::failbit | std::ios::badbit);
-  is.open(inputPath + "theta_compact_empty_from_java.sk", std::ios::binary | std::ios::ate);
-
-  std::vector<uint8_t> buf;
-  if(is) {
-      auto size = is.tellg();
-      buf.reserve(size);
-      buf.assign(size, 0);
-      is.seekg(0, std::ios_base::beg);
-      is.read((char*)(buf.data()), buf.size());
-  }
-
-  auto sketch = wrapped_compact_theta_sketch::wrap(buf.data(), buf.size());
-  REQUIRE(sketch.is_empty());
-  REQUIRE_FALSE(sketch.is_estimation_mode());
-  REQUIRE(sketch.get_num_retained() == 0);
-  REQUIRE(sketch.get_theta() == 1.0);
-  REQUIRE(sketch.get_estimate() == 0.0);
-  REQUIRE(sketch.get_lower_bound(1) == 0.0);
-  REQUIRE(sketch.get_upper_bound(1) == 0.0);
-}
-
 TEST_CASE("theta sketch: wrap compact v1 empty from java", "[theta_sketch]") {
   std::ifstream is;
   is.exceptions(std::ios::failbit | std::ios::badbit);
@@ -545,33 +425,10 @@ TEST_CASE("theta sketch: wrap compact v2 empty from java", "[theta_sketch]") {
   REQUIRE(sketch.get_upper_bound(1) == 0.0);
 }
 
-TEST_CASE("theta sketch: wrap single item from java", "[theta_sketch]") {
-  std::ifstream is;
-  is.exceptions(std::ios::failbit | std::ios::badbit);
-  is.open(inputPath + "theta_compact_single_item_from_java.sk", std::ios::binary | std::ios::ate);
-  std::vector<uint8_t> buf;
-  if(is) {
-      auto size = is.tellg();
-      buf.reserve(size);
-      buf.assign(size, 0);
-      is.seekg(0, std::ios_base::beg);
-      is.read((char*)(buf.data()), buf.size());
-  }
-
-  auto sketch = wrapped_compact_theta_sketch::wrap(buf.data(), buf.size());
-  REQUIRE_FALSE(sketch.is_empty());
-  REQUIRE_FALSE(sketch.is_estimation_mode());
-  REQUIRE(sketch.get_num_retained() == 1);
-  REQUIRE(sketch.get_theta() == 1.0);
-  REQUIRE(sketch.get_estimate() == 1.0);
-  REQUIRE(sketch.get_lower_bound(1) == 1.0);
-  REQUIRE(sketch.get_upper_bound(1) == 1.0);
-}
-
-TEST_CASE("theta sketch: wrap compact estimation from java", "[theta_sketch]") {
+TEST_CASE("theta sketch: wrap compact v1 estimation from java", "[theta_sketch]") {
   std::ifstream is;
   is.exceptions(std::ios::failbit | std::ios::badbit);
-  is.open(inputPath + "theta_compact_estimation_from_java.sk", std::ios::binary | std::ios::ate);
+  is.open(inputPath + "theta_compact_estimation_from_java_v1.sk", std::ios::binary | std::ios::ate);
   std::vector<uint8_t> buf;
   if(is) {
       auto size = is.tellg();
@@ -584,7 +441,7 @@ TEST_CASE("theta sketch: wrap compact estimation from java", "[theta_sketch]") {
   auto sketch = wrapped_compact_theta_sketch::wrap(buf.data(), buf.size());
   REQUIRE_FALSE(sketch.is_empty());
   REQUIRE(sketch.is_estimation_mode());
-  REQUIRE(sketch.is_ordered());
+//  REQUIRE(sketch.is_ordered());       // v1 may not be ordered
   REQUIRE(sketch.get_num_retained() == 4342);
   REQUIRE(sketch.get_theta() == Approx(0.531700444213199).margin(1e-10));
   REQUIRE(sketch.get_estimate() == Approx(8166.25234614053).margin(1e-10));
@@ -607,16 +464,16 @@ TEST_CASE("theta sketch: wrap compact estimation from java", "[theta_sketch]") {
   compact_theta_sketch compact_sketch = update_sketch.compact();
   // the sketches are ordered, so the iteration sequence must match exactly
   auto iter = sketch.begin();
-  for (const auto& key: compact_sketch) {
+  for (const auto key: compact_sketch) {
     REQUIRE(*iter == key);
     ++iter;
   }
 }
 
-TEST_CASE("theta sketch: wrap compact v1 estimation from java", "[theta_sketch]") {
+TEST_CASE("theta sketch: wrap compact v2 estimation from java", "[theta_sketch]") {
   std::ifstream is;
   is.exceptions(std::ios::failbit | std::ios::badbit);
-  is.open(inputPath + "theta_compact_estimation_from_java_v1.sk", std::ios::binary | std::ios::ate);
+  is.open(inputPath + "theta_compact_estimation_from_java_v2.sk", std::ios::binary | std::ios::ate);
   std::vector<uint8_t> buf;
   if(is) {
       auto size = is.tellg();
@@ -652,52 +509,46 @@ TEST_CASE("theta sketch: wrap compact v1 estimation from java", "[theta_sketch]"
   compact_theta_sketch compact_sketch = update_sketch.compact();
   // the sketches are ordered, so the iteration sequence must match exactly
   auto iter = sketch.begin();
-  for (const auto& key: compact_sketch) {
+  for (const auto key: compact_sketch) {
     REQUIRE(*iter == key);
     ++iter;
   }
 }
 
-TEST_CASE("theta sketch: wrap compact v2 estimation from java", "[theta_sketch]") {
-  std::ifstream is;
-  is.exceptions(std::ios::failbit | std::ios::badbit);
-  is.open(inputPath + "theta_compact_estimation_from_java_v2.sk", std::ios::binary | std::ios::ate);
-  std::vector<uint8_t> buf;
-  if(is) {
-      auto size = is.tellg();
-      buf.reserve(size);
-      buf.assign(size, 0);
-      is.seekg(0, std::ios_base::beg);
-      is.read((char*)(buf.data()), buf.size());
+TEST_CASE("theta sketch: serialize deserialize compressed", "[theta_sketch]") {
+  auto update_sketch = update_theta_sketch::builder().build();
+  for (int i = 0; i < 10000; i++) update_sketch.update(i);
+  auto compact_sketch = update_sketch.compact();
+
+  auto bytes = compact_sketch.serialize_compressed();
+  { // deserialize bytes
+    auto deserialized_sketch = compact_theta_sketch::deserialize(bytes.data(), bytes.size());
+    REQUIRE(deserialized_sketch.get_num_retained() == compact_sketch.get_num_retained());
+    REQUIRE(deserialized_sketch.get_theta() == compact_sketch.get_theta());
+    auto iter = deserialized_sketch.begin();
+    for (const auto key: compact_sketch) {
+      REQUIRE(*iter == key);
+      ++iter;
+    }
+  }
+  { // wrap bytes
+    auto wrapped_sketch = wrapped_compact_theta_sketch::wrap(bytes.data(), bytes.size());
+    REQUIRE(wrapped_sketch.get_num_retained() == compact_sketch.get_num_retained());
+    REQUIRE(wrapped_sketch.get_theta() == compact_sketch.get_theta());
+    auto iter = wrapped_sketch.begin();
+    for (const auto key: compact_sketch) {
+      REQUIRE(*iter == key);
+      ++iter;
+    }
   }
 
-  auto sketch = wrapped_compact_theta_sketch::wrap(buf.data(), buf.size());
-  REQUIRE_FALSE(sketch.is_empty());
-  REQUIRE(sketch.is_estimation_mode());
-//  REQUIRE(sketch.is_ordered());       // v1 may not be ordered
-  REQUIRE(sketch.get_num_retained() == 4342);
-  REQUIRE(sketch.get_theta() == Approx(0.531700444213199).margin(1e-10));
-  REQUIRE(sketch.get_estimate() == Approx(8166.25234614053).margin(1e-10));
-  REQUIRE(sketch.get_lower_bound(2) == Approx(7996.956955317471).margin(1e-10));
-  REQUIRE(sketch.get_upper_bound(2) == Approx(8339.090301078124).margin(1e-10));
-
-  // the same construction process in Java must have produced exactly the same sketch
-  update_theta_sketch update_sketch = update_theta_sketch::builder().build();
-  const int n = 8192;
-  for (int i = 0; i < n; i++) update_sketch.update(i);
-  REQUIRE(sketch.get_num_retained() == update_sketch.get_num_retained());
-  REQUIRE(sketch.get_theta() == Approx(update_sketch.get_theta()).margin(1e-10));
-  REQUIRE(sketch.get_estimate() == Approx(update_sketch.get_estimate()).margin(1e-10));
-  REQUIRE(sketch.get_lower_bound(1) == Approx(update_sketch.get_lower_bound(1)).margin(1e-10));
-  REQUIRE(sketch.get_upper_bound(1) == Approx(update_sketch.get_upper_bound(1)).margin(1e-10));
-  REQUIRE(sketch.get_lower_bound(2) == Approx(update_sketch.get_lower_bound(2)).margin(1e-10));
-  REQUIRE(sketch.get_upper_bound(2) == Approx(update_sketch.get_upper_bound(2)).margin(1e-10));
-  REQUIRE(sketch.get_lower_bound(3) == Approx(update_sketch.get_lower_bound(3)).margin(1e-10));
-  REQUIRE(sketch.get_upper_bound(3) == Approx(update_sketch.get_upper_bound(3)).margin(1e-10));
-  compact_theta_sketch compact_sketch = update_sketch.compact();
-  // the sketches are ordered, so the iteration sequence must match exactly
-  auto iter = sketch.begin();
-  for (const auto& key: compact_sketch) {
+  std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
+  compact_sketch.serialize_compressed(s);
+  auto deserialized_sketch = compact_theta_sketch::deserialize(s);
+  REQUIRE(deserialized_sketch.get_num_retained() == compact_sketch.get_num_retained());
+  REQUIRE(deserialized_sketch.get_theta() == compact_sketch.get_theta());
+  auto iter = deserialized_sketch.begin();
+  for (const auto key: compact_sketch) {
     REQUIRE(*iter == key);
     ++iter;
   }

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

@@ -128,4 +128,29 @@ TEST_CASE("theta union: seed mismatch", "[theta_union]") {
   REQUIRE_THROWS_AS(u.update(sketch), std::invalid_argument);
 }
 
+TEST_CASE("theta union: larger K", "[theta_union]") {
+  auto update_sketch1 = datasketches::update_theta_sketch::builder().set_lg_k(14).build();
+  for(int i = 0; i < 16384; ++i) update_sketch1.update(i);
+
+  auto update_sketch2 = datasketches::update_theta_sketch::builder().set_lg_k(14).build();
+  for(int i = 0; i < 26384; ++i) update_sketch2.update(i);
+
+  auto update_sketch3 = datasketches::update_theta_sketch::builder().set_lg_k(14).build();
+  for(int i = 0; i < 86384; ++i) update_sketch3.update(i);
+
+  auto union1 = datasketches::theta_union::builder().set_lg_k(16).build();
+  union1.update(update_sketch2);
+  union1.update(update_sketch1);
+  union1.update(update_sketch3);
+  auto result1 = union1.get_result();
+  REQUIRE(result1.get_estimate() == update_sketch3.get_estimate());
+
+  auto union2 = datasketches::theta_union::builder().set_lg_k(16).build();
+  union2.update(update_sketch1);
+  union2.update(update_sketch3);
+  union2.update(update_sketch2);
+  auto result2 = union2.get_result();
+  REQUIRE(result2.get_estimate() == update_sketch3.get_estimate());
+}
+
 } /* namespace datasketches */

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

@@ -47,11 +47,12 @@ install(FILES
 		include/tuple_a_not_b_impl.hpp
 		include/tuple_jaccard_similarity.hpp
 		include/array_of_doubles_sketch.hpp
-		include/array_of_doubles_sketch_impl.hpp
-		include/array_of_doubles_union.hpp
-		include/array_of_doubles_union_impl.hpp
-		include/array_of_doubles_intersection.hpp
-		include/array_of_doubles_intersection_impl.hpp
-		include/array_of_doubles_a_not_b.hpp
-		include/array_of_doubles_a_not_b_impl.hpp
+		include/array_tuple_sketch.hpp
+		include/array_tuple_sketch_impl.hpp
+		include/array_tuple_union.hpp
+		include/array_tuple_union_impl.hpp
+		include/array_tuple_intersection.hpp
+		include/array_tuple_intersection_impl.hpp
+		include/array_tuple_a_not_b.hpp
+		include/array_tuple_a_not_b_impl.hpp
   DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/DataSketches")

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

@@ -20,160 +20,35 @@
 #ifndef ARRAY_OF_DOUBLES_SKETCH_HPP_
 #define ARRAY_OF_DOUBLES_SKETCH_HPP_
 
-#include <vector>
-#include <memory>
-
-#include "serde.hpp"
-#include "tuple_sketch.hpp"
+#include "array_tuple_sketch.hpp"
+#include "array_tuple_union.hpp"
+#include "array_tuple_intersection.hpp"
+#include "array_tuple_a_not_b.hpp"
 
 namespace datasketches {
 
-// This sketch is equivalent of ArrayOfDoublesSketch in Java
-
-// This simple array of double is faster than std::vector and should be sufficient for this application
-template<typename Allocator = std::allocator<double>>
-class aod {
-public:
-  explicit aod(uint8_t size, const Allocator& allocator = Allocator()):
-  allocator_(allocator), size_(size), array_(allocator_.allocate(size_)) {
-    std::fill(array_, array_ + size_, 0);
-  }
-  aod(const aod& other):
-    allocator_(other.allocator_),
-    size_(other.size_),
-    array_(allocator_.allocate(size_))
-  {
-    std::copy(other.array_, other.array_ + size_, array_);
-  }
-  aod(aod&& other) noexcept:
-    allocator_(std::move(other.allocator_)),
-    size_(other.size_),
-    array_(other.array_)
-  {
-    other.array_ = nullptr;
-  }
-  ~aod() {
-    if (array_ != nullptr) allocator_.deallocate(array_, size_);
-  }
-  aod& operator=(const aod& other) {
-    aod copy(other);
-    std::swap(allocator_, copy.allocator_);
-    std::swap(size_, copy.size_);
-    std::swap(array_, copy.array_);
-    return *this;
-  }
-  aod& operator=(aod&& other) {
-    std::swap(allocator_, other.allocator_);
-    std::swap(size_, other.size_);
-    std::swap(array_, other.array_);
-    return *this;
-  }
-  double& operator[](size_t index) { return array_[index]; }
-  double operator[](size_t index) const { return array_[index]; }
-  uint8_t size() const { return size_; }
-  double* data() { return array_; }
-  const double* data() const { return array_; }
-  bool operator==(const aod& other) const {
-    for (uint8_t i = 0; i < size_; ++i) if (array_[i] != other.array_[i]) return false;
-    return true;
-  }
-private:
-  Allocator allocator_;
-  uint8_t size_;
-  double* array_;
-};
-
-template<typename A = std::allocator<double>>
-class array_of_doubles_update_policy {
-public:
-  array_of_doubles_update_policy(uint8_t num_values = 1, const A& allocator = A()):
-    allocator_(allocator), num_values_(num_values) {}
-  aod<A> create() const {
-    return aod<A>(num_values_, allocator_);
-  }
-  template<typename InputVector> // to allow any type with indexed access (such as double*)
-  void update(aod<A>& summary, const InputVector& update) const {
-    for (uint8_t i = 0; i < num_values_; ++i) summary[i] += update[i];
-  }
-  uint8_t get_num_values() const {
-    return num_values_;
-  }
-
-private:
-  A allocator_;
-  uint8_t num_values_;
-};
-
-// forward declaration
-template<typename A> class compact_array_of_doubles_sketch_alloc;
-
-template<typename A> using AllocAOD = typename std::allocator_traits<A>::template rebind_alloc<aod<A>>;
-
-template<typename A = std::allocator<double>>
-class update_array_of_doubles_sketch_alloc: public update_tuple_sketch<aod<A>, aod<A>, array_of_doubles_update_policy<A>, AllocAOD<A>> {
-public:
-  using Base = update_tuple_sketch<aod<A>, aod<A>, array_of_doubles_update_policy<A>, AllocAOD<A>>;
-  using resize_factor = typename Base::resize_factor;
-
-  class builder;
+/// convenience alias with default allocator, default policy for update_array_of_doubles_sketch
+using default_array_of_doubles_update_policy = default_array_tuple_update_policy<array<double>>;
 
-  compact_array_of_doubles_sketch_alloc<A> compact(bool ordered = true) const;
-  uint8_t get_num_values() const;
+/// convenience alias with default allocator, equivalent to ArrayOfDoublesUpdatableSketch in Java
+using update_array_of_doubles_sketch = update_array_tuple_sketch<array<double>>;
 
-private:
-  // for builder
-  update_array_of_doubles_sketch_alloc(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, float p, uint64_t theta,
-      uint64_t seed, const array_of_doubles_update_policy<A>& policy, const A& allocator);
-};
+/// convenience alias with default allocator, equivalent to ArrayOfDoublesCompactSketch in Java
+using compact_array_of_doubles_sketch = compact_array_tuple_sketch<array<double>>;
 
-// alias with the default allocator for convenience
-using update_array_of_doubles_sketch = update_array_of_doubles_sketch_alloc<>;
+/// convenience alias, default policy for array_of_doubles_union
+using default_array_of_doubles_union_policy = default_array_tuple_union_policy<array<double>>;
 
-template<typename A>
-class update_array_of_doubles_sketch_alloc<A>::builder: public tuple_base_builder<builder, array_of_doubles_update_policy<A>, A> {
-public:
-  builder(const array_of_doubles_update_policy<A>& policy = array_of_doubles_update_policy<A>(), const A& allocator = A());
-  update_array_of_doubles_sketch_alloc<A> build() const;
-};
+/// convenience alias with default allocator, equivalent to ArrayOfDoublesUnion in Java
+using array_of_doubles_union = array_tuple_union<array<double>>;
 
-template<typename A = std::allocator<double>>
-class compact_array_of_doubles_sketch_alloc: public compact_tuple_sketch<aod<A>, AllocAOD<A>> {
-public:
-  using Base = compact_tuple_sketch<aod<A>, AllocAOD<A>>;
-  using Entry = typename Base::Entry;
-  using AllocEntry = typename Base::AllocEntry;
-  using AllocU64 = typename Base::AllocU64;
-  using vector_bytes = typename Base::vector_bytes;
+/// convenience alias with default allocator, equivalent to ArrayOfDoublesIntersection in Java
+/// no default policy since it is not clear in general
+template<typename Policy> using array_of_doubles_intersection = array_tuple_intersection<array<double>, Policy>;
 
-  static const uint8_t SERIAL_VERSION = 1;
-  static const uint8_t SKETCH_FAMILY = 9;
-  static const uint8_t SKETCH_TYPE = 3;
-  enum flags { UNUSED1, UNUSED2, IS_EMPTY, HAS_ENTRIES, IS_ORDERED };
-
-  template<typename Sketch>
-  compact_array_of_doubles_sketch_alloc(const Sketch& other, bool ordered = true);
-
-  uint8_t get_num_values() const;
-
-  void serialize(std::ostream& os) const;
-  vector_bytes serialize(unsigned header_size_bytes = 0) const;
-
-  static compact_array_of_doubles_sketch_alloc deserialize(std::istream& is, uint64_t seed = DEFAULT_SEED, const A& allocator = A());
-  static compact_array_of_doubles_sketch_alloc deserialize(const void* bytes, size_t size, uint64_t seed = DEFAULT_SEED,
-      const A& allocator = A());
-
-  // for internal use
-  compact_array_of_doubles_sketch_alloc(bool is_empty, bool is_ordered, uint16_t seed_hash, uint64_t theta, std::vector<Entry, AllocEntry>&& entries, uint8_t num_values);
-  compact_array_of_doubles_sketch_alloc(uint8_t num_values, Base&& base);
-private:
-  uint8_t num_values_;
-};
-
-// alias with the default allocator for convenience
-using compact_array_of_doubles_sketch = compact_array_of_doubles_sketch_alloc<>;
+/// convenience alias with default allocator, equivalent to ArrayOfDoublesAnotB in Java
+using array_of_doubles_a_not_b = array_tuple_a_not_b<array<double>>;
 
 } /* namespace datasketches */
 
-#include "array_of_doubles_sketch_impl.hpp"
-
 #endif

data/vendor/datasketches-cpp/tuple/include/{array_of_doubles_a_not_b.hpp → array_tuple_a_not_b.hpp}

@@ -17,36 +17,44 @@
  * under the License.
  */
 
-#ifndef ARRAY_OF_DOUBLES_A_NOT_B_HPP_
-#define ARRAY_OF_DOUBLES_A_NOT_B_HPP_
+#ifndef ARRAY_TUPLE_A_NOT_B_HPP_
+#define ARRAY_TUPLE_A_NOT_B_HPP_
 
 #include <vector>
 #include <memory>
 
-#include "array_of_doubles_sketch.hpp"
+#include "array_tuple_sketch.hpp"
 #include "tuple_a_not_b.hpp"
 
 namespace datasketches {
 
-template<typename Allocator = std::allocator<double>>
-class array_of_doubles_a_not_b_alloc: tuple_a_not_b<aod<Allocator>, AllocAOD<Allocator>> {
+/// array tuple A-not-B
+template<typename Array, typename Allocator = typename Array::allocator_type>
+class array_tuple_a_not_b: tuple_a_not_b<Array, Allocator> {
 public:
-  using Summary = aod<Allocator>;
-  using AllocSummary = AllocAOD<Allocator>;
-  using Base = tuple_a_not_b<Summary, AllocSummary>;
-  using CompactSketch = compact_array_of_doubles_sketch_alloc<Allocator>;
-
-  explicit array_of_doubles_a_not_b_alloc(uint64_t seed = DEFAULT_SEED, const Allocator& allocator = Allocator());
-
+  using Base = tuple_a_not_b<Array, Allocator>;
+  using CompactSketch = compact_array_tuple_sketch<Array, Allocator>;
+
+  /**
+   * Constructor
+   * @param seed for the hash function that was used to create the sketch
+   * @param allocator to use for allocating and deallocating memory
+   */
+  explicit array_tuple_a_not_b(uint64_t seed = DEFAULT_SEED, const Allocator& allocator = Allocator());
+
+  /**
+   * Computes the A-not-B set operation given two sketches.
+   * @param a sketch A
+   * @param b sketch B
+   * @param ordered optional flag to specify if an ordered sketch should be produced
+   * @return the result of A-not-B as a compact sketch
+   */
   template<typename FwdSketch, typename Sketch>
   CompactSketch compute(FwdSketch&& a, const Sketch& b, bool ordered = true) const;
 };
 
-// alias with the default allocator for convenience
-using array_of_doubles_a_not_b = array_of_doubles_a_not_b_alloc<>;
-
 } /* namespace datasketches */
 
-#include "array_of_doubles_a_not_b_impl.hpp"
+#include "array_tuple_a_not_b_impl.hpp"
 
 #endif

data/vendor/datasketches-cpp/tuple/include/{array_of_doubles_a_not_b_impl.hpp → array_tuple_a_not_b_impl.hpp}

@@ -19,13 +19,13 @@
 
 namespace datasketches {
 
-template<typename A>
-array_of_doubles_a_not_b_alloc<A>::array_of_doubles_a_not_b_alloc(uint64_t seed, const A& allocator):
+template<typename Array, typename Allocator>
+array_tuple_a_not_b<Array, Allocator>::array_tuple_a_not_b(uint64_t seed, const Allocator& allocator):
 Base(seed, allocator) {}
 
-template<typename A>
+template<typename Array, typename Allocator>
 template<typename FwdSketch, typename Sketch>
-auto array_of_doubles_a_not_b_alloc<A>::compute(FwdSketch&& a, const Sketch& b, bool ordered) const -> CompactSketch {
+auto array_tuple_a_not_b<Array, Allocator>::compute(FwdSketch&& a, const Sketch& b, bool ordered) const -> CompactSketch {
   return CompactSketch(a.get_num_values(), Base::compute(std::forward<FwdSketch>(a), b, ordered));
 }
 

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

@@ -0,0 +1,65 @@
+/*
+ * 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.
+ */
+
+#ifndef ARRAY_TUPLE_INTERSECTION_HPP_
+#define ARRAY_TUPLE_INTERSECTION_HPP_
+
+#include <vector>
+#include <memory>
+
+#include "array_tuple_sketch.hpp"
+#include "tuple_intersection.hpp"
+
+namespace datasketches {
+
+/// array tuple intersection
+template<
+  typename Array,
+  typename Policy,
+  typename Allocator = typename Array::allocator_type
+>
+class array_tuple_intersection: public tuple_intersection<Array, Policy, Allocator> {
+public:
+  using Base = tuple_intersection<Array, Policy, Allocator>;
+  using CompactSketch = compact_array_tuple_sketch<Array, Allocator>;
+  using resize_factor = theta_constants::resize_factor;
+
+  /**
+   * Constructor
+   * @param seed for the hash function that was used to create the sketch
+   * @param policy user-defined way of combining Summary during intersection
+   * @param allocator to use for allocating and deallocating memory
+   */
+  explicit array_tuple_intersection(uint64_t seed = DEFAULT_SEED, const Policy& policy = Policy(), const Allocator& allocator = Allocator());
+
+  /**
+   * Produces a copy of the current state of the intersection.
+   * If update() was not called, the state is the infinite "universe",
+   * which is considered an undefined state, and throws an exception.
+   * @param ordered optional flag to specify if an ordered sketch should be produced
+   * @return the result of the intersection as a compact sketch
+   */
+  CompactSketch get_result(bool ordered = true) const;
+};
+
+} /* namespace datasketches */
+
+#include "array_tuple_intersection_impl.hpp"
+
+#endif