datasketches 0.2.7 → 0.3.0

data/vendor/datasketches-cpp/kll/test/kll_sketch_test.cpp

@@ -39,9 +39,9 @@ static std::string testBinaryInputPath = "test/";
 #endif
 
 // typical usage would be just kll_sketch<float> or kll_sketch<std::string>, but here we use test_allocator
-using kll_float_sketch = kll_sketch<float, std::less<float>, serde<float>, test_allocator<float>>;
+using kll_float_sketch = kll_sketch<float, std::less<float>, test_allocator<float>>;
 // let std::string use the default allocator for simplicity, otherwise we need to define "less" and "serde"
-using kll_string_sketch = kll_sketch<std::string, std::less<std::string>, serde<std::string>, test_allocator<std::string>>;
+using kll_string_sketch = kll_sketch<std::string, std::less<std::string>, test_allocator<std::string>>;
 
 TEST_CASE("kll sketch", "[kll_sketch]") {
 
@@ -49,71 +49,78 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
   test_allocator_total_bytes = 0;
 
   SECTION("k limits") {
-    kll_float_sketch sketch1(kll_float_sketch::MIN_K, 0); // this should work
-    kll_float_sketch sketch2(kll_float_sketch::MAX_K, 0); // this should work
-    REQUIRE_THROWS_AS(new kll_float_sketch(kll_float_sketch::MIN_K - 1, 0), std::invalid_argument);
+    kll_float_sketch sketch1(kll_float_sketch::MIN_K, std::less<float>(), 0); // this should work
+    kll_float_sketch sketch2(kll_float_sketch::MAX_K, std::less<float>(), 0); // this should work
+    REQUIRE_THROWS_AS(new kll_float_sketch(kll_float_sketch::MIN_K - 1, std::less<float>(), 0), std::invalid_argument);
     // MAX_K + 1 makes no sense because k is uint16_t
+    //std::cout << "sizeof(kll_sketch<float>)=" << sizeof(kll_sketch<float>) << "\n";
+    //std::cout << "sizeof(kll_sketch<double>)=" << sizeof(kll_sketch<double>) << "\n";
   }
 
   SECTION("empty") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, 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)));
-    const double fractions[3] {0, 0.5, 1};
-    REQUIRE(sketch.get_quantiles(fractions, 3).size() == 0);
+    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 ranks[3] {0, 0.5, 1};
+    REQUIRE_THROWS_AS(sketch.get_quantiles(ranks, 3), std::runtime_error);
     const float split_points[1] {0};
-    REQUIRE(sketch.get_PMF(split_points, 1).size() == 0);
-    REQUIRE(sketch.get_CDF(split_points, 1).size() == 0);
+    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) {
-      (void) it; // to suppress "unused" warning
+    for (auto pair: sketch) {
+      unused(pair); // to suppress "unused" warning
       FAIL("should be no iterations over an empty sketch");
     }
   }
 
   SECTION("get bad quantile") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, std::less<float>(), 0);
     sketch.update(0); // has to be non-empty to reach the check
     REQUIRE_THROWS_AS(sketch.get_quantile(-1), std::invalid_argument);
   }
 
   SECTION("one item") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, 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<true>(1.0f) == 1.0);
-    REQUIRE(sketch.get_rank(2.0f) == 1.0);
+    REQUIRE(sketch.get_rank(1.0f, false) == 0.0);
+    REQUIRE(sketch.get_rank(1.0f) == 1.0);
+    REQUIRE(sketch.get_rank(2.0f, false) == 1.0);
     REQUIRE(sketch.get_rank(std::numeric_limits<float>::infinity()) == 1.0);
-    REQUIRE(sketch.get_min_value() == 1.0);
-    REQUIRE(sketch.get_max_value() == 1.0);
+    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);
+    const double ranks[3] {0, 0.5, 1};
+    auto quantiles = sketch.get_quantiles(ranks, 3);
     REQUIRE(quantiles.size() == 3);
     REQUIRE(quantiles[0] == 1.0);
     REQUIRE(quantiles[1] == 1.0);
     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") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, std::less<float>(), 0);
     sketch.update(std::numeric_limits<float>::quiet_NaN());
     REQUIRE(sketch.is_empty());
 
