datasketches 0.2.0 → 0.2.4

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

@@ -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, const A& allocator = A());
+    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
@@ -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;
 
@@ -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, const A& allocator = A());
+    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,13 +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;
+    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).
@@ -598,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:
 
@@ -611,21 +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;
     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

@@ -45,7 +45,7 @@ TEST_CASE("aux hash map: check grow space", "[aux_hash_map]") {
       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);

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

@@ -30,7 +30,7 @@
 namespace datasketches {
 
 TEST_CASE("coupon hash set: check corrupt bytearray", "[coupon_hash_set]") {
-  int lgK = 8;
+  uint8_t lgK = 8;
   hll_sketch sk1(lgK);
   for (int i = 0; i < 24; ++i) {
     sk1.update(i);
@@ -39,42 +39,42 @@ TEST_CASE("coupon hash set: check corrupt bytearray", "[coupon_hash_set]") {
   uint8_t* bytes = sketchBytes.data();
   const size_t size = sketchBytes.size();
 
-  bytes[HllUtil<>::PREAMBLE_INTS_BYTE] = 0;
+  bytes[hll_constants::PREAMBLE_INTS_BYTE] = 0;
   // fail in HllSketchImpl
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
   // fail in CouponHashSet
   REQUIRE_THROWS_AS(CouponHashSet<std::allocator<uint8_t>>::newSet(bytes, size, std::allocator<uint8_t>()), std::invalid_argument);
-  bytes[HllUtil<>::PREAMBLE_INTS_BYTE] = HllUtil<>::HASH_SET_PREINTS;
+  bytes[hll_constants::PREAMBLE_INTS_BYTE] = hll_constants::HASH_SET_PREINTS;
 
-  bytes[HllUtil<>::SER_VER_BYTE] = 0;
+  bytes[hll_constants::SER_VER_BYTE] = 0;
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
-  bytes[HllUtil<>::SER_VER_BYTE] = HllUtil<>::SER_VER;
+  bytes[hll_constants::SER_VER_BYTE] = hll_constants::SER_VER;
 
-  bytes[HllUtil<>::FAMILY_BYTE] = 0;
+  bytes[hll_constants::FAMILY_BYTE] = 0;
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
-  bytes[HllUtil<>::FAMILY_BYTE] = HllUtil<>::FAMILY_ID;
+  bytes[hll_constants::FAMILY_BYTE] = hll_constants::FAMILY_ID;
 
-  bytes[HllUtil<>::LG_K_BYTE] = 6;
+  bytes[hll_constants::LG_K_BYTE] = 6;
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
-  bytes[HllUtil<>::LG_K_BYTE] = lgK;
+  bytes[hll_constants::LG_K_BYTE] = lgK;
 
-  uint8_t tmp = bytes[HllUtil<>::MODE_BYTE];
-  bytes[HllUtil<>::MODE_BYTE] = 0x10; // HLL_6, LIST
+  uint8_t tmp = bytes[hll_constants::MODE_BYTE];
+  bytes[hll_constants::MODE_BYTE] = 0x10; // HLL_6, LIST
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
-  bytes[HllUtil<>::MODE_BYTE] = tmp;
+  bytes[hll_constants::MODE_BYTE] = tmp;
 
-  tmp = bytes[HllUtil<>::LG_ARR_BYTE];
-  bytes[HllUtil<>::LG_ARR_BYTE] = 0;
+  tmp = bytes[hll_constants::LG_ARR_BYTE];
+  bytes[hll_constants::LG_ARR_BYTE] = 0;
   hll_sketch::deserialize(bytes, size);
   // should work fine despite the corruption
-  bytes[HllUtil<>::LG_ARR_BYTE] = tmp;
+  bytes[hll_constants::LG_ARR_BYTE] = tmp;
 
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size - 1), std::out_of_range);
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, 3), std::out_of_range);
 }
 
 TEST_CASE("coupon hash set: check corrupt stream", "[coupon_hash_set]") {
-  int lgK = 9;
+  uint8_t lgK = 9;
   hll_sketch sk1(lgK);
   for (int i = 0; i < 24; ++i) {
     sk1.update(i);
@@ -82,48 +82,48 @@ TEST_CASE("coupon hash set: check corrupt stream", "[coupon_hash_set]") {
   std::stringstream ss;
   sk1.serialize_compact(ss);
 
-  ss.seekp(HllUtil<>::PREAMBLE_INTS_BYTE);
+  ss.seekp(hll_constants::PREAMBLE_INTS_BYTE);
   ss.put(0);
   ss.seekg(0);
   // fail in HllSketchImpl
   REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
   // fail in CouponHashSet
   REQUIRE_THROWS_AS(CouponHashSet<std::allocator<uint8_t>>::newSet(ss, std::allocator<uint8_t>()), std::invalid_argument);
-  ss.seekp(HllUtil<>::PREAMBLE_INTS_BYTE);
-  ss.put(HllUtil<>::HASH_SET_PREINTS);
+  ss.seekp(hll_constants::PREAMBLE_INTS_BYTE);
+  ss.put(hll_constants::HASH_SET_PREINTS);
 
-  ss.seekp(HllUtil<>::SER_VER_BYTE);
+  ss.seekp(hll_constants::SER_VER_BYTE);
   ss.put(0);
   ss.seekg(0);
   REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
-  ss.seekp(HllUtil<>::SER_VER_BYTE);
-  ss.put(HllUtil<>::SER_VER);
+  ss.seekp(hll_constants::SER_VER_BYTE);
+  ss.put(hll_constants::SER_VER);
 
-  ss.seekp(HllUtil<>::FAMILY_BYTE);
+  ss.seekp(hll_constants::FAMILY_BYTE);
   ss.put(0);
   ss.seekg(0);
   REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
-  ss.seekp(HllUtil<>::FAMILY_BYTE);
-  ss.put(HllUtil<>::FAMILY_ID);
+  ss.seekp(hll_constants::FAMILY_BYTE);
+  ss.put(hll_constants::FAMILY_ID);
 
-  ss.seekg(HllUtil<>::MODE_BYTE);
-  uint8_t tmp = ss.get();
-  ss.seekp(HllUtil<>::MODE_BYTE);
+  ss.seekg(hll_constants::MODE_BYTE);
+  auto tmp = ss.get();
+  ss.seekp(hll_constants::MODE_BYTE);
   ss.put(0x22); // HLL_8, HLL
   ss.seekg(0);
   REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
-  ss.seekp(HllUtil<>::MODE_BYTE);
-  ss.put(tmp);
+  ss.seekp(hll_constants::MODE_BYTE);
+  ss.put((char)tmp);
 
-  ss.seekg(HllUtil<>::LG_ARR_BYTE);
+  ss.seekg(hll_constants::LG_ARR_BYTE);
   tmp = ss.get();
-  ss.seekp(HllUtil<>::LG_ARR_BYTE);
+  ss.seekp(hll_constants::LG_ARR_BYTE);
   ss.put(0);
   ss.seekg(0);
   hll_sketch::deserialize(ss);
   // should work fine despite the corruption
-  ss.seekp(HllUtil<>::LG_ARR_BYTE);
-  ss.put(tmp);
+  ss.seekp(hll_constants::LG_ARR_BYTE);
+  ss.put((char)tmp);
 }
 
 

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

@@ -35,9 +35,9 @@ void println_string(std::string str) {
 }
 
 TEST_CASE("coupon list: check iterator", "[coupon_list]") {
-  int lgConfigK = 8;
+  uint8_t lgConfigK = 8;
   CouponList<std::allocator<uint8_t>> cl(lgConfigK, HLL_4, LIST, std::allocator<uint8_t>());
-  for (int i = 1; i <= 7; ++i) { cl.couponUpdate(HllUtil<>::pair(i, i)); } // not hashes but distinct values
+  for (uint8_t i = 1; i <= 7; ++i) { cl.couponUpdate(HllUtil<>::pair(i, i)); } // not hashes but distinct values
   const int mask = (1 << lgConfigK) - 1;
   int idx = 0;
   auto itr = cl.begin(false);
@@ -56,7 +56,7 @@ TEST_CASE("coupon list: check iterator", "[coupon_list]") {
 }
 
 TEST_CASE("coupon list: check duplicates and misc", "[coupon_list]") {
-  int lgConfigK = 8;
+  uint8_t lgConfigK = 8;
   hll_sketch sk(lgConfigK);
 
   for (int i = 1; i <= 7; ++i) {
@@ -79,7 +79,7 @@ TEST_CASE("coupon list: check duplicates and misc", "[coupon_list]") {
   REQUIRE(relErr < 0.0);
 }
 
-static void serializeDeserialize(const int lgK) {
+static void serializeDeserialize(uint8_t lgK) {
   hll_sketch sk1(lgK);
 
   int u = (lgK < 8) ? 7 : (((1 << (lgK - 3))/ 4) * 3);
@@ -110,7 +110,7 @@ TEST_CASE("coupon list: check serialize deserialize", "[coupon_list]") {
 }
 
 TEST_CASE("coupon list: check corrupt bytearray data", "[coupon_list]") {
-  int lgK = 6;
+  uint8_t lgK = 6;
   hll_sketch sk1(lgK);
   sk1.update(1);
   sk1.update(2);
@@ -118,24 +118,24 @@ TEST_CASE("coupon list: check corrupt bytearray data", "[coupon_list]") {
   uint8_t* bytes = sketchBytes.data();
   const size_t size = sketchBytes.size();
 
-  bytes[HllUtil<>::PREAMBLE_INTS_BYTE] = 0;
+  bytes[hll_constants::PREAMBLE_INTS_BYTE] = 0;
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
   REQUIRE_THROWS_AS(CouponList<std::allocator<uint8_t>>::newList(bytes, size, std::allocator<uint8_t>()), std::invalid_argument);
 
-  bytes[HllUtil<>::PREAMBLE_INTS_BYTE] = HllUtil<>::LIST_PREINTS;
+  bytes[hll_constants::PREAMBLE_INTS_BYTE] = hll_constants::LIST_PREINTS;
 
-  bytes[HllUtil<>::SER_VER_BYTE] = 0;
+  bytes[hll_constants::SER_VER_BYTE] = 0;
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
-  bytes[HllUtil<>::SER_VER_BYTE] = HllUtil<>::SER_VER;
+  bytes[hll_constants::SER_VER_BYTE] = hll_constants::SER_VER;
 
-  bytes[HllUtil<>::FAMILY_BYTE] = 0;
+  bytes[hll_constants::FAMILY_BYTE] = 0;
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
-  bytes[HllUtil<>::FAMILY_BYTE] = HllUtil<>::FAMILY_ID;
+  bytes[hll_constants::FAMILY_BYTE] = hll_constants::FAMILY_ID;
 
-  uint8_t tmp = bytes[HllUtil<>::MODE_BYTE];
-  bytes[HllUtil<>::MODE_BYTE] = 0x01; // HLL_4, SET
+  uint8_t tmp = bytes[hll_constants::MODE_BYTE];
+  bytes[hll_constants::MODE_BYTE] = 0x01; // HLL_4, SET
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
-  bytes[HllUtil<>::MODE_BYTE] = tmp;
+  bytes[hll_constants::MODE_BYTE] = tmp;
 
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size - 1), std::out_of_range);
 
@@ -143,36 +143,36 @@ TEST_CASE("coupon list: check corrupt bytearray data", "[coupon_list]") {
 }
 
 TEST_CASE("coupon list: check corrupt stream data", "[coupon_list]") {
-  int lgK = 6;
+  uint8_t lgK = 6;
   hll_sketch sk1(lgK);
   sk1.update(1);
   sk1.update(2);
   std::stringstream ss;
   sk1.serialize_compact(ss);
 
-  ss.seekp(HllUtil<>::PREAMBLE_INTS_BYTE);
+  ss.seekp(hll_constants::PREAMBLE_INTS_BYTE);
   ss.put(0);
   ss.seekg(0);
   REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
   REQUIRE_THROWS_AS(CouponList<std::allocator<uint8_t>>::newList(ss, std::allocator<uint8_t>()), std::invalid_argument);
-  ss.seekp(HllUtil<>::PREAMBLE_INTS_BYTE);
-  ss.put(HllUtil<>::LIST_PREINTS);
+  ss.seekp(hll_constants::PREAMBLE_INTS_BYTE);
+  ss.put(hll_constants::LIST_PREINTS);
 
-  ss.seekp(HllUtil<>::SER_VER_BYTE);
+  ss.seekp(hll_constants::SER_VER_BYTE);
   ss.put(0);
   ss.seekg(0);
   REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
-  ss.seekp(HllUtil<>::SER_VER_BYTE);
-  ss.put(HllUtil<>::SER_VER);
+  ss.seekp(hll_constants::SER_VER_BYTE);
+  ss.put(hll_constants::SER_VER);
 
-  ss.seekp(HllUtil<>::FAMILY_BYTE);
+  ss.seekp(hll_constants::FAMILY_BYTE);
   ss.put(0);
   ss.seekg(0);
   REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
-  ss.seekp(HllUtil<>::FAMILY_BYTE);
-  ss.put(HllUtil<>::FAMILY_ID);
+  ss.seekp(hll_constants::FAMILY_BYTE);
+  ss.put(hll_constants::FAMILY_ID);
 
-  ss.seekp(HllUtil<>::MODE_BYTE);
+  ss.seekp(hll_constants::MODE_BYTE);
   ss.put(0x22); // HLL_8, HLL
   ss.seekg(0);
   REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);

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

@@ -26,7 +26,7 @@
 
 namespace datasketches {
 
-static hll_sketch buildSketch(const int n, const int lgK, const target_hll_type tgtHllType) {
+static hll_sketch buildSketch(const int n, const uint8_t lgK, const target_hll_type tgtHllType) {
   hll_sketch sketch(lgK, tgtHllType);
   for (int i = 0; i < n; ++i) {
     sketch.update(i);
@@ -34,7 +34,7 @@ static hll_sketch buildSketch(const int n, const int lgK, const target_hll_type
   return sketch;
 }
 
-static void crossCountingCheck(const int lgK, const int n) {
+static void crossCountingCheck(const uint8_t lgK, const int n) {
   hll_sketch sk4 = buildSketch(n, lgK, HLL_4);
   const double est = sk4.get_estimate();
   const double lb = sk4.get_lower_bound(1);

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

@@ -25,7 +25,7 @@
 
 namespace datasketches {
 
-static void testComposite(const int lgK, const target_hll_type tgtHllType, const int n) {
+static void testComposite(uint8_t lgK, const target_hll_type tgtHllType, const int n) {
   hll_union u(lgK);
   hll_sketch sk(lgK, tgtHllType);
   for (int i = 0; i < n; ++i) {
@@ -45,7 +45,7 @@ TEST_CASE("hll array: check composite estimate", "[hll_array]") {
   testComposite(13, target_hll_type::HLL_8, 10000);
 }
 
-static void serializeDeserialize(const int lgK, target_hll_type tgtHllType, const int n) {
+static void serializeDeserialize(uint8_t lgK, target_hll_type tgtHllType, const int n) {
   hll_sketch sk1(lgK, tgtHllType);
 
   for (int i = 0; i < n; ++i) {
@@ -72,7 +72,7 @@ static void serializeDeserialize(const int lgK, target_hll_type tgtHllType, cons
 }
 
 TEST_CASE("hll array: check serialize deserialize", "[hll_array]") {
-  int lgK = 4;
+  uint8_t lgK = 4;
   int n = 8;
   serializeDeserialize(lgK, HLL_4, n);
   serializeDeserialize(lgK, HLL_6, n);
@@ -100,7 +100,7 @@ TEST_CASE("hll array: check is compact", "[hll_array]") {
 }
 
 TEST_CASE("hll array: check corrupt bytearray", "[hll_array]") {
-  int lgK = 8;
+  uint8_t lgK = 8;
   hll_sketch sk1(lgK, HLL_8);
   for (int i = 0; i < 50; ++i) {
     sk1.update(i);
@@ -109,36 +109,36 @@ TEST_CASE("hll array: check corrupt bytearray", "[hll_array]") {
   uint8_t* bytes = sketchBytes.data();
   const size_t size = sketchBytes.size();
 
-  bytes[HllUtil<>::PREAMBLE_INTS_BYTE] = 0;
+  bytes[hll_constants::PREAMBLE_INTS_BYTE] = 0;
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
   REQUIRE_THROWS_AS(HllArray<std::allocator<uint8_t>>::newHll(bytes, size, std::allocator<uint8_t>()), std::invalid_argument);
-  bytes[HllUtil<>::PREAMBLE_INTS_BYTE] = HllUtil<>::HLL_PREINTS;
+  bytes[hll_constants::PREAMBLE_INTS_BYTE] = hll_constants::HLL_PREINTS;
 
-  bytes[HllUtil<>::SER_VER_BYTE] = 0;
+  bytes[hll_constants::SER_VER_BYTE] = 0;
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
-  bytes[HllUtil<>::SER_VER_BYTE] = HllUtil<>::SER_VER;
+  bytes[hll_constants::SER_VER_BYTE] = hll_constants::SER_VER;
 
-  bytes[HllUtil<>::FAMILY_BYTE] = 0;
+  bytes[hll_constants::FAMILY_BYTE] = 0;
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
-  bytes[HllUtil<>::FAMILY_BYTE] = HllUtil<>::FAMILY_ID;
+  bytes[hll_constants::FAMILY_BYTE] = hll_constants::FAMILY_ID;
 
-  uint8_t tmp = bytes[HllUtil<>::MODE_BYTE];
-  bytes[HllUtil<>::MODE_BYTE] = 0x10; // HLL_6, LIST
+  uint8_t tmp = bytes[hll_constants::MODE_BYTE];
+  bytes[hll_constants::MODE_BYTE] = 0x10; // HLL_6, LIST
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size), std::invalid_argument);
-  bytes[HllUtil<>::MODE_BYTE] = tmp;
+  bytes[hll_constants::MODE_BYTE] = tmp;
 
-  tmp = bytes[HllUtil<>::LG_ARR_BYTE];
-  bytes[HllUtil<>::LG_ARR_BYTE] = 0;
+  tmp = bytes[hll_constants::LG_ARR_BYTE];
+  bytes[hll_constants::LG_ARR_BYTE] = 0;
   hll_sketch::deserialize(bytes, size);
   // should work fine despite the corruption
-  bytes[HllUtil<>::LG_ARR_BYTE] = tmp;
+  bytes[hll_constants::LG_ARR_BYTE] = tmp;
 
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, size - 1), std::out_of_range);
   REQUIRE_THROWS_AS(hll_sketch::deserialize(bytes, 3), std::out_of_range);
 }
 
 TEST_CASE("hll array: check corrupt stream", "[hll_array]") {
-  int lgK = 6;
+  uint8_t lgK = 6;
   hll_sketch sk1(lgK);
   for (int i = 0; i < 50; ++i) {
     sk1.update(i);
@@ -146,46 +146,46 @@ TEST_CASE("hll array: check corrupt stream", "[hll_array]") {
   std::stringstream ss;
   sk1.serialize_compact(ss);
 
-  ss.seekp(HllUtil<>::PREAMBLE_INTS_BYTE);
+  ss.seekp(hll_constants::PREAMBLE_INTS_BYTE);
   ss.put(0);
   ss.seekg(0);
   REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
   REQUIRE_THROWS_AS(HllArray<std::allocator<uint8_t>>::newHll(ss, std::allocator<uint8_t>()), std::invalid_argument);
-  ss.seekp(HllUtil<>::PREAMBLE_INTS_BYTE);
-  ss.put(HllUtil<>::HLL_PREINTS);
+  ss.seekp(hll_constants::PREAMBLE_INTS_BYTE);
+  ss.put(hll_constants::HLL_PREINTS);
 
-  ss.seekp(HllUtil<>::SER_VER_BYTE);
+  ss.seekp(hll_constants::SER_VER_BYTE);
   ss.put(0);
   ss.seekg(0);
   REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
-  ss.seekp(HllUtil<>::SER_VER_BYTE);
-  ss.put(HllUtil<>::SER_VER);
+  ss.seekp(hll_constants::SER_VER_BYTE);
+  ss.put(hll_constants::SER_VER);
 
-  ss.seekp(HllUtil<>::FAMILY_BYTE);
+  ss.seekp(hll_constants::FAMILY_BYTE);
   ss.put(0);
   ss.seekg(0);
   REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
-  ss.seekp(HllUtil<>::FAMILY_BYTE);
-  ss.put(HllUtil<>::FAMILY_ID);
+  ss.seekp(hll_constants::FAMILY_BYTE);
+  ss.put(hll_constants::FAMILY_ID);
 
-  ss.seekg(HllUtil<>::MODE_BYTE);
-  uint8_t tmp = ss.get();
-  ss.seekp(HllUtil<>::MODE_BYTE);
+  ss.seekg(hll_constants::MODE_BYTE);
+  auto tmp = ss.get();
+  ss.seekp(hll_constants::MODE_BYTE);
   ss.put(0x11); // HLL_6, SET
   ss.seekg(0);
   REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
-  ss.seekp(HllUtil<>::MODE_BYTE);
-  ss.put(tmp);
+  ss.seekp(hll_constants::MODE_BYTE);
+  ss.put((char)tmp);
 
-  ss.seekg(HllUtil<>::LG_ARR_BYTE);
+  ss.seekg(hll_constants::LG_ARR_BYTE);
   tmp = ss.get();
-  ss.seekp(HllUtil<>::LG_ARR_BYTE);
+  ss.seekp(hll_constants::LG_ARR_BYTE);
   ss.put(0);
   ss.seekg(0);
   hll_sketch::deserialize(ss);
   // should work fine despite the corruption
-  ss.seekp(HllUtil<>::LG_ARR_BYTE);
-  ss.put(tmp);
+  ss.seekp(hll_constants::LG_ARR_BYTE);
+  ss.put((char)tmp);
 }
 
 } /* namespace datasketches */