datasketches 0.1.2 → 0.2.3

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

@@ -20,103 +20,70 @@
 #ifndef THETA_UNION_HPP_
 #define THETA_UNION_HPP_
 
-#include <memory>
-#include <functional>
-#include <climits>
-
+#include "serde.hpp"
 #include "theta_sketch.hpp"
+#include "theta_union_base.hpp"
 
 namespace datasketches {
 
-/*
- * author Alexander Saydakov
- * author Lee Rhodes
- * author Kevin Lang
- */
-
-template<typename A>
+template<typename Allocator = std::allocator<uint64_t>>
 class theta_union_alloc {
 public:
-  class builder;
+  using Entry = uint64_t;
+  using ExtractKey = trivial_extract_key;
+  using Sketch = theta_sketch_alloc<Allocator>;
+  using CompactSketch = compact_theta_sketch_alloc<Allocator>;
+  using resize_factor = theta_constants::resize_factor;
+
+  struct nop_policy {
+    void operator()(uint64_t internal_entry, uint64_t incoming_entry) const {
+      unused(internal_entry);
+      unused(incoming_entry);
+    }
+  };
+  using State = theta_union_base<Entry, ExtractKey, nop_policy, Sketch, CompactSketch, Allocator>;
 
   // No constructor here. Use builder instead.
+  class builder;
 
   /**
    * This method is to update the union with a given sketch
    * @param sketch to update the union with
    */
-  void update(const theta_sketch_alloc<A>& sketch);
+  template<typename FwdSketch>
+  void update(FwdSketch&& sketch);
 
   /**
    * This method produces a copy of the current state of the union as a compact sketch.
    * @param ordered optional flag to specify if ordered sketch should be produced
    * @return the result of the union
    */
-  compact_theta_sketch_alloc<A> get_result(bool ordered = true) const;
+  CompactSketch get_result(bool ordered = true) const;
 
 private:
-  bool is_empty_;
-  uint64_t theta_;
-  update_theta_sketch_alloc<A> state_;
+  State state_;
 
   // for builder
-  theta_union_alloc(uint64_t theta, update_theta_sketch_alloc<A>&& state);
+  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);
 };
 
-// builder
-
 template<typename A>
-class theta_union_alloc<A>::builder {
+class theta_union_alloc<A>::builder: public theta_base_builder<builder, A> {
 public:
-  typedef typename update_theta_sketch_alloc<A>::resize_factor resize_factor;
-
-  /**
-   * Set log2(k), where k is a nominal number of entries in the sketch
-   * @param lg_k base 2 logarithm of nominal number of entries
-   * @return this builder
-   */
-  builder& set_lg_k(uint8_t lg_k);
-
-  /**
-   * Set resize factor for the internal hash table (defaults to 8)
-   * @param rf resize factor
-   * @return this builder
-   */
-  builder& set_resize_factor(resize_factor rf);
-
-  /**
-   * Set sampling probability (initial theta). The default is 1, so the sketch retains
-   * all entries until it reaches the limit, at which point it goes into the estimation mode
-   * and reduces the effective sampling probability (theta) as necessary.
-   * @param p sampling probability
-   * @return this builder
-   */
-  builder& set_p(float p);
-
-  /**
-   * Set the seed for the hash function. Should be used carefully if needed.
-   * Sketches produced with different seed are not compatible
-   * and cannot be mixed in set operations.
-   * @param seed hash seed
-   * @return this builder
-   */
-  builder& set_seed(uint64_t seed);
+  builder(const A& allocator = A());
 
   /**
    * This is to create an instance of the union with predefined parameters.
-   * @return and instance of the union
+   * @return an instance of the union
    */
   theta_union_alloc<A> build() const;
-
-private:
-  typename update_theta_sketch_alloc<A>::builder sketch_builder;
 };
 
 // alias with default allocator for convenience
-typedef theta_union_alloc<std::allocator<void>> theta_union;
+using theta_union = theta_union_alloc<std::allocator<uint64_t>>;
 
 } /* namespace datasketches */
 
 #include "theta_union_impl.hpp"
 
-# endif
+#endif

data/vendor/datasketches-cpp/{tuple → theta}/include/theta_union_base.hpp

