datasketches 0.1.2 → 0.2.3

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

@@ -24,10 +24,11 @@
 
 namespace datasketches {
 
-typedef hll_sketch_alloc<test_allocator<void>> hll_sketch_test_alloc;
+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) {
-  hll_sketch_test_alloc sk(lgConfigK, 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) {
     sk.update(i);
@@ -65,13 +66,13 @@ 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;
   int base = 0;
 
-  hll_sketch_test_alloc src(lgK, srcType);
+  hll_sketch_test_alloc src(lgK, srcType, false, 0);
   for (int i = 0; i < n1; ++i) {
     src.update(i + base);
   }
@@ -108,9 +109,9 @@ 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);
+    hll_sketch_test_alloc sk(lgConfigK, srcType, false, 0);
 
     for (int i = 0; i < 7; ++i) { sk.update(i); } // LIST
     REQUIRE(sk.get_compact_serialization_bytes() == 36);
@@ -123,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);
   }
@@ -134,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) {
-  hll_sketch_test_alloc sk(lgConfigK, 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);
 }
 
@@ -162,27 +163,23 @@ TEST_CASE("hll sketch: check ser sizes", "[hll_sketch]") {
 }
 
 TEST_CASE("hll sketch: exercise to string", "[hll_sketch]") {
-  test_allocator_total_bytes = 0;
-  {
-    hll_sketch_test_alloc sk(15, HLL_4);
-    for (int i = 0; i < 25; ++i) { sk.update(i); }
-    std::ostringstream oss(std::ios::binary);
-    oss << sk.to_string(false, true, true, true);
-    for (int i = 25; i < (1 << 20); ++i) { sk.update(i); }
-    oss << sk.to_string(false, true, true, true);
-    oss << sk.to_string(false, true, true, false);
-
-    sk = hll_sketch_test_alloc(8, HLL_8);
-    for (int i = 0; i < 25; ++i) { sk.update(i); }
-    oss << sk.to_string(false, true, true, true);
-  }
-  REQUIRE(test_allocator_total_bytes == 0);
+  hll_sketch sk(15, HLL_4);
+  for (int i = 0; i < 25; ++i) { sk.update(i); }
+  std::ostringstream oss(std::ios::binary);
+  oss << sk.to_string(false, true, true, true);
+  for (int i = 25; i < (1 << 20); ++i) { sk.update(i); }
+  oss << sk.to_string(false, true, true, true);
+  oss << sk.to_string(false, true, true, false);
+
+  sk = hll_sketch(8, HLL_8);
+  for (int i = 0; i < 25; ++i) { sk.update(i); }
+  oss << sk.to_string(false, true, true, true);
 }
 
 // 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) {
-  hll_sketch_test_alloc sk(lgK, type);
+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); }
   
   std::stringstream ss(std::ios::in | std::ios::out | std::ios::binary);
@@ -194,7 +191,7 @@ static bool checkCompact(const int lgK, const int n, const target_hll_type type,
     REQUIRE(ss.tellp() == sk.get_updatable_serialization_bytes());
   }
   
-  hll_sketch_test_alloc sk2 = hll_sketch_test_alloc::deserialize(ss);
+  hll_sketch_test_alloc sk2 = hll_sketch_test_alloc::deserialize(ss, alloc(0));
   REQUIRE(sk2.get_estimate() == Approx(n).margin(0.01));
   bool isCompact = sk2.is_compact();
 
@@ -204,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
@@ -233,11 +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);
-    hll_sketch_test_alloc sketch2(HllUtil<>::MAX_LOG_K, target_hll_type::HLL_4);
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc(HllUtil<>::MIN_LOG_K - 1), std::invalid_argument);
-
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc(HllUtil<>::MAX_LOG_K + 1), 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);
 }
@@ -245,7 +241,7 @@ TEST_CASE("hll sketch: check k limits", "[hll_sketch]") {
 TEST_CASE("hll sketch: check input types", "[hll_sketch]") {
   test_allocator_total_bytes = 0;
   {
-    hll_sketch_test_alloc sk(8, target_hll_type::HLL_8);
+    hll_sketch_test_alloc sk(8, target_hll_type::HLL_8, false, 0);
 
     // inserting the same value as a variety of input types
     sk.update((uint8_t) 102);
@@ -271,19 +267,19 @@ TEST_CASE("hll sketch: check input types", "[hll_sketch]") {
     sk.update(str.c_str(), str.length());
     REQUIRE(sk.get_estimate() == Approx(4.0).margin(0.01));
 
-    sk = hll_sketch_test_alloc(8, target_hll_type::HLL_6);
+    sk = hll_sketch_test_alloc(8, target_hll_type::HLL_6, false, 0);
     sk.update((float) 0.0);
     sk.update((float) -0.0);
     sk.update((double) 0.0);
     sk.update((double) -0.0);
     REQUIRE(sk.get_estimate() == Approx(1.0).margin(0.01));
 
-    sk = hll_sketch_test_alloc(8, target_hll_type::HLL_4);
+    sk = hll_sketch_test_alloc(8, target_hll_type::HLL_4, false, 0);
     sk.update(std::nanf("3"));
     sk.update(std::nan("9"));
     REQUIRE(sk.get_estimate() == Approx(1.0).margin(0.01));
 
-    sk = hll_sketch_test_alloc(8, target_hll_type::HLL_4);
+    sk = hll_sketch_test_alloc(8, target_hll_type::HLL_4, false, 0);
     sk.update(nullptr, 0);
     sk.update("");
     REQUIRE(sk.is_empty());
@@ -294,24 +290,24 @@ TEST_CASE("hll sketch: check input types", "[hll_sketch]") {
 TEST_CASE("hll sketch: deserialize list mode buffer overrun", "[hll_sketch]") {
   test_allocator_total_bytes = 0;
   {
-    hll_sketch_test_alloc sketch(10);
+    hll_sketch_test_alloc sketch(10, target_hll_type::HLL_4, false, 0);
     sketch.update(1);
     auto bytes = sketch.serialize_compact();
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 7), std::out_of_range);
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 7, 0), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1, 0), std::out_of_range);
 
     // ckeck for leaks on stream exceptions
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
       ss.str(std::string((char*)bytes.data(), 7));
-      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss, alloc(0)), std::ios_base::failure);
     }
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
       ss.str(std::string((char*)bytes.data(), bytes.size() - 1));
