datasketches 0.3.1 → 0.4.0

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

@@ -29,6 +29,7 @@
 namespace datasketches {
 
 /**
+ * Bounds on ratios in sampled sets.
  * This class is used to compute the bounds on the estimate of the ratio <i>|B| / |A|</i>, where:
  * <ul>
  * <li><i>|A|</i> is the unknown size of a set <i>A</i> of unique identifiers.</li>

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

@@ -28,6 +28,7 @@
 namespace datasketches {
 
 /**
+ * Bounds on ratios in Theta sketched sets.
  * This is to compute the bounds on the estimate of the ratio <i>B / A</i>, where:
  * <ul>
  * <li><i>A</i> is a Theta Sketch of population <i>PopA</i>.</li>
@@ -50,8 +51,8 @@ class bounds_on_ratios_in_theta_sketched_sets {
 public:
   /**
    * Gets the approximate lower bound for B over A based on a 95% confidence interval
-   * @param sketchA the sketch A
-   * @param sketchB the sketch B
+   * @param sketch_a the sketch A
+   * @param sketch_b the sketch B
    * @return the approximate lower bound for B over A
    */
   template<typename SketchA, typename SketchB>
@@ -72,8 +73,8 @@ public:
 
   /**
    * Gets the approximate upper bound for B over A based on a 95% confidence interval
-   * @param sketchA the sketch A
-   * @param sketchB the sketch B
+   * @param sketch_a the sketch A
+   * @param sketch_b the sketch B
    * @return the approximate upper bound for B over A
    */
   template<typename SketchA, typename SketchB>
@@ -94,8 +95,8 @@ public:
 
   /**
    * Gets the estimate for B over A
-   * @param sketchA the sketch A
-   * @param sketchB the sketch B
+   * @param sketch_a the sketch A
+   * @param sketch_b the sketch B
    * @return the estimate for B over A
    */
   template<typename SketchA, typename SketchB>

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

@@ -20,7 +20,7 @@
 #ifndef COMPACT_THETA_SKETCH_PARSER_HPP_
 #define COMPACT_THETA_SKETCH_PARSER_HPP_
 
-#include <stdint.h>
+#include <cstdint>
 
 namespace datasketches {
 
@@ -33,7 +33,8 @@ public:
     uint16_t seed_hash;
     uint32_t num_entries;
     uint64_t theta;
-    const uint64_t* entries;
+    const void* entries_start_ptr;
+    uint8_t entry_bits;
   };
 
   static compact_theta_sketch_data parse(const void* ptr, size_t size, uint64_t seed, bool dump_on_error = false);
@@ -45,18 +46,23 @@ private:
   static const size_t COMPACT_SKETCH_TYPE_BYTE = 2;
   static const size_t COMPACT_SKETCH_FLAGS_BYTE = 5;
   static const size_t COMPACT_SKETCH_SEED_HASH_U16 = 3;
-  static const size_t COMPACT_SKETCH_NUM_ENTRIES_U32 = 2;
-  static const size_t COMPACT_SKETCH_SINGLE_ENTRY_U64 = 1;
-  static const size_t COMPACT_SKETCH_ENTRIES_EXACT_U64 = 2;
-  static const size_t COMPACT_SKETCH_THETA_U64 = 2;
-  static const size_t COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 = 3;
+  static const size_t COMPACT_SKETCH_SINGLE_ENTRY_U64 = 1; // ver 3
+  static const size_t COMPACT_SKETCH_NUM_ENTRIES_U32 = 2; // ver 1-3
+  static const size_t COMPACT_SKETCH_ENTRIES_EXACT_U64 = 2; // ver 1-3
+  static const size_t COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 = 3; // ver 1-3
+  static const size_t COMPACT_SKETCH_THETA_U64 = 2; // ver 1-3
+  static const size_t COMPACT_SKETCH_V4_ENTRY_BITS_BYTE = 3;
+  static const size_t COMPACT_SKETCH_V4_NUM_ENTRIES_BYTES_BYTE = 4;
+  static const size_t COMPACT_SKETCH_V4_THETA_U64 = 1;
+  static const size_t COMPACT_SKETCH_V4_PACKED_DATA_EXACT_BYTE = 8;
+  static const size_t COMPACT_SKETCH_V4_PACKED_DATA_ESTIMATION_BYTE = 16;
 
   static const uint8_t COMPACT_SKETCH_IS_EMPTY_FLAG = 2;
   static const uint8_t COMPACT_SKETCH_IS_ORDERED_FLAG = 4;
 
-  static const uint8_t COMPACT_SKETCH_SERIAL_VERSION = 3;
   static const uint8_t COMPACT_SKETCH_TYPE = 3;
 
+  static void check_memory_size(const void* ptr, size_t actual_bytes, size_t expected_bytes, bool dump_on_error);
   static std::string hex_dump(const uint8_t* ptr, size_t size);
 };
 

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