@@ -123,44 +130,44 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
   }
 
   SECTION("many items, exact mode") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, std::less<float>(), 0);
     const uint32_t n = 200;
-    for (uint32_t i = 0; i < n; i++) {
+    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);
+    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] == n / 2);
-    REQUIRE(quantiles[2] == n - 1 );
-
-    for (uint32_t i = 0; i < n; i++) {
-      const double true_rank = (double) i / n;
-      REQUIRE(sketch.get_rank(static_cast<float>(i)) == true_rank);
-      const double true_rank_inclusive = (double) (i + 1) / n;
-      REQUIRE(sketch.get_rank<true>(static_cast<float>(i)) == true_rank_inclusive);
-    }
+    REQUIRE(quantiles[2] == n);
 
-    // the alternative method must produce the same result
+    // alternative method must produce the same result
     auto quantiles2 = sketch.get_quantiles(3);
     REQUIRE(quantiles2.size() == 3);
     REQUIRE(quantiles[0] == quantiles2[0]);
     REQUIRE(quantiles[1] == quantiles2[1]);
     REQUIRE(quantiles[2] == quantiles2[2]);
+
+    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") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, std::less<float>(), 0);
     sketch.update(1.0f);
     sketch.update(2.0f);
     sketch.update(3.0f);
@@ -172,23 +179,23 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     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.5) == 5.0);
     REQUIRE(sketch.get_quantile(0.99) == 10.0);
     REQUIRE(sketch.get_quantile(1) == 10.0);
   }
 
   SECTION("100 items") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, std::less<float>(), 0);
     for (int i = 0; i < 100; ++i) sketch.update(static_cast<float>(i));
     REQUIRE(sketch.get_quantile(0) == 0);
-    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(0.01) == 0);
+    REQUIRE(sketch.get_quantile(0.5) == 49);
+    REQUIRE(sketch.get_quantile(0.99) == 98.0);
     REQUIRE(sketch.get_quantile(1) == 99.0);
   }
 
   SECTION("many items, estimation mode") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, std::less<float>(), 0);
     const int n = 1000000;
     for (int i = 0; i < n; i++) {
       sketch.update(static_cast<float>(i));
@@ -196,87 +203,62 @@ TEST_CASE("kll sketch", "[kll_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 = (double) i / n;
-      REQUIRE(sketch.get_rank(static_cast<float>(i)) == Approx(trueRank).margin(RANK_EPS_FOR_K_200));
-    }
-
-    // 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;
+      REQUIRE(sketch.get_rank(static_cast<float>(i), false) == Approx(trueRank).margin(RANK_EPS_FOR_K_200));
     }
 
     //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 adn get_PMF/CDF") {