-      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss, alloc(0)), std::ios_base::failure);
     }
   }
   REQUIRE(test_allocator_total_bytes == 0);
@@ -320,25 +316,25 @@ TEST_CASE("hll sketch: deserialize list mode buffer overrun", "[hll_sketch]") {
 TEST_CASE("hll sketch: deserialize set mode buffer overrun", "[hll_sketch]") {
   test_allocator_total_bytes = 0;
   {
-    hll_sketch_test_alloc sketch(10);
+    hll_sketch_test_alloc sketch(10, target_hll_type::HLL_4, false, 0);
     for (int i = 0; i < 10; ++i) sketch.update(i);
     //std::cout << sketch.to_string();
     auto bytes = sketch.serialize_updatable();
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 7), std::out_of_range);
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 7, 0), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1, 0), std::out_of_range);
 
     // ckeck for leaks on stream exceptions
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
       ss.str(std::string((char*)bytes.data(), 7));
-      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss, alloc(0)), std::ios_base::failure);
     }
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
       ss.str(std::string((char*)bytes.data(), bytes.size() - 1));
-      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss, alloc(0)), std::ios_base::failure);
     }
   }
   REQUIRE(test_allocator_total_bytes == 0);
@@ -348,39 +344,39 @@ TEST_CASE("hll sketch: deserialize HLL mode buffer overrun", "[hll_sketch]") {
   test_allocator_total_bytes = 0;
   {
     // this sketch should have aux table
-    hll_sketch_test_alloc sketch(15);
+    hll_sketch_test_alloc sketch(15, target_hll_type::HLL_4, false, 0);
     for (int i = 0; i < 14444; ++i) sketch.update(i);
     //std::cout << sketch.to_string();
     auto bytes = sketch.serialize_compact();
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 7), std::out_of_range);
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 15), std::out_of_range);
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 16420), std::out_of_range); // before aux table
-    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 7, 0), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 15, 0), std::out_of_range);
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 16420, 0), std::out_of_range); // before aux table
+    REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1, 0), std::out_of_range);
 
     // ckeck for leaks on stream exceptions
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
       ss.str(std::string((char*)bytes.data(), 7));
-      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss, alloc(0)), std::ios_base::failure);
     }
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
       ss.str(std::string((char*)bytes.data(), 15));
-      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss, alloc(0)), std::ios_base::failure);
     }
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
       ss.str(std::string((char*)bytes.data(), 16420)); // before aux table
-      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss, alloc(0)), std::ios_base::failure);
     }
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
       ss.str(std::string((char*)bytes.data(), bytes.size() - 1));
-      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss), std::ios_base::failure);
+      REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(ss, alloc(0)), std::ios_base::failure);
     }
   }
   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) {

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

@@ -24,19 +24,27 @@
 
 namespace datasketches {
 
+// forward declaration
+template<typename T, typename C, typename S, typename A> class kll_sketch;
+
 template <typename T, typename C, typename A>
 class kll_quantile_calculator {
   public:
-    // assumes that all levels are sorted including level 0
-    kll_quantile_calculator(const T* items, const uint32_t* levels, uint8_t num_levels, uint64_t n);
+    using Entry = std::pair<T, uint64_t>;
+    using AllocEntry = typename std::allocator_traits<A>::template rebind_alloc<Entry>;
+    using Container = std::vector<Entry, AllocEntry>;
+    using const_iterator = typename Container::const_iterator;
+
+    template<typename S>
+    kll_quantile_calculator(const kll_sketch<T, C, S, A>& sketch);
+
     T get_quantile(double fraction) const;
+    const_iterator begin() const;
+    const_iterator end() const;
 
   private:
     using AllocU32 = typename std::allocator_traits<A>::template rebind_alloc<uint32_t>;
     using vector_u32 = std::vector<uint32_t, AllocU32>;
-    using Entry = std::pair<T, uint64_t>;
-    using AllocEntry = typename std::allocator_traits<A>::template rebind_alloc<Entry>;
-    using Container = std::vector<Entry, AllocEntry>;
     uint64_t n_;
     vector_u32 levels_;
     Container entries_;
@@ -45,7 +53,7 @@ class kll_quantile_calculator {
     T approximately_answer_positional_query(uint64_t pos) const;
     void convert_to_preceding_cummulative();
     uint32_t chunk_containing_pos(uint64_t pos) const;
-    uint32_t search_for_chunk_containing_pos(uint64_t pos, uint32_t l, uint32_t r) const;
+    uint32_t search_for_chunk_containing_pos(uint64_t pos, uint64_t l, uint64_t r) const;
     static void merge_sorted_blocks(Container& entries, const uint32_t* levels, uint8_t num_levels, uint32_t num_items);
     static void merge_sorted_blocks_direct(Container& orig, Container& temp, const uint32_t* levels, uint8_t starting_level, uint8_t num_levels);
     static void merge_sorted_blocks_reversed(Container& orig, Container& temp, const uint32_t* levels, uint8_t starting_level, uint8_t num_levels);