datasketches 0.2.1 → 0.2.2

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 */

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

@@ -27,7 +27,7 @@ namespace datasketches {
 using hll_sketch_test_alloc = hll_sketch_alloc<test_allocator<uint8_t>>;
 using alloc = test_allocator<uint8_t>;
 
-static void runCheckCopy(int lgConfigK, target_hll_type tgtHllType) {
+static void runCheckCopy(uint8_t lgConfigK, target_hll_type tgtHllType) {
   hll_sketch_test_alloc sk(lgConfigK, tgtHllType, false, 0);
 
   for (int i = 0; i < 7; ++i) {
@@ -66,7 +66,7 @@ TEST_CASE("hll sketch: check copies", "[hll_sketch]") {
 }
 
 static void copyAs(target_hll_type srcType, target_hll_type dstType) {
-  int lgK = 8;
+  uint8_t lgK = 8;
   int n1 = 7;
   int n2 = 24;
   int n3 = 1000;
@@ -109,7 +109,7 @@ TEST_CASE("hll sketch: check copy as", "[hll_sketch]") {
 TEST_CASE("hll sketch: check misc1", "[hll_sketch]") {
   test_allocator_total_bytes = 0;
   {
-    int lgConfigK = 8;
+    uint8_t lgConfigK = 8;
     target_hll_type srcType = target_hll_type::HLL_8;
     hll_sketch_test_alloc sk(lgConfigK, srcType, false, 0);
 
@@ -124,7 +124,7 @@ TEST_CASE("hll sketch: check misc1", "[hll_sketch]") {
     sk.update(24); // HLL
     REQUIRE(sk.get_updatable_serialization_bytes() == 40 + 256);
 
-    const int hllBytes = HllUtil<>::HLL_BYTE_ARR_START + (1 << lgConfigK);
+    const auto hllBytes = hll_constants::HLL_BYTE_ARR_START + (1 << lgConfigK);
     REQUIRE(sk.get_compact_serialization_bytes() == hllBytes);
     REQUIRE(hll_sketch::get_max_updatable_serialization_bytes(lgConfigK, HLL_8) == hllBytes);
   }
@@ -135,22 +135,22 @@ TEST_CASE("hll sketch: check num std dev", "[hll_sketch]") {
   REQUIRE_THROWS_AS(HllUtil<>::checkNumStdDev(0), std::invalid_argument);
 }
 
-void checkSerializationSizes(const int lgConfigK, target_hll_type tgtHllType) {
+void checkSerializationSizes(uint8_t lgConfigK, target_hll_type tgtHllType) {
   hll_sketch_test_alloc sk(lgConfigK, tgtHllType, false, 0);
   int i;
 
   // LIST
   for (i = 0; i < 7; ++i) { sk.update(i); }
-  int expected = HllUtil<>::LIST_INT_ARR_START + (i << 2);
+  auto expected = hll_constants::LIST_INT_ARR_START + (i << 2);
   REQUIRE(sk.get_compact_serialization_bytes() == expected);
-  expected = HllUtil<>::LIST_INT_ARR_START + (4 << HllUtil<>::LG_INIT_LIST_SIZE);
+  expected = hll_constants::LIST_INT_ARR_START + (4 << hll_constants::LG_INIT_LIST_SIZE);
   REQUIRE(sk.get_updatable_serialization_bytes() == expected);
 
   // SET
   for (i = 7; i < 24; ++i) { sk.update(i); }
-  expected = HllUtil<>::HASH_SET_INT_ARR_START + (i << 2);
+  expected = hll_constants::HASH_SET_INT_ARR_START + (i << 2);
   REQUIRE(sk.get_compact_serialization_bytes() == expected);
-  expected = HllUtil<>::HASH_SET_INT_ARR_START + (4 << HllUtil<>::LG_INIT_SET_SIZE);
+  expected = hll_constants::HASH_SET_INT_ARR_START + (4 << hll_constants::LG_INIT_SET_SIZE);
   REQUIRE(sk.get_updatable_serialization_bytes() == expected);
 }
 
@@ -178,7 +178,7 @@ TEST_CASE("hll sketch: exercise to string", "[hll_sketch]") {
 
 // Creates and serializes then deserializes sketch.
 // Returns true if deserialized sketch is compact.
-static bool checkCompact(const int lgK, const int n, const target_hll_type type, bool compact) {
+static bool checkCompact(uint8_t lgK, const int n, const target_hll_type type, bool compact) {
   hll_sketch_test_alloc sk(lgK, type, false, 0);
   for (int i = 0; i < n; ++i) { sk.update(i); }
   
@@ -201,7 +201,7 @@ static bool checkCompact(const int lgK, const int n, const target_hll_type type,
 TEST_CASE("hll sketch: check compact flag", "[hll_sketch]") {
   test_allocator_total_bytes = 0;
   {
-    int lgK = 8;
+    uint8_t lgK = 8;
     // unless/until we create non-updatable "direct" versions,
     // deserialized image should never be compact
     // LIST: follows serialization request
@@ -230,10 +230,10 @@ TEST_CASE("hll sketch: check compact flag", "[hll_sketch]") {
 TEST_CASE("hll sketch: check k limits", "[hll_sketch]") {
   test_allocator_total_bytes = 0;
   {
-    hll_sketch_test_alloc sketch1(HllUtil<>::MIN_LOG_K, target_hll_type::HLL_8, false, 0);
-    hll_sketch_test_alloc sketch2(HllUtil<>::MAX_LOG_K, target_hll_type::HLL_4, false, 0);
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc(HllUtil<>::MIN_LOG_K - 1, target_hll_type::HLL_4, false, 0), std::invalid_argument);
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc(HllUtil<>::MAX_LOG_K + 1, target_hll_type::HLL_4, false, 0), std::invalid_argument);
+    hll_sketch_test_alloc sketch1(hll_constants::MIN_LOG_K, target_hll_type::HLL_8, false, 0);
+    hll_sketch_test_alloc sketch2(hll_constants::MAX_LOG_K, target_hll_type::HLL_4, false, 0);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc(hll_constants::MIN_LOG_K - 1, target_hll_type::HLL_4, false, 0), std::invalid_argument);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc(hll_constants::MAX_LOG_K + 1, target_hll_type::HLL_4, false, 0), std::invalid_argument);
   }
   REQUIRE(test_allocator_total_bytes == 0);
 }

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

@@ -24,23 +24,19 @@
 
 namespace datasketches {
 
-static int min(int a, int b) {
-  return (a < b) ? a : b;
-}
-
 static void println(std::string& str) {
   //std::cout << str << "\n";
 }
 
 static void basicUnion(uint64_t n1, uint64_t n2,
-		                   uint64_t lgk1, uint64_t lgk2, uint64_t lgMaxK,
+		                   uint8_t lgk1, uint8_t lgk2, uint8_t lgMaxK,
                        target_hll_type type1, target_hll_type type2, target_hll_type resultType) {
   uint64_t v = 0;
   //int tot = n1 + n2;
 
   hll_sketch h1(lgk1, type1);
   hll_sketch h2(lgk2, type2);
-  int lgControlK = min(min(lgk1, lgk2), lgMaxK);
+  uint8_t lgControlK = std::min(std::min(lgk1, lgk2), lgMaxK);
   hll_sketch control(lgControlK, resultType);
 
   for (uint64_t i = 0; i < n1; ++i) {
@@ -89,9 +85,9 @@ TEST_CASE("hll union: check unions", "[hll_union]") {
   target_hll_type type2 = HLL_8;
   target_hll_type resultType = HLL_8;
 
-  uint64_t lgK1 = 7;
-  uint64_t lgK2 = 7;
-  uint64_t lgMaxK = 7;
+  uint8_t lgK1 = 7;
+  uint8_t lgK2 = 7;
+  uint8_t lgMaxK = 7;
   uint64_t n1 = 7;
   uint64_t n2 = 7;
   basicUnion(n1, n2, lgK1, lgK2, lgMaxK, type1, type2, resultType);
@@ -108,7 +104,7 @@ TEST_CASE("hll union: check unions", "[hll_union]") {
   n2 = 14;
   basicUnion(n1, n2, lgK1, lgK2, lgMaxK, type1, type2, resultType);
 
-  int i = 0;
+  uint8_t i = 0;
   for (i = 7; i <= 13; ++i) {
     lgK1 = i;
     lgK2 = i;
@@ -184,9 +180,9 @@ TEST_CASE("hll union: check composite estimate", "[hll_union]") {
 }
 
 TEST_CASE("hll union: check config k limits", "[hll_union]") {
-  REQUIRE_THROWS_AS(hll_union(HllUtil<>::MIN_LOG_K - 1), std::invalid_argument);
+  REQUIRE_THROWS_AS(hll_union(hll_constants::MIN_LOG_K - 1), std::invalid_argument);
 
-  REQUIRE_THROWS_AS(hll_union(HllUtil<>::MAX_LOG_K + 1), std::invalid_argument);
+  REQUIRE_THROWS_AS(hll_union(hll_constants::MAX_LOG_K + 1), std::invalid_argument);
 }
 
 static double getBound(int lgK, bool ub, bool oooFlag, int numStdDev, double est) {
@@ -195,7 +191,7 @@ static double getBound(int lgK, bool ub, bool oooFlag, int numStdDev, double est
 }
 
 TEST_CASE("hll union: check ub lb", "[hll_union]") {
-  int lgK = 4;
+  uint8_t lgK = 4;
   int n = 1 << 20;
   bool oooFlag = false;
   
@@ -223,7 +219,7 @@ TEST_CASE("hll union: check ub lb", "[hll_union]") {
 }
 
 TEST_CASE("hll union: check conversions", "[hll_union]") {
-  int lgK = 4;
+  uint8_t lgK = 4;
   hll_sketch sk1(lgK, HLL_8);
   hll_sketch sk2(lgK, HLL_8);
   int n = 1 << 20;

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

@@ -57,7 +57,7 @@ static int get_n(int lg_k, hll_mode mode) {
 
 static long v = 0;
 
-static hll_sketch build_sketch(int lg_k, target_hll_type hll_type, hll_mode mode) {
+static hll_sketch build_sketch(uint8_t lg_k, target_hll_type hll_type, hll_mode mode) {
   hll_sketch sk(lg_k, hll_type);
   int n = get_n(lg_k, mode);
   for (int i = 0; i < n; i++) sk.update(static_cast<uint64_t>(i + v));
@@ -67,7 +67,7 @@ static hll_sketch build_sketch(int lg_k, target_hll_type hll_type, hll_mode mode
 
 // merges a sketch to an empty union and gets result of the same type, checks binary equivalence
 static void union_one_update(bool compact) {
-  for (int lg_k = 4; lg_k <= 21; lg_k++) { // all lg_k
+  for (uint8_t lg_k = 4; lg_k <= 21; lg_k++) { // all lg_k
     for (int mode = 0; mode <= 2; mode++) { // List, Set, Hll
       if ((lg_k < 8) && (mode == 1)) continue; // lg_k < 8 list transitions directly to HLL
       for (int t = 0; t <= 2; t++) { // HLL_4, HLL_6, HLL_8
@@ -102,7 +102,7 @@ TEST_CASE("hll isomorphic: union one update serialize compact", "[hll_isomorphic
 
 // converts a sketch to a different type and converts back to the original type to check binary equivalence
 static void convert_back_and_forth(bool compact) {
-  for (int lg_k = 4; lg_k <= 21; lg_k++) { // all lg_k
+  for (uint8_t lg_k = 4; lg_k <= 21; lg_k++) { // all lg_k
     for (int mode = 0; mode <= 2; mode++) { // List, Set, Hll
       if ((lg_k < 8) && (mode == 1)) continue; // lg_k < 8 list transitions directly to HLL
       for (int t1 = 0; t1 <= 2; t1++) { // HLL_4, HLL_6, HLL_8

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

@@ -44,11 +44,11 @@ TEST_CASE("hll to/from byte array: double serialize", "[hll_byte_array]") {
   auto ser2 = sk.serialize_updatable();
 
   REQUIRE(ser1.size() == ser2.size());
-  int len = ser1.size();
+  size_t len = ser1.size();
   uint8_t* b1 = ser1.data();
   uint8_t* b2 = ser2.data();
 
-  for (int i = 0; i < len; ++i) {
+  for (size_t i = 0; i < len; ++i) {
     REQUIRE(b2[i] == b1[i]);
   }
 }
@@ -129,7 +129,7 @@ static void checkSketchEquality(hll_sketch& sk1, hll_sketch& sk2) {
   REQUIRE(sk1.get_target_type() == sk2.get_target_type());
 }
 
-static void toFrom(const int lgConfigK, const target_hll_type tgtHllType, const int n) {
+static void toFrom(const uint8_t lgConfigK, const target_hll_type tgtHllType, const int n) {
   hll_sketch src(lgConfigK, tgtHllType);
   for (int i = 0; i < n; ++i) {
     src.update(i);
@@ -157,7 +157,7 @@ static void toFrom(const int lgConfigK, const target_hll_type tgtHllType, const
 TEST_CASE("hll to/from byte array: to from sketch", "[hll_byte_array]") {
   for (int i = 0; i < 10; ++i) {
     int n = nArr[i];
-    for (int lgK = 4; lgK <= 13; ++lgK) {
+    for (uint8_t lgK = 4; lgK <= 13; ++lgK) {
       toFrom(lgK, HLL_4, n);
       toFrom(lgK, HLL_6, n);
       toFrom(lgK, HLL_8, n);

data/vendor/datasketches-cpp/kll/include/kll_helper.hpp

@@ -26,7 +26,8 @@
 
 namespace datasketches {
 
-static std::independent_bits_engine<std::mt19937, 1, uint32_t> random_bit(std::chrono::system_clock::now().time_since_epoch().count());
+static std::independent_bits_engine<std::mt19937, 1, uint32_t>
+  random_bit(static_cast<uint32_t>(std::chrono::system_clock::now().time_since_epoch().count()));
 
 #ifdef KLL_VALIDATION
 extern uint32_t kll_next_offset;
@@ -46,9 +47,9 @@ class kll_helper {
     static inline uint8_t floor_of_log2_of_fraction(uint64_t numer, uint64_t denom);
     static inline uint8_t ub_on_num_levels(uint64_t n);
     static inline uint32_t compute_total_capacity(uint16_t k, uint8_t m, uint8_t num_levels);
-    static inline uint32_t level_capacity(uint16_t k, uint8_t numLevels, uint8_t height, uint8_t min_wid);
-    static inline uint32_t int_cap_aux(uint16_t k, uint8_t depth);
-    static inline uint32_t int_cap_aux_aux(uint16_t k, uint8_t depth);
+    static inline uint16_t level_capacity(uint16_t k, uint8_t numLevels, uint8_t height, uint8_t min_wid);
+    static inline uint16_t int_cap_aux(uint16_t k, uint8_t depth);
+    static inline uint16_t int_cap_aux_aux(uint16_t k, uint8_t depth);
     static inline uint64_t sum_the_sample_weights(uint8_t num_levels, const uint32_t* levels);
 
     /*

data/vendor/datasketches-cpp/kll/include/kll_helper_impl.hpp

@@ -55,28 +55,28 @@ uint32_t kll_helper::compute_total_capacity(uint16_t k, uint8_t m, uint8_t num_l
   return total;
 }
 
-uint32_t kll_helper::level_capacity(uint16_t k, uint8_t numLevels, uint8_t height, uint8_t min_wid) {
+uint16_t kll_helper::level_capacity(uint16_t k, uint8_t numLevels, uint8_t height, uint8_t min_wid) {
   if (height >= numLevels) throw std::invalid_argument("height >= numLevels");
   const uint8_t depth = numLevels - height - 1;
-  return std::max((uint32_t) min_wid, int_cap_aux(k, depth));
+  return std::max<uint16_t>(min_wid, int_cap_aux(k, depth));
 }
 
-uint32_t kll_helper::int_cap_aux(uint16_t k, uint8_t depth) {
+uint16_t kll_helper::int_cap_aux(uint16_t k, uint8_t depth) {
   if (depth > 60) throw std::invalid_argument("depth > 60");
   if (depth <= 30) return int_cap_aux_aux(k, depth);
   const uint8_t half = depth / 2;
   const uint8_t rest = depth - half;
-  const uint32_t tmp = int_cap_aux_aux(k, half);
+  const uint16_t tmp = int_cap_aux_aux(k, half);
   return int_cap_aux_aux(tmp, rest);
 }
 
-uint32_t kll_helper::int_cap_aux_aux(uint16_t k, uint8_t depth) {
+uint16_t kll_helper::int_cap_aux_aux(uint16_t k, uint8_t depth) {
   if (depth > 30) throw std::invalid_argument("depth > 30");
   const uint64_t twok = k << 1; // for rounding, we pre-multiply by 2
   const uint64_t tmp = (uint64_t) (((uint64_t) twok << depth) / powers_of_three[depth]);
   const uint64_t result = (tmp + 1) >> 1; // then here we add 1 and divide by 2
   if (result > k) throw std::logic_error("result > k");
-  return result;
+  return static_cast<uint16_t>(result);
 }
 
 uint64_t kll_helper::sum_the_sample_weights(uint8_t num_levels, const uint32_t* levels) {