datasketches 0.3.1 → 0.4.0

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

@@ -33,58 +33,58 @@
 
 namespace datasketches {
 
-/*
- * High performance C++ implementation of Compressed Probabilistic Counting (CPC) Sketch
- *
- * This is a very compact (in serialized form) distinct counting sketch.
- * The theory is described in the following paper:
- * https://arxiv.org/abs/1708.06839
- *
- * author Kevin Lang
- * author Alexander Saydakov
- */
-
-// forward-declarations
+// forward declarations
 template<typename A> class cpc_sketch_alloc;
 template<typename A> class cpc_union_alloc;
 
-// alias with default allocator for convenience
+/// CPC sketch alias with default allocator
 using cpc_sketch = cpc_sketch_alloc<std::allocator<uint8_t>>;
 
-// allocation and initialization of global decompression (decoding) tables
-// call this before anything else if you want to control the initialization time
-// for instance, to have this happen outside of a transaction context
-// otherwise initialization happens on the first use (serialization or deserialization)
-// it is safe to call more than once assuming no race conditions
-// this is not thread safe! neither is the rest of the library
+/**
+ * Allocation and initialization of global decompression (decoding) tables.
+ * Call this before anything else if you want to control the initialization time.
+ * For instance, to have this happen outside of a transaction context.
+ * Otherwise initialization happens on the first use (serialization or deserialization).
+ * It is safe to call more than once assuming no race conditions.
+ * This is not thread safe! Neither is the rest of the library.
+ */
 template<typename A> void cpc_init();
 
+/**
+ * High performance C++ implementation of Compressed Probabilistic Counting (CPC) Sketch
+ *
+ * This is a very compact (in serialized form) distinct counting sketch.
+ * The theory is described in the following paper:
+ * https://arxiv.org/abs/1708.06839
+ *
+ * @author Kevin Lang
+ * @author Alexander Saydakov
+ */
 template<typename A>
 class cpc_sketch_alloc {
 public:
+  using allocator_type = A;
+  using vector_bytes = std::vector<uint8_t, typename std::allocator_traits<A>::template rebind_alloc<uint8_t>>;
+  using vector_u64 = std::vector<uint64_t, typename std::allocator_traits<A>::template rebind_alloc<uint64_t>>;
+
   /**
    * Creates an instance of the sketch given the lg_k parameter and hash seed.
    * @param lg_k base 2 logarithm of the number of bins in the sketch
    * @param seed for hash function
+   * @param allocator instance of an allocator
    */
   explicit cpc_sketch_alloc(uint8_t lg_k = cpc_constants::DEFAULT_LG_K, uint64_t seed = DEFAULT_SEED, const A& allocator = A());
 
-  using allocator_type = A;
+  /// @return allocator
   A get_allocator() const;
 
-  /**
-   * @return configured lg_k of this sketch
-   */
+  /// @return configured lg_k of this sketch
   uint8_t get_lg_k() const;
 
-  /**
-   * @return true if this sketch represents an empty set
-   */
+  /// @return true if this sketch represents an empty set
   bool is_empty() const;
 
-  /**
-   * @return estimate of the distinct count of the input stream
-   */
+  /// @return estimate of the distinct count of the input stream
   double get_estimate() const;
 
   /**
@@ -189,13 +189,14 @@ public:
    * Otherwise two sketches that should represent overlapping sets will be disjoint
    * For instance, for signed 32-bit values call update(int32_t) method above,
    * which does widening conversion to int64_t, if compatibility with Java is expected
-   * @param data pointer to the data
-   * @param length of the data in bytes
+   * @param value pointer to the data
+   * @param size of the data in bytes
    */
   void update(const void* value, size_t size);
 
   /**
    * Returns a human-readable summary of this sketch
+   * @return a human-readable summary of this sketch
    */
   string<A> to_string() const;
 
@@ -205,16 +206,13 @@ public:
    */
   void serialize(std::ostream& os) const;
 
-  // This is a convenience alias for users
-  // The type returned by the following serialize method
-  using vector_bytes = vector_u8<A>;
-
   /**
    * This method serializes the sketch as a vector of bytes.
    * An optional header can be reserved in front of the sketch.
    * It is an uninitialized space of a given size.
    * This header is used in Datasketches PostgreSQL extension.
    * @param header_size_bytes space to reserve in front of the sketch
+   * @return serialized sketch as a vector of bytes
    */
   vector_bytes serialize(unsigned header_size_bytes = 0) const;
 
@@ -222,6 +220,7 @@ public:
    * This method deserializes a sketch from a given stream.
    * @param is input stream
    * @param seed the seed for the hash function that was used to create the sketch
+   * @param allocator instance of an Allocator
    * @return an instance of a sketch
    */
   static cpc_sketch_alloc<A> deserialize(std::istream& is, uint64_t seed = DEFAULT_SEED, const A& allocator = A());
@@ -231,6 +230,7 @@ public:
    * @param bytes pointer to the array of bytes
    * @param size the size of the array
    * @param seed the seed for the hash function that was used to create the sketch
+   * @param allocator instance of an Allocator
    * @return an instance of the sketch
    */
   static cpc_sketch_alloc<A> deserialize(const void* bytes, size_t size, uint64_t seed = DEFAULT_SEED, const A& allocator = A());
@@ -246,10 +246,10 @@ public:
    */
   static size_t get_max_serialized_size_bytes(uint8_t lg_k);
 
-  // for internal use
+  /// @private for internal use
   uint32_t get_num_coupons() const;
 
-  // for debugging
+  /// @private for debugging
   // this should catch some forms of corruption during serialization-deserialization
   bool validate() const;
 
@@ -276,7 +276,7 @@ private:
   uint32_t num_coupons; // the number of coupons collected so far
 
   u32_table<A> surprising_value_table;
-  vector_u8<A> sliding_window;
+  vector_bytes sliding_window;
   uint8_t window_offset; // derivable from num_coupons, but made explicit for speed
   uint8_t first_interesting_column; // This is part of a speed optimization
 
@@ -285,7 +285,7 @@ private:
 
   // for deserialization and cpc_union::get_result()
   cpc_sketch_alloc(uint8_t lg_k, uint32_t num_coupons, uint8_t first_interesting_column, u32_table<A>&& table,
-      vector_u8<A>&& window, bool has_hip, double kxp, double hip_est_accum, uint64_t seed);
+      vector_bytes&& window, bool has_hip, double kxp, double hip_est_accum, uint64_t seed);
 
   inline void row_col_update(uint32_t row_col);
   inline void update_sparse(uint32_t row_col);
@@ -308,7 +308,7 @@ private:
   static inline uint8_t determine_correct_offset(uint8_t lg_k, uint64_t c);
 
   // this produces a full-size k-by-64 bit matrix
-  vector_u64<A> build_bit_matrix() const;
+  vector_u64 build_bit_matrix() const;
 
   static uint8_t get_preamble_ints(uint32_t num_coupons, bool has_hip, bool has_table, bool has_window);
   inline void write_hip(std::ostream& os) const;

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

@@ -315,7 +315,7 @@ void cpc_sketch_alloc<A>::move_window() {
   const uint32_t k = 1 << lg_k;
 
   // Construct the full-sized bit matrix that corresponds to the sketch
-  vector_u64<A> bit_matrix = build_bit_matrix();
+  vector_u64 bit_matrix = build_bit_matrix();
 
   // refresh the KXP register on every 8th window shift.
   if ((new_offset & 0x7) == 0) refresh_kxp(bit_matrix.data());
@@ -359,7 +359,7 @@ void cpc_sketch_alloc<A>::refresh_kxp(const uint64_t* bit_matrix) {
 
   // for improved numerical accuracy, we separately sum the bytes of the U64's
   double byte_sums[8]; // allocating on the stack
-  std::fill(byte_sums, &byte_sums[8], 0);
+  std::fill(byte_sums, byte_sums + 8, 0);
 
   for (size_t i = 0; i < k; i++) {
     uint64_t word = bit_matrix[i];
@@ -458,7 +458,7 @@ void cpc_sketch_alloc<A>::serialize(std::ostream& os) const {
 }
 
 template<typename A>
-vector_u8<A> cpc_sketch_alloc<A>::serialize(unsigned header_size_bytes) const {
+auto cpc_sketch_alloc<A>::serialize(unsigned header_size_bytes) const -> vector_bytes {
   compressed_state<A> compressed(sliding_window.get_allocator());
   compressed.table_data_words = 0;
   compressed.table_num_entries = 0;
@@ -469,7 +469,7 @@ vector_u8<A> cpc_sketch_alloc<A>::serialize(unsigned header_size_bytes) const {
   const bool has_window = compressed.window_data.size() > 0;
   const uint8_t preamble_ints = get_preamble_ints(num_coupons, has_hip, has_table, has_window);
   const size_t size = header_size_bytes + (preamble_ints + compressed.table_data_words + compressed.window_data_words) * sizeof(uint32_t);
-  vector_u8<A> bytes(size, 0, sliding_window.get_allocator());
+  vector_bytes bytes(size, 0, sliding_window.get_allocator());
   uint8_t* ptr = bytes.data() + header_size_bytes;
   ptr += copy_to_mem(preamble_ints, ptr);
   const uint8_t serial_version = SERIAL_VERSION;
@@ -712,15 +712,18 @@ static const size_t CPC_MAX_PREAMBLE_SIZE_BYTES = 40;
 template<typename A>
 size_t cpc_sketch_alloc<A>::get_max_serialized_size_bytes(uint8_t lg_k) {
   check_lg_k(lg_k);
-  if (lg_k <= CPC_EMPIRICAL_SIZE_MAX_LGK) return CPC_EMPIRICAL_MAX_SIZE_BYTES[lg_k - CPC_MIN_LG_K] + CPC_MAX_PREAMBLE_SIZE_BYTES;
+  if (lg_k <= CPC_EMPIRICAL_SIZE_MAX_LGK) {
+    return CPC_EMPIRICAL_MAX_SIZE_BYTES[lg_k - cpc_constants::MIN_LG_K] + CPC_MAX_PREAMBLE_SIZE_BYTES;
+  }
   const uint32_t k = 1 << lg_k;
   return (int) (CPC_EMPIRICAL_MAX_SIZE_FACTOR * k) + CPC_MAX_PREAMBLE_SIZE_BYTES;
 }
 
 template<typename A>
 void cpc_sketch_alloc<A>::check_lg_k(uint8_t lg_k) {
-  if (lg_k < CPC_MIN_LG_K || lg_k > CPC_MAX_LG_K) {
-    throw std::invalid_argument("lg_k must be >= " + std::to_string(CPC_MIN_LG_K) + " and <= " + std::to_string(CPC_MAX_LG_K) + ": " + std::to_string(lg_k));
+  if (lg_k < cpc_constants::MIN_LG_K || lg_k > cpc_constants::MAX_LG_K) {
+    throw std::invalid_argument("lg_k must be >= " + std::to_string(cpc_constants::MIN_LG_K) + " and <= "
+        + std::to_string(cpc_constants::MAX_LG_K) + ": " + std::to_string(lg_k));
   }
 }
 
@@ -731,14 +734,14 @@ uint32_t cpc_sketch_alloc<A>::get_num_coupons() const {
 
 template<typename A>
 bool cpc_sketch_alloc<A>::validate() const {
-  vector_u64<A> bit_matrix = build_bit_matrix();
+  vector_u64 bit_matrix = build_bit_matrix();
   const uint64_t num_bits_set = count_bits_set_in_matrix(bit_matrix.data(), 1ULL << lg_k);
   return num_bits_set == num_coupons;
 }
 
 template<typename A>
 cpc_sketch_alloc<A>::cpc_sketch_alloc(uint8_t lg_k, uint32_t num_coupons, uint8_t first_interesting_column,
-    u32_table<A>&& table, vector_u8<A>&& window, bool has_hip, double kxp, double hip_est_accum, uint64_t seed):
+    u32_table<A>&& table, vector_bytes&& window, bool has_hip, double kxp, double hip_est_accum, uint64_t seed):
 lg_k(lg_k),
 seed(seed),
 was_merged(!has_hip),
@@ -800,14 +803,14 @@ uint8_t cpc_sketch_alloc<A>::determine_correct_offset(uint8_t lg_k, uint64_t c)
 }
 
 template<typename A>
-vector_u64<A> cpc_sketch_alloc<A>::build_bit_matrix() const {
+auto cpc_sketch_alloc<A>::build_bit_matrix() const -> vector_u64 {
   const uint32_t k = 1 << lg_k;
   if (window_offset > 56) throw std::logic_error("offset > 56");
 
   // Fill the matrix with default rows in which the "early zone" is filled with ones.
   // This is essential for the routine's O(k) time cost (as opposed to O(C)).
   const uint64_t default_row = (static_cast<uint64_t>(1) << window_offset) - 1;
-  vector_u64<A> matrix(k, default_row, sliding_window.get_allocator());
+  vector_u64 matrix(k, default_row, sliding_window.get_allocator());
 
   if (num_coupons == 0) return matrix;
 

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

@@ -27,31 +27,55 @@
 
 namespace datasketches {
 
-/*
+/// CPC union alias with default allocator
+using cpc_union = cpc_union_alloc<std::allocator<uint8_t>>;
+
+/**
  * High performance C++ implementation of Compressed Probabilistic Counting (CPC) Union
  *
  * author Kevin Lang
  * author Alexander Saydakov
  */
-
-// alias with default allocator for convenience
-using cpc_union = cpc_union_alloc<std::allocator<uint8_t>>;
-
 template<typename A>
 class cpc_union_alloc {
 public:
+  using vector_bytes = std::vector<uint8_t, typename std::allocator_traits<A>::template rebind_alloc<uint8_t>>;
+  using vector_u64 = std::vector<uint64_t, typename std::allocator_traits<A>::template rebind_alloc<uint64_t>>;
+
   /**
    * Creates an instance of the union given the lg_k parameter and hash seed.
    * @param lg_k base 2 logarithm of the number of bins in the sketch
    * @param seed for hash function
+   * @param allocator instance of an allocator
    */
   explicit cpc_union_alloc(uint8_t lg_k = cpc_constants::DEFAULT_LG_K, uint64_t seed = DEFAULT_SEED, const A& allocator = A());
 
+  /**
+   * Copy constructor
+   * @param other union to be copied
+   */
   cpc_union_alloc(const cpc_union_alloc<A>& other);
+
+  /**
+   * Move constructor
+   * @param other union to be moved
+   */
   cpc_union_alloc(cpc_union_alloc<A>&& other) noexcept;
+
   ~cpc_union_alloc();
 
+  /**
+   * Copy assignment
+   * @param other union to be copied
+   * @return reference to this union
+   */
   cpc_union_alloc<A>& operator=(const cpc_union_alloc<A>& other);
+
+  /**
+   * Move assignment
+   * @param other union to be moved
+   * @return reference to this union
+   */
   cpc_union_alloc<A>& operator=(cpc_union_alloc<A>&& other) noexcept;
 
   /**
@@ -73,14 +97,14 @@ public:
   cpc_sketch_alloc<A> get_result() const;
 
 private:
-  typedef typename std::allocator_traits<A>::template rebind_alloc<uint8_t> AllocU8;
-  typedef typename std::allocator_traits<A>::template rebind_alloc<uint64_t> AllocU64;
-  typedef typename std::allocator_traits<A>::template rebind_alloc<cpc_sketch_alloc<A>> AllocCpc;
+  using AllocU8 = typename std::allocator_traits<A>::template rebind_alloc<uint8_t>;
+  using AllocU64 = typename std::allocator_traits<A>::template rebind_alloc<uint64_t>;
+  using AllocCpc = typename std::allocator_traits<A>::template rebind_alloc<cpc_sketch_alloc<A>>;
 
   uint8_t lg_k;
   uint64_t seed;
   cpc_sketch_alloc<A>* accumulator;
-  vector_u64<A> bit_matrix;
+  vector_u64 bit_matrix;
 
   template<typename S> void internal_update(S&& sketch); // to support both rvalue and lvalue
 
@@ -90,8 +114,8 @@ private:
   void switch_to_bit_matrix();
   void walk_table_updating_sketch(const u32_table<A>& table);
   void or_table_into_matrix(const u32_table<A>& table);
-  void or_window_into_matrix(const vector_u8<A>& sliding_window, uint8_t offset, uint8_t src_lg_k);
-  void or_matrix_into_matrix(const vector_u64<A>& src_matrix, uint8_t src_lg_k);
+  void or_window_into_matrix(const vector_bytes& sliding_window, uint8_t offset, uint8_t src_lg_k);
+  void or_matrix_into_matrix(const vector_u64& src_matrix, uint8_t src_lg_k);
   void reduce_k(uint8_t new_lg_k);
 };
 

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

@@ -33,8 +33,8 @@ seed(seed),
 accumulator(nullptr),
 bit_matrix(allocator)
 {
-  if (lg_k < CPC_MIN_LG_K || lg_k > CPC_MAX_LG_K) {
-    throw std::invalid_argument("lg_k must be >= " + std::to_string(CPC_MIN_LG_K) + " and <= " + std::to_string(CPC_MAX_LG_K) + ": " + std::to_string(lg_k));
+  if (lg_k < cpc_constants::MIN_LG_K || lg_k > cpc_constants::MAX_LG_K) {
+    throw std::invalid_argument("lg_k must be >= " + std::to_string(cpc_constants::MIN_LG_K) + " and <= " + std::to_string(cpc_constants::MAX_LG_K) + ": " + std::to_string(lg_k));
   }
   accumulator = new (AllocCpc(allocator).allocate(1)) cpc_sketch_alloc<A>(lg_k, seed, allocator);
 }
@@ -166,7 +166,7 @@ void cpc_union_alloc<A>::internal_update(S&& sketch) {
   // SLIDING mode involves inverted logic, so we can't just walk the source sketch.
   // Instead, we convert it to a bitMatrix that can be OR'ed into the destination.
   if (cpc_sketch_alloc<A>::flavor::SLIDING != src_flavor) throw std::logic_error("wrong flavor"); // Case D
-  vector_u64<A> src_matrix = sketch.build_bit_matrix();
+  vector_u64 src_matrix = sketch.build_bit_matrix();
   or_matrix_into_matrix(src_matrix, sketch.get_lg_k());
 }
 
@@ -203,7 +203,7 @@ cpc_sketch_alloc<A> cpc_union_alloc<A>::get_result_from_bit_matrix() const {
 
   const uint8_t offset = cpc_sketch_alloc<A>::determine_correct_offset(lg_k, num_coupons);
 
-  vector_u8<A> sliding_window(k, 0, bit_matrix.get_allocator());
+  vector_bytes sliding_window(k, 0, bit_matrix.get_allocator());
   // don't need to zero the window's memory
 
   // dynamically growing caused snowplow effect
@@ -289,7 +289,7 @@ void cpc_union_alloc<A>::or_table_into_matrix(const u32_table<A>& table) {
 }
 
 template<typename A>
-void cpc_union_alloc<A>::or_window_into_matrix(const vector_u8<A>& sliding_window, uint8_t offset, uint8_t src_lg_k) {
+void cpc_union_alloc<A>::or_window_into_matrix(const vector_bytes& sliding_window, uint8_t offset, uint8_t src_lg_k) {
   if (lg_k > src_lg_k) throw std::logic_error("dst LgK > src LgK");
   const uint64_t dst_mask = (1 << lg_k) - 1; // downsamples when dst lgK < src LgK
   const uint32_t src_k = 1 << src_lg_k;
@@ -299,7 +299,7 @@ void cpc_union_alloc<A>::or_window_into_matrix(const vector_u8<A>& sliding_windo
 }
 
 template<typename A>
-void cpc_union_alloc<A>::or_matrix_into_matrix(const vector_u64<A>& src_matrix, uint8_t src_lg_k) {
+void cpc_union_alloc<A>::or_matrix_into_matrix(const vector_u64& src_matrix, uint8_t src_lg_k) {
   if (lg_k > src_lg_k) throw std::logic_error("dst LgK > src LgK");
   const uint64_t dst_mask = (1 << lg_k) - 1; // downsamples when dst lgK < src LgK
   const uint32_t src_k = 1 << src_lg_k;
@@ -315,10 +315,10 @@ void cpc_union_alloc<A>::reduce_k(uint8_t new_lg_k) {
 
   if (bit_matrix.size() > 0) { // downsample the unioner's bit matrix
     if (accumulator != nullptr) throw std::logic_error("accumulator is not null");
-    vector_u64<A> old_matrix = std::move(bit_matrix);
+    vector_u64 old_matrix = std::move(bit_matrix);
     const uint8_t old_lg_k = lg_k;
     const uint32_t new_k = 1 << new_lg_k;
-    bit_matrix = vector_u64<A>(new_k, 0, old_matrix.get_allocator());
+    bit_matrix = vector_u64(new_k, 0, old_matrix.get_allocator());
     lg_k = new_lg_k;
     or_matrix_into_matrix(old_matrix, old_lg_k);
     return;

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

@@ -89,7 +89,13 @@ static inline uint32_t warren_count_bits_set_in_matrix(const uint64_t* array, ui
 
 // This code is Figure 5-9 in "Hacker's Delight" by Henry S. Warren.
 
-#define CSA(h,l,a,b,c) {uint64_t u = a ^ b; uint64_t v = c; h = (a & b) | (u & v); l = u ^ v;}
+#define DATASKETCHES_CSA(h, l, a, b, c) \
+  {                                     \
+    uint64_t u = a ^ b;                 \
+    uint64_t v = c;                     \
+    h = (a & b) | (u & v);              \
+    l = u ^ v;                          \
+  }
 
 static inline uint32_t count_bits_set_in_matrix(const uint64_t* a, uint32_t length) {
   if ((length & 0x7) != 0) throw std::invalid_argument("the length of the array must be a multiple of 8");
@@ -98,15 +104,15 @@ static inline uint32_t count_bits_set_in_matrix(const uint64_t* a, uint32_t leng
   fours = twos = ones = 0;
 
   for (uint32_t i = 0; i <= length - 8; i += 8) {
-    CSA(twos_a, ones, ones, a[i+0], a[i+1]);
-    CSA(twos_b, ones, ones, a[i+2], a[i+3]);
-    CSA(fours_a, twos, twos, twos_a, twos_b);
+    DATASKETCHES_CSA(twos_a, ones, ones, a[i+0], a[i+1]);
+    DATASKETCHES_CSA(twos_b, ones, ones, a[i+2], a[i+3]);
+    DATASKETCHES_CSA(fours_a, twos, twos, twos_a, twos_b);
 
-    CSA(twos_a, ones, ones, a[i+4], a[i+5]);
-    CSA(twos_b, ones, ones, a[i+6], a[i+7]);
-    CSA(fours_b, twos, twos, twos_a, twos_b);
+    DATASKETCHES_CSA(twos_a, ones, ones, a[i+4], a[i+5]);
+    DATASKETCHES_CSA(twos_b, ones, ones, a[i+6], a[i+7]);
+    DATASKETCHES_CSA(fours_b, twos, twos, twos_a, twos_b);
 
-    CSA(eights, fours, fours, fours_a, fours_b);
+    DATASKETCHES_CSA(eights, fours, fours, fours_a, fours_b);
 
     total += warren_bit_count(eights);
   }
@@ -119,6 +125,8 @@ static inline uint32_t count_bits_set_in_matrix(const uint64_t* a, uint32_t leng
   return total;
 }
 
+#undef DATASKETCHES_CSA
+
 // Here are some timings made with quickTestMerge.c
 // for the "5 5" case:
 

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

@@ -38,6 +38,7 @@ static const uint32_t U32_TABLE_DOWNSIZE_DENOM = 4LL;
 template<typename A>
 class u32_table {
 public:
+  using vector_u32 = std::vector<uint32_t, typename std::allocator_traits<A>::template rebind_alloc<uint32_t>>;
 
   u32_table(const A& allocator);
   u32_table(uint8_t lg_size, uint8_t num_valid_bits, const A& allocator);
@@ -54,7 +55,7 @@ public:
 
   static u32_table make_from_pairs(const uint32_t* pairs, uint32_t num_pairs, uint8_t lg_k, const A& allocator);
 
-  vector_u32<A> unwrapping_get_items() const;
+  vector_u32 unwrapping_get_items() const;
 
   static void merge(
     const uint32_t* arr_a, size_t start_a, size_t length_a, // input
@@ -70,7 +71,7 @@ private:
   uint8_t lg_size; // log2 of number of slots
   uint8_t num_valid_bits;
   uint32_t num_items;
-  vector_u32<A> slots;
+  vector_u32 slots;
 
   inline uint32_t lookup(uint32_t item) const;
   inline void must_insert(uint32_t item);

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

@@ -151,8 +151,8 @@ void u32_table<A>::rebuild(uint8_t new_lg_size) {
   const uint32_t old_size = 1 << lg_size;
   const uint32_t new_size = 1 << new_lg_size;
   if (new_size <= num_items) throw std::logic_error("new_size <= num_items");
-  vector_u32<A> old_slots = std::move(slots);
-  slots = vector_u32<A>(new_size, UINT32_MAX, old_slots.get_allocator());
+  vector_u32 old_slots = std::move(slots);
+  slots = vector_u32(new_size, UINT32_MAX, old_slots.get_allocator());
   lg_size = new_lg_size;
   for (uint32_t i = 0; i < old_size; i++) {
     if (old_slots[i] != UINT32_MAX) {
@@ -168,10 +168,10 @@ void u32_table<A>::rebuild(uint8_t new_lg_size) {
 // and even then the subsequent sort would fix things up.
 // The result is nearly sorted, so make sure to use an efficient sort for that case
 template<typename A>
-vector_u32<A> u32_table<A>::unwrapping_get_items() const {
-  if (num_items == 0) return vector_u32<A>(slots.get_allocator());
+auto u32_table<A>::unwrapping_get_items() const -> vector_u32 {
+  if (num_items == 0) return vector_u32(slots.get_allocator());
   const uint32_t table_size = 1 << lg_size;
-  vector_u32<A> result(num_items, 0, slots.get_allocator());
+  vector_u32 result(num_items, 0, slots.get_allocator());
   size_t i = 0;
   size_t l = 0;
   size_t r = num_items - 1;

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

@@ -20,16 +20,15 @@ add_executable(cpc_test)
 target_link_libraries(cpc_test cpc common_test_lib)
 
 set_target_properties(cpc_test PROPERTIES
-  CXX_STANDARD 11
   CXX_STANDARD_REQUIRED YES
 )
 
-#file(TO_CMAKE_PATH "${CMAKE_CURRENT_SOURCE_DIR}" CPC_TEST_BINARY_PATH)
-#string(APPEND CPC_TEST_BINARY_PATH "/")
-#target_compile_definitions(cpc_test
-#  PRIVATE
-#    TEST_BINARY_INPUT_PATH="${CPC_TEST_BINARY_PATH}"
-#)
+file(TO_CMAKE_PATH "${CMAKE_CURRENT_SOURCE_DIR}" CPC_TEST_BINARY_PATH)
+string(APPEND CPC_TEST_BINARY_PATH "/")
+target_compile_definitions(cpc_test
+  PRIVATE
+    TEST_BINARY_INPUT_PATH="${CPC_TEST_BINARY_PATH}"
+)
 
 add_test(
   NAME cpc_test
@@ -43,3 +42,17 @@ target_sources(cpc_test
     compression_test.cpp
     cpc_sketch_allocation_test.cpp
 )
+
+if (SERDE_COMPAT)
+target_sources(cpc_test
+  PRIVATE
+    cpc_sketch_deserialize_from_java_test.cpp
+)
+endif()
+
+if (GENERATE)
+target_sources(cpc_test
+  PRIVATE
+    cpc_sketch_serialize_for_java.cpp
+)
+endif()

data/vendor/datasketches-cpp/cpc/test/cpc_sketch_deserialize_from_java_test.cpp

@@ -0,0 +1,60 @@
+/*
+ * 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 <fstream>
+#include <cpc_sketch.hpp>
+
+namespace datasketches {
+
+// assume the binary sketches for this test have been generated by datasketches-java code
+// in the subdirectory called "java" in the root directory of this project
+static std::string testBinaryInputPath = std::string(TEST_BINARY_INPUT_PATH) + "../../java/";
+
+TEST_CASE("cpc sketch", "[serde_compat]") {
+  const unsigned n_arr[] = {0, 100, 200, 2000, 20000};
+  for (const unsigned n: n_arr) {
+    std::ifstream is;
+    is.exceptions(std::ios::failbit | std::ios::badbit);
+    is.open(testBinaryInputPath + "cpc_n" + std::to_string(n) + "_java.sk", std::ios::binary);
+    const auto sketch = cpc_sketch::deserialize(is);
+    REQUIRE(sketch.is_empty() == (n == 0));
+    REQUIRE(sketch.get_estimate() == Approx(n).margin(n * 0.02));
+  }
+}
+
+TEST_CASE("cpc sketch negative one", "[serde_compat]") {
+  std::ifstream is;
+  is.exceptions(std::ios::failbit | std::ios::badbit);
+  is.open(testBinaryInputPath + "cpc_negative_one_java.sk", std::ios::binary);
+  auto sketch = cpc_sketch::deserialize(is);
+  REQUIRE_FALSE(sketch.is_empty());
+  REQUIRE(sketch.get_estimate() == Approx(1).margin(0.01));
+  sketch.update((uint64_t) -1);
+  sketch.update((int64_t) -1);
+  sketch.update((uint32_t) -1);
+  sketch.update((int32_t) -1);
+  sketch.update((uint16_t) -1);
+  sketch.update((int16_t) -1);
+  sketch.update((uint8_t) -1);
+  sketch.update((int8_t) -1);
+  REQUIRE(sketch.get_estimate() == Approx(1).margin(0.01));
+}
+
+} /* namespace datasketches */

data/vendor/datasketches-cpp/cpc/test/cpc_sketch_serialize_for_java.cpp

@@ -0,0 +1,38 @@
+/*
+ * 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 <fstream>
+#include <cpc_sketch.hpp>
+
+namespace datasketches {
+
+TEST_CASE("cpc sketch generate", "[serialize_for_java]") {
+  const unsigned n_arr[] = {0, 100, 200, 2000, 20000};
+  for (const unsigned n: n_arr) {
+    cpc_sketch sketch;
+    for (unsigned i = 1; i <= n; ++i) sketch.update(i);
+    REQUIRE(sketch.is_empty() == (n == 0));
+    REQUIRE(sketch.get_estimate() == Approx(n).margin(n * 0.02));
+    std::ofstream os("cpc_n" + std::to_string(n) + "_cpp.sk", std::ios::binary);
+    sketch.serialize(os);
+  }
+}
+
+} /* namespace datasketches */