datasketches 0.3.1 → 0.4.0

data/vendor/datasketches-cpp/count/test/count_min_test.cpp

@@ -0,0 +1,303 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <catch2/catch.hpp>
+#include <vector>
+#include <cstring>
+#include <sstream>
+#include <fstream>
+
+#include "count_min.hpp"
+#include "common_defs.hpp"
+
+namespace datasketches {
+
+TEST_CASE("CM init - throws") {
+    REQUIRE_THROWS_AS(count_min_sketch<uint64_t>(5, 1), std::invalid_argument);
+    REQUIRE_THROWS_AS(count_min_sketch<uint64_t>(4, 268435456), std::invalid_argument);
+}
+
+TEST_CASE("CM init") {
+    uint8_t n_hashes = 3;
+    uint32_t n_buckets = 5;
+    uint64_t seed = 1234567;
+    count_min_sketch<uint64_t> c(n_hashes, n_buckets, seed);
+    REQUIRE(c.get_num_hashes() == n_hashes);
+    REQUIRE(c.get_num_buckets() == n_buckets);
+    REQUIRE(c.get_seed() == seed);
+    REQUIRE(c.is_empty());
+
+    for (auto x: c) {
+      REQUIRE(x == 0);
+    }
+
+    // Check the default seed is appropriately set.
+    count_min_sketch<uint64_t> c1(n_hashes, n_buckets);
+    REQUIRE(c1.get_seed() == DEFAULT_SEED);
+}
+
+TEST_CASE("CM parameter suggestions", "[error parameters]") {
+
+    // Bucket suggestions
+    REQUIRE_THROWS(count_min_sketch<uint64_t>::suggest_num_buckets(-1.0), "Confidence must be between 0 and 1.0 (inclusive)." );
+    REQUIRE(count_min_sketch<uint64_t>::suggest_num_buckets(0.2) == 14);
+    REQUIRE(count_min_sketch<uint64_t>::suggest_num_buckets(0.1) == 28);
+    REQUIRE(count_min_sketch<uint64_t>::suggest_num_buckets(0.05) == 55);
+    REQUIRE(count_min_sketch<uint64_t>::suggest_num_buckets(0.01) == 272);
+
+    // Check that the sketch get_epsilon acts inversely to suggest_num_buckets
+    uint8_t n_hashes = 3;
+    REQUIRE(count_min_sketch<uint64_t>(n_hashes, 14).get_relative_error() <= 0.2);
+    REQUIRE(count_min_sketch<uint64_t>(n_hashes, 28).get_relative_error() <= 0.1);
+    REQUIRE(count_min_sketch<uint64_t>(n_hashes, 55).get_relative_error() <= 0.05);
+    REQUIRE(count_min_sketch<uint64_t>(n_hashes, 272).get_relative_error() <= 0.01);
+
+    // Hash suggestions
+    REQUIRE_THROWS(count_min_sketch<uint64_t>::suggest_num_hashes(10.0), "Confidence must be between 0 and 1.0 (inclusive)." );
+    REQUIRE_THROWS(count_min_sketch<uint64_t>::suggest_num_hashes(-1.0), "Confidence must be between 0 and 1.0 (inclusive)." );
+    REQUIRE(count_min_sketch<uint64_t>::suggest_num_hashes(0.682689492) == 2); // 1 STDDEV
+    REQUIRE(count_min_sketch<uint64_t>::suggest_num_hashes(0.954499736) == 4); // 2 STDDEV
+    REQUIRE(count_min_sketch<uint64_t>::suggest_num_hashes(0.997300204) == 6); // 3 STDDEV
+}
+
+TEST_CASE("CM one update: uint64_t") {
+  uint8_t n_hashes = 3;
+  uint32_t n_buckets = 5;
+  uint64_t seed = 9223372036854775807; //1234567;
+  uint64_t inserted_weight = 0;
+  count_min_sketch<uint64_t> c(n_hashes, n_buckets, seed);
+  std::string x = "x";
+
+  REQUIRE(c.is_empty());
+  REQUIRE(c.get_estimate("x") == 0); // No items in sketch so estimates should be zero
+  c.update(x);
+  REQUIRE(!c.is_empty());
+  REQUIRE(c.get_estimate(x) == 1);
+  inserted_weight += 1;
+
+  uint64_t w = 9;
+  inserted_weight += w;
+  c.update(x, w);
+  REQUIRE(c.get_estimate(x) == inserted_weight);
+
+    // Doubles are converted to uint64_t
+    double w1 = 10.0;
+    inserted_weight += static_cast<uint64_t>(w1);
+    c.update(x, static_cast<uint64_t>(w1));
+    REQUIRE(c.get_estimate(x) == inserted_weight);
+    REQUIRE(c.get_total_weight() == inserted_weight);
+    REQUIRE(c.get_estimate(x) <= c.get_upper_bound(x));
+    REQUIRE(c.get_estimate(x) >= c.get_lower_bound(x));
+}
+
+TEST_CASE("CM frequency cancellation") {
+  count_min_sketch<int64_t> c(1, 5);
+  c.update("x");
+  c.update("y", -1);
+  REQUIRE(c.get_total_weight() == 2);
+  REQUIRE(c.get_estimate("x") == 1);
+  REQUIRE(c.get_estimate("y") == -1);
+}
+
+TEST_CASE("CM frequency estimates") {
+    int number_of_items = 10;
+    std::vector<uint64_t> data(number_of_items);
+    std::vector<uint64_t> frequencies(number_of_items);
+
+    // Populate data vector
+    for (int i = 0; i < number_of_items; ++i) {
+      data[i] = i;
+      frequencies[i] = 1ULL << (number_of_items - i);
+    }
+
+    double relative_error = 0.1;
+    double confidence = 0.99;
+    uint32_t n_buckets = count_min_sketch<uint64_t>::suggest_num_buckets(relative_error);
+    uint8_t n_hashes = count_min_sketch<uint64_t>::suggest_num_hashes(confidence);
+
+    count_min_sketch<uint64_t> c(n_hashes, n_buckets);
+    for (int i = 0; i < number_of_items; ++i) {
+      uint64_t value = data[i];
+      uint64_t freq = frequencies[i];
+      c.update(value, freq);
+    }
+
+    for (const auto i: data) {
+      uint64_t est = c.get_estimate(i);
+      uint64_t upp = c.get_upper_bound(i);
+      uint64_t low = c.get_lower_bound(i);
+      REQUIRE(est <= upp);
+      REQUIRE(est >= low);
+    }
+}
+
+TEST_CASE("CM merge - reject", "[reject cases]") {
+    double relative_error = 0.25;
+    double confidence = 0.9;
+    uint32_t n_buckets = count_min_sketch<uint64_t>::suggest_num_buckets(relative_error);
+    uint8_t n_hashes = count_min_sketch<uint64_t>::suggest_num_hashes(confidence);
+    count_min_sketch<uint64_t> s(n_hashes, n_buckets, 9082435234709287);
+
+    // Generate sketches that we cannot merge into ie they disagree on at least one of the config entries
+    count_min_sketch<uint64_t> s1(n_hashes+1, n_buckets); // incorrect number of hashes
+    count_min_sketch<uint64_t> s2(n_hashes, n_buckets + 1); // incorrect number of buckets
+    count_min_sketch<uint64_t> s3(n_hashes, n_buckets, 1); // incorrect seed
+    std::vector<count_min_sketch<uint64_t>> sketches = {s1, s2, s3};
+
+    // Fail cases
+    REQUIRE_THROWS(s.merge(s), "Cannot merge a sketch with itself." );
+    for (count_min_sketch<uint64_t> sk : sketches) {
+      REQUIRE_THROWS(s.merge(sk), "Incompatible sketch config." );
+    }
+}
+
+TEST_CASE("CM merge - pass", "[acceptable cases]") {
+    double relative_error = 0.25;
+    double confidence = 0.9;
+    uint32_t n_buckets = count_min_sketch<uint64_t>::suggest_num_buckets(relative_error);
+    uint8_t n_hashes = count_min_sketch<uint64_t>::suggest_num_hashes(confidence);
+    count_min_sketch<uint64_t> s(n_hashes, n_buckets);
+    uint8_t s_hashes = s.get_num_hashes();
+    uint32_t s_buckets = s.get_num_buckets();
+    count_min_sketch<uint64_t> t(s_hashes, s_buckets);
+
+    // Merge in an all-zeros sketch t.  Should not change the total weight.
+    s.merge(t);
+    REQUIRE(s.get_total_weight() == 0 );
+
+    std::vector<uint64_t> data = {2,3,5,7};
+    for (auto d: data) {
+      s.update(d);
+      t.update(d);
+    }
+    s.merge(t);
+
+    REQUIRE(s.get_total_weight() == 2 * t.get_total_weight());
+
+    // Estimator checks.
+    for (auto x: data) {
+      REQUIRE(s.get_estimate(x) <= s.get_upper_bound(x));
+      REQUIRE(s.get_estimate(x) <= 2); // True frequency x == 2 for all x.
+    }
+  }
+
+TEST_CASE("CountMin sketch: serialize-deserialize empty", "[cm_sketch]") {
+    uint8_t n_hashes = 1;
+    uint32_t n_buckets = 5;
+    std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
+    count_min_sketch<uint64_t> c(n_hashes, n_buckets);
+    c.serialize(s);
+    count_min_sketch<uint64_t> d = count_min_sketch<uint64_t>::deserialize(s, DEFAULT_SEED);
+    REQUIRE(c.get_num_hashes() == d.get_num_hashes());
+    REQUIRE(c.get_num_buckets() == d.get_num_buckets());
+    REQUIRE(c.get_seed() == d.get_seed());
+    uint64_t zero = 0;
+    REQUIRE(c.get_estimate(zero) == d.get_estimate(zero));
+    REQUIRE(c.get_total_weight() == d.get_total_weight());
+
+    // Check that all entries are equal and 0
+    for (auto di: d) {
+      REQUIRE(di == 0);
+    }
+    std::ofstream os("count_min-empty.bin");
+    c.serialize(os);
+}
+
+TEST_CASE("CountMin sketch: serialize-deserialize non-empty", "[cm_sketch]") {
+  uint8_t n_hashes = 3;
+  uint32_t n_buckets = 1024;
+  std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
+  count_min_sketch<uint64_t> c(n_hashes, n_buckets);
+  for (uint64_t i = 0; i < 10; ++i) c.update(i, 10 * i * i);
+  c.serialize(s);
+  count_min_sketch<uint64_t> d = count_min_sketch<uint64_t>::deserialize(s, DEFAULT_SEED);
+  REQUIRE(c.get_num_hashes() == d.get_num_hashes());
+  REQUIRE(c.get_num_buckets() == d.get_num_buckets());
+  REQUIRE(c.get_seed() == d.get_seed());
+  REQUIRE(c.get_total_weight() == d.get_total_weight());
+  for (uint64_t i = 0; i < 10; ++i) {
+    REQUIRE(c.get_estimate(i) == d.get_estimate(i));
+  }
+
+  auto c_it = c.begin();
+  auto d_it = d.begin();
+  while (c_it != c.end()) {
+    REQUIRE(*c_it == *d_it);
+    ++c_it;
+    ++d_it;
+  }
+
+  std::ofstream os("count_min-non-empty.bin");
+  c.serialize(os);
+}
+
+TEST_CASE("CountMin sketch: bytes serialize-deserialize empty", "[cm_sketch]") {
+  uint8_t n_hashes = 3;
+  uint32_t n_buckets = 32;
+  count_min_sketch<uint64_t> c(n_hashes, n_buckets);
+  auto bytes = c.serialize();
+
+  REQUIRE_THROWS_AS(count_min_sketch<uint64_t>::deserialize(bytes.data(), bytes.size(), DEFAULT_SEED-1), std::invalid_argument);
+  auto d = count_min_sketch<uint64_t>::deserialize(bytes.data(), bytes.size(), DEFAULT_SEED);
+  REQUIRE(c.get_num_hashes() == d.get_num_hashes());
+  REQUIRE(c.get_num_buckets() == d.get_num_buckets());
+  REQUIRE(c.get_seed() == d.get_seed());
+  uint64_t zero = 0;
+  REQUIRE(c.get_estimate(zero) == d.get_estimate(zero));
+  REQUIRE(c.get_total_weight() == d.get_total_weight());
+
+  // Check that all entries are equal and 0
+  for (auto di: d) {
+    REQUIRE(di == 0);
+  }
+}
+
+
+TEST_CASE("CountMin sketch: bytes serialize-deserialize non-empty", "[cm_sketch]") {
+  uint8_t n_hashes = 5;
+  uint32_t n_buckets = 64;
+  count_min_sketch<uint64_t> c(n_hashes, n_buckets);
+  for(uint64_t i=0; i < 10; ++i) c.update(i,10*i*i);
+
+  auto bytes = c.serialize();
+  REQUIRE_THROWS_AS(count_min_sketch<uint64_t>::deserialize(bytes.data(), bytes.size(), DEFAULT_SEED-1), std::invalid_argument);
+  auto d = count_min_sketch<uint64_t>::deserialize(bytes.data(), bytes.size(), DEFAULT_SEED);
+
+  REQUIRE(c.get_num_hashes() == d.get_num_hashes());
+  REQUIRE(c.get_num_buckets() == d.get_num_buckets());
+  REQUIRE(c.get_seed() == d.get_seed());
+  REQUIRE(c.get_total_weight() == d.get_total_weight());
+
+  // Check that all entries are equal
+  auto c_it = c.begin();
+  auto d_it = d.begin();
+  while (c_it != c.end()) {
+    REQUIRE(*c_it == *d_it);
+    ++c_it;
+    ++d_it;
+  }
+
+  // Check that the estimates agree
+  for (uint64_t i = 0; i < 10; ++i) {
+    REQUIRE(c.get_estimate(i) == d.get_estimate(i));
+  }
+
+}
+
+} /* namespace datasketches */