-    kll_float_sketch sketch(200, 0);
-    const int n = 1000;
+  SECTION("consistency between get_rank and get_PMF/CDF") {
+    kll_float_sketch sketch(200, std::less<float>(), 0);
+    const int n = 200;
     float values[n];
     for (int i = 0; i < n; i++) {
       sketch.update(static_cast<float>(i));
       values[i] = static_cast<float>(i);
     }
-    { // inclusive=false (default)
-      const auto ranks(sketch.get_CDF(values, n));
-      const auto pmf(sketch.get_PMF(values, n));
+    { // inclusive=false
+      const auto ranks(sketch.get_CDF(values, n, false));
+      const auto pmf(sketch.get_PMF(values, n, false));
 
       double subtotal_pmf = 0;
       for (int i = 0; i < n; i++) {
-        if (sketch.get_rank(values[i]) != ranks[i]) {
-          std::cerr << "checking rank vs CDF for value " << i << std::endl;
-          REQUIRE(sketch.get_rank(values[i]) == ranks[i]);
+        if (sketch.get_rank(values[i], false) != ranks[i]) {
+          FAIL("checking rank vs CDF for value " + std::to_string(i));
         }
         subtotal_pmf += pmf[i];
         if (abs(ranks[i] - subtotal_pmf) > NUMERIC_NOISE_TOLERANCE) {
-          std::cerr << "CDF vs PMF for value " << i << std::endl;
-          REQUIRE(ranks[i] == Approx(subtotal_pmf).margin(NUMERIC_NOISE_TOLERANCE));
+          FAIL("CDF vs PMF for value " + std::to_string(i));
         }
       }
     }
-    {  // inclusive=true
-      const auto ranks(sketch.get_CDF<true>(values, n));
-      const auto pmf(sketch.get_PMF<true>(values, n));
+    {  // inclusive=true (default)
+      const auto ranks(sketch.get_CDF(values, n));
+      const auto pmf(sketch.get_PMF(values, n));
 
       double subtotal_pmf = 0;
       for (int i = 0; i < n; i++) {
-        if (sketch.get_rank<true>(values[i]) != ranks[i]) {
-          std::cerr << "checking rank vs CDF for value " << i << std::endl;
-          REQUIRE(sketch.get_rank(values[i]) == ranks[i]);
+        if (sketch.get_rank(values[i]) != ranks[i]) {
+          FAIL("checking rank vs CDF for value " + std::to_string(i));
         }
         subtotal_pmf += pmf[i];
         if (abs(ranks[i] - subtotal_pmf) > NUMERIC_NOISE_TOLERANCE) {
-          std::cerr << "CDF vs PMF for value " << i << std::endl;
-          REQUIRE(ranks[i] == Approx(subtotal_pmf).margin(NUMERIC_NOISE_TOLERANCE));
+          FAIL("CDF vs PMF for value " + std::to_string(i));
         }
       }
     }
@@ -286,151 +268,151 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     std::ifstream is;
     is.exceptions(std::ios::failbit | std::ios::badbit);
     is.open(testBinaryInputPath + "kll_sketch_from_java.sk", std::ios::binary);
-    auto sketch = kll_float_sketch::deserialize(is, test_allocator<float>(0));
+    auto sketch = kll_float_sketch::deserialize(is, serde<float>(), std::less<float>(), 0);
     REQUIRE_FALSE(sketch.is_empty());
     REQUIRE(sketch.is_estimation_mode());
     REQUIRE(sketch.get_n() == 1000000);
     REQUIRE(sketch.get_num_retained() == 614);
-    REQUIRE(sketch.get_min_value() == 0.0);
-    REQUIRE(sketch.get_max_value() == 999999.0);
+    REQUIRE(sketch.get_min_item() == 0.0);
+    REQUIRE(sketch.get_max_item() == 999999.0);
   }
 
   SECTION("stream serialize deserialize empty") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, 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 = kll_float_sketch::deserialize(s, test_allocator<float>(0));
+    auto sketch2 = kll_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") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, std::less<float>(), 0);
     auto bytes = sketch.serialize();
-    auto sketch2 = kll_float_sketch::deserialize(bytes.data(), bytes.size(), serde<float>(), 0);
+    auto sketch2 = kll_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") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, 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 = kll_float_sketch::deserialize(s, serde<float>(), 0);
+    auto sketch2 = kll_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_min_item() == 1.0);
+    REQUIRE(sketch2.get_max_item() == 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_rank(1, false) == 0.0);
+    REQUIRE(sketch2.get_rank(2, false) == 1.0);
   }
 
   SECTION("bytes serialize deserialize one item") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, std::less<float>(), 0);
     sketch.update(1.0f);
     auto bytes = sketch.serialize();
     REQUIRE(bytes.size() == sketch.get_serialized_size_bytes());
-    auto sketch2 = kll_float_sketch::deserialize(bytes.data(), bytes.size(), serde<float>(), 0);
+    auto sketch2 = kll_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_min_item() == 1.0);
+    REQUIRE(sketch2.get_max_item() == 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_rank(1, false) == 0.0);
+    REQUIRE(sketch2.get_rank(2, false) == 1.0);
   }
 
   SECTION("deserialize one item v1") {
     std::ifstream is;
     is.exceptions(std::ios::failbit | std::ios::badbit);
     is.open(testBinaryInputPath + "kll_sketch_float_one_item_v1.sk", std::ios::binary);
-    auto sketch = kll_float_sketch::deserialize(is, serde<float>(), 0);
+    auto sketch = kll_float_sketch::deserialize(is, serde<float>(), std::less<float>(), 0);
     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_min_value() == 1.0);