@@ -26,106 +26,120 @@
 
 namespace datasketches {
 
+template<typename T>
+T whole_bytes_to_hold_bits(T bits) {
+  static_assert(std::is_integral<T>::value, "integral type expected");
+  return (bits >> 3) + ((bits & 7) > 0);
+}
+
 template<bool dummy>
 auto compact_theta_sketch_parser<dummy>::parse(const void* ptr, size_t size, uint64_t seed, bool dump_on_error) -> compact_theta_sketch_data {
-  if (size < 8) throw std::out_of_range("at least 8 bytes expected, actual " + std::to_string(size)
-      + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
-
+  check_memory_size(ptr, size, 8, dump_on_error);
+  checker<true>::check_sketch_type(reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_TYPE_BYTE], COMPACT_SKETCH_TYPE);
   uint8_t serial_version = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_SERIAL_VERSION_BYTE];
-
   switch(serial_version) {
-  case COMPACT_SKETCH_SERIAL_VERSION: {
-      checker<true>::check_sketch_type(reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_TYPE_BYTE], COMPACT_SKETCH_TYPE);
+  case 4: {
+    // version 4 sketches are ordered and always have entries (single item in exact mode is v3)
+    const uint16_t seed_hash = reinterpret_cast<const uint16_t*>(ptr)[COMPACT_SKETCH_SEED_HASH_U16];
+    checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
+    const bool has_theta = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_PRE_LONGS_BYTE] > 1;
+    uint64_t theta = theta_constants::MAX_THETA;
+    if (has_theta) {
+      check_memory_size(ptr, size, 16, dump_on_error);
+      theta = reinterpret_cast<const uint64_t*>(ptr)[COMPACT_SKETCH_V4_THETA_U64];
+    }
+    const uint8_t num_entries_bytes = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_V4_NUM_ENTRIES_BYTES_BYTE];
+    size_t data_offset_bytes = has_theta ? COMPACT_SKETCH_V4_PACKED_DATA_ESTIMATION_BYTE : COMPACT_SKETCH_V4_PACKED_DATA_EXACT_BYTE;
+    check_memory_size(ptr, size, data_offset_bytes + num_entries_bytes, dump_on_error);
+    uint32_t num_entries = 0;
+    const uint8_t* num_entries_ptr = reinterpret_cast<const uint8_t*>(ptr) + data_offset_bytes;
+    for (unsigned i = 0; i < num_entries_bytes; ++i) {
+      num_entries |= (*num_entries_ptr++) << (i << 3);
+    }
+    data_offset_bytes += num_entries_bytes;
+    const uint8_t entry_bits = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_V4_ENTRY_BITS_BYTE];
+    const size_t expected_bits = entry_bits * num_entries;
+    const size_t expected_size_bytes = data_offset_bytes + whole_bytes_to_hold_bits(expected_bits);
+    check_memory_size(ptr, size, expected_size_bytes, dump_on_error);
+    return {false, true, seed_hash, num_entries, theta,
+      reinterpret_cast<const uint8_t*>(ptr) + data_offset_bytes, entry_bits};
+  }
+  case 3: {
       uint64_t theta = theta_constants::MAX_THETA;
       const uint16_t seed_hash = reinterpret_cast<const uint16_t*>(ptr)[COMPACT_SKETCH_SEED_HASH_U16];
       if (reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_FLAGS_BYTE] & (1 << COMPACT_SKETCH_IS_EMPTY_FLAG)) {
-        return {true, true, seed_hash, 0, theta, nullptr};
+        return {true, true, seed_hash, 0, theta, nullptr, 64};
       }
       checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
       const bool has_theta = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_PRE_LONGS_BYTE] > 2;
       if (has_theta) {
-        if (size < 16) throw std::out_of_range("at least 16 bytes expected, actual " + std::to_string(size));
+        check_memory_size(ptr, size, (COMPACT_SKETCH_THETA_U64 + 1) * sizeof(uint64_t), dump_on_error);
         theta = reinterpret_cast<const uint64_t*>(ptr)[COMPACT_SKETCH_THETA_U64];
       }
       if (reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_PRE_LONGS_BYTE] == 1) {
-        if (size < 16) throw std::out_of_range("at least 16 bytes expected, actual " + std::to_string(size));
-        return {false, true, seed_hash, 1, theta, reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_SINGLE_ENTRY_U64};
+        check_memory_size(ptr, size, 16, dump_on_error);
+        return {false, true, seed_hash, 1, theta, reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_SINGLE_ENTRY_U64, 64};
       }
       const uint32_t num_entries = reinterpret_cast<const uint32_t*>(ptr)[COMPACT_SKETCH_NUM_ENTRIES_U32];
       const size_t entries_start_u64 = has_theta ? COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 : COMPACT_SKETCH_ENTRIES_EXACT_U64;
       const uint64_t* entries = reinterpret_cast<const uint64_t*>(ptr) + entries_start_u64;
       const size_t expected_size_bytes = (entries_start_u64 + num_entries) * sizeof(uint64_t);