data/vendor/datasketches-cpp/cpc/include/cpc_common.hpp

@@ -26,45 +26,39 @@
 
 namespace datasketches {
 
+/// CPC constants
 namespace cpc_constants {
-    const uint8_t MIN_LG_K = 4;
-    const uint8_t MAX_LG_K = 26;
-    const uint8_t DEFAULT_LG_K = 11;
+  /// min log2 of K
+  const uint8_t MIN_LG_K = 4;
+  /// max log2 of K
+  const uint8_t MAX_LG_K = 26;
+  /// default log2 of K
+  const uint8_t DEFAULT_LG_K = 11;
 }
 
-// TODO: Redundant and deprecated. Will be removed in next major version release.
-static const uint8_t CPC_MIN_LG_K = cpc_constants::MIN_LG_K;
-static const uint8_t CPC_MAX_LG_K = cpc_constants::MAX_LG_K;
-static const uint8_t CPC_DEFAULT_LG_K = cpc_constants::DEFAULT_LG_K;
-
-template<typename A> using AllocU8 = typename std::allocator_traits<A>::template rebind_alloc<uint8_t>;
-template<typename A> using AllocU16 = typename std::allocator_traits<A>::template rebind_alloc<uint16_t>;
-template<typename A> using AllocU32 = typename std::allocator_traits<A>::template rebind_alloc<uint32_t>;
-template<typename A> using AllocU64 = typename std::allocator_traits<A>::template rebind_alloc<uint64_t>;
-
-template<typename A> using vector_u8 = std::vector<uint8_t, AllocU8<A>>;
-template<typename A> using vector_u32 = std::vector<uint32_t, AllocU32<A>>;
-template<typename A> using vector_u64 = std::vector<uint64_t, AllocU64<A>>;
-
 // forward declaration
 template<typename A> class u32_table;
 
 template<typename A>
 struct compressed_state {
+  using vector_u32 = std::vector<uint32_t, typename std::allocator_traits<A>::template rebind_alloc<uint32_t>>;
+
   explicit compressed_state(const A& allocator): table_data(allocator), table_data_words(0), table_num_entries(0),
       window_data(allocator), window_data_words(0) {}
-  vector_u32<A> table_data;
+  vector_u32 table_data;
   uint32_t table_data_words;
   uint32_t table_num_entries; // can be different from the number of entries in the sketch in hybrid mode
-  vector_u32<A> window_data;
+  vector_u32 window_data;
   uint32_t window_data_words;
 };
 
 template<typename A>
 struct uncompressed_state {
+  using vector_bytes = std::vector<uint8_t, typename std::allocator_traits<A>::template rebind_alloc<uint8_t>>;
+
   explicit uncompressed_state(const A& allocator): table(allocator), window(allocator) {}
   u32_table<A> table;
-  vector_u8<A> window;
+  vector_bytes window;
 };
 
 } /* namespace datasketches */