-    REQUIRE(sketch.get_max_value() == 1.0);
+    REQUIRE(sketch.get_min_item() == 1.0);
+    REQUIRE(sketch.get_max_item() == 1.0);
   }
 
   SECTION("stream serialize deserialize three items") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, 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 = kll_float_sketch::deserialize(s, serde<float>(), 0);
+    auto sketch2 = kll_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") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, 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 = kll_float_sketch::deserialize(bytes.data(), bytes.size(), serde<float>(), 0);
+    auto sketch2 = kll_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") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, 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 = kll_float_sketch::deserialize(s, serde<float>(), 0);
+    auto sketch2 = kll_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));
@@ -439,27 +421,27 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
   }
 
   SECTION("bytes serialize deserialize many floats") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, 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 = kll_float_sketch::deserialize(bytes.data(), bytes.size(), serde<float>(), 0);
+    auto sketch2 = kll_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(kll_sketch<int>::deserialize(bytes.data(), 7), std::out_of_range);
-    REQUIRE_THROWS_AS(kll_sketch<int>::deserialize(bytes.data(), 15), std::out_of_range);
-    REQUIRE_THROWS_AS(kll_sketch<int>::deserialize(bytes.data(), bytes.size() - 1), std::out_of_range);
+    REQUIRE_THROWS_AS(kll_float_sketch::deserialize(bytes.data(), 7, serde<float>(), std::less<float>(), 0), std::out_of_range);
+    REQUIRE_THROWS_AS(kll_float_sketch::deserialize(bytes.data(), 15, serde<float>(), std::less<float>(), 0), std::out_of_range);
+    REQUIRE_THROWS_AS(kll_float_sketch::deserialize(bytes.data(), bytes.size() - 1, serde<float>(), std::less<float>(), 0), std::out_of_range);
   }
 
   SECTION("bytes serialize deserialize many ints") {
@@ -474,8 +456,8 @@ TEST_CASE("kll sketch", "[kll_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));
@@ -499,7 +481,7 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
   }
 
   SECTION("out of order split points, float") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, std::less<float>(), 0);
     sketch.update(0); // 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);
@@ -513,48 +495,48 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
   }
 
   SECTION("NaN split point") {
-    kll_float_sketch sketch(200, 0);
+    kll_float_sketch sketch(200, std::less<float>(), 0);
     sketch.update(0); // 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") {
-    kll_float_sketch sketch1(200, 0);
-    kll_float_sketch sketch2(200, 0);
+    kll_float_sketch sketch1(200, std::less<float>(), 0);
+    kll_float_sketch sketch2(200, 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_200));
   }
 
   SECTION("merge lower k") {
-    kll_float_sketch sketch1(256, 0);
-    kll_float_sketch sketch2(128, 0);
+    kll_float_sketch sketch1(256, std::less<float>(), 0);
+    kll_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);
@@ -570,14 +552,14 @@ TEST_CASE("kll sketch", "[kll_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_200));
   }
 
   SECTION("merge exact mode, lower k") {
-    kll_float_sketch sketch1(256, 0);
-    kll_float_sketch sketch2(128, 0);
+    kll_float_sketch sketch1(256, std::less<float>(), 0);
+    kll_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));
@@ -590,8 +572,8 @@ TEST_CASE("kll sketch", "[kll_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_200));
 
     sketch2.update(0);
@@ -601,29 +583,29 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
   }
 
   SECTION("merge min value from other") {
-    kll_float_sketch sketch1(200, 0);
-    kll_float_sketch sketch2(200, 0);
+    kll_float_sketch sketch1(200, std::less<float>(), 0);
+    kll_float_sketch sketch2(200, 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") {
-    kll_float_sketch sketch1(200, 0);
+    kll_float_sketch sketch1(200, std::less<float>(), 0);
     for (int i = 0; i < 1000000; i++) sketch1.update(static_cast<float>(i));
-    kll_float_sketch sketch2(200, 0);
+    kll_float_sketch sketch2(200, 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("sketch of ints") {
     kll_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 = 1000;
     for (int i = 0; i < n; i++) sketch.update(i);
@@ -638,8 +620,8 @@ TEST_CASE("kll sketch", "[kll_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));
@@ -648,30 +630,30 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
   }
 
   SECTION("sketch of strings stream") {
-    kll_string_sketch sketch1(200, 0);
+    kll_string_sketch sketch1(200, 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 = kll_string_sketch::deserialize(s, test_allocator<std::string>(0));
+    auto sketch2 = kll_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));
@@ -687,28 +669,29 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
   }
 
   SECTION("sketch of strings bytes") {
-    kll_string_sketch sketch1(200, 0);
+    kll_string_sketch sketch1(200, 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"));
 
     auto bytes = sketch1.serialize();
     REQUIRE(bytes.size() == sketch1.get_serialized_size_bytes());
-    auto sketch2 = kll_string_sketch::deserialize(bytes.data(), bytes.size(), serde<std::string>(), 0);
+    auto sketch2 = kll_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));
@@ -718,11 +701,12 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
 
 
   SECTION("sketch of strings, single item, bytes") {
-    kll_string_sketch sketch1(200, 0);
+    kll_string_sketch sketch1(200, std::less<std::string>(), 0);
     sketch1.update("a");
     auto bytes = sketch1.serialize();
     REQUIRE(bytes.size() == sketch1.get_serialized_size_bytes());
-    auto sketch2 = kll_string_sketch::deserialize(bytes.data(), bytes.size(), serde<std::string>(), 0);
+    auto sketch2 = kll_string_sketch::deserialize(bytes.data(), bytes.size(), serde<std::string>(),
+        std::less<std::string>(), 0);
     REQUIRE(bytes.size() == sketch2.get_serialized_size_bytes());
   }
 
@@ -753,14 +737,14 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     // move constructor
     kll_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, false) == (double) i / n);
     }
 
     // move assignment
     kll_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, false) == (double) i / n);
     }
   }
 
