datasketches 0.2.7 → 0.3.0

data/vendor/datasketches-cpp/quantiles/test/quantiles_sketch_test.cpp

@@ -47,53 +47,57 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
   test_allocator_total_bytes = 0;
 
   SECTION("k limits") {
-    quantiles_float_sketch sketch1(quantiles_constants::MIN_K, 0); // this should work
-    quantiles_float_sketch sketch2(quantiles_constants::MAX_K, 0); // this should work
-    REQUIRE_THROWS_AS(new quantiles_float_sketch(quantiles_constants::MIN_K - 1, 0), std::invalid_argument);
-    REQUIRE_THROWS_AS(new quantiles_float_sketch(40, 0), std::invalid_argument); // not power of 2
+    //std::cout << "sizeof(quantiles_sketch<float>)=" << sizeof(quantiles_sketch<float>) << '\n';
+    quantiles_float_sketch sketch1(quantiles_constants::MIN_K, std::less<float>(), 0); // this should work
+    quantiles_float_sketch sketch2(quantiles_constants::MAX_K, std::less<float>(), 0); // this should work
+    REQUIRE_THROWS_AS(new quantiles_float_sketch(quantiles_constants::MIN_K - 1, std::less<float>(), 0), std::invalid_argument);
+    REQUIRE_THROWS_AS(new quantiles_float_sketch(40, std::less<float>(), 0), std::invalid_argument); // not power of 2
     // MAX_K + 1 makes no sense because k is uint16_t
   }
 
   SECTION("empty") {
-    quantiles_float_sketch sketch(128, 0);
+    quantiles_float_sketch sketch(128, std::less<float>(), 0);
     REQUIRE(sketch.is_empty());
     REQUIRE_FALSE(sketch.is_estimation_mode());
     REQUIRE(sketch.get_n() == 0);
     REQUIRE(sketch.get_num_retained() == 0);
-    REQUIRE(std::isnan(sketch.get_rank(0)));
-    REQUIRE(std::isnan(sketch.get_min_value()));
-    REQUIRE(std::isnan(sketch.get_max_value()));
-    REQUIRE(std::isnan(sketch.get_quantile(0.5)));
+    REQUIRE_THROWS_AS(sketch.get_min_item(), std::runtime_error);
+    REQUIRE_THROWS_AS(sketch.get_max_item(), std::runtime_error);
+    REQUIRE_THROWS_AS(sketch.get_rank(0), std::runtime_error);
+    REQUIRE_THROWS_AS(sketch.get_quantile(0.5), std::runtime_error);
     const double fractions[3] {0, 0.5, 1};
-    REQUIRE(sketch.get_quantiles(fractions, 3).empty());
+    REQUIRE_THROWS_AS(sketch.get_quantiles(fractions, 3).empty(), std::runtime_error);
     const float split_points[1] {0};
-    REQUIRE(sketch.get_PMF(split_points, 1).empty());
-    REQUIRE(sketch.get_CDF(split_points, 1).empty());
+    REQUIRE_THROWS_AS(sketch.get_PMF(split_points, 1), std::runtime_error);
+    REQUIRE_THROWS_AS(sketch.get_CDF(split_points, 1), std::runtime_error);
 
-    for (auto it: sketch) {
-      unused(it);
+    for (auto pair: sketch) {
+      unused(pair);
       FAIL("should be no iterations over an empty sketch");
     }
-  }
+}
 
   SECTION("get bad quantile") {
-    quantiles_float_sketch sketch(64, 0);
+    quantiles_float_sketch sketch(64, std::less<float>(), 0);
     sketch.update(0.0f); // has to be non-empty to reach the check
     REQUIRE_THROWS_AS(sketch.get_quantile(-1), std::invalid_argument);
   }
 
   SECTION("one item") {
-    quantiles_float_sketch sketch(128, 0);
+    quantiles_float_sketch sketch(128, std::less<float>(), 0);
     sketch.update(1.0f);
     REQUIRE_FALSE(sketch.is_empty());
     REQUIRE_FALSE(sketch.is_estimation_mode());
     REQUIRE(sketch.get_n() == 1);
     REQUIRE(sketch.get_num_retained() == 1);
-    REQUIRE(sketch.get_rank(1.0f) == 0.0);
-    REQUIRE(sketch.get_rank(2.0f) == 1.0);
-    REQUIRE(sketch.get_min_value() == 1.0);
-    REQUIRE(sketch.get_max_value() == 1.0);
+    REQUIRE(sketch.get_rank(0) == 0);
+    REQUIRE(sketch.get_rank(1.0f) == 1);
+    REQUIRE(sketch.get_rank(1.0f, false) == 0);
+    REQUIRE(sketch.get_rank(2.0f, false) == 1);
+    REQUIRE(sketch.get_min_item() == 1.0);
+    REQUIRE(sketch.get_max_item() == 1.0);
     REQUIRE(sketch.get_quantile(0.5) == 1.0);
+
     const double fractions[3] {0, 0.5, 1};
     auto quantiles = sketch.get_quantiles(fractions, 3);
     REQUIRE(quantiles.size() == 3);
@@ -102,15 +106,20 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
     REQUIRE(quantiles[2] == 1.0);
 
     int count = 0;
-    for (auto it: sketch) {
-      REQUIRE(it.second == 1);
+    for (auto pair: sketch) {
+      REQUIRE(pair.second == 1);
       ++count;
     }
     REQUIRE(count == 1);
-  }
+
+    // iterator dereferencing
+    auto it = sketch.begin();
+    REQUIRE(it->first == 1.0f);
+    REQUIRE((*it).first == 1.0f);
+}
 
   SECTION("NaN") {
-    quantiles_float_sketch sketch(256, 0);
+    quantiles_float_sketch sketch(256, std::less<float>(), 0);
     sketch.update(std::numeric_limits<float>::quiet_NaN());
     REQUIRE(sketch.is_empty());
 
@@ -123,45 +132,33 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
   SECTION("sampling mode") {
     const uint16_t k = 8;
     const uint32_t n = 16 * (2 * k) + 1;
-    quantiles_float_sketch sk(k, 0);
+    quantiles_float_sketch sk(k, std::less<float>(), 0);
     for (uint32_t i = 0; i < n; ++i) {
       sk.update(static_cast<float>(i));
     }
   }
 
   SECTION("many items, exact mode") {
-    const uint32_t n = 127;
-    quantiles_float_sketch sketch(n + 1, 0);
-    for (uint32_t i = 0; i < n; i++) {
+    const uint32_t n = 100;
+    quantiles_float_sketch sketch(128, std::less<float>(), 0);
+    for (uint32_t i = 1; i <= n; i++) {
       sketch.update(static_cast<float>(i));
-      REQUIRE(sketch.get_n() == i + 1);
+      REQUIRE(sketch.get_n() == i);
     }
     REQUIRE_FALSE(sketch.is_empty());
     REQUIRE_FALSE(sketch.is_estimation_mode());
     REQUIRE(sketch.get_num_retained() == n);
-    REQUIRE(sketch.get_min_value() == 0.0);
-    REQUIRE(sketch.get_quantile(0) == 0.0);
-    REQUIRE(sketch.get_max_value() == n - 1);
-    REQUIRE(sketch.get_quantile(1) == n - 1);
-
-    int count = 0;
-    for (auto it: sketch) {
-      REQUIRE(it.second == 1);
-      ++count;
-    }
-    REQUIRE(count == n);
+    REQUIRE(sketch.get_min_item() == 1);
+    REQUIRE(sketch.get_quantile(0) == 1);
+    REQUIRE(sketch.get_max_item() == n);
+    REQUIRE(sketch.get_quantile(1) == n);
 
-    const double fractions[3] {0, 0.5, 1};
-    auto quantiles = sketch.get_quantiles(fractions, 3);
+    const double ranks[3] {0, 0.5, 1};
+    auto quantiles = sketch.get_quantiles(ranks, 3);
     REQUIRE(quantiles.size() == 3);
-    REQUIRE(quantiles[0] == 0.0);
+    REQUIRE(quantiles[0] == 1);
     REQUIRE(quantiles[1] == static_cast<float>(n / 2));
-    REQUIRE(quantiles[2] == n - 1 );
-
-    for (uint32_t i = 0; i < n; i++) {
-      const double trueRank = (double) i / n;
-      REQUIRE(sketch.get_rank(static_cast<float>(i)) == trueRank);
-    }
+    REQUIRE(quantiles[2] == n);
 
     // the alternative method must produce the same result
     auto quantiles2 = sketch.get_quantiles(3);
@@ -169,10 +166,24 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
     REQUIRE(quantiles[0] == quantiles2[0]);
     REQUIRE(quantiles[1] == quantiles2[1]);
     REQUIRE(quantiles[2] == quantiles2[2]);
+
+    int count = 0;
+    for (auto pair: sketch) {
+      REQUIRE(pair.second == 1);
+      ++count;
+    }
+    REQUIRE(count == n);
+
+    for (uint32_t i = 1; i <= n; i++) {
+      const double true_rank_inclusive = static_cast<double>(i) / n;
+      REQUIRE(sketch.get_rank(static_cast<float>(i)) == true_rank_inclusive);
+      const double true_rank_exclusive = static_cast<double>(i - 1) / n;
+      REQUIRE(sketch.get_rank(static_cast<float>(i), false) == true_rank_exclusive);
+    }
   }
 
   SECTION("10 items") {
-    quantiles_float_sketch sketch(128, 0);
+    quantiles_float_sketch sketch(128, std::less<float>(), 0);
     sketch.update(1.0f);
     sketch.update(2.0f);
     sketch.update(3.0f);
@@ -183,24 +194,24 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
     sketch.update(8.0f);
     sketch.update(9.0f);
     sketch.update(10.0f);
-    REQUIRE(sketch.get_quantile(0) == 1.0);
-    REQUIRE(sketch.get_quantile(0.5) == 6.0);
-    REQUIRE(sketch.get_quantile(0.99) == 10.0);
-    REQUIRE(sketch.get_quantile(1) == 10.0);
+    REQUIRE(sketch.get_quantile(0) == 1);
+    REQUIRE(sketch.get_quantile(0.5) == 5);
+    REQUIRE(sketch.get_quantile(0.99) == 10);
+    REQUIRE(sketch.get_quantile(1) == 10);
   }
 
-  SECTION("100 items") {
-    quantiles_float_sketch sketch(128, 0);
-    for (int i = 0; i < 100; ++i) sketch.update(static_cast<float>(i));
-    REQUIRE(sketch.get_quantile(0) == 0);
+  SECTION("100 items, exact mode") {
+    quantiles_float_sketch sketch(128, std::less<float>(), 0);
+    for (int i = 1; i <= 100; ++i) sketch.update(static_cast<float>(i));
+    REQUIRE(sketch.get_quantile(0) == 1);
     REQUIRE(sketch.get_quantile(0.01) == 1);
     REQUIRE(sketch.get_quantile(0.5) == 50);
-    REQUIRE(sketch.get_quantile(0.99) == 99.0);
-    REQUIRE(sketch.get_quantile(1) == 99.0);
+    REQUIRE(sketch.get_quantile(0.99) == 99);
+    REQUIRE(sketch.get_quantile(1) == 100);
   }
 
   SECTION("many items, estimation mode") {
-    quantiles_float_sketch sketch(128, 0);
+    quantiles_float_sketch sketch(128, std::less<float>(), 0);
     const int n = 1000000;
     for (int i = 0; i < n; i++) {
       sketch.update(static_cast<float>(i));
@@ -208,51 +219,30 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
     }
     REQUIRE_FALSE(sketch.is_empty());
     REQUIRE(sketch.is_estimation_mode());
-    REQUIRE(sketch.get_min_value() == 0.0); // min value is exact
-    REQUIRE(sketch.get_quantile(0) == 0.0); // min value is exact
-    REQUIRE(sketch.get_max_value() == n - 1); // max value is exact
-    REQUIRE(sketch.get_quantile(1) == n - 1); // max value is exact
+    REQUIRE(sketch.get_min_item() == 0.0); // min value is exact
+    REQUIRE(sketch.get_max_item() == n - 1); // max value is exact
 
     // test rank
     for (int i = 0; i < n; i++) {
-      const double trueRank = static_cast<float>(i) / n;
+      const double trueRank = static_cast<float>(i + 1) / n;
       const double sketchRank = sketch.get_rank(static_cast<float>(i));
       REQUIRE(sketchRank == Approx(trueRank).margin(RANK_EPS_FOR_K_128));
     }
 
-    // test quantiles at every 0.1 percentage point
-    double fractions[1001];
-    double reverse_fractions[1001]; // check that ordering does not matter
-    for (int i = 0; i < 1001; i++) {
-      fractions[i] = (double) i / 1000;
-      reverse_fractions[1000 - i] = fractions[i];
-    }
-    auto quantiles = sketch.get_quantiles(fractions, 1001);
-    auto reverse_quantiles = sketch.get_quantiles(reverse_fractions, 1001);
-    float previous_quantile(0);
-    for (int i = 0; i < 1001; i++) {
-      // expensive in a loop, just to check the equivalence here, not advised for real code
-      const float quantile = sketch.get_quantile(fractions[i]);
-      REQUIRE(quantiles[i] == quantile);
-      REQUIRE(reverse_quantiles[1000 - i] == quantile);
-      REQUIRE(previous_quantile <= quantile);
-      previous_quantile = quantile;
-    }
-
     //std::cout << sketch.to_string();
 
     uint32_t count = 0;
     uint64_t total_weight = 0;
-    for (auto it: sketch) {
+    for (auto pair: sketch) {
       ++count;
-      total_weight += it.second;
+      total_weight += pair.second;
     }
     REQUIRE(count == sketch.get_num_retained());
     REQUIRE(total_weight == sketch.get_n());
   }
 
   SECTION("consistency between get_rank and get_PMF/CDF") {
-    quantiles_float_sketch sketch(64, 0);
+    quantiles_float_sketch sketch(64, std::less<float>(), 0);
     const int n = 1000;
     float values[n];
     for (int i = 0; i < n; i++) {
@@ -287,149 +277,154 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
     // get_rank()
     // using knowledge of internal structure
     // value still in the base buffer to avoid randomness
-    REQUIRE(sketch.get_rank<false>(80) == 0.79);
-    REQUIRE(sketch.get_rank<true>(80) == 0.80);
+    REQUIRE(sketch.get_rank(80, false) == 0.79);
+    REQUIRE(sketch.get_rank(80, true) == 0.80);
 
     // value pushed into higher level
-    REQUIRE(sketch.get_rank<false>(50) == Approx(0.49).margin(0.01));
-    REQUIRE(sketch.get_rank<true>(50) == 0.50);
+    REQUIRE(sketch.get_rank(50, false) == Approx(0.49).margin(0.01));
+    REQUIRE(sketch.get_rank(50, true) == 0.50);
   
     // get_quantile()
     // value still in base buffer
-    REQUIRE(sketch.get_quantile<false>(0.70) == 71);
-    REQUIRE(sketch.get_quantile<true>(0.70) == 70);
+    REQUIRE(sketch.get_quantile(0.70, false) == 71);
+    REQUIRE(sketch.get_quantile(0.70, true) == 70);
   
     // value pushed into higher levell
-    int quantile = sketch.get_quantile<false>(0.30);
+    int quantile = sketch.get_quantile(0.30, false);
     if (quantile != 31 && quantile != 32) { FAIL(); }
     
-    quantile = sketch.get_quantile<true>(0.30);
+    quantile = sketch.get_quantile(0.30, true);
     if (quantile != 29 && quantile != 30) { FAIL(); }
   }
 
   SECTION("stream serialize deserialize empty") {
-    quantiles_float_sketch sketch(128, 0);
+    quantiles_float_sketch sketch(128, std::less<float>(), 0);
     std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
     sketch.serialize(s);
     REQUIRE(static_cast<size_t>(s.tellp()) == sketch.get_serialized_size_bytes());
-    auto sketch2 = quantiles_float_sketch::deserialize(s, serde<float>(), test_allocator<float>(0));
+    auto sketch2 = quantiles_float_sketch::deserialize(s, serde<float>(), std::less<float>(), 0);
     REQUIRE(static_cast<size_t>(s.tellp()) == sketch2.get_serialized_size_bytes());
     REQUIRE(s.tellg() == s.tellp());
     REQUIRE(sketch2.is_empty() == sketch.is_empty());
     REQUIRE(sketch2.is_estimation_mode() == sketch.is_estimation_mode());
     REQUIRE(sketch2.get_n() == sketch.get_n());
     REQUIRE(sketch2.get_num_retained() == sketch.get_num_retained());
-    REQUIRE(std::isnan(sketch2.get_min_value()));
-    REQUIRE(std::isnan(sketch2.get_max_value()));
+    REQUIRE_THROWS_AS(sketch2.get_min_item(), std::runtime_error);
+    REQUIRE_THROWS_AS(sketch2.get_max_item(), std::runtime_error);
     REQUIRE(sketch2.get_normalized_rank_error(false) == sketch.get_normalized_rank_error(false));
     REQUIRE(sketch2.get_normalized_rank_error(true) == sketch.get_normalized_rank_error(true));
   }
 
   SECTION("bytes serialize deserialize empty") {
-    quantiles_float_sketch sketch(256, 0);
+    quantiles_float_sketch sketch(256, std::less<float>(), 0);
     auto bytes = sketch.serialize();
-    auto sketch2 = quantiles_float_sketch::deserialize(bytes.data(), bytes.size(), serde<float>(), 0);
+    auto sketch2 = quantiles_float_sketch::deserialize(bytes.data(), bytes.size(), serde<float>(),
+        std::less<float>(), 0);
     REQUIRE(bytes.size() == sketch.get_serialized_size_bytes());
     REQUIRE(sketch2.is_empty() == sketch.is_empty());
     REQUIRE(sketch2.is_estimation_mode() == sketch.is_estimation_mode());
     REQUIRE(sketch2.get_n() == sketch.get_n());
     REQUIRE(sketch2.get_num_retained() == sketch.get_num_retained());
-    REQUIRE(std::isnan(sketch2.get_min_value()));
-    REQUIRE(std::isnan(sketch2.get_max_value()));
+    REQUIRE_THROWS_AS(sketch2.get_min_item(), std::runtime_error);
+    REQUIRE_THROWS_AS(sketch2.get_max_item(), std::runtime_error);
     REQUIRE(sketch2.get_normalized_rank_error(false) == sketch.get_normalized_rank_error(false));
     REQUIRE(sketch2.get_normalized_rank_error(true) == sketch.get_normalized_rank_error(true));
   }
 
   SECTION("stream serialize deserialize one item") {
-    quantiles_float_sketch sketch(32, 0);
+    quantiles_float_sketch sketch(32, std::less<float>(), 0);
     sketch.update(1.0f);
     std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
     sketch.serialize(s);
     REQUIRE(static_cast<size_t>(s.tellp()) == sketch.get_serialized_size_bytes());
-    auto sketch2 = quantiles_float_sketch::deserialize(s, serde<float>(), test_allocator<float>(0));
+    auto sketch2 = quantiles_float_sketch::deserialize(s, serde<float>(), std::less<float>(), 0);
     REQUIRE(static_cast<size_t>(s.tellp()) == sketch2.get_serialized_size_bytes());
     REQUIRE(s.tellg() == s.tellp());
     REQUIRE_FALSE(sketch2.is_empty());
     REQUIRE_FALSE(sketch2.is_estimation_mode());
     REQUIRE(sketch2.get_n() == 1);
     REQUIRE(sketch2.get_num_retained() == 1);
-    REQUIRE(sketch2.get_min_value() == 1.0);
-    REQUIRE(sketch2.get_max_value() == 1.0);
-    REQUIRE(sketch2.get_quantile(0.5) == 1.0);
-    REQUIRE(sketch2.get_rank(1) == 0.0);
-    REQUIRE(sketch2.get_rank(2) == 1.0);
+    REQUIRE(sketch2.get_min_item() == 1);
+    REQUIRE(sketch2.get_max_item() == 1);
+    REQUIRE(sketch2.get_quantile(0.5) == 1);
+    REQUIRE(sketch2.get_rank(0) == 0);
+    REQUIRE(sketch2.get_rank(1) == 1);
+    REQUIRE(sketch2.get_rank(2) == 1);
   }
 
   SECTION("bytes serialize deserialize one item") {
-    quantiles_float_sketch sketch(64, 0);
+    quantiles_float_sketch sketch(64, std::less<float>(), 0);
     sketch.update(1.0f);
     auto bytes = sketch.serialize();
     REQUIRE(bytes.size() == sketch.get_serialized_size_bytes());
-    auto sketch2 = quantiles_float_sketch::deserialize(bytes.data(), bytes.size(), serde<float>(), 0);
+    auto sketch2 = quantiles_float_sketch::deserialize(bytes.data(), bytes.size(), serde<float>(),
+        std::less<float>(), 0);
     REQUIRE(bytes.size() == sketch2.get_serialized_size_bytes());
     REQUIRE_FALSE(sketch2.is_empty());
     REQUIRE_FALSE(sketch2.is_estimation_mode());
     REQUIRE(sketch2.get_n() == 1);
     REQUIRE(sketch2.get_num_retained() == 1);
-    REQUIRE(sketch2.get_min_value() == 1.0);
-    REQUIRE(sketch2.get_max_value() == 1.0);
-    REQUIRE(sketch2.get_quantile(0.5) == 1.0);
-    REQUIRE(sketch2.get_rank(1) == 0.0);
-    REQUIRE(sketch2.get_rank(2) == 1.0);
+    REQUIRE(sketch2.get_min_item() == 1);
+    REQUIRE(sketch2.get_max_item() == 1);
+    REQUIRE(sketch2.get_quantile(0.5) == 1);
+    REQUIRE(sketch2.get_rank(0) == 0);
+    REQUIRE(sketch2.get_rank(1) == 1);
+    REQUIRE(sketch2.get_rank(2) == 1);
   }
 
   SECTION("stream serialize deserialize three items") {
-    quantiles_float_sketch sketch(128, 0);
+    quantiles_float_sketch sketch(128, std::less<float>(), 0);
     sketch.update(1.0f);
     sketch.update(2.0f);
     sketch.update(3.0f);
     std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
     sketch.serialize(s);
     REQUIRE(static_cast<size_t>(s.tellp()) == sketch.get_serialized_size_bytes());
-    auto sketch2 = quantiles_float_sketch::deserialize(s, serde<float>(), test_allocator<float>(0));
+    auto sketch2 = quantiles_float_sketch::deserialize(s, serde<float>(), std::less<float>(), 0);
     REQUIRE(static_cast<size_t>(s.tellp()) == sketch2.get_serialized_size_bytes());
     REQUIRE(s.tellg() == s.tellp());
     REQUIRE_FALSE(sketch2.is_empty());
     REQUIRE_FALSE(sketch2.is_estimation_mode());
     REQUIRE(sketch2.get_n() == 3);
     REQUIRE(sketch2.get_num_retained() == 3);
-    REQUIRE(sketch2.get_min_value() == 1.0);
-    REQUIRE(sketch2.get_max_value() == 3.0);
+    REQUIRE(sketch2.get_min_item() == 1.0);
+    REQUIRE(sketch2.get_max_item() == 3.0);
   }
 
   SECTION("bytes serialize deserialize three items") {
-    quantiles_float_sketch sketch(128, 0);
+    quantiles_float_sketch sketch(128, std::less<float>(), 0);
     sketch.update(1.0f);
     sketch.update(2.0f);
     sketch.update(3.0f);
     auto bytes = sketch.serialize();
     REQUIRE(bytes.size() == sketch.get_serialized_size_bytes());
-    auto sketch2 = quantiles_float_sketch::deserialize(bytes.data(), bytes.size(), serde<float>(), 0);
+    auto sketch2 = quantiles_float_sketch::deserialize(bytes.data(), bytes.size(), serde<float>(),
+        std::less<float>(), 0);
     REQUIRE(bytes.size() == sketch2.get_serialized_size_bytes());
     REQUIRE_FALSE(sketch2.is_empty());
     REQUIRE_FALSE(sketch2.is_estimation_mode());
     REQUIRE(sketch2.get_n() == 3);
     REQUIRE(sketch2.get_num_retained() == 3);
-    REQUIRE(sketch2.get_min_value() == 1.0);
-    REQUIRE(sketch2.get_max_value() == 3.0);
+    REQUIRE(sketch2.get_min_item() == 1.0);
+    REQUIRE(sketch2.get_max_item() == 3.0);
   }
 
   SECTION("stream serialize deserialize many floats") {
-    quantiles_float_sketch sketch(128, 0);
+    quantiles_float_sketch sketch(128, std::less<float>(), 0);
     const int n = 1000;
     for (int i = 0; i < n; i++) sketch.update(static_cast<float>(i));
     std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
     sketch.serialize(s);
     REQUIRE(static_cast<size_t>(s.tellp()) == sketch.get_serialized_size_bytes());
-    auto sketch2 = quantiles_float_sketch::deserialize(s, serde<float>(), test_allocator<float>(0));
+    auto sketch2 = quantiles_float_sketch::deserialize(s, serde<float>(), std::less<float>(), 0);
     REQUIRE(static_cast<size_t>(s.tellp()) == sketch2.get_serialized_size_bytes());
     REQUIRE(s.tellg() == s.tellp());
     REQUIRE(sketch2.is_empty() == sketch.is_empty());
     REQUIRE(sketch2.is_estimation_mode() == sketch.is_estimation_mode());
     REQUIRE(sketch2.get_n() == sketch.get_n());
     REQUIRE(sketch2.get_num_retained() == sketch.get_num_retained());
-    REQUIRE(sketch2.get_min_value() == sketch.get_min_value());
-    REQUIRE(sketch2.get_max_value() == sketch.get_max_value());
+    REQUIRE(sketch2.get_min_item() == sketch.get_min_item());
+    REQUIRE(sketch2.get_max_item() == sketch.get_max_item());
     REQUIRE(sketch2.get_normalized_rank_error(false) == sketch.get_normalized_rank_error(false));
     REQUIRE(sketch2.get_normalized_rank_error(true) == sketch.get_normalized_rank_error(true));
     REQUIRE(sketch2.get_quantile(0.5) == sketch.get_quantile(0.5));
@@ -437,27 +432,31 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
     REQUIRE(sketch2.get_rank(static_cast<float>(n)) == sketch.get_rank(static_cast<float>(n)));
   }
   SECTION("bytes serialize deserialize many floats") {
-    quantiles_float_sketch sketch(128, 0);
+    quantiles_float_sketch sketch(128, std::less<float>(), 0);
     const int n = 1000;
     for (int i = 0; i < n; i++) sketch.update(static_cast<float>(i));
     auto bytes = sketch.serialize();
     REQUIRE(bytes.size() == sketch.get_serialized_size_bytes());
-    auto sketch2 = quantiles_float_sketch::deserialize(bytes.data(), bytes.size(), serde<float>(), 0);
+    auto sketch2 = quantiles_float_sketch::deserialize(bytes.data(), bytes.size(), serde<float>(),
+        std::less<float>(), 0);
     REQUIRE(bytes.size() == sketch2.get_serialized_size_bytes());
     REQUIRE(sketch2.is_empty() == sketch.is_empty());
     REQUIRE(sketch2.is_estimation_mode() == sketch.is_estimation_mode());
     REQUIRE(sketch2.get_n() == sketch.get_n());
     REQUIRE(sketch2.get_num_retained() == sketch.get_num_retained());
-    REQUIRE(sketch2.get_min_value() == sketch.get_min_value());
-    REQUIRE(sketch2.get_max_value() == sketch.get_max_value());
+    REQUIRE(sketch2.get_min_item() == sketch.get_min_item());
+    REQUIRE(sketch2.get_max_item() == sketch.get_max_item());
     REQUIRE(sketch2.get_normalized_rank_error(false) == sketch.get_normalized_rank_error(false));
     REQUIRE(sketch2.get_normalized_rank_error(true) == sketch.get_normalized_rank_error(true));
     REQUIRE(sketch2.get_quantile(0.5) == sketch.get_quantile(0.5));
     REQUIRE(sketch2.get_rank(0) == sketch.get_rank(0));
     REQUIRE(sketch2.get_rank(static_cast<float>(n)) == sketch.get_rank(static_cast<float>(n)));
-    REQUIRE_THROWS_AS(quantiles_sketch<int>::deserialize(bytes.data(), 7), std::out_of_range);
-    REQUIRE_THROWS_AS(quantiles_sketch<int>::deserialize(bytes.data(), 15), std::out_of_range);
-    REQUIRE_THROWS_AS(quantiles_sketch<int>::deserialize(bytes.data(), bytes.size() - 1), std::out_of_range);
+    REQUIRE_THROWS_AS(quantiles_float_sketch::deserialize(bytes.data(), 7, serde<float>(), std::less<float>(), 0),
+        std::out_of_range);
+    REQUIRE_THROWS_AS(quantiles_float_sketch::deserialize(bytes.data(), 15, serde<float>(), std::less<float>(), 0),
+        std::out_of_range);
+    REQUIRE_THROWS_AS(quantiles_float_sketch::deserialize(bytes.data(), bytes.size() - 1, serde<float>(),
+        std::less<float>(), 0), std::out_of_range);
   }
 
   SECTION("bytes serialize deserialize many ints") {
@@ -472,8 +471,8 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
     REQUIRE(sketch2.is_estimation_mode() == sketch.is_estimation_mode());
     REQUIRE(sketch2.get_n() == sketch.get_n());
     REQUIRE(sketch2.get_num_retained() == sketch.get_num_retained());
-    REQUIRE(sketch2.get_min_value() == sketch.get_min_value());
-    REQUIRE(sketch2.get_max_value() == sketch.get_max_value());
+    REQUIRE(sketch2.get_min_item() == sketch.get_min_item());
+    REQUIRE(sketch2.get_max_item() == sketch.get_max_item());
     REQUIRE(sketch2.get_normalized_rank_error(false) == sketch.get_normalized_rank_error(false));
     REQUIRE(sketch2.get_normalized_rank_error(true) == sketch.get_normalized_rank_error(true));
     REQUIRE(sketch2.get_quantile(0.5) == sketch.get_quantile(0.5));
@@ -485,7 +484,7 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
   }
 
   SECTION("out of order split points, float") {
-    quantiles_float_sketch sketch(256, 0);
+    quantiles_float_sketch sketch(256, std::less<float>(), 0);
     sketch.update(0.0f); // has too be non-empty to reach the check
     float split_points[2] = {1, 0};
     REQUIRE_THROWS_AS(sketch.get_CDF(split_points, 2), std::invalid_argument);
@@ -499,72 +498,72 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
   }
 
   SECTION("NaN split point") {
-    quantiles_float_sketch sketch(512, 0);
+    quantiles_float_sketch sketch(512, std::less<float>(), 0);
     sketch.update(0.0f); // has too be non-empty to reach the check
     float split_points[1] = {std::numeric_limits<float>::quiet_NaN()};
     REQUIRE_THROWS_AS(sketch.get_CDF(split_points, 1), std::invalid_argument);
   }
 
   SECTION("merge") {
-    quantiles_float_sketch sketch1(128, 0);
-    quantiles_float_sketch sketch2(128, 0);
+    quantiles_float_sketch sketch1(128, std::less<float>(), 0);
+    quantiles_float_sketch sketch2(128, std::less<float>(), 0);
     const int n = 10000;
     for (int i = 0; i < n; i++) {
       sketch1.update(static_cast<float>(i));
       sketch2.update(static_cast<float>((2 * n) - i - 1));
     }
 
-    REQUIRE(sketch1.get_min_value() == 0.0f);
-    REQUIRE(sketch1.get_max_value() == n - 1);
-    REQUIRE(sketch2.get_min_value() == n);
-    REQUIRE(sketch2.get_max_value() == 2.0f * n - 1);
+    REQUIRE(sketch1.get_min_item() == 0.0f);
+    REQUIRE(sketch1.get_max_item() == n - 1);
+    REQUIRE(sketch2.get_min_item() == n);
+    REQUIRE(sketch2.get_max_item() == 2.0f * n - 1);
 
     sketch1.merge(sketch2);
 
     REQUIRE_FALSE(sketch1.is_empty());
     REQUIRE(sketch1.get_n() == 2 * n);
-    REQUIRE(sketch1.get_min_value() == 0.0f);
-    REQUIRE(sketch1.get_max_value() == 2.0f * n - 1);
+    REQUIRE(sketch1.get_min_item() == 0.0f);
+    REQUIRE(sketch1.get_max_item() == 2.0f * n - 1);
     REQUIRE(sketch1.get_quantile(0.5) == Approx(n).margin(n * RANK_EPS_FOR_K_128));
   }
 
   SECTION("merge from const") {
-    quantiles_float_sketch sketch1(128, 0);
-    quantiles_float_sketch sketch2(128, 0);
+    quantiles_float_sketch sketch1(128, std::less<float>(), 0);
+    quantiles_float_sketch sketch2(128, std::less<float>(), 0);
     const int n = 10000;
     for (int i = 0; i < n; i++) {
       sketch1.update(static_cast<float>(i));
       sketch2.update(static_cast<float>((2 * n) - i - 1));
     }
 
-    REQUIRE(sketch1.get_min_value() == 0.0f);
-    REQUIRE(sketch1.get_max_value() == n - 1);
-    REQUIRE(sketch2.get_min_value() == n);
-    REQUIRE(sketch2.get_max_value() == 2.0f * n - 1);
+    REQUIRE(sketch1.get_min_item() == 0.0f);
+    REQUIRE(sketch1.get_max_item() == n - 1);
+    REQUIRE(sketch2.get_min_item() == n);
+    REQUIRE(sketch2.get_max_item() == 2.0f * n - 1);
 
     sketch1.merge(const_cast<const quantiles_float_sketch&>(sketch2));
 
     REQUIRE_FALSE(sketch1.is_empty());
     REQUIRE(sketch1.get_n() == 2 * n);
-    REQUIRE(sketch1.get_min_value() == 0.0f);
-    REQUIRE(sketch1.get_max_value() == 2.0f * n - 1);
+    REQUIRE(sketch1.get_min_item() == 0.0f);
+    REQUIRE(sketch1.get_max_item() == 2.0f * n - 1);
     REQUIRE(sketch1.get_quantile(0.5) == Approx(n).margin(n * RANK_EPS_FOR_K_128));
   }
 
 
   SECTION("merge lower k") {
-    quantiles_float_sketch sketch1(256, 0);
-    quantiles_float_sketch sketch2(128, 0);
+    quantiles_float_sketch sketch1(256, std::less<float>(), 0);
+    quantiles_float_sketch sketch2(128, std::less<float>(), 0);
     const int n = 10000;
     for (int i = 0; i < n; i++) {
       sketch1.update(static_cast<float>(i));
       sketch2.update(static_cast<float>((2 * n) - i - 1));
     }
 
-    REQUIRE(sketch1.get_min_value() == 0.0f);
-    REQUIRE(sketch1.get_max_value() == n - 1);
-    REQUIRE(sketch2.get_min_value() == n);
-    REQUIRE(sketch2.get_max_value() == 2.0f * n - 1);
+    REQUIRE(sketch1.get_min_item() == 0.0f);
+    REQUIRE(sketch1.get_max_item() == n - 1);
+    REQUIRE(sketch2.get_min_item() == n);
+    REQUIRE(sketch2.get_max_item() == 2.0f * n - 1);
 
     REQUIRE(sketch1.get_k() == 256);
     REQUIRE(sketch2.get_k() == 128);
@@ -580,14 +579,14 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
 
     REQUIRE_FALSE(sketch1.is_empty());
     REQUIRE(sketch1.get_n() == 2 * n);
-    REQUIRE(sketch1.get_min_value() == 0.0f);
-    REQUIRE(sketch1.get_max_value() == 2.0f * n - 1);
+    REQUIRE(sketch1.get_min_item() == 0.0f);
+    REQUIRE(sketch1.get_max_item() == 2.0f * n - 1);
     REQUIRE(sketch1.get_quantile(0.5) == Approx(n).margin(n * RANK_EPS_FOR_K_128));
   }
 
   SECTION("merge exact mode, lower k") {
-    quantiles_float_sketch sketch1(256, 0);
-    quantiles_float_sketch sketch2(128, 0);
+    quantiles_float_sketch sketch1(256, std::less<float>(), 0);
+    quantiles_float_sketch sketch2(128, std::less<float>(), 0);
     const int n = 10000;
     for (int i = 0; i < n; i++) {
       sketch1.update(static_cast<float>(i));
@@ -600,8 +599,8 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
 
     REQUIRE_FALSE(sketch1.is_empty());
     REQUIRE(sketch1.get_n() == n);
-    REQUIRE(sketch1.get_min_value() == 0.0f);
-    REQUIRE(sketch1.get_max_value() == n - 1);
+    REQUIRE(sketch1.get_min_item() == 0.0f);
+    REQUIRE(sketch1.get_max_item() == n - 1);
     REQUIRE(sketch1.get_quantile(0.5) == Approx(n / 2).margin(n / 2 * RANK_EPS_FOR_K_128));
 
     sketch2.update(static_cast<float>(0));
@@ -611,27 +610,27 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
   }
 
   SECTION("merge min value from other") {
-    quantiles_float_sketch sketch1(128, 0);
-    quantiles_float_sketch sketch2(128, 0);
+    quantiles_float_sketch sketch1(128, std::less<float>(), 0);
+    quantiles_float_sketch sketch2(128, std::less<float>(), 0);
     sketch1.update(1.0f);
     sketch2.update(2.0f);
     sketch2.merge(sketch1);
-    REQUIRE(sketch2.get_min_value() == 1.0f);
-    REQUIRE(sketch2.get_max_value() == 2.0f);
+    REQUIRE(sketch2.get_min_item() == 1.0f);
+    REQUIRE(sketch2.get_max_item() == 2.0f);
   }
 
   SECTION("merge min and max values from other") {
-    quantiles_float_sketch sketch1(128, 0);
+    quantiles_float_sketch sketch1(128, std::less<float>(), 0);
     for (int i = 0; i < 1000000; i++) sketch1.update(static_cast<float>(i));
-    quantiles_float_sketch sketch2(128, 0);
+    quantiles_float_sketch sketch2(128, std::less<float>(), 0);
     sketch2.merge(sketch1);
-    REQUIRE(sketch2.get_min_value() == 0.0f);
-    REQUIRE(sketch2.get_max_value() == 999999.0f);
+    REQUIRE(sketch2.get_min_item() == 0.0f);
+    REQUIRE(sketch2.get_max_item() == 999999.0f);
   }
 
   SECTION("merge: two empty") {
-    quantiles_float_sketch sk1(128, 0);
-    quantiles_float_sketch sk2(64, 0);
+    quantiles_float_sketch sk1(128, std::less<float>(), 0);
+    quantiles_float_sketch sk2(64, std::less<float>(), 0);
     sk1.merge(sk2);
     REQUIRE(sk1.get_n() == 0);
     REQUIRE(sk1.get_k() == 128);
@@ -643,8 +642,8 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
 
   SECTION("merge: exact as input") {
     const uint16_t k = 128;
-    quantiles_float_sketch sketch1(2 * k, 0);
-    quantiles_float_sketch sketch2(k, 0);
+    quantiles_float_sketch sketch1(2 * k, std::less<float>(), 0);
+    quantiles_float_sketch sketch2(k, std::less<float>(), 0);
 
     for (int i = 0; i < k / 2; i++) {
       sketch1.update(static_cast<float>(i));
@@ -658,14 +657,14 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
     sketch1.merge(sketch2);
     REQUIRE(sketch1.get_n() == 101 * k);
     REQUIRE(sketch1.get_k() == 2 * k); // no reason to have shrunk
-    REQUIRE(sketch1.get_min_value() == 0.0f);
-    REQUIRE(sketch1.get_max_value() == static_cast<float>(100 * k - 1));
+    REQUIRE(sketch1.get_min_item() == 0.0f);
+    REQUIRE(sketch1.get_max_item() == static_cast<float>(100 * k - 1));
   }
 
   SECTION("merge: src estimation, tgt exact, tgt.k > src.k") {
     const uint16_t k = 128;
-    quantiles_float_sketch sketch1(2 * k, 0);
-    quantiles_float_sketch sketch2(k, 0);
+    quantiles_float_sketch sketch1(2 * k, std::less<float>(), 0);
+    quantiles_float_sketch sketch2(k, std::less<float>(), 0);
 
     for (int i = 0; i < k / 2; i++) {
       sketch1.update(static_cast<float>(i));
@@ -679,14 +678,14 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
     sketch1.merge(sketch2);
     REQUIRE(sketch1.get_n() == 101 * k);
     REQUIRE(sketch1.get_k() == k); // no reason to have shrunk
-    REQUIRE(sketch1.get_min_value() == 0.0f);
-    REQUIRE(sketch1.get_max_value() == static_cast<float>(100 * k - 1));
+    REQUIRE(sketch1.get_min_item() == 0.0f);
+    REQUIRE(sketch1.get_max_item() == static_cast<float>(100 * k - 1));
   }
 
   SECTION("merge: both estimation, tgt.k < src.k") {
     const uint16_t k = 128;
-    quantiles_float_sketch sketch1(k, 0);
-    quantiles_float_sketch sketch2(2 * k, 0);
+    quantiles_float_sketch sketch1(k, std::less<float>(), 0);
+    quantiles_float_sketch sketch2(2 * k, std::less<float>(), 0);
 
     for (int i = 0; i < 100 * k; i++) {
       sketch1.update(static_cast<float>(i));
@@ -696,15 +695,15 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
     sketch1.merge(sketch2);
     REQUIRE(sketch1.get_n() == 200 * k);
     REQUIRE(sketch1.get_k() == k); // no reason to have shrunk
-    REQUIRE(sketch1.get_min_value() == static_cast<float>(-100 * k + 1));
-    REQUIRE(sketch1.get_max_value() == static_cast<float>(100 * k - 1));
+    REQUIRE(sketch1.get_min_item() == static_cast<float>(-100 * k + 1));
+    REQUIRE(sketch1.get_max_item() == static_cast<float>(100 * k - 1));
     REQUIRE(sketch1.get_quantile(0.5) == Approx(0.0).margin(100 * k * RANK_EPS_FOR_K_128));
   }
 
   SECTION("merge: src estimation, tgt exact, equal k") {
     const uint16_t k = 128;
-    quantiles_float_sketch sketch1(k, 0);
-    quantiles_float_sketch sketch2(k, 0);
+    quantiles_float_sketch sketch1(k, std::less<float>(), 0);
+    quantiles_float_sketch sketch2(k, std::less<float>(), 0);
 
     for (int i = 0; i < k / 2; i++) {
       sketch1.update(static_cast<float>(i));
@@ -718,16 +717,16 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
     sketch1.merge(sketch2);
     REQUIRE(sketch1.get_n() == 100 * k);
     REQUIRE(sketch1.get_k() == k);
-    REQUIRE(sketch1.get_min_value() == 0.0f);
-    REQUIRE(sketch1.get_max_value() == static_cast<float>(100 * k - 1));
+    REQUIRE(sketch1.get_min_item() == 0.0f);
+    REQUIRE(sketch1.get_max_item() == static_cast<float>(100 * k - 1));
     float n = 100 * k - 1;
     REQUIRE(sketch1.get_quantile(0.5) == Approx(n / 2).margin(n / 2 * RANK_EPS_FOR_K_128));
   }
 
   SECTION("merge: both estimation, no base buffer, same k") {
     const uint16_t k = 128;
-    quantiles_float_sketch sketch1(k, 0);
-    quantiles_float_sketch sketch2(k, 0);
+    quantiles_float_sketch sketch1(k, std::less<float>(), 0);
+    quantiles_float_sketch sketch2(k, std::less<float>(), 0);
 
     uint64_t n = 2 * k;
     for (uint64_t i = 0; i < n; i++) {
@@ -738,15 +737,15 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
     sketch1.merge(sketch2);
     REQUIRE(sketch1.get_n() == 2 * n);
     REQUIRE(sketch1.get_k() == k);
-    REQUIRE(sketch1.get_min_value() == 0.0f);
-    REQUIRE(sketch1.get_max_value() == static_cast<float>(2 * n - 1));
+    REQUIRE(sketch1.get_min_item() == 0.0f);
+    REQUIRE(sketch1.get_max_item() == static_cast<float>(2 * n - 1));
     REQUIRE(sketch1.get_quantile(0.5) == Approx(n).margin(n * RANK_EPS_FOR_K_128));
   }
 
   SECTION("merge: both estimation, no base buffer, tgt.k < src.k") {
     const uint16_t k = 128;
-    quantiles_float_sketch sketch1(k, 0);
-    quantiles_float_sketch sketch2(2 * k, 0);
+    quantiles_float_sketch sketch1(k, std::less<float>(), 0);
+    quantiles_float_sketch sketch2(2 * k, std::less<float>(), 0);
 
     uint64_t n = 4 * k;
     for (uint64_t i = 0; i < n; i++) {
@@ -757,16 +756,16 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
     sketch1.merge(sketch2);
     REQUIRE(sketch1.get_n() == 2 * n);
     REQUIRE(sketch1.get_k() == k);
-    REQUIRE(sketch1.get_min_value() == 0.0f);
-    REQUIRE(sketch1.get_max_value() == static_cast<float>(2 * n - 1));
+    REQUIRE(sketch1.get_min_item() == 0.0f);
+    REQUIRE(sketch1.get_max_item() == static_cast<float>(2 * n - 1));
     REQUIRE(sketch1.get_quantile(0.5) == Approx(n).margin(n * RANK_EPS_FOR_K_128));
   }
 
   SECTION("sketch of ints") {
     quantiles_sketch<int> sketch;
     REQUIRE_THROWS_AS(sketch.get_quantile(0), std::runtime_error);
-    REQUIRE_THROWS_AS(sketch.get_min_value(), std::runtime_error);
-    REQUIRE_THROWS_AS(sketch.get_max_value(), std::runtime_error);
+    REQUIRE_THROWS_AS(sketch.get_min_item(), std::runtime_error);
+    REQUIRE_THROWS_AS(sketch.get_max_item(), std::runtime_error);
 
     const int n = 10000;
     for (int i = 0; i < n; i++) sketch.update(i);
@@ -781,8 +780,8 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
     REQUIRE(sketch2.is_estimation_mode() == sketch.is_estimation_mode());
     REQUIRE(sketch2.get_n() == sketch.get_n());
     REQUIRE(sketch2.get_num_retained() == sketch.get_num_retained());
-    REQUIRE(sketch2.get_min_value() == sketch.get_min_value());
-    REQUIRE(sketch2.get_max_value() == sketch.get_max_value());
+    REQUIRE(sketch2.get_min_item() == sketch.get_min_item());
+    REQUIRE(sketch2.get_max_item() == sketch.get_max_item());
     REQUIRE(sketch2.get_normalized_rank_error(false) == sketch.get_normalized_rank_error(false));
     REQUIRE(sketch2.get_normalized_rank_error(true) == sketch.get_normalized_rank_error(true));
     REQUIRE(sketch2.get_quantile(0.5) == sketch.get_quantile(0.5));
@@ -791,30 +790,31 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
   }
 
   SECTION("sketch of strings stream") {
-    quantiles_string_sketch sketch1(128, 0);
+    quantiles_string_sketch sketch1(128, std::less<std::string>(), 0);
     REQUIRE_THROWS_AS(sketch1.get_quantile(0), std::runtime_error);
-    REQUIRE_THROWS_AS(sketch1.get_min_value(), std::runtime_error);
-    REQUIRE_THROWS_AS(sketch1.get_max_value(), std::runtime_error);
+    REQUIRE_THROWS_AS(sketch1.get_min_item(), std::runtime_error);
+    REQUIRE_THROWS_AS(sketch1.get_max_item(), std::runtime_error);
     REQUIRE(sketch1.get_serialized_size_bytes() == 8);
 
     const int n = 1000;
     for (int i = 0; i < n; i++) sketch1.update(std::to_string(i));
 
-    REQUIRE(sketch1.get_min_value() == std::string("0"));
-    REQUIRE(sketch1.get_max_value() == std::string("999"));
+    REQUIRE(sketch1.get_min_item() == std::string("0"));
+    REQUIRE(sketch1.get_max_item() == std::string("999"));
 
     std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
     sketch1.serialize(s);
     REQUIRE(static_cast<size_t>(s.tellp()) == sketch1.get_serialized_size_bytes());
-    auto sketch2 = quantiles_string_sketch::deserialize(s, serde<std::string>(), test_allocator<std::string>(0));
+    auto sketch2 = quantiles_string_sketch::deserialize(s, serde<std::string>(),
+        std::less<std::string>(), 0);
     REQUIRE(static_cast<size_t>(s.tellp()) == sketch2.get_serialized_size_bytes());
     REQUIRE(s.tellg() == s.tellp());
     REQUIRE(sketch2.is_empty() == sketch1.is_empty());
     REQUIRE(sketch2.is_estimation_mode() == sketch1.is_estimation_mode());
     REQUIRE(sketch2.get_n() == sketch1.get_n());
     REQUIRE(sketch2.get_num_retained() == sketch1.get_num_retained());
-    REQUIRE(sketch2.get_min_value() == sketch1.get_min_value());
-    REQUIRE(sketch2.get_max_value() == sketch1.get_max_value());
+    REQUIRE(sketch2.get_min_item() == sketch1.get_min_item());
+    REQUIRE(sketch2.get_max_item() == sketch1.get_max_item());
     REQUIRE(sketch2.get_normalized_rank_error(false) == sketch1.get_normalized_rank_error(false));
     REQUIRE(sketch2.get_normalized_rank_error(true) == sketch1.get_normalized_rank_error(true));
     REQUIRE(sketch2.get_quantile(0.5) == sketch1.get_quantile(0.5));
@@ -827,28 +827,29 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
   }
 
   SECTION("sketch of strings bytes") {
-    quantiles_string_sketch sketch1(128, 0);
+    quantiles_string_sketch sketch1(128, std::less<std::string>(), 0);
     REQUIRE_THROWS_AS(sketch1.get_quantile(0), std::runtime_error);
-    REQUIRE_THROWS_AS(sketch1.get_min_value(), std::runtime_error);
-    REQUIRE_THROWS_AS(sketch1.get_max_value(), std::runtime_error);
+    REQUIRE_THROWS_AS(sketch1.get_min_item(), std::runtime_error);
+    REQUIRE_THROWS_AS(sketch1.get_max_item(), std::runtime_error);
     REQUIRE(sketch1.get_serialized_size_bytes() == 8);
 
     const int n = 10000;
     for (int i = 0; i < n; i++) sketch1.update(std::to_string(i));
 
-    REQUIRE(sketch1.get_min_value() == std::string("0"));
-    REQUIRE(sketch1.get_max_value() == std::string("9999"));
+    REQUIRE(sketch1.get_min_item() == std::string("0"));
+    REQUIRE(sketch1.get_max_item() == std::string("9999"));
 
     auto bytes = sketch1.serialize();
     REQUIRE(bytes.size() == sketch1.get_serialized_size_bytes());
-    auto sketch2 = quantiles_string_sketch::deserialize(bytes.data(), bytes.size(), serde<std::string>(), 0);
+    auto sketch2 = quantiles_string_sketch::deserialize(bytes.data(), bytes.size(), serde<std::string>(),
+        std::less<std::string>(), 0);
     REQUIRE(bytes.size() == sketch2.get_serialized_size_bytes());
     REQUIRE(sketch2.is_empty() == sketch1.is_empty());
     REQUIRE(sketch2.is_estimation_mode() == sketch1.is_estimation_mode());
     REQUIRE(sketch2.get_n() == sketch1.get_n());
     REQUIRE(sketch2.get_num_retained() == sketch1.get_num_retained());
-    REQUIRE(sketch2.get_min_value() == sketch1.get_min_value());
-    REQUIRE(sketch2.get_max_value() == sketch1.get_max_value());
+    REQUIRE(sketch2.get_min_item() == sketch1.get_min_item());
+    REQUIRE(sketch2.get_max_item() == sketch1.get_max_item());
     REQUIRE(sketch2.get_normalized_rank_error(false) == sketch1.get_normalized_rank_error(false));
     REQUIRE(sketch2.get_normalized_rank_error(true) == sketch1.get_normalized_rank_error(true));
     REQUIRE(sketch2.get_quantile(0.5) == sketch1.get_quantile(0.5));
@@ -857,11 +858,12 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
   }
 
   SECTION("sketch of strings, single item, bytes") {
-    quantiles_string_sketch sketch1(64, 0);
+    quantiles_string_sketch sketch1(64, std::less<std::string>(), 0);
     sketch1.update("a");
     auto bytes = sketch1.serialize();
     REQUIRE(bytes.size() == sketch1.get_serialized_size_bytes());
-    auto sketch2 = quantiles_string_sketch::deserialize(bytes.data(), bytes.size(), serde<std::string>(), 0);
+    auto sketch2 = quantiles_string_sketch::deserialize(bytes.data(), bytes.size(),
+        serde<std::string>(), std::less<std::string>(), 0);
     REQUIRE(bytes.size() == sketch2.get_serialized_size_bytes());
   }
 
@@ -886,20 +888,20 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
 
   SECTION("move") {
     quantiles_sketch<int> sketch1;
-    const int n(100);
+    const int n = 100;
     for (int i = 0; i < n; i++) sketch1.update(i);
 
     // move constructor
     quantiles_sketch<int> sketch2(std::move(sketch1));
     for (int i = 0; i < n; i++) {
-      REQUIRE(sketch2.get_rank(i) == (double) i / n);
+      REQUIRE(sketch2.get_rank(i) == static_cast<double>(i + 1) / n);
     }
 
     // move assignment
     quantiles_sketch<int> sketch3;
     sketch3 = std::move(sketch2);
     for (int i = 0; i < n; i++) {
-      REQUIRE(sketch3.get_rank(i) == (double) i / n);
+      REQUIRE(sketch3.get_rank(i) == static_cast<double>(i + 1) / n);
     }
   }
 
@@ -908,7 +910,7 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
     const int n = 403;
     quantiles_sketch<double> sk_double(k);
     
-    quantiles_sketch<float> sk_float(k, sk_double.get_allocator());
+    quantiles_sketch<float> sk_float(k);
     REQUIRE(sk_float.is_empty());
     
     for (int i = 0; i < n; ++i) sk_double.update(i + .01);
@@ -918,10 +920,10 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
     REQUIRE(sk_double.get_k() == sk_int.get_k());
     REQUIRE(sk_double.get_num_retained() == sk_int.get_num_retained());
 
-    auto sv_double = sk_double.get_sorted_view(false);
+    auto sv_double = sk_double.get_sorted_view();
     std::vector<std::pair<double, uint64_t>> vec_double(sv_double.begin(), sv_double.end()); 
 
-    auto sv_int = sk_int.get_sorted_view(false);
+    auto sv_int = sk_int.get_sorted_view();
     std::vector<std::pair<int, uint64_t>> vec_int(sv_int.begin(), sv_int.end()); 
 
     REQUIRE(vec_double.size() == vec_int.size());
@@ -966,6 +968,12 @@ TEST_CASE("quantiles sketch", "[quantiles_sketch]") {
     REQUIRE(sb.get_n() == 3);
   }
 
+  SECTION("comparator and allocator") {
+    quantiles_sketch<int> sketch;
+    REQUIRE(sketch.get_comparator()(1, 2));
+    REQUIRE(sketch.get_allocator() == std::allocator<int>());
+  }
+
   // cleanup
   if (test_allocator_total_bytes != 0) {
     REQUIRE(test_allocator_total_bytes == 0);