data/vendor/datasketches-cpp/cpc/include/cpc_compressor.hpp

@@ -47,6 +47,9 @@ inline cpc_compressor<A>& get_compressor();
 template<typename A>
 class cpc_compressor {
 public:
+  using vector_bytes = std::vector<uint8_t, typename std::allocator_traits<A>::template rebind_alloc<uint8_t>>;
+  using vector_u32 = std::vector<uint32_t, typename std::allocator_traits<A>::template rebind_alloc<uint32_t>>;
+
   void compress(const cpc_sketch_alloc<A>& source, compressed_state<A>& target) const;
   void uncompress(const compressed_state<A>& source, uncompressed_state<A>& target, uint8_t lg_k, uint32_t num_coupons) const;
 
@@ -126,17 +129,17 @@ private:
   uint16_t* make_decoding_table(const uint16_t* encoding_table, unsigned num_byte_values);
   void validate_decoding_table(const uint16_t* decoding_table, const uint16_t* encoding_table) const;
 
-  void compress_surprising_values(const vector_u32<A>& pairs, uint8_t lg_k, compressed_state<A>& result) const;
+  void compress_surprising_values(const vector_u32& pairs, uint8_t lg_k, compressed_state<A>& result) const;
   void compress_sliding_window(const uint8_t* window, uint8_t lg_k, uint32_t num_coupons, compressed_state<A>& target) const;
 
-  vector_u32<A> uncompress_surprising_values(const uint32_t* data, uint32_t data_words, uint32_t num_pairs, uint8_t lg_k, const A& allocator) const;
-  void uncompress_sliding_window(const uint32_t* data, uint32_t data_words, vector_u8<A>& window, uint8_t lg_k, uint32_t num_coupons) const;
+  vector_u32 uncompress_surprising_values(const uint32_t* data, uint32_t data_words, uint32_t num_pairs, uint8_t lg_k, const A& allocator) const;
+  void uncompress_sliding_window(const uint32_t* data, uint32_t data_words, vector_bytes& window, uint8_t lg_k, uint32_t num_coupons) const;
 
   static size_t safe_length_for_compressed_pair_buf(uint32_t k, uint32_t num_pairs, uint8_t num_base_bits);
   static size_t safe_length_for_compressed_window_buf(uint32_t k);
   static uint8_t determine_pseudo_phase(uint8_t lg_k, uint32_t c);
 
-  static inline vector_u32<A> tricky_get_pairs_from_window(const uint8_t* window, uint32_t k, uint32_t num_pairs_to_get, uint32_t empty_space, const A& allocator);
+  static inline vector_u32 tricky_get_pairs_from_window(const uint8_t* window, uint32_t k, uint32_t num_pairs_to_get, uint32_t empty_space, const A& allocator);
   static inline uint8_t golomb_choose_number_of_base_bits(uint32_t k, uint64_t count);
 };
 

