datasketches 0.5.1 → 0.5.3

data/vendor/datasketches-cpp/tdigest/test/tdigest_test.cpp

@@ -18,13 +18,40 @@
  */
 
 #include <catch2/catch.hpp>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <initializer_list>
 #include <iostream>
 #include <fstream>
+#include <sstream>
+#include <utility>
 
 #include "tdigest.hpp"
 
 namespace datasketches {
 
+namespace {
+constexpr size_t header_size = 8;
+constexpr size_t counts_size = 8;
+constexpr size_t min_offset = header_size + counts_size;
+constexpr size_t max_offset = min_offset + sizeof(double);
+constexpr size_t first_centroid_mean_offset = min_offset + sizeof(double) * 2;
+constexpr size_t first_centroid_weight_offset = first_centroid_mean_offset + sizeof(double);
+constexpr size_t first_buffered_value_offset = first_centroid_mean_offset;
+constexpr size_t single_value_offset = header_size;
+
+template <typename T>
+void write_bytes(std::vector<uint8_t>& bytes, size_t offset, T value) {
+  std::memcpy(bytes.data() + offset, &value, sizeof(T));
+}
+
+template <typename T>
+void write_bytes(std::string& data, size_t offset, T value) {
+  std::memcpy(&data[offset], &value, sizeof(T));
+}
+} // namespace
+
 TEST_CASE("empty", "[tdigest]") {
   tdigest_double td(10);
 //  std::cout << td.to_string();
@@ -145,6 +172,31 @@ TEST_CASE("merge small", "[tdigest]") {
   REQUIRE(td1.get_rank(3.01) == 1);
 }
 
+TEST_CASE("merge preserves deserialized min max with weighted tails", "[tdigest]") {
+  tdigest_double source(100);
+  source.update(0);
+  source.update(50);
+  source.update(90);
+  auto bytes = source.serialize();
+  write_bytes(bytes, min_offset, -1.0);
+  write_bytes(bytes, max_offset, 100.0);
+  auto other = tdigest_double::deserialize(bytes.data(), bytes.size());
+  REQUIRE(other.get_min_value() == -1.0);
+  REQUIRE(other.get_max_value() == 100.0);
+
+  tdigest_double empty(100);
+  empty.merge(other);
+  REQUIRE(empty.get_min_value() == -1.0);
+  REQUIRE(empty.get_max_value() == 100.0);
+
+  tdigest_double left(100);
+  left.update(10);
+  left.update(20);
+  left.merge(other);
+  REQUIRE(left.get_min_value() == -1.0);
+  REQUIRE(left.get_max_value() == 100.0);
+}
+
 TEST_CASE("merge large", "[tdigest]") {
   const size_t n = 10000;
   tdigest_double td1;
@@ -453,4 +505,227 @@ TEST_CASE("deserialize from reference implementation bytes float", "[tdigest]")
   REQUIRE(td.get_rank(n) == 1);
 }
 
+TEST_CASE("iterate centroids", "[tdigest]") {
+  tdigest_double td(100);
+  for (int i = 0; i < 10; i++) {
+    td.update(i);
+  }
+
+  auto centroid_count = 0;
+  uint64_t total_weight = 0;
+  for (const auto &centroid: td) {
+    centroid_count++;
+    total_weight += centroid.second;
+  }
+  // Ensure that centroids are retrieved for a case where there is buffered values
+  REQUIRE(centroid_count == 10);
+  REQUIRE(td.get_total_weight() == total_weight);
+}
+
+TEST_CASE("update rejects positive infinity", "[tdigest]") {
+  tdigest_double td(100);
+  td.update(1.0);
+  td.update(2.0);
+  td.update(std::numeric_limits<double>::infinity());
+  REQUIRE(td.get_total_weight() == 2);
+  REQUIRE(td.get_max_value() == 2.0);
+}
+
+TEST_CASE("update rejects negative infinity", "[tdigest]") {
+  tdigest_double td(100);
+  td.update(1.0);
+  td.update(2.0);
+  td.update(-std::numeric_limits<double>::infinity());
+  REQUIRE(td.get_total_weight() == 2);
+  REQUIRE(td.get_min_value() == 1.0);
+}
+
+TEST_CASE("deserialize bytes rejects NaN single value", "[tdigest]") {
+  tdigest_double td(100);
+  td.update(1.0);
+  auto bytes = td.serialize();
+  write_bytes(bytes, single_value_offset, std::numeric_limits<double>::quiet_NaN());
+  REQUIRE_THROWS_AS(tdigest_double::deserialize(bytes.data(), bytes.size()), std::invalid_argument);
+}
+
+TEST_CASE("deserialize stream rejects infinity min", "[tdigest]") {
+  tdigest_double td(100);
+  td.update(1.0);
+  td.update(2.0);
+  td.update(3.0);
+  auto bytes = td.serialize();
+  std::string data(reinterpret_cast<const char*>(bytes.data()), bytes.size());
+  write_bytes(data, min_offset, std::numeric_limits<double>::infinity());
+  std::istringstream is(data, std::ios::binary);
+  REQUIRE_THROWS_AS(tdigest_double::deserialize(is), std::invalid_argument);
+}
+
+TEST_CASE("deserialize bytes rejects NaN centroid mean", "[tdigest]") {
+  tdigest_double td(100);
+  for (int i = 0; i < 10; ++i) td.update(i);
+  auto bytes = td.serialize();
+  write_bytes(bytes, first_centroid_mean_offset, std::numeric_limits<double>::quiet_NaN());
+  REQUIRE_THROWS_AS(tdigest_double::deserialize(bytes.data(), bytes.size()), std::invalid_argument);
+}
+
+TEST_CASE("deserialize bytes rejects NaN buffered value", "[tdigest]") {
+  tdigest_double td(100);
+  td.update(1.0);
+  td.update(2.0);
+  auto bytes = td.serialize(0, true);
+  write_bytes(bytes, first_buffered_value_offset, std::numeric_limits<double>::quiet_NaN());
+  REQUIRE_THROWS_AS(tdigest_double::deserialize(bytes.data(), bytes.size()), std::invalid_argument);
+}
+
+TEST_CASE("deserialize bytes rejects infinity single value", "[tdigest]") {
+  tdigest_double td(100);
+  td.update(1.0);
+  auto bytes = td.serialize();
+  write_bytes(bytes, single_value_offset, std::numeric_limits<double>::infinity());
+  REQUIRE_THROWS_AS(tdigest_double::deserialize(bytes.data(), bytes.size()), std::invalid_argument);
+}
+
+TEST_CASE("deserialize bytes rejects NaN max", "[tdigest]") {
+  tdigest_double td(100);
+  td.update(1.0);
+  td.update(2.0);
+  auto bytes = td.serialize();
+  write_bytes(bytes, max_offset, std::numeric_limits<double>::quiet_NaN());
+  REQUIRE_THROWS_AS(tdigest_double::deserialize(bytes.data(), bytes.size()), std::invalid_argument);
+}
+
+TEST_CASE("deserialize bytes rejects infinity max", "[tdigest]") {
+  tdigest_double td(100);
+  td.update(1.0);
+  td.update(2.0);
+  auto bytes = td.serialize();
+  write_bytes(bytes, max_offset, std::numeric_limits<double>::infinity());
+  REQUIRE_THROWS_AS(tdigest_double::deserialize(bytes.data(), bytes.size()), std::invalid_argument);
+}
+
+TEST_CASE("deserialize bytes rejects infinity buffered value", "[tdigest]") {
+  tdigest_double td(100);
+  td.update(1.0);
+  td.update(2.0);
+  auto bytes = td.serialize(0, true);
+  write_bytes(bytes, first_buffered_value_offset, std::numeric_limits<double>::infinity());
+  REQUIRE_THROWS_AS(tdigest_double::deserialize(bytes.data(), bytes.size()), std::invalid_argument);
+}
+
+TEST_CASE("deserialize bytes rejects zero centroid weight", "[tdigest]") {
+  tdigest_double td(100);
+  for (int i = 0; i < 10; ++i) td.update(i);
+  auto bytes = td.serialize();
+  write_bytes(bytes, first_centroid_weight_offset, static_cast<uint64_t>(0));
+  REQUIRE_THROWS_AS(tdigest_double::deserialize(bytes.data(), bytes.size()), std::invalid_argument);
+}
+
+TEST_CASE("deserialize stream rejects zero centroid weight", "[tdigest]") {
+  tdigest_double td(100);
+  for (int i = 0; i < 10; ++i) td.update(i);
+  auto bytes = td.serialize();
+  std::string data(reinterpret_cast<const char*>(bytes.data()), bytes.size());
+  write_bytes(data, first_centroid_weight_offset, static_cast<uint64_t>(0));
+  std::istringstream is(data, std::ios::binary);
+  REQUIRE_THROWS_AS(tdigest_double::deserialize(is), std::invalid_argument);
+}
+
+TEST_CASE("quantiles are monotonic and stay within min and max", "[tdigest]") {
+  tdigest_double td(100);
+  for (int i = 0; i < 10000; ++i) td.update(i);
+  double previous = td.get_min_value();
+  for (int i = 0; i <= 1000; ++i) {
+    const double quantile = td.get_quantile(i / 1000.0);
+    REQUIRE(quantile >= previous);
+    REQUIRE(quantile >= td.get_min_value());
+    REQUIRE(quantile <= td.get_max_value());
+    previous = quantile;
+  }
+}
+
+TEST_CASE("rank below the first centroid stays normalized", "[tdigest]") {
+  // The format allows a first centroid heavier than 1. The left tail of get_rank()
+  // must be divided by the total weight, the same way the right tail is.
+  tdigest_double source(200);
+  for (int i = 0; i < 1000; ++i) source.update(i);
+  auto bytes = source.serialize();
+  double first_mean = 0;
+  std::memcpy(&first_mean, bytes.data() + first_centroid_mean_offset, sizeof(double));
+  REQUIRE(first_mean == 0);
+  write_bytes(bytes, min_offset, -1.0);
+  write_bytes(bytes, first_centroid_weight_offset, static_cast<uint64_t>(100));
+  const auto td = tdigest_double::deserialize(bytes.data(), bytes.size());
+  const double total_weight = static_cast<double>(td.get_total_weight());
+  REQUIRE(td.get_rank(-1) == 0.5 / total_weight);
+  REQUIRE(td.get_rank(-0.5) == (1.0 + ((100.0 / 2.0 - 1.0) * 0.5)) / total_weight);
+  double previous = 0;
+  for (int i = 0; i <= 100; ++i) {
+    const double rank = td.get_rank(-1.0 + (i / 100.0));
+    REQUIRE(rank >= 0);
+    REQUIRE(rank <= 1);
+    REQUIRE(rank >= previous);
+    previous = rank;
+  }
+}
+
+TEST_CASE("quantile above the last centroid does not exceed max", "[tdigest]") {
+  tdigest_double source(200);
+  for (int i = 0; i < 1000; ++i) source.update(i);
+  auto bytes = source.serialize();
+  uint32_t num_centroids = 0;
+  std::memcpy(&num_centroids, bytes.data() + header_size, sizeof(uint32_t));
+  REQUIRE(num_centroids > 1);
+  const size_t last_weight_offset = first_centroid_weight_offset + (num_centroids - 1) * 16;
+  write_bytes(bytes, last_weight_offset, static_cast<uint64_t>(100));
+  const auto td = tdigest_double::deserialize(bytes.data(), bytes.size());
+  double previous = td.get_min_value();
+  for (int i = 0; i <= 1000; ++i) {
+    const double quantile = td.get_quantile(i / 1000.0);
+    REQUIRE(quantile >= previous);
+    REQUIRE(quantile <= td.get_max_value());
+    previous = quantile;
+  }
+}
+
+tdigest_double sketch_from_centroids(double min, double max,
+    std::initializer_list<std::pair<double, uint64_t>> centroids) {
+  const auto num_centroids = static_cast<uint32_t>(centroids.size());
+  std::vector<uint8_t> bytes(first_centroid_mean_offset + static_cast<size_t>(num_centroids) * 16, 0);
+  bytes[0] = 2; // preamble longs
+  bytes[1] = 1; // serial version
+  bytes[2] = 20; // sketch type
+  write_bytes(bytes, 3, static_cast<uint16_t>(100));
+  write_bytes(bytes, header_size, num_centroids);
+  write_bytes(bytes, header_size + sizeof(uint32_t), static_cast<uint32_t>(0));
+  write_bytes(bytes, min_offset, min);
+  write_bytes(bytes, max_offset, max);
+  size_t offset = first_centroid_mean_offset;
+  for (const auto& centroid : centroids) {
+    write_bytes(bytes, offset, centroid.first);
+    write_bytes(bytes, offset + sizeof(double), centroid.second);
+    offset += 16;
+  }
+  return tdigest_double::deserialize(bytes.data(), bytes.size());
+}
+
+TEST_CASE("quantile with a last centroid of weight 2 returns max", "[tdigest]") {
+  // weight == total - 1 and last weight == 2 is 0/0 unless that case returns max.
+  const auto td = sketch_from_centroids(0, 20, {{0, 10}, {10, 2}});
+  const double quantile = td.get_quantile(11.0 / 12.0);
+  REQUIRE_FALSE(std::isnan(quantile));
+  REQUIRE(quantile == 20);
+}
+
+TEST_CASE("quantile right tail approaches max from below", "[tdigest]") {
+  const auto td = sketch_from_centroids(0, 40, {{10, 100}, {20, 100}, {30, 100}});
+  REQUIRE(td.get_quantile(0.9) == Approx(34.081632653061224).epsilon(1e-12));
+}
+
+TEST_CASE("quantile interpolation weights the nearer centroid more", "[tdigest]") {
+  const auto td = sketch_from_centroids(0, 40, {{10, 100}, {20, 100}, {30, 100}});
+  // Target weight 80 sits between 10 and 20, closer to 10.
+  // weighted_average(10, 70, 20, 30) == 13; the swapped weights would return 17.
+  REQUIRE(td.get_quantile(80.0 / 300.0) == 13);
+}
+
 } /* namespace datasketches */

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

@@ -38,6 +38,8 @@ public:
   };
 
   static compact_theta_sketch_data parse(const void* ptr, size_t size, uint64_t seed, bool dump_on_error = false);
