datasketches 0.1.2 → 0.2.3

data/vendor/datasketches-cpp/hll/include/HllUtil.hpp

@@ -34,140 +34,133 @@ namespace datasketches {
 
 enum hll_mode { LIST = 0, SET, HLL };
 
+namespace hll_constants {
+
+// preamble stuff
+static const uint8_t SER_VER = 1;
+static const uint8_t FAMILY_ID = 7;
+
+static const uint8_t EMPTY_FLAG_MASK          = 4;
+static const uint8_t COMPACT_FLAG_MASK        = 8;
+static const uint8_t OUT_OF_ORDER_FLAG_MASK   = 16;
+static const uint8_t FULL_SIZE_FLAG_MASK      = 32;
+
+static const uint32_t PREAMBLE_INTS_BYTE = 0;
+static const uint32_t SER_VER_BYTE       = 1;
+static const uint32_t FAMILY_BYTE        = 2;
+static const uint32_t LG_K_BYTE          = 3;
+static const uint32_t LG_ARR_BYTE        = 4;
+static const uint32_t FLAGS_BYTE         = 5;
+static const uint32_t LIST_COUNT_BYTE    = 6;
+static const uint32_t HLL_CUR_MIN_BYTE   = 6;
+static const uint32_t MODE_BYTE          = 7; // lo2bits = curMode, next 2 bits = tgtHllMode
+
+// Coupon List
+static const uint32_t LIST_INT_ARR_START = 8;
+static const uint8_t LIST_PREINTS = 2;
+// Coupon Hash Set
+static const uint32_t HASH_SET_COUNT_INT             = 8;
+static const uint32_t HASH_SET_INT_ARR_START         = 12;
+static const uint8_t HASH_SET_PREINTS         = 3;
+// HLL
+static const uint8_t HLL_PREINTS = 10;
+static const uint32_t HLL_BYTE_ARR_START = 40;
+static const uint32_t HIP_ACCUM_DOUBLE = 8;
+static const uint32_t KXQ0_DOUBLE = 16;
+static const uint32_t KXQ1_DOUBLE = 24;
+static const uint32_t CUR_MIN_COUNT_INT = 32;
+static const uint32_t AUX_COUNT_INT = 36;
+
+static const uint32_t EMPTY_SKETCH_SIZE_BYTES = 8;
+
+// other HllUtil stuff
+static const uint8_t KEY_BITS_26 = 26;
+static const uint8_t VAL_BITS_6 = 6;
+static const uint32_t KEY_MASK_26 = (1 << KEY_BITS_26) - 1;
+static const uint32_t VAL_MASK_6 = (1 << VAL_BITS_6) - 1;
+static const uint32_t EMPTY = 0;
+static const uint8_t MIN_LOG_K = 4;
+static const uint8_t MAX_LOG_K = 21;
+
+static const double HLL_HIP_RSE_FACTOR = 0.8325546; // sqrt(ln(2))
+static const double HLL_NON_HIP_RSE_FACTOR = 1.03896; // sqrt((3 * ln(2)) - 1)
+static const double COUPON_RSE_FACTOR = 0.409; // at transition point not the asymptote
+static const double COUPON_RSE = COUPON_RSE_FACTOR / (1 << 13);
+
+static const uint8_t LG_INIT_LIST_SIZE = 3;
+static const uint8_t LG_INIT_SET_SIZE = 5;
+static const uint32_t RESIZE_NUMER = 3;
+static const uint32_t RESIZE_DENOM = 4;
+
+static const uint8_t loNibbleMask = 0x0f;
+static const uint8_t hiNibbleMask = 0xf0;
+static const uint8_t AUX_TOKEN = 0xf;
+
+/**
+* Log2 table sizes for exceptions based on lgK from 0 to 26.
+* However, only lgK from 4 to 21 are used.
+*/
+static const uint8_t LG_AUX_ARR_INTS[] = {
+  0, 2, 2, 2, 2, 2, 2, 3, 3, 3,   // 0 - 9
+  4, 4, 5, 5, 6, 7, 8, 9, 10, 11, // 10-19
+  12, 13, 14, 15, 16, 17, 18      // 20-26
+};
+
+} // namespace hll_constants
+
+
 // template provides internal consistency and allows static float values
 // but we don't use the template parameter anywhere
-template<typename A = std::allocator<char> >
+template<typename A = std::allocator<uint8_t> >
 class HllUtil final {
 public:
-  // preamble stuff
-  static const int SER_VER = 1;
-  static const int FAMILY_ID = 7;
-
-  static const int EMPTY_FLAG_MASK          = 4;
-  static const int COMPACT_FLAG_MASK        = 8;
-  static const int OUT_OF_ORDER_FLAG_MASK   = 16;
-  static const int FULL_SIZE_FLAG_MASK      = 32;
-
-  static const int PREAMBLE_INTS_BYTE = 0;
-  static const int SER_VER_BYTE       = 1;
-  static const int FAMILY_BYTE        = 2;
-  static const int LG_K_BYTE          = 3;
-  static const int LG_ARR_BYTE        = 4;
-  static const int FLAGS_BYTE         = 5;
-  static const int LIST_COUNT_BYTE    = 6;
-  static const int HLL_CUR_MIN_BYTE   = 6;
-  static const int MODE_BYTE          = 7; // lo2bits = curMode, next 2 bits = tgtHllMode
-
-  // Coupon List
-  static const int LIST_INT_ARR_START = 8;
-  static const int LIST_PREINTS = 2;
-  // Coupon Hash Set
-  static const int HASH_SET_COUNT_INT             = 8;
-  static const int HASH_SET_INT_ARR_START         = 12;
-  static const int HASH_SET_PREINTS         = 3;
-  // HLL
-  static const int HLL_PREINTS = 10;
-  static const int HLL_BYTE_ARR_START = 40;
-  static const int HIP_ACCUM_DOUBLE = 8;
-  static const int KXQ0_DOUBLE = 16;
-  static const int KXQ1_DOUBLE = 24;
-  static const int CUR_MIN_COUNT_INT = 32;
-  static const int AUX_COUNT_INT = 36;
-  
-  static const int EMPTY_SKETCH_SIZE_BYTES = 8;
-
-  // other HllUtil stuff
-  static const int KEY_BITS_26 = 26;
-  static const int VAL_BITS_6 = 6;
-  static const int KEY_MASK_26 = (1 << KEY_BITS_26) - 1;
-  static const int VAL_MASK_6 = (1 << VAL_BITS_6) - 1;
-  static const int EMPTY = 0;
-  static const int MIN_LOG_K = 4;
-  static const int MAX_LOG_K = 21;
-
-  static const double HLL_HIP_RSE_FACTOR; // sqrt(log(2.0)) = 0.8325546
-  static const double HLL_NON_HIP_RSE_FACTOR; // sqrt((3.0 * log(2.0)) - 1.0) = 1.03896
-  static const double COUPON_RSE_FACTOR; // 0.409 at transition point not the asymptote
-  static const double COUPON_RSE; // COUPON_RSE_FACTOR / (1 << 13);
-
-  static const int LG_INIT_LIST_SIZE = 3;
-  static const int LG_INIT_SET_SIZE = 5;
-  static const int RESIZE_NUMER = 3;
-  static const int RESIZE_DENOM = 4;
-
-  static const int loNibbleMask = 0x0f;
-  static const int hiNibbleMask = 0xf0;
-  static const int AUX_TOKEN = 0xf;
-
-  /**
-  * Log2 table sizes for exceptions based on lgK from 0 to 26.
-  * However, only lgK from 4 to 21 are used.
-  */
-  static const int LG_AUX_ARR_INTS[];
-
-  static int coupon(const uint64_t hash[]);
-  static int coupon(const HashState& hashState);
-  static void hash(const void* key, int keyLen, uint64_t seed, HashState& result);
-  static int checkLgK(int lgK);
+
+  static uint32_t coupon(const uint64_t hash[]);
+  static uint32_t coupon(const HashState& hashState);
+  static void hash(const void* key, size_t keyLen, uint64_t seed, HashState& result);
+  static uint8_t checkLgK(uint8_t lgK);
   static void checkMemSize(uint64_t minBytes, uint64_t capBytes);
-  static inline void checkNumStdDev(int numStdDev);
-  static int pair(int slotNo, int value);
-  static int getLow26(unsigned int coupon);
-  static int getValue(unsigned int coupon);
-  static double invPow2(int e);
-  static unsigned int ceilingPowerOf2(unsigned int n);
-  static unsigned int simpleIntLog2(unsigned int n); // n must be power of 2
-  static int computeLgArrInts(hll_mode mode, int count, int lgConfigK);
-  static double getRelErr(bool upperBound, bool unioned,
-                          int lgConfigK, int numStdDev);
+  static inline void checkNumStdDev(uint8_t numStdDev);
+  static uint32_t pair(uint32_t slotNo, uint8_t value);
+  static uint32_t getLow26(uint32_t coupon);
+  static uint8_t getValue(uint32_t coupon);
+  static double invPow2(uint8_t e);
+  static uint8_t ceilingPowerOf2(uint32_t n);
+  static uint8_t simpleIntLog2(uint32_t n); // n must be power of 2
+  static uint8_t computeLgArrInts(hll_mode mode, uint32_t count, uint8_t lgConfigK);
+  static double getRelErr(bool upperBound, bool unioned, uint8_t lgConfigK, uint8_t numStdDev);
 };
 
 template<typename A>
-const double HllUtil<A>::HLL_HIP_RSE_FACTOR = sqrt(log(2.0)); // 0.8325546
-template<typename A>
-const double HllUtil<A>::HLL_NON_HIP_RSE_FACTOR = sqrt((3.0 * log(2.0)) - 1.0); // 1.03896
-template<typename A>
-const double HllUtil<A>::COUPON_RSE_FACTOR = 0.409;
-template<typename A>
-const double HllUtil<A>::COUPON_RSE = COUPON_RSE_FACTOR / (1 << 13);
-
-template<typename A>
-const int HllUtil<A>::LG_AUX_ARR_INTS[] = {
-      0, 2, 2, 2, 2, 2, 2, 3, 3, 3,   // 0 - 9
-      4, 4, 5, 5, 6, 7, 8, 9, 10, 11, // 10-19
-      12, 13, 14, 15, 16, 17, 18      // 20-26
-      };
-
-template<typename A>
-inline int HllUtil<A>::coupon(const uint64_t hash[]) {
-  int addr26 = (int) (hash[0] & KEY_MASK_26);
-  int lz = count_leading_zeros_in_u64(hash[1]);
-  int value = ((lz > 62 ? 62 : lz) + 1); 
-  return (value << KEY_BITS_26) | addr26;
+inline uint32_t HllUtil<A>::coupon(const uint64_t hash[]) {
+  uint32_t addr26 = hash[0] & hll_constants::KEY_MASK_26;
+  uint8_t lz = count_leading_zeros_in_u64(hash[1]);
+  uint8_t value = ((lz > 62 ? 62 : lz) + 1); 
+  return (value << hll_constants::KEY_BITS_26) | addr26;
 }
 
 template<typename A>
-inline int HllUtil<A>::coupon(const HashState& hashState) {
-  int addr26 = (int) (hashState.h1 & KEY_MASK_26);
-  int lz = count_leading_zeros_in_u64(hashState.h2);  
-  int value = ((lz > 62 ? 62 : lz) + 1); 
-  return (value << KEY_BITS_26) | addr26;
+inline uint32_t HllUtil<A>::coupon(const HashState& hashState) {
+  uint32_t addr26 = (int) (hashState.h1 & hll_constants::KEY_MASK_26);
+  uint8_t lz = count_leading_zeros_in_u64(hashState.h2);  
+  uint8_t value = ((lz > 62 ? 62 : lz) + 1); 
+  return (value << hll_constants::KEY_BITS_26) | addr26;
 }
 
 template<typename A>
-inline void HllUtil<A>::hash(const void* key, const int keyLen, const uint64_t seed, HashState& result) {
+inline void HllUtil<A>::hash(const void* key, size_t keyLen, uint64_t seed, HashState& result) {
   MurmurHash3_x64_128(key, keyLen, seed, result);
 }
 
 template<typename A>
-inline double HllUtil<A>::getRelErr(const bool upperBound, const bool unioned,
-                                    const int lgConfigK, const int numStdDev) {
+inline double HllUtil<A>::getRelErr(bool upperBound, bool unioned,
+                                    uint8_t lgConfigK, uint8_t numStdDev) {
   return RelativeErrorTables<A>::getRelErr(upperBound, unioned, lgConfigK, numStdDev);
 }
 
 template<typename A>
-inline int HllUtil<A>::checkLgK(const int lgK) {
-  if ((lgK >= HllUtil<A>::MIN_LOG_K) && (lgK <= HllUtil<A>::MAX_LOG_K)) {
+inline uint8_t HllUtil<A>::checkLgK(uint8_t lgK) {
+  if ((lgK >= hll_constants::MIN_LOG_K) && (lgK <= hll_constants::MAX_LOG_K)) {
     return lgK;
   } else {
     throw std::invalid_argument("Invalid value of k: " + std::to_string(lgK));
@@ -175,36 +168,36 @@ inline int HllUtil<A>::checkLgK(const int lgK) {
 }
 
 template<typename A>
-inline void HllUtil<A>::checkMemSize(const uint64_t minBytes, const uint64_t capBytes) {
+inline void HllUtil<A>::checkMemSize(uint64_t minBytes, uint64_t capBytes) {
   if (capBytes < minBytes) {
     throw std::invalid_argument("Given destination array is not large enough: " + std::to_string(capBytes));
   }
 }
 
 template<typename A>
-inline void HllUtil<A>::checkNumStdDev(const int numStdDev) {
+inline void HllUtil<A>::checkNumStdDev(uint8_t numStdDev) {
   if ((numStdDev < 1) || (numStdDev > 3)) {
     throw std::invalid_argument("NumStdDev may not be less than 1 or greater than 3.");
   }
 }
 
 template<typename A>
-inline int HllUtil<A>::pair(const int slotNo, const int value) {
-  return (value << HllUtil<A>::KEY_BITS_26) | (slotNo & HllUtil<A>::KEY_MASK_26);
+inline uint32_t HllUtil<A>::pair(uint32_t slotNo, uint8_t value) {
+  return (value << hll_constants::KEY_BITS_26) | (slotNo & hll_constants::KEY_MASK_26);
 }
 
 template<typename A>
-inline int HllUtil<A>::getLow26(const unsigned int coupon) {
-  return coupon & HllUtil<A>::KEY_MASK_26;
+inline uint32_t HllUtil<A>::getLow26(uint32_t coupon) {
+  return coupon & hll_constants::KEY_MASK_26;
 }
 
 template<typename A>
-inline int HllUtil<A>::getValue(const unsigned int coupon) {
-  return coupon >> HllUtil<A>::KEY_BITS_26;
+inline uint8_t HllUtil<A>::getValue(uint32_t coupon) {
+  return coupon >> hll_constants::KEY_BITS_26;
 }
 
 template<typename A>
-inline double HllUtil<A>::invPow2(const int e) {
+inline double HllUtil<A>::invPow2(uint8_t e) {
   union {
     long long longVal;
     double doubleVal;
@@ -214,7 +207,7 @@ inline double HllUtil<A>::invPow2(const int e) {
 }
 
 template<typename A>
-inline uint32_t HllUtil<A>::simpleIntLog2(uint32_t n) {
+inline uint8_t HllUtil<A>::simpleIntLog2(uint32_t n) {
   if (n == 0) {
     throw std::logic_error("cannot take log of 0");
   }
@@ -222,16 +215,16 @@ inline uint32_t HllUtil<A>::simpleIntLog2(uint32_t n) {
 }
 
 template<typename A>
-inline int HllUtil<A>::computeLgArrInts(hll_mode mode, int count, int lgConfigK) {
+inline uint8_t HllUtil<A>::computeLgArrInts(hll_mode mode, uint32_t count, uint8_t lgConfigK) {
   // assume value missing and recompute
-  if (mode == LIST) { return HllUtil<A>::LG_INIT_LIST_SIZE; }
-  int ceilPwr2 = ceiling_power_of_2(count);
-  if ((HllUtil<A>::RESIZE_DENOM * count) > (HllUtil<A>::RESIZE_NUMER * ceilPwr2)) { ceilPwr2 <<= 1;}
+  if (mode == LIST) { return hll_constants::LG_INIT_LIST_SIZE; }
+  uint32_t ceilPwr2 = ceiling_power_of_2(count);
+  if ((hll_constants::RESIZE_DENOM * count) > (hll_constants::RESIZE_NUMER * ceilPwr2)) { ceilPwr2 <<= 1;}
   if (mode == SET) {
-    return fmax(HllUtil<A>::LG_INIT_SET_SIZE, HllUtil<A>::simpleIntLog2(ceilPwr2));
+    return std::max(hll_constants::LG_INIT_SET_SIZE, HllUtil<A>::simpleIntLog2(ceilPwr2));
   }
   //only used for HLL4
-  return fmax(HllUtil<A>::LG_AUX_ARR_INTS[lgConfigK], HllUtil<A>::simpleIntLog2(ceilPwr2));
+  return std::max(hll_constants::LG_AUX_ARR_INTS[lgConfigK], HllUtil<A>::simpleIntLog2(ceilPwr2));
 }
 
 }

data/vendor/datasketches-cpp/hll/include/RelativeErrorTables.hpp

@@ -24,7 +24,7 @@
 
 namespace datasketches {
 
-template<typename A = std::allocator<char>>
+template<typename A = std::allocator<uint8_t>>
 class RelativeErrorTables {
   public:
     /**

data/vendor/datasketches-cpp/hll/include/coupon_iterator-internal.hpp

@@ -25,30 +25,30 @@
 namespace datasketches {
 
 template<typename A>
-coupon_iterator<A>::coupon_iterator(const int* array, size_t array_size, size_t index, bool all):
-array(array), array_size(array_size), index(index), all(all) {
-  while (this->index < array_size) {
-    if (all || array[this->index] != HllUtil<A>::EMPTY) break;
-    this->index++;
+coupon_iterator<A>::coupon_iterator(const uint32_t* array, size_t array_size, size_t index, bool all):
+array_(array), array_size_(array_size), index_(index), all_(all) {
+  while (index_ < array_size_) {
+    if (all_ || array_[index_] != hll_constants::EMPTY) break;
+    ++index_;
   }
 }
 
 template<typename A>
 coupon_iterator<A>& coupon_iterator<A>::operator++() {
-  while (++index < array_size) {
-    if (all || array[index] != HllUtil<A>::EMPTY) break;
+  while (++index_ < array_size_) {
+    if (all_ || array_[index_] != hll_constants::EMPTY) break;
   }
   return *this;
 }
 
 template<typename A>
 bool coupon_iterator<A>::operator!=(const coupon_iterator& other) const {
-  return index != other.index;
+  return index_ != other.index_;
 }
 
 template<typename A>
 uint32_t coupon_iterator<A>::operator*() const {
-  return array[index];
+  return array_[index_];
 }
 
 }

data/vendor/datasketches-cpp/hll/include/coupon_iterator.hpp

@@ -25,15 +25,15 @@ namespace datasketches {
 template<typename A>
 class coupon_iterator: public std::iterator<std::input_iterator_tag, uint32_t> {
 public:
-  coupon_iterator(const int* array, size_t array_slze, size_t index, bool all);
+  coupon_iterator(const uint32_t* array, size_t array_slze, size_t index, bool all);
   coupon_iterator& operator++();
   bool operator!=(const coupon_iterator& other) const;
   uint32_t operator*() const;
 private:
-  const int* array;
-  size_t array_size;
-  size_t index;
-  bool all;
+  const uint32_t* array_;
+  size_t array_size_;
+  size_t index_;
+  bool all_;
 };
 
 }

data/vendor/datasketches-cpp/hll/include/hll.hpp

@@ -108,7 +108,7 @@ class hll_union_alloc;
 template<typename A> using AllocU8 = typename std::allocator_traits<A>::template rebind_alloc<uint8_t>;
 template<typename A> using vector_u8 = std::vector<uint8_t, AllocU8<A>>;
 
-template<typename A = std::allocator<char> >
+template<typename A = std::allocator<uint8_t> >
 class hll_sketch_alloc final {
   public:
     /**
@@ -119,7 +119,7 @@ class hll_sketch_alloc final {
      *        keeping memory use constant (if HLL_6 or HLL_8) at the cost of
      *        starting out using much more memory
      */
-    explicit hll_sketch_alloc(int lg_config_k, target_hll_type tgt_type = HLL_4, bool start_full_size = false);
+    explicit hll_sketch_alloc(uint8_t lg_config_k, target_hll_type tgt_type = HLL_4, bool start_full_size = false, const A& allocator = A());
 
     /**
      * Copy constructor
@@ -140,14 +140,14 @@ class hll_sketch_alloc final {
      * Reconstructs a sketch from a serialized image on a stream.
      * @param is An input stream with a binary image of a sketch
      */
-    static hll_sketch_alloc deserialize(std::istream& is);
+    static hll_sketch_alloc deserialize(std::istream& is, const A& allocator = A());
 
     /**
      * Reconstructs a sketch from a serialized image in a byte array.
      * @param is bytes An input array with a binary image of a sketch
      * @param len Length of the input array, in bytes
      */
-    static hll_sketch_alloc deserialize(const void* bytes, size_t len);
+    static hll_sketch_alloc deserialize(const void* bytes, size_t len, const A& allocator = A());
 
     //! Class destructor
     virtual ~hll_sketch_alloc();
@@ -306,7 +306,7 @@ class hll_sketch_alloc final {
      * @param num_std_dev Number of standard deviations, an integer from the set  {1, 2, 3}.
      * @return The approximate lower bound.
      */
-    double get_lower_bound(int num_std_dev) const;
+    double get_lower_bound(uint8_t num_std_dev) const;
 
     /**
      * Returns the approximate upper error bound given the specified
@@ -314,13 +314,13 @@ class hll_sketch_alloc final {
      * @param num_std_dev Number of standard deviations, an integer from the set  {1, 2, 3}.
      * @return The approximate upper bound.
      */
-    double get_upper_bound(int num_std_dev) const;
+    double get_upper_bound(uint8_t num_std_dev) const;
 
     /**
      * Returns sketch's configured lg_k value.
      * @return Configured lg_k value.
      */
-    int get_lg_config_k() const;
+    uint8_t get_lg_config_k() const;
 
     /**
      * Returns the sketch's target HLL mode (from #target_hll_type).
@@ -344,13 +344,13 @@ class hll_sketch_alloc final {
      * Returns the size of the sketch serialized in compact form.
      * @return Size of the sketch serialized in compact form, in bytes.
      */
-    int get_compact_serialization_bytes() const;
+    uint32_t get_compact_serialization_bytes() const;
 
     /**
      * Returns the size of the sketch serialized without compaction.
      * @return Size of the sketch serialized without compaction, in bytes.
      */
-    int get_updatable_serialization_bytes() const;
+    uint32_t get_updatable_serialization_bytes() const;
 
     /**
      * Returns the maximum size in bytes that this sketch can grow to
@@ -363,7 +363,7 @@ class hll_sketch_alloc final {
      * @param tgt_type the desired Hll type
      * @return the maximum size in bytes that this sketch can grow to.
      */
-    static int get_max_updatable_serialization_bytes(int lg_k, target_hll_type tgt_type);
+    static uint32_t get_max_updatable_serialization_bytes(uint8_t lg_k, target_hll_type tgt_type);
   
     /**
      * Gets the current (approximate) Relative Error (RE) asymptotic values given several
@@ -376,18 +376,18 @@ class hll_sketch_alloc final {
      * @return the current (approximate) RelativeError
      */
     static double get_rel_err(bool upper_bound, bool unioned,
-                              int lg_config_k, int num_std_dev);
+                              uint8_t lg_config_k, uint8_t num_std_dev);
 
   private:
     explicit hll_sketch_alloc(HllSketchImpl<A>* that);
 
-    void coupon_update(int coupon);
+    void coupon_update(uint32_t coupon);
 
     std::string type_as_string() const;
     std::string mode_as_string() const;
 
     hll_mode get_current_mode() const;
-    int get_serialization_version() const;
+    uint8_t get_serialization_version() const;
     bool is_out_of_order_flag() const;
     bool is_estimation_mode() const;
 
@@ -423,7 +423,7 @@ class hll_sketch_alloc final {
  * author Kevin Lang
  */
  
-template<typename A = std::allocator<char> >
+template<typename A = std::allocator<uint8_t> >
 class hll_union_alloc {
   public:
     /**
@@ -431,7 +431,7 @@ class hll_union_alloc {
      * @param lg_max_k The maximum size, in log2, of k. The value must
      * be between 7 and 21, inclusive.
      */
-    explicit hll_union_alloc(int lg_max_k);
+    explicit hll_union_alloc(uint8_t lg_max_k, const A& allocator = A());
 
     /**
      * Returns the current cardinality estimate
@@ -458,7 +458,7 @@ class hll_union_alloc {
      * @param num_std_dev Number of standard deviations, an integer from the set  {1, 2, 3}.
      * @return The approximate lower bound.
      */
-    double get_lower_bound(int num_std_dev) const;
+    double get_lower_bound(uint8_t num_std_dev) const;
 
     /**
      * Returns the approximate upper error bound given the specified
@@ -466,25 +466,13 @@ class hll_union_alloc {
      * @param num_std_dev Number of standard deviations, an integer from the set  {1, 2, 3}.
      * @return The approximate upper bound.
      */
-    double get_upper_bound(int num_std_dev) const;
-
-    /**
-     * Returns the size of the union serialized in compact form.
-     * @return Size of the union serialized in compact form, in bytes.
-     */
-    int get_compact_serialization_bytes() const;
-
-    /**
-     * Returns the size of the union serialized without compaction.
-     * @return Size of the union serialized without compaction, in bytes.
-     */
-    int get_updatable_serialization_bytes() const;
+    double get_upper_bound(uint8_t num_std_dev) const;
 
     /**
      * Returns union's configured lg_k value.
      * @return Configured lg_k value.
      */
-    int get_lg_config_k() const;
+    uint8_t get_lg_config_k() const;
 
     /**
      * Returns the union's target HLL mode (from #target_hll_type).
@@ -492,12 +480,6 @@ class hll_union_alloc {
      */
     target_hll_type get_target_type() const;
 
-    /**
-     * Indicates if the union is currently stored compacted.
-     * @return True if the union is stored in compact form.
-     */
-    bool is_compact() const;
-
     /**
      * Indicates if the union is currently empty.
      * @return True if the union is empty.
@@ -605,15 +587,6 @@ class hll_union_alloc {
      */
     void update(const void* data, size_t length_bytes);
 
-    /**
-     * Returns the maximum size in bytes that this union operator can grow to given a lg_k.
-     *
-     * @param lg_k The maximum Log2 of k for this union operator. This value must be
-     * between 4 and 21 inclusively.
-     * @return the maximum size in bytes that this union operator can grow to.
-     */
-    static int get_max_serialization_bytes(int lg_k);
-
     /**
      * Gets the current (approximate) Relative Error (RE) asymptotic values given several
      * parameters. This is used primarily for testing.
@@ -625,7 +598,7 @@ class hll_union_alloc {
      * @return the current (approximate) RelativeError
      */
     static double get_rel_err(bool upper_bound, bool unioned,
-                              int lg_config_k, int num_std_dev);
+                              uint8_t lg_config_k, uint8_t num_std_dev);
 
   private:
 
@@ -638,22 +611,21 @@ class hll_union_alloc {
     * @param incoming_impl the given incoming sketch, which may not be modified.
     * @param lg_max_k the maximum value of log2 K for this union.
     */
-    inline void union_impl(const hll_sketch_alloc<A>& sketch, int lg_max_k);
+    inline void union_impl(const hll_sketch_alloc<A>& sketch, uint8_t lg_max_k);
 
-    static HllSketchImpl<A>* copy_or_downsample(const HllSketchImpl<A>* src_impl, int tgt_lg_k);
+    static HllSketchImpl<A>* copy_or_downsample(const HllSketchImpl<A>* src_impl, uint8_t tgt_lg_k);
 
-    void coupon_update(int coupon);
+    void coupon_update(uint32_t coupon);
 
     hll_mode get_current_mode() const;
-    int get_serialization_version() const;
     bool is_out_of_order_flag() const;
     bool is_estimation_mode() const;
 
     // calls couponUpdate on sketch, freeing the old sketch upon changes in hll_mode
-    static HllSketchImpl<A>* leak_free_coupon_update(HllSketchImpl<A>* impl, int coupon);
+    static HllSketchImpl<A>* leak_free_coupon_update(HllSketchImpl<A>* impl, uint32_t coupon);
 
-    int lg_max_k;
-    hll_sketch_alloc<A> gadget;
+    uint8_t lg_max_k_;
+    hll_sketch_alloc<A> gadget_;
 };
 
 /// convenience alias for hll_sketch with default allocator

data/vendor/datasketches-cpp/hll/test/AuxHashMapTest.cpp

@@ -25,7 +25,7 @@
 namespace datasketches {
 
 TEST_CASE("aux hash map: check must replace", "[aux_hash_map]") {
-  AuxHashMap<>* map = new AuxHashMap<>(3, 7);
+  AuxHashMap<std::allocator<uint8_t>>* map = new AuxHashMap<std::allocator<uint8_t>>(3, 7, std::allocator<uint8_t>());
   map->mustAdd(100, 5);
   int val = map->mustFindValueFor(100);
   REQUIRE(val == 5);
@@ -40,12 +40,12 @@ TEST_CASE("aux hash map: check must replace", "[aux_hash_map]") {
 }
 
 TEST_CASE("aux hash map: check grow space", "[aux_hash_map]") {
-  auto map = std::unique_ptr<AuxHashMap<>, std::function<void(AuxHashMap<>*)>>(
-      AuxHashMap<>::newAuxHashMap(3, 7),
-      AuxHashMap<>::make_deleter()
+  auto map = std::unique_ptr<AuxHashMap<std::allocator<uint8_t>>, std::function<void(AuxHashMap<std::allocator<uint8_t>>*)>>(
+      AuxHashMap<std::allocator<uint8_t>>::newAuxHashMap(3, 7, std::allocator<uint8_t>()),
+      AuxHashMap<std::allocator<uint8_t>>::make_deleter()
       );
   REQUIRE(map->getLgAuxArrInts() == 3);
-  for (int i = 1; i <= 7; ++i) {
+  for (uint8_t i = 1; i <= 7; ++i) {
     map->mustAdd(i, i);
   }
   REQUIRE(map->getLgAuxArrInts() == 4);
@@ -63,17 +63,17 @@ TEST_CASE("aux hash map: check grow space", "[aux_hash_map]") {
 }
 
 TEST_CASE("aux hash map: check exception must find value for", "[aux_hash_map]") {
-  AuxHashMap<> map(3, 7);
+  AuxHashMap<std::allocator<uint8_t>> map(3, 7, std::allocator<uint8_t>());
   map.mustAdd(100, 5);
   REQUIRE_THROWS_AS(map.mustFindValueFor(101), std::invalid_argument);
 }
 
 TEST_CASE("aux hash map: check exception must add", "[aux_hash_map]") {
-  AuxHashMap<>* map = AuxHashMap<>::newAuxHashMap(3, 7);
+  AuxHashMap<std::allocator<uint8_t>>* map = AuxHashMap<std::allocator<uint8_t>>::newAuxHashMap(3, 7, std::allocator<uint8_t>());
   map->mustAdd(100, 5);
   REQUIRE_THROWS_AS(map->mustAdd(100, 6), std::invalid_argument);
   
-  AuxHashMap<>::make_deleter()(map);
+  AuxHashMap<std::allocator<uint8_t>>::make_deleter()(map);
 }
 
 } /* namespace datasketches */