data/vendor/datasketches-cpp/cpc/include/cpc_compressor_impl.hpp

@@ -183,7 +183,7 @@ void cpc_compressor<A>::uncompress(const compressed_state<A>& source, uncompress
 template<typename A>
 void cpc_compressor<A>::compress_sparse_flavor(const cpc_sketch_alloc<A>& source, compressed_state<A>& result) const {
   if (source.sliding_window.size() > 0) throw std::logic_error("unexpected sliding window");
-  vector_u32<A> pairs = source.surprising_value_table.unwrapping_get_items();
+  vector_u32 pairs = source.surprising_value_table.unwrapping_get_items();
   u32_table<A>::introspective_insertion_sort(pairs.data(), 0, pairs.size());
   compress_surprising_values(pairs, source.get_lg_k(), result);
 }
@@ -192,7 +192,7 @@ template<typename A>
 void cpc_compressor<A>::uncompress_sparse_flavor(const compressed_state<A>& source, uncompressed_state<A>& target, uint8_t lg_k) const {
   if (source.window_data.size() > 0) throw std::logic_error("unexpected sliding window");
   if (source.table_data.size() == 0) throw std::logic_error("table is expected");
-  vector_u32<A> pairs = uncompress_surprising_values(source.table_data.data(), source.table_data_words, source.table_num_entries,
+  vector_u32 pairs = uncompress_surprising_values(source.table_data.data(), source.table_data_words, source.table_num_entries,
       lg_k, source.table_data.get_allocator());
   target.table = u32_table<A>::make_from_pairs(pairs.data(), source.table_num_entries, lg_k, pairs.get_allocator());
 }
@@ -204,12 +204,12 @@ void cpc_compressor<A>::compress_hybrid_flavor(const cpc_sketch_alloc<A>& source
   if (source.sliding_window.size() == 0) throw std::logic_error("no sliding window");
   if (source.window_offset != 0) throw std::logic_error("window_offset != 0");
   const uint32_t k = 1 << source.get_lg_k();
-  vector_u32<A> pairs_from_table = source.surprising_value_table.unwrapping_get_items();
+  vector_u32 pairs_from_table = source.surprising_value_table.unwrapping_get_items();
   const uint32_t num_pairs_from_table = static_cast<uint32_t>(pairs_from_table.size());
   if (num_pairs_from_table > 0) u32_table<A>::introspective_insertion_sort(pairs_from_table.data(), 0, num_pairs_from_table);
   const uint32_t num_pairs_from_window = source.get_num_coupons() - num_pairs_from_table; // because the window offset is zero
 
-  vector_u32<A> all_pairs = tricky_get_pairs_from_window(source.sliding_window.data(), k, num_pairs_from_window, num_pairs_from_table, source.get_allocator());
+  vector_u32 all_pairs = tricky_get_pairs_from_window(source.sliding_window.data(), k, num_pairs_from_window, num_pairs_from_table, source.get_allocator());
 
   u32_table<A>::merge(
       pairs_from_table.data(), 0, pairs_from_table.size(),
@@ -224,7 +224,7 @@ template<typename A>
 void cpc_compressor<A>::uncompress_hybrid_flavor(const compressed_state<A>& source, uncompressed_state<A>& target, uint8_t lg_k) const {
   if (source.window_data.size() > 0) throw std::logic_error("window is not expected");
   if (source.table_data.size() == 0) throw std::logic_error("table is expected");
-  vector_u32<A> pairs = uncompress_surprising_values(source.table_data.data(), source.table_data_words, source.table_num_entries,
+  vector_u32 pairs = uncompress_surprising_values(source.table_data.data(), source.table_data_words, source.table_num_entries,
       lg_k, source.table_data.get_allocator());
 
   // In the hybrid flavor, some of these pairs actually
@@ -250,7 +250,7 @@ void cpc_compressor<A>::uncompress_hybrid_flavor(const compressed_state<A>& sour
 template<typename A>
 void cpc_compressor<A>::compress_pinned_flavor(const cpc_sketch_alloc<A>& source, compressed_state<A>& result) const {
   compress_sliding_window(source.sliding_window.data(), source.get_lg_k(), source.get_num_coupons(), result);
-  vector_u32<A> pairs = source.surprising_value_table.unwrapping_get_items();
+  vector_u32 pairs = source.surprising_value_table.unwrapping_get_items();
   if (pairs.size() > 0) {
     // Here we subtract 8 from the column indices. Because they are stored in the low 6 bits
     // of each row_col pair, and because no column index is less than 8 for a "Pinned" sketch,
@@ -277,7 +277,7 @@ void cpc_compressor<A>::uncompress_pinned_flavor(const compressed_state<A>& sour
     target.table = u32_table<A>(2, 6 + lg_k, source.table_data.get_allocator());
   } else {
     if (source.table_data.size() == 0) throw std::logic_error("table is expected");
-    vector_u32<A> pairs = uncompress_surprising_values(source.table_data.data(), source.table_data_words, num_pairs,
+    vector_u32 pairs = uncompress_surprising_values(source.table_data.data(), source.table_data_words, num_pairs,
         lg_k, source.table_data.get_allocator());
     // undo the compressor's 8-column shift
     for (uint32_t i = 0; i < num_pairs; i++) {
@@ -291,7 +291,7 @@ void cpc_compressor<A>::uncompress_pinned_flavor(const compressed_state<A>& sour
 template<typename A>
 void cpc_compressor<A>::compress_sliding_flavor(const cpc_sketch_alloc<A>& source, compressed_state<A>& result) const {
   compress_sliding_window(source.sliding_window.data(), source.get_lg_k(), source.get_num_coupons(), result);
-  vector_u32<A> pairs = source.surprising_value_table.unwrapping_get_items();
+  vector_u32 pairs = source.surprising_value_table.unwrapping_get_items();
   if (pairs.size() > 0) {
     // Here we apply a complicated transformation to the column indices, which
     // changes the implied ordering of the pairs, so we must do it before sorting.
@@ -330,7 +330,7 @@ void cpc_compressor<A>::uncompress_sliding_flavor(const compressed_state<A>& sou
     target.table = u32_table<A>(2, 6 + lg_k, source.table_data.get_allocator());
   } else {
     if (source.table_data.size() == 0) throw std::logic_error("table is expected");
-    vector_u32<A> pairs = uncompress_surprising_values(source.table_data.data(), source.table_data_words, num_pairs,
+    vector_u32 pairs = uncompress_surprising_values(source.table_data.data(), source.table_data_words, num_pairs,
         lg_k, source.table_data.get_allocator());
 
     const uint8_t pseudo_phase = determine_pseudo_phase(lg_k, num_coupons);
@@ -356,7 +356,7 @@ void cpc_compressor<A>::uncompress_sliding_flavor(const compressed_state<A>& sou
 }
 
 template<typename A>
-void cpc_compressor<A>::compress_surprising_values(const vector_u32<A>& pairs, uint8_t lg_k, compressed_state<A>& result) const {
+void cpc_compressor<A>::compress_surprising_values(const vector_u32& pairs, uint8_t lg_k, compressed_state<A>& result) const {
   const uint32_t k = 1 << lg_k;
   const uint32_t num_pairs = static_cast<uint32_t>(pairs.size());
   const uint8_t num_base_bits = golomb_choose_number_of_base_bits(k + num_pairs, num_pairs);
@@ -374,10 +374,10 @@ void cpc_compressor<A>::compress_surprising_values(const vector_u32<A>& pairs, u
 }
 
 template<typename A>
-vector_u32<A> cpc_compressor<A>::uncompress_surprising_values(const uint32_t* data, uint32_t data_words, uint32_t num_pairs,
-    uint8_t lg_k, const A& allocator) const {
+auto cpc_compressor<A>::uncompress_surprising_values(const uint32_t* data, uint32_t data_words, uint32_t num_pairs,
+    uint8_t lg_k, const A& allocator) const -> vector_u32 {
   const uint32_t k = 1 << lg_k;
-  vector_u32<A> pairs(num_pairs, 0, allocator);
+  vector_u32 pairs(num_pairs, 0, allocator);
   const uint8_t num_base_bits = golomb_choose_number_of_base_bits(k + num_pairs, num_pairs);
   low_level_uncompress_pairs(pairs.data(), num_pairs, num_base_bits, data, data_words);
   return pairs;
@@ -399,7 +399,7 @@ void cpc_compressor<A>::compress_sliding_window(const uint8_t* window, uint8_t l
 }
 
 template<typename A>
-void cpc_compressor<A>::uncompress_sliding_window(const uint32_t* data, uint32_t data_words, vector_u8<A>& window,
+void cpc_compressor<A>::uncompress_sliding_window(const uint32_t* data, uint32_t data_words, vector_bytes& window,
     uint8_t lg_k, uint32_t num_coupons) const {
   const uint32_t k = 1 << lg_k;
   window.resize(k); // zeroing not needed here (unlike the Hybrid Flavor)
@@ -722,10 +722,10 @@ void write_unary(
 // The empty space that this leaves at the beginning of the output array
 // will be filled in later by the caller.
 template<typename A>
-vector_u32<A> cpc_compressor<A>::tricky_get_pairs_from_window(const uint8_t* window, uint32_t k, uint32_t num_pairs_to_get,
-    uint32_t empty_space, const A& allocator) {
+auto cpc_compressor<A>::tricky_get_pairs_from_window(const uint8_t* window, uint32_t k, uint32_t num_pairs_to_get,
+    uint32_t empty_space, const A& allocator) -> vector_u32 {
   const size_t output_length = empty_space + num_pairs_to_get;
-  vector_u32<A> pairs(output_length, 0, allocator);
+  vector_u32 pairs(output_length, 0, allocator);
   size_t pair_index = empty_space;
   for (unsigned row_index = 0; row_index < k; row_index++) {
     uint8_t byte = window[row_index];

data/vendor/datasketches-cpp/cpc/include/cpc_confidence.hpp

@@ -30,7 +30,7 @@
 namespace datasketches {
 
 // ln 2.0
-static const double ICON_ERROT_CONSTANT = 0.693147180559945286;
+static const double ICON_ERROR_CONSTANT = 0.693147180559945286;
 
 //  1,    2,    3, // kappa
 static const int16_t ICON_LOW_SIDE_DATA [33] = {   // Empirically measured at N = 1000 * K.
@@ -102,7 +102,7 @@ double get_icon_confidence_lb(const cpc_sketch_alloc<A>& sketch, int kappa) {
   const long k = 1 << lg_k;
   if (lg_k < 4) throw std::logic_error("lgk < 4");
   if (kappa < 1 || kappa > 3) throw std::invalid_argument("kappa must be between 1 and 3");
-  double x = ICON_ERROT_CONSTANT;
+  double x = ICON_ERROR_CONSTANT;
   if (lg_k <= 14) x = ((double) ICON_HIGH_SIDE_DATA[3 * (lg_k - 4) + (kappa - 1)]) / 10000.0;
   const double rel = x / sqrt(k);
   const double eps = kappa * rel;
@@ -120,7 +120,7 @@ double get_icon_confidence_ub(const cpc_sketch_alloc<A>& sketch, int kappa) {
   const long k = 1 << lg_k;
   if (lg_k < 4) throw std::logic_error("lgk < 4");
   if (kappa < 1 || kappa > 3) throw std::invalid_argument("kappa must be between 1 and 3");
-  double x = ICON_ERROT_CONSTANT;
+  double x = ICON_ERROR_CONSTANT;
   if (lg_k <= 14) x = ((double) ICON_LOW_SIDE_DATA[3 * (lg_k - 4) + (kappa - 1)]) / 10000.0;
   const double rel = x / sqrt(k);
   const double eps = kappa * rel;