@@ -30,7 +30,7 @@ template<
   typename Policy,
   typename Sketch,
   typename CompactSketch,
-  typename Allocator = std::allocator<Entry>
+  typename Allocator
 >
 class theta_union_base {
 public:

data/vendor/datasketches-cpp/{tuple → theta}/include/theta_union_base_impl.hpp

@@ -17,6 +17,9 @@
  * under the License.
  */
 
+#ifndef THETA_UNION_BASE_IMPL_HPP_
+#define THETA_UNION_BASE_IMPL_HPP_
+
 #include <algorithm>
 
 #include "conditional_forward.hpp"
@@ -40,7 +43,7 @@ void theta_union_base<EN, EK, P, S, CS, A>::update(SS&& sketch) {
   if (sketch.get_theta64() < union_theta_) union_theta_ = sketch.get_theta64();
   for (auto& entry: sketch) {
     const uint64_t hash = EK()(entry);
-    if (hash < union_theta_) {
+    if (hash < union_theta_ && hash < table_.theta_) {
       auto result = table_.find(hash);
       if (!result.second) {
         table_.insert(result.first, conditional_forward<SS>(entry));
@@ -82,3 +85,5 @@ const P& theta_union_base<EN, EK, P, S, CS, A>::get_policy() const {
 }
 
 } /* namespace datasketches */
+
+#endif

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

@@ -22,86 +22,30 @@
 
 namespace datasketches {
 
-/*
- * author Alexander Saydakov
- * author Lee Rhodes
- * author Kevin Lang
- */
-
-template<typename A>
-theta_union_alloc<A>::theta_union_alloc(uint64_t theta, update_theta_sketch_alloc<A>&& state):
-is_empty_(true), theta_(theta), state_(std::move(state)) {}
-
-template<typename A>
-void theta_union_alloc<A>::update(const theta_sketch_alloc<A>& sketch) {
-  if (sketch.is_empty()) return;
-  if (sketch.get_seed_hash() != state_.get_seed_hash()) throw std::invalid_argument("seed hash mismatch");
-  is_empty_ = false;
-  if (sketch.get_theta64() < theta_) theta_ = sketch.get_theta64();
-  if (sketch.is_ordered()) {
-    for (auto hash: sketch) {
-      if (hash >= theta_) break; // early stop
-      state_.internal_update(hash);
-    }
-  } else {
-    for (auto hash: sketch) if (hash < theta_) state_.internal_update(hash);
-  }
-  if (state_.get_theta64() < theta_) theta_ = state_.get_theta64();
-}
-
 template<typename A>
-compact_theta_sketch_alloc<A> theta_union_alloc<A>::get_result(bool ordered) const {
-  if (is_empty_) return state_.compact(ordered);
-  const uint32_t nom_num_keys = 1 << state_.lg_nom_size_;
-  if (theta_ >= state_.theta_ && state_.get_num_retained() <= nom_num_keys) return state_.compact(ordered);
-  uint64_t theta = std::min(theta_, state_.get_theta64());
-  vector_u64<A> keys(state_.get_num_retained());
-  uint32_t num_keys = 0;
-  for (auto key: state_) {
-    if (key < theta) keys[num_keys++] = key;
-  }
-  if (num_keys > nom_num_keys) {
-    std::nth_element(keys.begin(), keys.begin() + nom_num_keys, keys.begin() + num_keys);
-    theta = keys[nom_num_keys];
-    num_keys = nom_num_keys;
-  }
-  if (num_keys != state_.get_num_retained()) {
-    keys.resize(num_keys);
-  }
-  if (ordered) std::sort(keys.begin(), keys.end());
-  return compact_theta_sketch_alloc<A>(false, theta, std::move(keys), state_.get_seed_hash(), ordered);
-}
-
-// builder
+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)
+{}
 
 template<typename A>
-typename theta_union_alloc<A>::builder& theta_union_alloc<A>::builder::set_lg_k(uint8_t lg_k) {
-  sketch_builder.set_lg_k(lg_k);
-  return *this;
+template<typename SS>
+void theta_union_alloc<A>::update(SS&& sketch) {
+  state_.update(std::forward<SS>(sketch));
 }
 
 template<typename A>
-typename theta_union_alloc<A>::builder& theta_union_alloc<A>::builder::set_resize_factor(resize_factor rf) {
-  sketch_builder.set_resize_factor(rf);
-  return *this;
+auto theta_union_alloc<A>::get_result(bool ordered) const -> CompactSketch {
+  return state_.get_result(ordered);
 }
 
 template<typename A>
-typename theta_union_alloc<A>::builder& theta_union_alloc<A>::builder::set_p(float p) {
-  sketch_builder.set_p(p);
-  return *this;
-}
-
-template<typename A>
-typename theta_union_alloc<A>::builder& theta_union_alloc<A>::builder::set_seed(uint64_t seed) {
-  sketch_builder.set_seed(seed);
-  return *this;
-}
+theta_union_alloc<A>::builder::builder(const A& allocator): theta_base_builder<builder, A>(allocator) {}
 
 template<typename A>
-theta_union_alloc<A> theta_union_alloc<A>::builder::build() const {
-  update_theta_sketch_alloc<A> sketch = sketch_builder.build();
-  return theta_union_alloc(sketch.get_theta64(), std::move(sketch));
+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_);
 }
 
 } /* namespace datasketches */

data/vendor/datasketches-cpp/{tuple → theta}/include/theta_update_sketch_base.hpp

@@ -34,7 +34,7 @@ namespace datasketches {
 template<
   typename Entry,
   typename ExtractKey,
-  typename Allocator = std::allocator<Entry>
+  typename Allocator
 >
 struct theta_update_sketch_base {
   using resize_factor = theta_constants::resize_factor;
@@ -53,6 +53,8 @@ struct theta_update_sketch_base {
   inline uint64_t hash_and_screen(const void* data, size_t length);
 
   inline std::pair<iterator, bool> find(uint64_t key) const;
+  static inline std::pair<iterator, bool> find(Entry* entries, uint8_t lg_size, uint64_t key);
+
 
   template<typename FwdEntry>
   inline void insert(iterator it, FwdEntry&& entry);
@@ -92,11 +94,14 @@ 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.
   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;
-  static const uint8_t DEFAULT_LG_K = 12;
-  static const resize_factor DEFAULT_RESIZE_FACTOR = resize_factor::X8;
+  // 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.
@@ -147,7 +152,7 @@ protected:
   static uint8_t starting_sub_multiple(uint8_t lg_tgt, uint8_t lg_min, uint8_t lg_rf);
 };
 
-// key extractors
+// key extractor
 
 struct trivial_extract_key {
   template<typename T>
@@ -156,17 +161,7 @@ struct trivial_extract_key {
   }
 };
 
-template<typename K, typename V>
-struct pair_extract_key {
-  K& operator()(std::pair<K, V>& entry) const {
-    return entry.first;
-  }
-  const K& operator()(const std::pair<K, V>& entry) const {
-    return entry.first;
-  }
-};
-
-// not zero
+// key not zero
 
 template<typename Entry, typename ExtractKey>
 class key_not_zero {
@@ -195,12 +190,6 @@ static inline uint64_t compute_hash(const void* data, size_t length, uint64_t se
   return (hashes.h1 >> 1); // Java implementation does unsigned shift >>> to make values positive
 }
 
-static inline uint16_t compute_seed_hash(uint64_t seed) {
-  HashState hashes;
-  MurmurHash3_x64_128(&seed, sizeof(seed), 0, hashes);
-  return hashes.h1;
-}
-
 // iterators
 
 template<typename Entry, typename ExtractKey>

data/vendor/datasketches-cpp/{tuple → theta}/include/theta_update_sketch_base_impl.hpp

@@ -17,6 +17,9 @@
  * under the License.
  */
 
+#ifndef THETA_UPDATE_SKETCH_BASE_IMPL_HPP_
+#define THETA_UPDATE_SKETCH_BASE_IMPL_HPP_
+
 #include <iostream>
 #include <sstream>
 #include <algorithm>
@@ -36,7 +39,7 @@ seed_(seed),
 entries_(nullptr)
 {
   if (lg_cur_size > 0) {
-    const size_t size = 1 << lg_cur_size;
+    const size_t size = 1ULL << lg_cur_size;
     entries_ = allocator_.allocate(size);
     for (size_t i = 0; i < size; ++i) EK()(entries_[i]) = 0;
   }
@@ -55,7 +58,7 @@ seed_(other.seed_),
 entries_(nullptr)
 {
   if (other.entries_ != nullptr) {
-    const size_t size = 1 << lg_cur_size_;
+    const size_t size = 1ULL << lg_cur_size_;
     entries_ = allocator_.allocate(size);
     for (size_t i = 0; i < size; ++i) {
       if (EK()(other.entries_[i]) != 0) {
@@ -69,7 +72,7 @@ entries_(nullptr)
 
 template<typename EN, typename EK, typename A>
 theta_update_sketch_base<EN, EK, A>::theta_update_sketch_base(theta_update_sketch_base&& other) noexcept:
-allocator_(other.allocator_),
+allocator_(std::move(other.allocator_)),
 is_empty_(other.is_empty_),
 lg_cur_size_(other.lg_cur_size_),
 lg_nom_size_(other.lg_nom_size_),
@@ -86,7 +89,7 @@ template<typename EN, typename EK, typename A>
 theta_update_sketch_base<EN, EK, A>::~theta_update_sketch_base()
 {
   if (entries_ != nullptr) {
-    const size_t size = 1 << lg_cur_size_;
+    const size_t size = 1ULL << lg_cur_size_;
     for (size_t i = 0; i < size; ++i) {
       if (EK()(entries_[i]) != 0) entries_[i].~EN();
     }
@@ -133,18 +136,23 @@ uint64_t theta_update_sketch_base<EN, EK, A>::hash_and_screen(const void* data,
 
 template<typename EN, typename EK, typename A>
 auto theta_update_sketch_base<EN, EK, A>::find(uint64_t key) const -> std::pair<iterator, bool> {
-  const size_t size = 1 << lg_cur_size_;
-  const size_t mask = size - 1;
-  const uint32_t stride = get_stride(key, lg_cur_size_);
+  return find(entries_, lg_cur_size_, key);
+}
+
+template<typename EN, typename EK, typename A>
+auto theta_update_sketch_base<EN, EK, A>::find(EN* entries, uint8_t lg_size, uint64_t key) -> std::pair<iterator, bool> {
+  const uint32_t size = 1 << lg_size;
+  const uint32_t mask = size - 1;
+  const uint32_t stride = get_stride(key, lg_size);
   uint32_t index = static_cast<uint32_t>(key) & mask;
   // search for duplicate or zero
   const uint32_t loop_index = index;
   do {
-    const uint64_t probe = EK()(entries_[index]);
+    const uint64_t probe = EK()(entries[index]);
     if (probe == 0) {
-      return std::pair<iterator, bool>(&entries_[index], false);
+      return std::pair<iterator, bool>(&entries[index], false);
     } else if (probe == key) {
-      return std::pair<iterator, bool>(&entries_[index], true);
+      return std::pair<iterator, bool>(&entries[index], true);
     }
     index = (index + stride) & mask;
   } while (index != loop_index);
@@ -172,13 +180,13 @@ auto theta_update_sketch_base<EN, EK, A>::begin() const -> iterator {
 
 template<typename EN, typename EK, typename A>
 auto theta_update_sketch_base<EN, EK, A>::end() const -> iterator {
-  return &entries_[1 << lg_cur_size_];
+  return &entries_[1ULL << lg_cur_size_];
 }
 
 template<typename EN, typename EK, typename A>
 uint32_t theta_update_sketch_base<EN, EK, A>::get_capacity(uint8_t lg_cur_size, uint8_t lg_nom_size) {
   const double fraction = (lg_cur_size <= lg_nom_size) ? RESIZE_THRESHOLD : REBUILD_THRESHOLD;
-  return std::floor(fraction * (1 << lg_cur_size));
+  return static_cast<uint32_t>(std::floor(fraction * (1 << lg_cur_size)));
 }
 
 template<typename EN, typename EK, typename A>
@@ -189,29 +197,29 @@ uint32_t theta_update_sketch_base<EN, EK, A>::get_stride(uint64_t key, uint8_t l
 
 template<typename EN, typename EK, typename A>
 void theta_update_sketch_base<EN, EK, A>::resize() {
-  const size_t old_size = 1 << lg_cur_size_;
-  const uint8_t lg_tgt_size = lg_nom_size_ + 1;
-  const uint8_t factor = std::max(1, std::min(static_cast<int>(rf_), lg_tgt_size - lg_cur_size_));
-  lg_cur_size_ += factor;
-  const size_t new_size = 1 << lg_cur_size_;
-  EN* old_entries = entries_;
-  entries_ = allocator_.allocate(new_size);
-  for (size_t i = 0; i < new_size; ++i) EK()(entries_[i]) = 0;
-  num_entries_ = 0;
+  const size_t old_size = 1ULL << lg_cur_size_;
+  const uint8_t lg_new_size = std::min<uint8_t>(lg_cur_size_ + static_cast<uint8_t>(rf_), lg_nom_size_ + 1);
+  const size_t new_size = 1ULL << lg_new_size;
+  EN* new_entries = allocator_.allocate(new_size);
+  for (size_t i = 0; i < new_size; ++i) EK()(new_entries[i]) = 0;
   for (size_t i = 0; i < old_size; ++i) {
-    const uint64_t key = EK()(old_entries[i]);
+    const uint64_t key = EK()(entries_[i]);
     if (key != 0) {
-      insert(find(key).first, std::move(old_entries[i])); // consider a special insert with no comparison
-      old_entries[i].~EN();
+      // always finds an empty slot in a larger table
+      new (find(new_entries, lg_new_size, key).first) EN(std::move(entries_[i]));
+      entries_[i].~EN();
+      EK()(entries_[i]) = 0;
     }
   }
-  allocator_.deallocate(old_entries, old_size);
+  std::swap(entries_, new_entries);
+  lg_cur_size_ = lg_new_size;
+  allocator_.deallocate(new_entries, old_size);
 }
 
 // assumes number of entries > nominal size
 template<typename EN, typename EK, typename A>
 void theta_update_sketch_base<EN, EK, A>::rebuild() {
-  const size_t size = 1 << lg_cur_size_;
+  const size_t size = 1ULL << lg_cur_size_;
   const uint32_t nominal_size = 1 << lg_nom_size_;
 
   // empty entries have uninitialized payloads
@@ -224,10 +232,10 @@ void theta_update_sketch_base<EN, EK, A>::rebuild() {
   const size_t num_old_entries = num_entries_;
   entries_ = allocator_.allocate(size);
   for (size_t i = 0; i < size; ++i) EK()(entries_[i]) = 0;
-  num_entries_ = 0;
+  num_entries_ = nominal_size;
   // relies on consolidating non-empty entries to the front
   for (size_t i = 0; i < nominal_size; ++i) {
-    insert(find(EK()(old_entries[i])).first, std::move(old_entries[i])); // consider a special insert with no comparison
+    new (find(EK()(old_entries[i])).first) EN(std::move(old_entries[i]));
     old_entries[i].~EN();
   }
   for (size_t i = nominal_size; i < num_old_entries; ++i) old_entries[i].~EN();
@@ -263,7 +271,11 @@ void theta_update_sketch_base<EN, EK, A>::consolidate_non_empty(EN* entries, siz
 
 template<typename Derived, typename Allocator>
 theta_base_builder<Derived, Allocator>::theta_base_builder(const Allocator& allocator):
-allocator_(allocator), lg_k_(DEFAULT_LG_K), rf_(DEFAULT_RESIZE_FACTOR), p_(1), seed_(DEFAULT_SEED) {}
+allocator_(allocator),
+lg_k_(theta_constants::DEFAULT_LG_K),
+rf_(theta_constants::DEFAULT_RESIZE_FACTOR),
+p_(1),
+seed_(DEFAULT_SEED) {}
 
 template<typename Derived, typename Allocator>
 Derived& theta_base_builder<Derived, Allocator>::set_lg_k(uint8_t lg_k) {
@@ -298,7 +310,7 @@ 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 theta_constants::MAX_THETA * p_;
+  if (p_ < 1) return static_cast<uint64_t>(theta_constants::MAX_THETA * p_);
   return theta_constants::MAX_THETA;
 }
 
@@ -387,3 +399,5 @@ auto theta_const_iterator<Entry, ExtractKey>::operator*() const -> const Entry&
 }
 
 } /* namespace datasketches */
+
+#endif

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

@@ -42,4 +42,5 @@ target_sources(theta_test
     theta_union_test.cpp
     theta_intersection_test.cpp
     theta_a_not_b_test.cpp
+    theta_jaccard_similarity_test.cpp
 )

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

@@ -37,7 +37,7 @@ TEST_CASE("theta a-not-b: empty", "[theta_a_not_b]") {
 TEST_CASE("theta a-not-b: non empty no retained keys", "[theta_a_not_b]") {
   update_theta_sketch a = update_theta_sketch::builder().build();
   a.update(1);
-  update_theta_sketch b = update_theta_sketch::builder().set_p(0.001).build();
+  update_theta_sketch b = update_theta_sketch::builder().set_p(0.001f).build();
   theta_a_not_b a_not_b;
 
   // B is still empty
@@ -167,6 +167,28 @@ TEST_CASE("theta a-not-b: estimation mode half overlap", "[theta_a_not_b]") {
   REQUIRE(result.get_estimate() == Approx(5000).margin(5000 * 0.02));
 }
 
+TEST_CASE("theta a-not-b: estimation mode half overlap wrapped compact", "[theta_a_not_b]") {
+  update_theta_sketch a = update_theta_sketch::builder().build();
+  int value = 0;
+  for (int i = 0; i < 10000; i++) a.update(value++);
+  auto bytes_a = a.compact().serialize();
+
+  update_theta_sketch b = update_theta_sketch::builder().build();
+  value = 5000;
+  for (int i = 0; i < 10000; i++) b.update(value++);
+  auto bytes_b = b.compact().serialize();
+
+  theta_a_not_b a_not_b;
+
+  auto result = a_not_b.compute(
+    wrapped_compact_theta_sketch::wrap(bytes_a.data(), bytes_a.size()),
+    wrapped_compact_theta_sketch::wrap(bytes_b.data(), bytes_b.size())
+  );
+  REQUIRE_FALSE(result.is_empty());
+  REQUIRE(result.is_estimation_mode());
+  REQUIRE(result.get_estimate() == Approx(5000).margin(5000 * 0.02));
+}
+
 TEST_CASE("theta a-not-b: estimation mode disjoint", "[theta_a_not_b]") {
   update_theta_sketch a = update_theta_sketch::builder().build();
   int value = 0;

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

@@ -48,7 +48,7 @@ TEST_CASE("theta intersection: empty", "[theta_intersection]") {
 }
 
 TEST_CASE("theta intersection: non empty no retained keys", "[theta_intersection]") {
-  update_theta_sketch sketch = update_theta_sketch::builder().set_p(0.001).build();
+  update_theta_sketch sketch = update_theta_sketch::builder().set_p(0.001f).build();
   sketch.update(1);
   theta_intersection intersection;
   intersection.update(sketch);
@@ -174,6 +174,26 @@ TEST_CASE("theta intersection: estimation mode half overlap ordered", "[theta_in
   REQUIRE(result.get_estimate() == Approx(5000).margin(5000 * 0.02));
 }
 
+TEST_CASE("theta intersection: estimation mode half overlap ordered wrapped compact", "[theta_intersection]") {
+  update_theta_sketch sketch1 = update_theta_sketch::builder().build();
+  int value = 0;
+  for (int i = 0; i < 10000; i++) sketch1.update(value++);
+  auto bytes1 = sketch1.compact().serialize();
+
+  update_theta_sketch sketch2 = update_theta_sketch::builder().build();
+  value = 5000;
+  for (int i = 0; i < 10000; i++) sketch2.update(value++);
+  auto bytes2 = sketch2.compact().serialize();
+
+  theta_intersection intersection;
+  intersection.update(wrapped_compact_theta_sketch::wrap(bytes1.data(), bytes1.size()));
+  intersection.update(wrapped_compact_theta_sketch::wrap(bytes2.data(), bytes2.size()));
+  compact_theta_sketch result = intersection.get_result();
+  REQUIRE_FALSE(result.is_empty());
+  REQUIRE(result.is_estimation_mode());
+  REQUIRE(result.get_estimate() == Approx(5000).margin(5000 * 0.02));
+}
+
 TEST_CASE("theta intersection: estimation mode disjoint unordered", "[theta_intersection]") {
   update_theta_sketch sketch1 = update_theta_sketch::builder().build();
   int value = 0;