+  static void check_v4_entry_bits(uint8_t entry_bits);
+  static void check_v4_num_entries_bytes(uint8_t num_entries_bytes);
 
 private:
   // offsets are in sizeof(type)

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

@@ -49,6 +49,7 @@ auto compact_theta_sketch_parser<dummy>::parse(const void* ptr, size_t size, uin
       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];
+    check_v4_num_entries_bytes(num_entries_bytes);
     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;
@@ -58,7 +59,8 @@ auto compact_theta_sketch_parser<dummy>::parse(const void* ptr, size_t size, uin
     }
     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;
+    check_v4_entry_bits(entry_bits);
+    const uint64_t expected_bits = static_cast<uint64_t>(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,
@@ -80,8 +82,9 @@ auto compact_theta_sketch_parser<dummy>::parse(const void* ptr, size_t size, uin
         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;
+      check_memory_size(ptr, size, entries_start_u64 * sizeof(uint64_t), dump_on_error);
+      const uint32_t num_entries = reinterpret_cast<const uint32_t*>(ptr)[COMPACT_SKETCH_NUM_ENTRIES_U32];
       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);
       check_memory_size(ptr, size, expected_size_bytes, dump_on_error);
@@ -90,6 +93,7 @@ auto compact_theta_sketch_parser<dummy>::parse(const void* ptr, size_t size, uin
   }
   case 1:  {
       uint16_t seed_hash = compute_seed_hash(seed);
+      check_memory_size(ptr, size, COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 * sizeof(uint64_t), dump_on_error);
       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);
@@ -106,16 +110,18 @@ auto compact_theta_sketch_parser<dummy>::parse(const void* ptr, size_t size, uin
       if (preamble_size == 1) {
           return {true, true, seed_hash, 0, theta_constants::MAX_THETA, nullptr, 64};
       } else if (preamble_size == 2) {
+          check_memory_size(ptr, size, COMPACT_SKETCH_ENTRIES_EXACT_U64 * sizeof(uint64_t), dump_on_error);
           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, 64};
           } else {
-              const size_t expected_size_bytes = (preamble_size + num_entries) << 3;
+              const size_t expected_size_bytes = (preamble_size + static_cast<size_t>(num_entries)) << 3;
               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, 64};
           }
       } else if (preamble_size == 3) {
+          check_memory_size(ptr, size, COMPACT_SKETCH_ENTRIES_ESTIMATION_U64 * sizeof(uint64_t), dump_on_error);
           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);
