datasketches 0.2.0 → 0.2.4

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, pass_through_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();
@@ -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);
@@ -73,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_;
@@ -81,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);
@@ -92,11 +96,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 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;
-  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.
@@ -144,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,22 +24,25 @@
 #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),
 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;
   }
@@ -52,13 +55,14 @@ 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_),
 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) {
@@ -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_),
@@ -89,7 +94,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();
     }
@@ -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_);
@@ -136,18 +143,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);
@@ -175,13 +187,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>
@@ -192,29 +204,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
@@ -227,10 +239,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();
@@ -242,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
@@ -266,7 +301,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) {
@@ -301,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 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
 )

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;

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

@@ -100,6 +100,28 @@ TEST_CASE("theta jaccard: half overlap estimation mode", "[theta_sketch]") {
   REQUIRE(jc[2] == Approx(0.33).margin(0.01));
 }
 
+TEST_CASE("theta jaccard: half overlap estimation mode custom seed", "[theta_sketch]") {
+  const uint64_t seed = 123;
+  auto sk_a = update_theta_sketch::builder().set_seed(seed).build();
+  auto sk_b = update_theta_sketch::builder().set_seed(seed).build();
+  for (int i = 0; i < 10000; ++i) {
+    sk_a.update(i);
+    sk_b.update(i + 5000);
+  }
+
+  // update sketches
+  auto jc = theta_jaccard_similarity::jaccard(sk_a, sk_b, seed);
+  REQUIRE(jc[0] == Approx(0.33).margin(0.01));
+  REQUIRE(jc[1] == Approx(0.33).margin(0.01));
+  REQUIRE(jc[2] == Approx(0.33).margin(0.01));
+
+  // compact sketches
+  jc = theta_jaccard_similarity::jaccard(sk_a.compact(), sk_b.compact(), seed);
+  REQUIRE(jc[0] == Approx(0.33).margin(0.01));
+  REQUIRE(jc[1] == Approx(0.33).margin(0.01));
+  REQUIRE(jc[2] == Approx(0.33).margin(0.01));
+}
+
 /**
  * The distribution is quite tight, about +/- 0.7%, which is pretty good since the accuracy of the
  * underlying sketch is about +/- 1.56%.
@@ -107,7 +129,7 @@ TEST_CASE("theta jaccard: half overlap estimation mode", "[theta_sketch]") {
 TEST_CASE("theta jaccard: similarity test", "[theta_sketch]") {
   const int8_t min_lg_k = 12;
   const int u1 = 1 << 20;
-  const int u2 = u1 * 0.95;
+  const int u2 = static_cast<int>(u1 * 0.95);
   const double threshold = 0.943;
 
   auto expected = update_theta_sketch::builder().set_lg_k(min_lg_k).build();
@@ -120,6 +142,23 @@ TEST_CASE("theta jaccard: similarity test", "[theta_sketch]") {
   REQUIRE(theta_jaccard_similarity::similarity_test(actual, actual, threshold));
 }
 
+TEST_CASE("theta jaccard: similarity test custom seed", "[theta_sketch]") {
+  const int8_t min_lg_k = 12;
+  const int u1 = 1 << 20;
+  const int u2 = static_cast<int>(u1 * 0.95);
+  const double threshold = 0.943;
+  const uint64_t seed = 1234;
+
+  auto expected = update_theta_sketch::builder().set_lg_k(min_lg_k).set_seed(seed).build();
+  for (int i = 0; i < u1; ++i) expected.update(i);
+
+  auto actual = update_theta_sketch::builder().set_lg_k(min_lg_k).set_seed(seed).build();
+  for (int i = 0; i < u2; ++i) actual.update(i);
+
+  REQUIRE(theta_jaccard_similarity::similarity_test(actual, expected, threshold, seed));
+  REQUIRE(theta_jaccard_similarity::similarity_test(actual, actual, threshold, seed));
+}
+
 /**
  * The distribution is much looser here, about +/- 14%. This is due to the fact that intersections loose accuracy
  * as the ratio of intersection to the union becomes a small number.
@@ -127,7 +166,7 @@ TEST_CASE("theta jaccard: similarity test", "[theta_sketch]") {
 TEST_CASE("theta jaccard: dissimilarity test", "[theta_sketch]") {
   const int8_t min_lg_k = 12;
   const int u1 = 1 << 20;
-  const int u2 = u1 * 0.05;
+  const int u2 = static_cast<int>(u1 * 0.05);
   const double threshold = 0.061;
 
   auto expected = update_theta_sketch::builder().set_lg_k(min_lg_k).build();
@@ -140,4 +179,21 @@ TEST_CASE("theta jaccard: dissimilarity test", "[theta_sketch]") {
   REQUIRE_FALSE(theta_jaccard_similarity::dissimilarity_test(actual, actual, threshold));
 }
 
+TEST_CASE("theta jaccard: dissimilarity test custom seed", "[theta_sketch]") {
+  const int8_t min_lg_k = 12;
+  const int u1 = 1 << 20;
+  const int u2 = static_cast<int>(u1 * 0.05);
+  const double threshold = 0.061;
+  const uint64_t seed = 1234;
+
+  auto expected = update_theta_sketch::builder().set_lg_k(min_lg_k).set_seed(seed).build();
+  for (int i = 0; i < u1; ++i) expected.update(i);
+
+  auto actual = update_theta_sketch::builder().set_lg_k(min_lg_k).set_seed(seed).build();
+  for (int i = 0; i < u2; ++i) actual.update(i);
+
+  REQUIRE(theta_jaccard_similarity::dissimilarity_test(actual, expected, threshold, seed));
+  REQUIRE_FALSE(theta_jaccard_similarity::dissimilarity_test(actual, actual, threshold, seed));
+}
+
 } /* namespace datasketches */