-      if (size < expected_size_bytes) {
-        throw std::out_of_range(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
-            + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
-      }
+      check_memory_size(ptr, size, expected_size_bytes, dump_on_error);
       const bool is_ordered = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_FLAGS_BYTE] & (1 << COMPACT_SKETCH_IS_ORDERED_FLAG);
-      return {false, is_ordered, seed_hash, num_entries, theta, entries};
+      return {false, is_ordered, seed_hash, num_entries, theta, entries, 64};
   }
   case 1:  {
       uint16_t seed_hash = compute_seed_hash(seed);
-      checker<true>::check_sketch_type(reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_TYPE_BYTE], COMPACT_SKETCH_TYPE);
       const uint32_t num_entries = reinterpret_cast<const uint32_t*>(ptr)[COMPACT_SKETCH_NUM_ENTRIES_U32];
       uint64_t theta = reinterpret_cast<const uint64_t*>(ptr)[COMPACT_SKETCH_THETA_U64];
       bool is_empty = (num_entries == 0) && (theta == theta_constants::MAX_THETA);
-      if (is_empty) {
-          return {true, true, seed_hash, 0, theta, nullptr};
-      }
+      if (is_empty) return {true, true, seed_hash, 0, theta, nullptr, 64};
       const uint64_t* entries = reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_ENTRIES_ESTIMATION_U64;
       const size_t expected_size_bytes = (COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 + num_entries) * sizeof(uint64_t);