@@ -140,6 +146,21 @@ void compact_theta_sketch_parser<dummy>::check_memory_size(const void* ptr, size
       + (dump_on_error ? (", sketch dump: " + hex_dump(reinterpret_cast<const uint8_t*>(ptr), actual_bytes)) : ""));
 }
 
+template<bool dummy>
+void compact_theta_sketch_parser<dummy>::check_v4_entry_bits(uint8_t entry_bits) {
+  // deltas between ordered hashes below 2^63 need 1 to 63 bits
+  if (entry_bits == 0 || entry_bits > 63) {
+    throw std::invalid_argument("entry bits must be in [1, 63], actual " + std::to_string(entry_bits));
+  }
+}
+
+template<bool dummy>
+void compact_theta_sketch_parser<dummy>::check_v4_num_entries_bytes(uint8_t num_entries_bytes) {
+  if (num_entries_bytes == 0 || num_entries_bytes > sizeof(uint32_t)) {
+    throw std::invalid_argument("num entries bytes must be in [1, 4], actual " + std::to_string(num_entries_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_constants.hpp

@@ -34,10 +34,12 @@ namespace theta_constants {
 
   /// 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;
+  /// min log2 of nominal entries (K)
+  const uint8_t MIN_LG_K = 4;
   /// max log2 of K
   const uint8_t MAX_LG_K = 26;
+  /// min log2 of cache size
+  const uint8_t MIN_LG_ARR = 5;
   /// default log2 of K
   const uint8_t DEFAULT_LG_K = 12;
 }

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

@@ -20,13 +20,45 @@
 #ifndef THETA_HELPERS_HPP_
 #define THETA_HELPERS_HPP_
 
+#include <algorithm>
+#include <cstdint>
 #include <stdexcept>
 #include <string>
+#include <vector>
 
 #include "theta_constants.hpp"
+#include "theta_comparators.hpp"
 
 namespace datasketches {
 
+/**
+ * Trims a vector of theta entries down to at most nominal_size and returns the theta the
+ * result must carry.
+ *
+ * The entry at index nominal_size becomes the new theta and is itself discarded, so every
+ * entry kept is strictly below the returned value. That is what keeps the estimator
+ * unbiased: theta must be an exclusive upper bound on the retained hashes. Getting this
+ * off by one does not fail loudly, it quietly biases every estimate the sketch produces.
+ *
+ * Capacity is released as well as size. Callers reserve an upper bound before filling, so
+ * without the shrink a trimmed result keeps the untrimmed allocation, which for an update
+ * sketch just under the rebuild threshold is nearly twice what it reports.
+ *
+ * @param entries entries to trim in place; reordered even when nothing is removed
+ * @param nominal_size the most entries to keep
+ * @param theta returned unchanged when there is nothing to trim
+ * @return the theta of the trimmed result
+ */
+template<typename ExtractKey, typename Entry, typename Allocator>
+static uint64_t trim_to_nominal(std::vector<Entry, Allocator>& entries, uint32_t nominal_size, uint64_t theta) {
+  if (entries.size() <= nominal_size) return theta;
+  std::nth_element(entries.begin(), entries.begin() + nominal_size, entries.end(), compare_by_key<ExtractKey>());
+  const uint64_t new_theta = ExtractKey()(entries[nominal_size]);
+  entries.erase(entries.begin() + nominal_size, entries.end());
+  entries.shrink_to_fit();
+  return new_theta;
+}
+
 template<typename T>
 static void check_value(T actual, T expected, const char* description) {
   if (actual != expected) {

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

@@ -39,7 +39,9 @@ template<typename FwdSketch, typename Sketch>
 CS theta_set_difference_base<EN, EK, CS, A>::compute(FwdSketch&& a, const Sketch& b, bool ordered) const {
   if (a.is_empty() || (a.get_num_retained() > 0 && b.is_empty())) return CS(a, ordered);
   if (a.get_seed_hash() != seed_hash_) throw std::invalid_argument("A seed hash mismatch");
-  if (b.get_seed_hash() != seed_hash_) throw std::invalid_argument("B seed hash mismatch");
+  // an empty sketch has no hashes, so its seed hash is meaningless and must be ignored,
+  // consistent with deserialization, theta_union::update() and theta_intersection::update()
+  if (!b.is_empty() && b.get_seed_hash() != seed_hash_) throw std::invalid_argument("B seed hash mismatch");
 
   const uint64_t theta = std::min(a.get_theta64(), b.get_theta64());
   std::vector<EN, A> entries(allocator_);
@@ -69,7 +71,7 @@ CS theta_set_difference_base<EN, EK, CS, A>::compute(FwdSketch&& a, const Sketch
         const uint64_t hash = EK()(entry);
         if (hash < theta) {
           auto result = table.find(hash);
-          if (!result.second) entries.push_back(conditional_forward<FwdSketch>(entry));
+          if (!result.second) entries.emplace_back(conditional_forward<FwdSketch>(entry));
         } else if (a.is_ordered()) {
           break; // early stop
         }

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

@@ -330,11 +330,25 @@ public:
   void reset();
 
   /**
-   * Converts this sketch to a compact sketch (ordered or unordered).
+   * Converts this sketch to a compact sketch (ordered or unordered, trimmed or not trimmed).
+   * This does not modify the source update sketch.
    * @param ordered optional flag to specify if an ordered sketch should be produced
+   * @param trim optional flag to reduce the size of the returned sketch to at most
+   * the nominal size k, if required. An update sketch retains more than k entries
+   * between rebuilds; those extra entries below theta improve the estimate, so the
+   * default is to keep them.
+   * Trimming is lossy and is never required for correctness. It discards retained
+   * entries, and since the relative error scales with 1 / sqrt(retained), it always
+   * degrades accuracy and widens the confidence bounds, whatever mode the source is
+   * in. Worst case, a sketch grown to just under the rebuild threshold of 15/16 * 2k
+   * loses nearly half its entries, widening the bounds by about sqrt(15/8), or
+   * roughly 37%. A sketch in exact mode that retains more than k entries loses
+   * exactness as well: it is returned in estimation mode, so get_estimate() carries
+   * error where it would otherwise have returned an exact count.
+   * Only pass true if a bounded result size matters more than that accuracy.
    * @return compact sketch
    */
-  compact_theta_sketch_alloc<Allocator> compact(bool ordered = true) const;
+  compact_theta_sketch_alloc<Allocator> compact(bool ordered = true, bool trim = false) const;
 
   virtual iterator begin();
   virtual iterator end();
@@ -492,7 +506,7 @@ public:
       uint64_t seed = DEFAULT_SEED, const Allocator& allocator = Allocator());
 
 private:
-  enum flags { IS_BIG_ENDIAN, IS_READ_ONLY, IS_EMPTY, IS_COMPACT, IS_ORDERED };
+  enum flags { IS_BIG_ENDIAN, IS_READ_ONLY, IS_EMPTY, IS_COMPACT, IS_ORDERED, IS_SINGLE_ITEM };
 
   bool is_empty_;
   bool is_ordered_;
@@ -501,6 +515,7 @@ private:
   std::vector<uint64_t, Allocator> entries_;
 
   uint8_t get_preamble_longs(bool compressed) const;
+  bool is_single_item() const;
   bool is_suitable_for_compression() const;
   uint8_t compute_entry_bits() const;
   uint8_t get_num_entries_bytes() const;
@@ -518,6 +533,7 @@ private:
   template<typename E, typename EK, typename P, typename S, typename CS, typename A> friend class theta_union_base;
   template<typename E, typename EK, typename P, typename S, typename CS, typename A> friend class theta_intersection_base;
   template<typename E, typename EK, typename CS, typename A> friend class theta_set_difference_base;
+  template<typename A> friend class update_theta_sketch_alloc;
   compact_theta_sketch_alloc(bool is_empty, bool is_ordered, uint16_t seed_hash, uint64_t theta, std::vector<uint64_t, Allocator>&& entries);
 };
 
@@ -609,9 +625,11 @@ private:
   uint32_t index_;
   uint64_t previous_;
   bool is_block_mode_;
-  uint8_t buf_i_;
   uint8_t offset_;
   uint64_t buffer_[8];
+
+  inline void unpack1();
+  inline void unpack8();
 };
 
 } /* namespace datasketches */