datasketches 0.2.1 → 0.2.2

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

@@ -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);