-      if (size < expected_size_bytes) {
-        throw std::out_of_range(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
-            + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
-      }
-      return {false, true, seed_hash, num_entries, theta, entries};
+      check_memory_size(ptr, size, expected_size_bytes, dump_on_error);
+      return {false, true, seed_hash, num_entries, theta, entries, 64};
   }
   case 2:  {
-      uint8_t preamble_size =  reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_PRE_LONGS_BYTE];
-      checker<true>::check_sketch_type(reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_TYPE_BYTE], COMPACT_SKETCH_TYPE);
+      uint8_t preamble_size = reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_PRE_LONGS_BYTE];
       const uint16_t seed_hash = reinterpret_cast<const uint16_t*>(ptr)[COMPACT_SKETCH_SEED_HASH_U16];
       checker<true>::check_seed_hash(seed_hash, compute_seed_hash(seed));
       if (preamble_size == 1) {
-          return {true, true, seed_hash, 0, theta_constants::MAX_THETA, nullptr};
+          return {true, true, seed_hash, 0, theta_constants::MAX_THETA, nullptr, 64};
       } else if (preamble_size == 2) {
           const uint32_t num_entries = reinterpret_cast<const uint32_t*>(ptr)[COMPACT_SKETCH_NUM_ENTRIES_U32];
           if (num_entries == 0) {
-              return {true, true, seed_hash, 0, theta_constants::MAX_THETA, nullptr};
+              return {true, true, seed_hash, 0, theta_constants::MAX_THETA, nullptr, 64};
           } else {
               const size_t expected_size_bytes = (preamble_size + num_entries) << 3;
-              if (size < expected_size_bytes) {
-                  throw std::out_of_range(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
-                      + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
-              }
+              check_memory_size(ptr, size, expected_size_bytes, dump_on_error);
               const uint64_t* entries = reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_ENTRIES_EXACT_U64;
-              return {false, true, seed_hash, num_entries, theta_constants::MAX_THETA, entries};
+              return {false, true, seed_hash, num_entries, theta_constants::MAX_THETA, entries, 64};
           }
       } else if (preamble_size == 3) {
           const uint32_t num_entries = reinterpret_cast<const uint32_t*>(ptr)[COMPACT_SKETCH_NUM_ENTRIES_U32];
           uint64_t theta = reinterpret_cast<const uint64_t*>(ptr)[COMPACT_SKETCH_THETA_U64];
           bool is_empty = (num_entries == 0) && (theta == theta_constants::MAX_THETA);
-          if (is_empty) {
-              return {true, true, seed_hash, 0, theta, nullptr};
-          }
+          if (is_empty) return {true, true, seed_hash, 0, theta, nullptr, 64};
           const uint64_t* entries = reinterpret_cast<const uint64_t*>(ptr) + COMPACT_SKETCH_ENTRIES_ESTIMATION_U64;
           const size_t expected_size_bytes = (COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 + num_entries) * sizeof(uint64_t);
-          if (size < expected_size_bytes) {
-            throw std::out_of_range(std::to_string(expected_size_bytes) + " bytes expected, actual " + std::to_string(size)
-                + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), size)) : ""));
-          }
-          return {false, true, seed_hash, num_entries, theta, entries};
+          check_memory_size(ptr, size, expected_size_bytes, dump_on_error);
+          return {false, true, seed_hash, num_entries, theta, entries, 64};
       } else {
           throw std::invalid_argument(std::to_string(preamble_size) + " longs of premable, but expected 1, 2, or 3");
       }
   }
   default:
-      // this should always fail since the valid cases are handled above
-      checker<true>::check_serial_version(reinterpret_cast<const uint8_t*>(ptr)[COMPACT_SKETCH_SERIAL_VERSION_BYTE], COMPACT_SKETCH_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");
+    throw std::invalid_argument("unsupported serial version " + std::to_string(serial_version));
   }
 }
 
