datasketches 0.2.3 → 0.2.4

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

@@ -31,64 +31,72 @@
 namespace datasketches {
 
 template<typename A>
-bool theta_sketch_alloc<A>::is_estimation_mode() const {
+bool base_theta_sketch_alloc<A>::is_estimation_mode() const {
   return get_theta64() < theta_constants::MAX_THETA && !is_empty();
 }
 
 template<typename A>
-double theta_sketch_alloc<A>::get_theta() const {
+double base_theta_sketch_alloc<A>::get_theta() const {
   return static_cast<double>(get_theta64()) / theta_constants::MAX_THETA;
 }
 
 template<typename A>
-double theta_sketch_alloc<A>::get_estimate() const {
+double base_theta_sketch_alloc<A>::get_estimate() const {
   return get_num_retained() / get_theta();
 }
 
 template<typename A>
-double theta_sketch_alloc<A>::get_lower_bound(uint8_t num_std_devs) const {
+double base_theta_sketch_alloc<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);
 }
 
 template<typename A>
-double theta_sketch_alloc<A>::get_upper_bound(uint8_t num_std_devs) const {
+double base_theta_sketch_alloc<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);
 }
 
 template<typename A>
-string<A> theta_sketch_alloc<A>::to_string(bool detail) const {
-  ostrstream os;
+string<A> base_theta_sketch_alloc<A>::to_string(bool print_details) const {
+  // Using a temporary stream for implementation here does not comply with AllocatorAwareContainer requirements.
+  // The stream does not support passing an allocator instance, and alternatives are complicated.
+  std::ostringstream os;
   os << "### Theta sketch summary:" << std::endl;
-  os << "   num retained entries : " << get_num_retained() << std::endl;
-  os << "   seed hash            : " << get_seed_hash() << std::endl;
-  os << "   empty?               : " << (is_empty() ? "true" : "false") << std::endl;
-  os << "   ordered?             : " << (is_ordered() ? "true" : "false") << std::endl;
-  os << "   estimation mode?     : " << (is_estimation_mode() ? "true" : "false") << std::endl;
-  os << "   theta (fraction)     : " << get_theta() << std::endl;
-  os << "   theta (raw 64-bit)   : " << get_theta64() << std::endl;
+  os << "   num retained entries : " << this->get_num_retained() << std::endl;
+  os << "   seed hash            : " << this->get_seed_hash() << std::endl;
+  os << "   empty?               : " << (this->is_empty() ? "true" : "false") << std::endl;
+  os << "   ordered?             : " << (this->is_ordered() ? "true" : "false") << std::endl;
+  os << "   estimation mode?     : " << (this->is_estimation_mode() ? "true" : "false") << std::endl;
+  os << "   theta (fraction)     : " << this->get_theta() << std::endl;
+  os << "   theta (raw 64-bit)   : " << this->get_theta64() << std::endl;
   os << "   estimate             : " << this->get_estimate() << std::endl;
   os << "   lower bound 95% conf : " << this->get_lower_bound(2) << std::endl;
   os << "   upper bound 95% conf : " << this->get_upper_bound(2) << std::endl;
   print_specifics(os);
   os << "### End sketch summary" << std::endl;
-  if (detail) {
+  if (print_details) {
+      print_items(os);
+  }
+  return string<A>(os.str().c_str(), this->get_allocator());
+}
+
+template<typename A>
+void theta_sketch_alloc<A>::print_items(std::ostringstream& os) const {
     os << "### Retained entries" << std::endl;
     for (const auto& hash: *this) {
       os << hash << std::endl;
     }
     os << "### End retained entries" << std::endl;
-  }
-  return os.str();
 }
 
+
 // update sketch
 
 template<typename A>
 update_theta_sketch_alloc<A>::update_theta_sketch_alloc(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf,
-    uint64_t theta, uint64_t seed, const A& allocator):
-table_(lg_cur_size, lg_nom_size, rf, theta, seed, allocator)
+    float p, uint64_t theta, uint64_t seed, const A& allocator):
+table_(lg_cur_size, lg_nom_size, rf, p, theta, seed, allocator)
 {}
 
 template<typename A>
@@ -103,12 +111,12 @@ bool update_theta_sketch_alloc<A>::is_empty() const {
 
 template<typename A>
 bool update_theta_sketch_alloc<A>::is_ordered() const {
-  return false;
+  return table_.num_entries_ > 1 ? false : true;
 }
 
 template<typename A>
 uint64_t update_theta_sketch_alloc<A>::get_theta64() const {
-  return table_.theta_;
+  return is_empty() ? theta_constants::MAX_THETA : table_.theta_;
 }
 
 template<typename A>
@@ -202,6 +210,11 @@ void update_theta_sketch_alloc<A>::trim() {
   table_.trim();
 }
 
+template<typename A>
+void update_theta_sketch_alloc<A>::reset() {
+  table_.reset();
+}
+
 template<typename A>
 auto update_theta_sketch_alloc<A>::begin() -> iterator {
   return iterator(table_.entries_, 1 << table_.lg_cur_size_, 0);
@@ -228,7 +241,7 @@ compact_theta_sketch_alloc<A> update_theta_sketch_alloc<A>::compact(bool ordered
 }
 
 template<typename A>
-void update_theta_sketch_alloc<A>::print_specifics(ostrstream& os) const {
+void update_theta_sketch_alloc<A>::print_specifics(std::ostringstream& os) const {
   os << "   lg nominal size      : " << static_cast<int>(table_.lg_nom_size_) << std::endl;
   os << "   lg current size      : " << static_cast<int>(table_.lg_cur_size_) << std::endl;
   os << "   resize factor        : " << (1 << table_.rf_) << std::endl;
@@ -241,7 +254,7 @@ update_theta_sketch_alloc<A>::builder::builder(const A& allocator): theta_base_b
 
 template<typename A>
 update_theta_sketch_alloc<A> update_theta_sketch_alloc<A>::builder::build() const {
-  return update_theta_sketch_alloc(this->starting_lg_size(), this->lg_k_, this->rf_, this->starting_theta(), this->seed_, this->allocator_);
+  return update_theta_sketch_alloc(this->starting_lg_size(), this->lg_k_, this->rf_, this->p_, this->starting_theta(), this->seed_, this->allocator_);
 }
 
 // compact sketch
@@ -255,16 +268,18 @@ seed_hash_(other.get_seed_hash()),
 theta_(other.get_theta64()),
 entries_(other.get_allocator())
 {
-  entries_.reserve(other.get_num_retained());
-  std::copy(other.begin(), other.end(), std::back_inserter(entries_));
-  if (ordered && !other.is_ordered()) std::sort(entries_.begin(), entries_.end());
+  if (!other.is_empty()) {
+    entries_.reserve(other.get_num_retained());
+    std::copy(other.begin(), other.end(), std::back_inserter(entries_));
+    if (ordered && !other.is_ordered()) std::sort(entries_.begin(), entries_.end());
+  }
 }
 
 template<typename A>
 compact_theta_sketch_alloc<A>::compact_theta_sketch_alloc(bool is_empty, bool is_ordered, uint16_t seed_hash, uint64_t theta,
     std::vector<uint64_t, A>&& entries):
 is_empty_(is_empty),
-is_ordered_(is_ordered),
+is_ordered_(is_ordered || (entries.size() <= 1ULL)),
 seed_hash_(seed_hash),
 theta_(theta),
 entries_(std::move(entries))
@@ -321,7 +336,7 @@ auto compact_theta_sketch_alloc<A>::end() const -> const_iterator {
 }
 
 template<typename A>
-void compact_theta_sketch_alloc<A>::print_specifics(ostrstream&) const {}
+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 {
@@ -400,33 +415,101 @@ compact_theta_sketch_alloc<A> compact_theta_sketch_alloc<A>::deserialize(std::is
   const auto preamble_longs = read<uint8_t>(is);
   const auto serial_version = read<uint8_t>(is);
   const auto type = read<uint8_t>(is);
-  read<uint16_t>(is); // unused
-  const auto flags_byte = read<uint8_t>(is);
-  const auto seed_hash = read<uint16_t>(is);
-  checker<true>::check_sketch_type(type, SKETCH_TYPE);
-  checker<true>::check_serial_version(serial_version, SERIAL_VERSION);
-  const bool is_empty = flags_byte & (1 << flags::IS_EMPTY);
-  if (!is_empty) checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
+  switch (serial_version) {
+  case SERIAL_VERSION: {
+      read<uint16_t>(is); // unused
+      const auto flags_byte = read<uint8_t>(is);
+      const auto seed_hash = read<uint16_t>(is);
+      checker<true>::check_sketch_type(type, SKETCH_TYPE);
+      checker<true>::check_serial_version(serial_version, SERIAL_VERSION);
+      const bool is_empty = flags_byte & (1 << flags::IS_EMPTY);
+      if (!is_empty) checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
+
+      uint64_t theta = theta_constants::MAX_THETA;
+      uint32_t num_entries = 0;
+      if (!is_empty) {
+        if (preamble_longs == 1) {
+          num_entries = 1;
+        } else {
+          num_entries = read<uint32_t>(is);
+          read<uint32_t>(is); // unused
+          if (preamble_longs > 2) {
+            theta = read<uint64_t>(is);
+          }
+        }
+      }
+      std::vector<uint64_t, A> entries(num_entries, 0, allocator);
+      if (!is_empty) read(is, entries.data(), sizeof(uint64_t) * entries.size());
 
-  uint64_t theta = theta_constants::MAX_THETA;
-  uint32_t num_entries = 0;
-  if (!is_empty) {
-    if (preamble_longs == 1) {
-      num_entries = 1;
-    } else {
-      num_entries = read<uint32_t>(is);
+      const bool is_ordered = flags_byte & (1 << flags::IS_ORDERED);
+      if (!is.good()) throw std::runtime_error("error reading from std::istream");
+      return compact_theta_sketch_alloc(is_empty, is_ordered, seed_hash, theta, std::move(entries));
+  }
+  case 1: {
+      const auto seed_hash = compute_seed_hash(seed);
+      checker<true>::check_sketch_type(type, SKETCH_TYPE);
+      read<uint8_t>(is); // unused
       read<uint32_t>(is); // unused
-      if (preamble_longs > 2) {
-        theta = read<uint64_t>(is);
+      const auto num_entries = read<uint32_t>(is);
+      read<uint32_t>(is); //unused
+      const auto theta = read<uint64_t>(is);
+      std::vector<uint64_t> entries(num_entries, 0, allocator);
+      bool is_empty = (num_entries == 0) && (theta == theta_constants::MAX_THETA);
+      if (!is_empty)
+          read(is, entries.data(), sizeof(uint64_t) * entries.size());
+      if (!is.good())
+          throw std::runtime_error("error reading from std::istream");
+      return compact_theta_sketch_alloc(is_empty, true, seed_hash, theta, std::move(entries));
+  }
+  case 2: {
+      checker<true>::check_sketch_type(type, SKETCH_TYPE);
+      read<uint8_t>(is); // unused
+      read<uint16_t>(is); // unused
+      const uint16_t seed_hash = read<uint16_t>(is);
+      checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
+      if (preamble_longs == 1) {
+          if (!is.good())
+              throw std::runtime_error("error reading from std::istream");
+          std::vector<uint64_t> entries(0, 0, allocator);
+          return compact_theta_sketch_alloc(true, true, seed_hash, theta_constants::MAX_THETA, std::move(entries));
+      } else if (preamble_longs == 2) {
+          const uint32_t num_entries = read<uint32_t>(is);
+          read<uint32_t>(is); // unused
+          std::vector<uint64_t> entries(num_entries, 0, allocator);
+          if (num_entries == 0) {
+              return compact_theta_sketch_alloc(true, true, seed_hash, theta_constants::MAX_THETA, std::move(entries));
+          }
+          read(is, entries.data(), entries.size() * sizeof(uint64_t));
+          if (!is.good())
+              throw std::runtime_error("error reading from std::istream");
+          return compact_theta_sketch_alloc(false, true, seed_hash, theta_constants::MAX_THETA, std::move(entries));
+      } else if (preamble_longs == 3) {
+          const uint32_t num_entries = read<uint32_t>(is);
+          read<uint32_t>(is); // unused
+          const auto theta = read<uint64_t>(is);
+          bool is_empty = (num_entries == 0) && (theta == theta_constants::MAX_THETA);
+          std::vector<uint64_t> entries(num_entries, 0, allocator);
+          if (is_empty) {
+              if (!is.good())
+                  throw std::runtime_error("error reading from std::istream");
+              return compact_theta_sketch_alloc(true, true, seed_hash, theta, std::move(entries));
+          } else {
+              read(is, entries.data(), sizeof(uint64_t) * entries.size());
+              if (!is.good())
+                  throw std::runtime_error("error reading from std::istream");
+              return compact_theta_sketch_alloc(false, true, seed_hash, theta, std::move(entries));
+          }
+      } else {
+          throw std::invalid_argument(std::to_string(preamble_longs) + " longs of premable, but expected 1, 2, or 3");
       }
-    }
   }
-  std::vector<uint64_t, A> entries(num_entries, 0, allocator);
-  if (!is_empty) read(is, entries.data(), sizeof(uint64_t) * entries.size());
-
-  const bool is_ordered = flags_byte & (1 << flags::IS_ORDERED);
-  if (!is.good()) throw std::runtime_error("error reading from std::istream");
-  return compact_theta_sketch_alloc(is_empty, is_ordered, seed_hash, theta, std::move(entries));
+  default:
+      // this should always fail since the valid cases are handled above
+      checker<true>::check_serial_version(serial_version, SERIAL_VERSION);
+      // this throw is never reached, because check_serial_version will throw an informative exception.
+      // This is only here to avoid a compiler warning about a path without a return value.
+      throw std::invalid_argument("unexpected sketch serialization version");
+  }
 }
 
 template<typename A>
@@ -533,6 +616,18 @@ auto wrapped_compact_theta_sketch_alloc<A>::end() const -> const_iterator {
   return entries_ + num_entries_;
 }
 
+template<typename A>
+void wrapped_compact_theta_sketch_alloc<A>::print_specifics(std::ostringstream&) const {}
+
+template<typename A>
+void wrapped_compact_theta_sketch_alloc<A>::print_items(std::ostringstream& os) const {
+    os << "### Retained entries" << std::endl;
+    for (const auto& hash: *this) {
+      os << hash << std::endl;
+    }
+    os << "### End retained entries" << std::endl;
+}
+
 } /* namespace datasketches */
 
 #endif

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

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

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

@@ -38,7 +38,7 @@ public:
   using resize_factor = typename hash_table::resize_factor;
   using comparator = compare_by_key<ExtractKey>;
 
-  theta_union_base(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, uint64_t theta, uint64_t seed, const Policy& policy, const Allocator& allocator);
+  theta_union_base(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, float p, uint64_t theta, uint64_t seed, const Policy& policy, const Allocator& allocator);
 
   template<typename FwdSketch>
   void update(FwdSketch&& sketch);
@@ -47,6 +47,8 @@ public:
 
   const Policy& get_policy() const;
 
+  void reset();
+
 private:
   Policy policy_;
   hash_table table_;

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

@@ -28,9 +28,9 @@ namespace datasketches {
 
 template<typename EN, typename EK, typename P, typename S, typename CS, typename A>
 theta_union_base<EN, EK, P, S, CS, A>::theta_union_base(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf,
-    uint64_t theta, uint64_t seed, const P& policy, const A& allocator):
+    float p, uint64_t theta, uint64_t seed, const P& policy, const A& allocator):
 policy_(policy),
-table_(lg_cur_size, lg_nom_size, rf, theta, seed, allocator),
+table_(lg_cur_size, lg_nom_size, rf, p, theta, seed, allocator),
 union_theta_(table_.theta_)
 {}
 
@@ -84,6 +84,12 @@ const P& theta_union_base<EN, EK, P, S, CS, A>::get_policy() const {
   return policy_;
 }
 
+template<typename EN, typename EK, typename P, typename S, typename CS, typename A>
+void theta_union_base<EN, EK, P, S, CS, A>::reset() {
+  table_.reset();
+  union_theta_ = table_.theta_;
+}
+
 } /* namespace datasketches */
 
 #endif

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

@@ -23,8 +23,8 @@
 namespace datasketches {
 
 template<typename A>
-theta_union_alloc<A>::theta_union_alloc(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, uint64_t theta, uint64_t seed, const A& allocator):
-state_(lg_cur_size, lg_nom_size, rf, theta, seed, nop_policy(), allocator)
+theta_union_alloc<A>::theta_union_alloc(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, float p, uint64_t theta, uint64_t seed, const A& allocator):
+state_(lg_cur_size, lg_nom_size, rf, p, theta, seed, nop_policy(), allocator)
 {}
 
 template<typename A>
@@ -38,14 +38,17 @@ auto theta_union_alloc<A>::get_result(bool ordered) const -> CompactSketch {
   return state_.get_result(ordered);
 }
 
+template<typename A>
+void theta_union_alloc<A>::reset() {
+  state_.reset();
+}
+
 template<typename A>
 theta_union_alloc<A>::builder::builder(const A& allocator): theta_base_builder<builder, A>(allocator) {}
 
 template<typename A>
 auto theta_union_alloc<A>::builder::build() const -> theta_union_alloc {
-  return theta_union_alloc(
-      this->starting_sub_multiple(this->lg_k_ + 1, this->MIN_LG_K, static_cast<uint8_t>(this->rf_)),
-      this->lg_k_, this->rf_, this->starting_theta(), this->seed_, this->allocator_);
+  return theta_union_alloc(this->starting_lg_size(), this->lg_k_, this->rf_, this->p_, this->starting_theta(), this->seed_, this->allocator_);
 }
 
 } /* namespace datasketches */

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

@@ -40,8 +40,8 @@ struct theta_update_sketch_base {
   using resize_factor = theta_constants::resize_factor;
   using comparator = compare_by_key<ExtractKey>;
 
-  theta_update_sketch_base(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, uint64_t theta,
-      uint64_t seed, const Allocator& allocator, bool is_empty = true);
+  theta_update_sketch_base(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, float p,
+      uint64_t theta, uint64_t seed, const Allocator& allocator, bool is_empty = true);
   theta_update_sketch_base(const theta_update_sketch_base& other);
   theta_update_sketch_base(theta_update_sketch_base&& other) noexcept;
   ~theta_update_sketch_base();
@@ -75,6 +75,7 @@ struct theta_update_sketch_base {
   uint8_t lg_cur_size_;
   uint8_t lg_nom_size_;
   resize_factor rf_;
+  float p_;
   uint32_t num_entries_;
   uint64_t theta_;
   uint64_t seed_;
@@ -83,6 +84,7 @@ struct theta_update_sketch_base {
   void resize();
   void rebuild();
   void trim();
+  void reset();
 
   static inline uint32_t get_capacity(uint8_t lg_cur_size, uint8_t lg_nom_size);
   static inline uint32_t get_stride(uint64_t key, uint8_t lg_size);
@@ -94,7 +96,7 @@ 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 verison release.
+  // 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;
@@ -149,7 +151,6 @@ protected:
 
   uint64_t starting_theta() const;
   uint8_t starting_lg_size() const;
-  static uint8_t starting_sub_multiple(uint8_t lg_tgt, uint8_t lg_min, uint8_t lg_rf);
 };
 
 // key extractor

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

@@ -24,15 +24,18 @@
 #include <sstream>
 #include <algorithm>
 
+#include "theta_helpers.hpp"
+
 namespace datasketches {
 
 template<typename EN, typename EK, typename A>
-theta_update_sketch_base<EN, EK, A>::theta_update_sketch_base(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, uint64_t theta, uint64_t seed, const A& allocator, bool is_empty):
+theta_update_sketch_base<EN, EK, A>::theta_update_sketch_base(uint8_t lg_cur_size, uint8_t lg_nom_size, resize_factor rf, float p, uint64_t theta, uint64_t seed, const A& allocator, bool is_empty):
 allocator_(allocator),
 is_empty_(is_empty),
 lg_cur_size_(lg_cur_size),
 lg_nom_size_(lg_nom_size),
 rf_(rf),
+p_(p),
 num_entries_(0),
 theta_(theta),
 seed_(seed),
@@ -52,6 +55,7 @@ is_empty_(other.is_empty_),
 lg_cur_size_(other.lg_cur_size_),
 lg_nom_size_(other.lg_nom_size_),
 rf_(other.rf_),
+p_(other.p_),
 num_entries_(other.num_entries_),
 theta_(other.theta_),
 seed_(other.seed_),
@@ -77,6 +81,7 @@ is_empty_(other.is_empty_),
 lg_cur_size_(other.lg_cur_size_),
 lg_nom_size_(other.lg_nom_size_),
 rf_(other.rf_),
+p_(other.p_),
 num_entries_(other.num_entries_),
 theta_(other.theta_),
 seed_(other.seed_),
@@ -105,6 +110,7 @@ theta_update_sketch_base<EN, EK, A>& theta_update_sketch_base<EN, EK, A>::operat
   std::swap(lg_cur_size_, copy.lg_cur_size_);
   std::swap(lg_nom_size_, copy.lg_nom_size_);
   std::swap(rf_, copy.rf_);
+  std::swap(p_, copy.p_);
   std::swap(num_entries_, copy.num_entries_);
   std::swap(theta_, copy.theta_);
   std::swap(seed_, copy.seed_);
@@ -119,6 +125,7 @@ theta_update_sketch_base<EN, EK, A>& theta_update_sketch_base<EN, EK, A>::operat
   std::swap(lg_cur_size_, other.lg_cur_size_);
   std::swap(lg_nom_size_, other.lg_nom_size_);
   std::swap(rf_, other.rf_);
+  std::swap(p_, other.p_);
   std::swap(num_entries_, other.num_entries_);
   std::swap(theta_, other.theta_);
   std::swap(seed_, other.seed_);
@@ -247,6 +254,29 @@ void theta_update_sketch_base<EN, EK, A>::trim() {
   if (num_entries_ > static_cast<uint32_t>(1 << lg_nom_size_)) rebuild();
 }
 
+template<typename EN, typename EK, typename A>
+void theta_update_sketch_base<EN, EK, A>::reset() {
+  const size_t cur_size = 1ULL << lg_cur_size_;
+  for (size_t i = 0; i < cur_size; ++i) {
+    if (EK()(entries_[i]) != 0) {
+      entries_[i].~EN();
+      EK()(entries_[i]) = 0;
+    }
+  }
+  const uint8_t starting_lg_size = theta_build_helper<true>::starting_sub_multiple(
+      lg_nom_size_ + 1, theta_constants::MIN_LG_K, static_cast<uint8_t>(rf_));
+  if (starting_lg_size != lg_cur_size_) {
+    allocator_.deallocate(entries_, cur_size);
+    lg_cur_size_ = starting_lg_size;
+    const size_t new_size = 1ULL << starting_lg_size;
+    entries_ = allocator_.allocate(new_size);
+    for (size_t i = 0; i < new_size; ++i) EK()(entries_[i]) = 0;
+  }
+  num_entries_ = 0;
+  theta_ = theta_build_helper<true>::starting_theta_from_p(p_);
+  is_empty_ = true;
+}
+
 template<typename EN, typename EK, typename A>
 void theta_update_sketch_base<EN, EK, A>::consolidate_non_empty(EN* entries, size_t size, size_t num) {
   // find the first empty slot
@@ -310,18 +340,12 @@ Derived& theta_base_builder<Derived, Allocator>::set_seed(uint64_t seed) {
 
 template<typename Derived, typename Allocator>
 uint64_t theta_base_builder<Derived, Allocator>::starting_theta() const {
-  if (p_ < 1) return static_cast<uint64_t>(theta_constants::MAX_THETA * p_);
-  return theta_constants::MAX_THETA;
+  return theta_build_helper<true>::starting_theta_from_p(p_);
 }
 
 template<typename Derived, typename Allocator>
 uint8_t theta_base_builder<Derived, Allocator>::starting_lg_size() const {
-  return starting_sub_multiple(lg_k_ + 1, MIN_LG_K, static_cast<uint8_t>(rf_));
-}
-
-template<typename Derived, typename Allocator>
-uint8_t theta_base_builder<Derived, Allocator>::starting_sub_multiple(uint8_t lg_tgt, uint8_t lg_min, uint8_t lg_rf) {
-  return (lg_tgt <= lg_min) ? lg_min : (lg_rf == 0) ? lg_tgt : ((lg_tgt - lg_min) % lg_rf) + lg_min;
+  return theta_build_helper<true>::starting_sub_multiple(lg_k_ + 1, MIN_LG_K, static_cast<uint8_t>(rf_));
 }
 
 // iterator

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

@@ -43,4 +43,5 @@ target_sources(theta_test
     theta_intersection_test.cpp
     theta_a_not_b_test.cpp
     theta_jaccard_similarity_test.cpp
+    theta_setop_test.cpp
 )