@@ -795,44 +779,24 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     kll.update(3);
     kll.update(1);
 
-    { // non-cumulative, using operator->
-      auto view = kll.get_sorted_view(false);
+    {
+      auto view = kll.get_sorted_view();
       REQUIRE(view.size() == 3);
       auto it = view.begin();
-      REQUIRE(it->first == 1);
+      REQUIRE(it->first == 1); // operator->
+      REQUIRE((*it).first == 1); // operator*
       REQUIRE(it->second == 1);
+      REQUIRE(it.get_weight() == 1);
       ++it;
       REQUIRE(it->first == 2);
-      REQUIRE(it->second == 1);
-      ++it;
-      REQUIRE(it->first == 3);
-      REQUIRE(it->second == 1);
-    }
-    { // cumulative, non-inclusive, using operator->
-      auto view = kll.get_sorted_view(true);
-      REQUIRE(view.size() == 3);
-      auto it = view.begin();
-      REQUIRE(it->first == 1);
-      REQUIRE(it->second == 0);
-      ++it;
-      REQUIRE(it->first == 2);
-      REQUIRE(it->second == 1);
-      ++it;
-      REQUIRE(it->first == 3);
       REQUIRE(it->second == 2);
-    }
-    { // cumulative, inclusive, using operator*
-      auto view = kll.get_sorted_view<true>(true);
-      REQUIRE(view.size() == 3);
-      auto it = view.begin();
-      REQUIRE((*it).first == 1);
-      REQUIRE((*it).second == 1);
+      REQUIRE(it.get_weight() == 1);
       ++it;
-      REQUIRE((*it).first == 2);
-      REQUIRE((*it).second == 2);
+      REQUIRE(it->first == 3);
+      REQUIRE(it->second == 3);
+      REQUIRE(it.get_weight() == 1);
       ++it;
-      REQUIRE((*it).first == 3);
-      REQUIRE((*it).second == 3);
+      REQUIRE(it == view.end());
     }
   }
 
@@ -854,8 +818,8 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     REQUIRE(kll_float.get_n() == kll_double.get_n());
     REQUIRE(kll_float.get_num_retained() == kll_double.get_num_retained());
 
-    auto sv_float = kll_float.get_sorted_view(false);
-    auto sv_double = kll_double.get_sorted_view(false);
+    auto sv_float = kll_float.get_sorted_view();
+    auto sv_double = kll_double.get_sorted_view();
     auto sv_float_it = sv_float.begin();
     auto sv_double_it = sv_double.begin();
     while (sv_float_it != sv_float.end()) {