+template<bool dummy>
+void compact_theta_sketch_parser<dummy>::check_memory_size(const void* ptr, size_t actual_bytes, size_t expected_bytes, bool dump_on_error) {
+  if (actual_bytes < expected_bytes) throw std::out_of_range("at least " + std::to_string(expected_bytes)
+      + " bytes expected, actual " + std::to_string(actual_bytes)
+      + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), actual_bytes)) : ""));
+}
+
 template<bool dummy>
 std::string compact_theta_sketch_parser<dummy>::hex_dump(const uint8_t* ptr, size_t size) {
   std::stringstream s;

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

@@ -25,6 +25,16 @@
 
 namespace datasketches {
 
+// forward declaration
+template<typename A> class theta_a_not_b_alloc;
+
+// alias with default allocator for convenience
+using theta_a_not_b = theta_a_not_b_alloc<std::allocator<uint64_t>>;
+
+/**
+ * Theta A-not-B (set difference).
+ * Computes set difference of Theta sketches.
+ */
 template<typename Allocator = std::allocator<uint64_t>>
 class theta_a_not_b_alloc {
 public:
@@ -33,11 +43,19 @@ public:
   using CompactSketch = compact_theta_sketch_alloc<Allocator>;
   using State = theta_set_difference_base<Entry, ExtractKey, CompactSketch, 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 theta_a_not_b_alloc(uint64_t seed = DEFAULT_SEED, const Allocator& allocator = Allocator());
 
   /**
-   * Computes the a-not-b set operation given two sketches.
-   * @return the result of a-not-b
+   * 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;
@@ -46,9 +64,6 @@ private:
   State state_;
 };
 
-// alias with default allocator for convenience
-using theta_a_not_b = theta_a_not_b_alloc<std::allocator<uint64_t>>;
-
 } /* namespace datasketches */
 
 #include "theta_a_not_b_impl.hpp"

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

@@ -25,15 +25,21 @@
 
 namespace datasketches {
 
+/// Theta constants
 namespace theta_constants {
+  /// hash table resize factor
   using resize_factor = datasketches::resize_factor;
-  //enum resize_factor { X1, X2, X4, X8 };
-  const uint64_t MAX_THETA = LLONG_MAX; // signed max for compatibility with Java
+  /// default resize factor
+  const resize_factor DEFAULT_RESIZE_FACTOR = resize_factor::X8;
+
+  /// max theta - signed max for compatibility with Java
+  const uint64_t MAX_THETA = LLONG_MAX;
+  /// min log2 of K
   const uint8_t MIN_LG_K = 5;
+  /// max log2 of K
   const uint8_t MAX_LG_K = 26;
-
+  /// default log2 of K
   const uint8_t DEFAULT_LG_K = 12;
-  const resize_factor DEFAULT_RESIZE_FACTOR = resize_factor::X8;
 }
 
 } /* namespace datasketches */

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

@@ -20,8 +20,10 @@
 #ifndef THETA_HELPERS_HPP_
 #define THETA_HELPERS_HPP_
 
-#include <string>
 #include <stdexcept>
+#include <string>
+
+#include "theta_constants.hpp"
 
 namespace datasketches {
 

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

@@ -25,6 +25,16 @@
 
 namespace datasketches {
 
+// forward declaration
+template<typename A> class theta_intersection_alloc;
+
+// alias with default allocator for convenience
+using theta_intersection = theta_intersection_alloc<std::allocator<uint64_t>>;
+
+/**
+ * Theta intersection.
+ * Computes intersection of Theta sketches.
+ */
 template<typename Allocator = std::allocator<uint64_t>>
 class theta_intersection_alloc {
 public:
@@ -33,6 +43,7 @@ public:
   using Sketch = theta_sketch_alloc<Allocator>;
   using CompactSketch = compact_theta_sketch_alloc<Allocator>;
 
+  // there is no payload in Theta sketch entry
   struct nop_policy {
     void operator()(uint64_t internal_entry, uint64_t incoming_entry) const {
       unused(incoming_entry);
@@ -41,7 +52,7 @@ public:
   };
   using State = theta_intersection_base<Entry, ExtractKey, nop_policy, Sketch, CompactSketch, Allocator>;
 
-  /*
+  /**
    * Constructor
    * @param seed for the hash function that was used to create the sketch
    * @param allocator to use for allocating and deallocating memory
@@ -61,7 +72,7 @@ public:
    * 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 ordered sketch should be produced
+   * @param ordered optional flag to specify if an ordered sketch should be produced
    * @return the result of the intersection
    */
   CompactSketch get_result(bool ordered = true) const;
@@ -76,9 +87,6 @@ private:
   State state_;
 };
 
-// alias with default allocator for convenience
-using theta_intersection = theta_intersection_alloc<std::allocator<uint64_t>>;
-
 } /* namespace datasketches */
 
 #include "theta_intersection_impl.hpp"

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

@@ -49,8 +49,8 @@ void theta_intersection_base<EN, EK, P, S, CS, A>::update(SS&& sketch) {
   if (!is_valid_) { // first update, copy or move incoming sketch
     is_valid_ = true;
     const uint8_t lg_size = lg_size_from_count(sketch.get_num_retained(), theta_update_sketch_base<EN, EK, A>::REBUILD_THRESHOLD);
-    table_ = hash_table(lg_size, lg_size, resize_factor::X1, 1, table_.theta_, table_.seed_, table_.allocator_, table_.is_empty_);
-    for (auto& entry: sketch) {
+    table_ = hash_table(lg_size, lg_size - 1, resize_factor::X1, 1, table_.theta_, table_.seed_, table_.allocator_, table_.is_empty_);
+    for (auto&& entry: sketch) {
       auto result = table_.find(EK()(entry));
       if (result.second) {
         throw std::invalid_argument("duplicate key, possibly corrupted input sketch");
@@ -64,7 +64,7 @@ void theta_intersection_base<EN, EK, P, S, CS, A>::update(SS&& sketch) {
     matched_entries.reserve(max_matches);
     uint32_t match_count = 0;
     uint32_t count = 0;
-    for (auto& entry: sketch) {
+    for (auto&& entry: sketch) {
       if (EK()(entry) < table_.theta_) {
         auto result = table_.find(EK()(entry));
         if (result.second) {
@@ -88,8 +88,8 @@ void theta_intersection_base<EN, EK, P, S, CS, A>::update(SS&& sketch) {
       if (table_.theta_ == theta_constants::MAX_THETA) table_.is_empty_ = true;
     } else {
       const uint8_t lg_size = lg_size_from_count(match_count, theta_update_sketch_base<EN, EK, A>::REBUILD_THRESHOLD);
-      table_ = hash_table(lg_size, lg_size, resize_factor::X1, 1, table_.theta_, table_.seed_, table_.allocator_, table_.is_empty_);
-      for (uint32_t i = 0; i < match_count; i++) {
+      table_ = hash_table(lg_size, lg_size - 1, resize_factor::X1, 1, table_.theta_, table_.seed_, table_.allocator_, table_.is_empty_);
+      for (uint32_t i = 0; i < match_count; ++i) {
         auto result = table_.find(EK()(matched_entries[i]));
         table_.insert(result.first, std::move(matched_entries[i]));
       }

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

@@ -28,9 +28,9 @@ state_(seed, nop_policy(), allocator)
 {}
 
 template<typename A>
-template<typename SS>
-void theta_intersection_alloc<A>::update(SS&& sketch) {
-  state_.update(std::forward<SS>(sketch));
+template<typename FwdSketch>
+void theta_intersection_alloc<A>::update(FwdSketch&& sketch) {
+  state_.update(std::forward<FwdSketch>(sketch));
 }
 
 template<typename A>

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

@@ -26,10 +26,11 @@
 
 namespace datasketches {
 
+/// Theta Jaccard similarity alias
 template<typename Allocator = std::allocator<uint64_t>>
 using theta_jaccard_similarity_alloc = jaccard_similarity_base<theta_union_alloc<Allocator>, theta_intersection_alloc<Allocator>, trivial_extract_key>;
 
-// alias with default allocator for convenience
+/// Theta Jaccard similarity alias with default allocator
 using theta_jaccard_similarity = theta_jaccard_similarity_alloc<std::allocator<uint64_t>>;
 
 } /* namespace datasketches */

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

@@ -30,6 +30,7 @@
 
 namespace datasketches {
 
+/// Base class for Jaccard similarity
 template<typename Union, typename Intersection, typename ExtractKey>
 class jaccard_similarity_base {
 public:

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

@@ -65,7 +65,7 @@ CS theta_set_difference_base<EN, EK, CS, A>::compute(FwdSketch&& a, const Sketch
       }
 
       // scan A lookup B
-      for (auto& entry: a) {
+      for (auto&& entry: a) {
         const uint64_t hash = EK()(entry);
         if (hash < theta) {
           auto result = table.find(hash);