datasketches 0.2.1 → 0.2.2

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

@@ -0,0 +1,67 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef KOLMOGOROV_SMIRNOV_HPP_
+#define KOLMOGOROV_SMIRNOV_HPP_
+
+namespace datasketches {
+
+class kolmogorov_smirnov {
+public:
+  /**
+   * Computes the raw delta area between two KLL quantile sketches for the Kolmogorov-Smirnov Test.
+   * @param sketch1 KLL sketch 1
+   * @param sketch2 KLL sketch 2
+   * @return the raw delta between two KLL quantile sketches
+   */
+  template<typename Sketch>
+  static double delta(const Sketch& sketch1, const Sketch& sketch2);
+
+  /**
+   * Computes the adjusted delta area threshold for the Kolmogorov-Smirnov Test.
+   * Adjusts the computed threshold by the error epsilons of the two given sketches.
+   * See <a href="https://en.wikipedia.org/wiki/Kolmogorov-Smirnov_test">Kolmogorov–Smirnov Test</a>
+   * @param sketch1 KLL sketch 1
+   * @param sketch2 KLL sketch 2
+   * @param p Target p-value. Typically .001 to .1, e.g., .05.
+   * @return the adjusted threshold to be compared with the raw delta
+   */
+  template<typename Sketch>
+  static double threshold(const Sketch& sketch1, const Sketch& sketch2, double p);
+
+  /**
+   * Performs the Kolmogorov-Smirnov Test between two KLL quantiles sketches.
+   * Note: if the given sketches have insufficient data or if the sketch sizes are too small,
+   * this will return false.
+   * @param sketch1 KLL sketch 1
+   * @param sketch2 KLL sketch 2
+   * @param p Target p-value. Typically .001 to .1, e.g., .05.
+   * @return Boolean indicating whether we can reject the null hypothesis (that the sketches
+   * reflect the same underlying distribution) using the provided p-value.
+   */
+  template<typename Sketch>
+  static bool test(const Sketch& sketch1, const Sketch& sketch2, double p);
+
+};
+
+} /* namespace datasketches */
+
+#include "kolmogorov_smirnov_impl.hpp"
+
+#endif

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

@@ -0,0 +1,78 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef KOLMOGOROV_SMIRNOV_IMPL_HPP_
+#define KOLMOGOROV_SMIRNOV_IMPL_HPP_
+
+namespace datasketches {
+
+// type resolver
+template<typename T, typename C, typename S, typename A>
+kll_quantile_calculator<T, C, A> make_quantile_calculator(const kll_sketch<T, C, S, A>& sketch) {
+  return kll_quantile_calculator<T, C, A>(sketch);
+}
+
+template<typename Sketch>
+double kolmogorov_smirnov::delta(const Sketch& sketch1, const Sketch& sketch2) {
+  using Comparator = typename Sketch::comparator;
+  auto calc1 = make_quantile_calculator(sketch1);
+  auto calc2 = make_quantile_calculator(sketch2);
+  auto it1 = calc1.begin();
+  auto it2 = calc2.begin();
+  const auto n1 = sketch1.get_n();
+  const auto n2 = sketch2.get_n();
+  double delta = 0;
+  while (it1 != calc1.end() && it2 != calc2.end()) {
+    const double norm_cum_wt1 = static_cast<double>((*it1).second) / n1;
+    const double norm_cum_wt2 = static_cast<double>((*it2).second) / n2;
+    delta = std::max(delta, std::abs(norm_cum_wt1 - norm_cum_wt2));
+    if (Comparator()((*it1).first, (*it2).first)) {
+      ++it1;
+    } else if (Comparator()((*it2).first, (*it1).first)) {
+      ++it2;
+    } else {
+      ++it1;
+      ++it2;
+    }
+  }
+  const double norm_cum_wt1 = it1 == calc1.end() ? 1 : static_cast<double>((*it1).second) / n1;
+  const double norm_cum_wt2 = it2 == calc2.end() ? 1 : static_cast<double>((*it2).second) / n2;
+  delta = std::max(delta, std::abs(norm_cum_wt1 - norm_cum_wt2));
+  return delta;
+}
+
+template<typename Sketch>
+double kolmogorov_smirnov::threshold(const Sketch& sketch1, const Sketch& sketch2, double p) {
+  const double r1 = sketch1.get_num_retained();
+  const double r2 = sketch2.get_num_retained();
+  const double alpha_factor = sqrt(-0.5 * log(0.5 * p));
+  const double delta_area_threshold = alpha_factor * sqrt((r1 + r2) / (r1 * r2));
+  const double eps1 = sketch1.get_normalized_rank_error(false);
+  const double eps2 = sketch2.get_normalized_rank_error(false);
+  return delta_area_threshold + eps1 + eps2;
+}
+
+template<typename Sketch>
+bool kolmogorov_smirnov::test(const Sketch& sketch1, const Sketch& sketch2, double p) {
+  return delta(sketch1, sketch2) > threshold(sketch1, sketch2, p);
+}
+
+} /* namespace datasketches */
+
+#endif

data/vendor/datasketches-cpp/kll/test/CMakeLists.txt

@@ -41,4 +41,5 @@ target_sources(kll_test
     kll_sketch_test.cpp
     kll_sketch_custom_type_test.cpp
     kll_sketch_validation.cpp
+    kolmogorov_smirnov_test.cpp
 )

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

@@ -70,12 +70,10 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     REQUIRE(sketch.get_PMF(split_points, 1).size() == 0);
     REQUIRE(sketch.get_CDF(split_points, 1).size() == 0);
 
-    int count = 0;
-    for (auto& it: sketch) {
+    for (auto it: sketch) {
       (void) it; // to suppress "unused" warning
-      ++count;
+      FAIL("should be no iterations over an empty sketch");
     }
-    REQUIRE(count == 0);
 }
 
   SECTION("get bad quantile") {
@@ -86,13 +84,13 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
 
   SECTION("one item") {
     kll_float_sketch sketch(200, 0);
-    sketch.update(1);
+    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) == 0.0);
-    REQUIRE(sketch.get_rank(2) == 1.0);
+    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_quantile(0.5) == 1.0);
@@ -104,7 +102,7 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     REQUIRE(quantiles[2] == 1.0);
 
     int count = 0;
-    for (auto& it: sketch) {
+    for (auto it: sketch) {
       REQUIRE(it.second == 1);
       ++count;
     }
@@ -116,16 +114,16 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     sketch.update(std::numeric_limits<float>::quiet_NaN());
     REQUIRE(sketch.is_empty());
 
-    sketch.update(0.0);
+    sketch.update(0);
     sketch.update(std::numeric_limits<float>::quiet_NaN());
     REQUIRE(sketch.get_n() == 1);
   }
 
   SECTION("many items, exact mode") {
     kll_float_sketch sketch(200, 0);
-    const uint32_t n(200);
+    const uint32_t n = 200;
     for (uint32_t i = 0; i < n; i++) {
-      sketch.update(i);
+      sketch.update(static_cast<float>(i));
       REQUIRE(sketch.get_n() == i + 1);
     }
     REQUIRE_FALSE(sketch.is_empty());
@@ -145,7 +143,7 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
 
     for (uint32_t i = 0; i < n; i++) {
       const double trueRank = (double) i / n;
-      REQUIRE(sketch.get_rank(i) == trueRank);
+      REQUIRE(sketch.get_rank(static_cast<float>(i)) == trueRank);
     }
 
     // the alternative method must produce the same result
@@ -158,16 +156,16 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
 
   SECTION("10 items") {
     kll_float_sketch sketch(200, 0);
-    sketch.update(1);
-    sketch.update(2);
-    sketch.update(3);
-    sketch.update(4);
-    sketch.update(5);
-    sketch.update(6);
-    sketch.update(7);
-    sketch.update(8);
-    sketch.update(9);
-    sketch.update(10);
+    sketch.update(1.0f);
+    sketch.update(2.0f);
+    sketch.update(3.0f);
+    sketch.update(4.0f);
+    sketch.update(5.0f);
+    sketch.update(6.0f);
+    sketch.update(7.0f);
+    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);
@@ -176,7 +174,7 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
 
   SECTION("100 items") {
     kll_float_sketch sketch(200, 0);
-    for (int i = 0; i < 100; ++i) sketch.update(i);
+    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);
@@ -186,9 +184,9 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
 
   SECTION("many items, estimation mode") {
     kll_float_sketch sketch(200, 0);
-    const int n(1000000);
+    const int n = 1000000;
     for (int i = 0; i < n; i++) {
-      sketch.update(i);
+      sketch.update(static_cast<float>(i));
       REQUIRE(sketch.get_n() == static_cast<uint64_t>(i + 1));
     }
     REQUIRE_FALSE(sketch.is_empty());
@@ -201,7 +199,7 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     // test rank
     for (int i = 0; i < n; i++) {
       const double trueRank = (double) i / n;
-      REQUIRE(sketch.get_rank(i) == Approx(trueRank).margin(RANK_EPS_FOR_K_200));
+      REQUIRE(sketch.get_rank(static_cast<float>(i)) == Approx(trueRank).margin(RANK_EPS_FOR_K_200));
     }
 
     // test quantiles at every 0.1 percentage point
@@ -224,6 +222,15 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     }
 
     //std::cout << sketch.to_string();
+
+    uint32_t count = 0;
+    uint64_t total_weight = 0;
+    for (auto it: sketch) {
+      ++count;
+      total_weight += it.second;
+    }
+    REQUIRE(count == sketch.get_num_retained());
+    REQUIRE(total_weight == sketch.get_n());
   }
 
   SECTION("consistency between get_rank adn get_PMF/CDF") {
@@ -231,8 +238,8 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     const int n = 1000;
     float values[n];
     for (int i = 0; i < n; i++) {
-      sketch.update(i);
-      values[i] = i;
+      sketch.update(static_cast<float>(i));
+      values[i] = static_cast<float>(i);
     }
 
     const auto ranks(sketch.get_CDF(values, n));
@@ -299,7 +306,7 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
 
   SECTION("serialize deserialize one item") {
     kll_float_sketch sketch(200, 0);
-    sketch.update(1);
+    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());
@@ -332,8 +339,8 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
 
   SECTION("stream serialize deserialize many floats") {
     kll_float_sketch sketch(200, 0);
-    const int n(1000);
-    for (int i = 0; i < n; i++) sketch.update(i);
+    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());
@@ -350,13 +357,13 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     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(n) == sketch.get_rank(n));
+    REQUIRE(sketch2.get_rank(static_cast<float>(n)) == sketch.get_rank(static_cast<float>(n)));
   }
 
   SECTION("bytes serialize deserialize many floats") {
     kll_float_sketch sketch(200, 0);
-    const int n(1000);
-    for (int i = 0; i < n; i++) sketch.update(i);
+    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(), 0);
@@ -371,7 +378,7 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     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(n) == sketch.get_rank(n));
+    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);
@@ -379,7 +386,7 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
 
   SECTION("bytes serialize deserialize many ints") {
     kll_sketch<int> sketch;
-    const int n(1000);
+    const int n = 1000;
     for (int i = 0; i < n; i++) sketch.update(i);
     auto bytes = sketch.serialize();
     REQUIRE(bytes.size() == sketch.get_serialized_size_bytes());
@@ -439,8 +446,8 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     kll_float_sketch sketch2(200, 0);
     const int n = 10000;
     for (int i = 0; i < n; i++) {
-      sketch1.update(i);
-      sketch2.update((2 * n) - i - 1);
+      sketch1.update(static_cast<float>(i));
+      sketch2.update(static_cast<float>((2 * n) - i - 1));
     }
 
     REQUIRE(sketch1.get_min_value() == 0.0f);
@@ -462,8 +469,8 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     kll_float_sketch sketch2(128, 0);
     const int n = 10000;
     for (int i = 0; i < n; i++) {
-      sketch1.update(i);
-      sketch2.update((2 * n) - i - 1);
+      sketch1.update(static_cast<float>(i));
+      sketch2.update(static_cast<float>((2 * n) - i - 1));
     }
 
     REQUIRE(sketch1.get_min_value() == 0.0f);
@@ -495,7 +502,7 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     kll_float_sketch sketch2(128, 0);
     const int n = 10000;
     for (int i = 0; i < n; i++) {
-      sketch1.update(i);
+      sketch1.update(static_cast<float>(i));
     }
 
     // rank error should not be affected by a merge with an empty sketch with lower k
@@ -518,8 +525,8 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
   SECTION("merge min value from other") {
     kll_float_sketch sketch1(200, 0);
     kll_float_sketch sketch2(200, 0);
-    sketch1.update(1);
-    sketch2.update(2);
+    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);
@@ -527,7 +534,7 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
 
   SECTION("merge min and max values from other") {
     kll_float_sketch sketch1(200, 0);
-    for (int i = 0; i < 1000000; i++) sketch1.update(i);
+    for (int i = 0; i < 1000000; i++) sketch1.update(static_cast<float>(i));
     kll_float_sketch sketch2(200, 0);
     sketch2.merge(sketch1);
     REQUIRE(sketch2.get_min_value() == 0.0f);
@@ -540,7 +547,7 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     REQUIRE_THROWS_AS(sketch.get_min_value(), std::runtime_error);
     REQUIRE_THROWS_AS(sketch.get_max_value(), std::runtime_error);
 
-    const int n(1000);
+    const int n = 1000;
     for (int i = 0; i < n; i++) sketch.update(i);
 
     std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
@@ -679,6 +686,22 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
     }
   }
 
+  SECTION("max serialized size arithmetic type") {
+    REQUIRE(kll_sketch<float>::get_max_serialized_size_bytes(200, 10) == 1968);
+    REQUIRE(kll_sketch<float>::get_max_serialized_size_bytes(200, 100) == 2316);
+    REQUIRE(kll_sketch<float>::get_max_serialized_size_bytes(200, 1000) == 2440);
+    REQUIRE(kll_sketch<float>::get_max_serialized_size_bytes(200, 1000000) == 2800);
+    REQUIRE(kll_sketch<float>::get_max_serialized_size_bytes(200, 1000000000) == 3160);
+  }
+
+  SECTION("max serialized size non-arithmetic type") {
+    REQUIRE(kll_sketch<std::string>::get_max_serialized_size_bytes(200, 10, 4) == 1968);
+    REQUIRE(kll_sketch<std::string>::get_max_serialized_size_bytes(200, 100, 4) == 2316);
+    REQUIRE(kll_sketch<std::string>::get_max_serialized_size_bytes(200, 1000, 4) == 2440);
+    REQUIRE(kll_sketch<std::string>::get_max_serialized_size_bytes(200, 1000000, 4) == 2800);
+    REQUIRE(kll_sketch<std::string>::get_max_serialized_size_bytes(200, 1000000000, 4) == 3160);
+  }
+
   // cleanup
   if (test_allocator_total_bytes != 0) {
     REQUIRE(test_allocator_total_bytes == 0);

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

@@ -0,0 +1,111 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <catch.hpp>
+
+#include <random>
+
+#include <kll_sketch.hpp>
+#include <kolmogorov_smirnov.hpp>
+
+namespace datasketches {
+
+TEST_CASE("kolmogorov-smirnov empty", "[kll_sketch]") {
+  const uint16_t k = 200;
+  kll_sketch<double> sketch1(k);
+  kll_sketch<double> sketch2(k);
+  REQUIRE(kolmogorov_smirnov::delta(sketch1, sketch2) == 0);
+  REQUIRE_FALSE(kolmogorov_smirnov::test(sketch1, sketch2, 0.01));
+}
+
+TEST_CASE("kolmogorov-smirnov same distribution", "[kll_sketch]") {
+  const uint16_t k = 200;
+  kll_sketch<double> sketch1(k);
+  kll_sketch<double> sketch2(k);
+  std::default_random_engine rand;
+  std::normal_distribution<double> distr;
+  const int n = k * 3 - 1;
+  for (int i = 0; i < n; ++i) {
+    const double x = distr(rand);
+    sketch1.update(x);
+    sketch2.update(x);
+  }
+  REQUIRE(kolmogorov_smirnov::delta(sketch1, sketch2) == Approx(0).margin(0.01));
+  REQUIRE_FALSE(kolmogorov_smirnov::test(sketch1, sketch2, 0.01));
+}
+
+TEST_CASE("kolmogorov-smirnov very different distributions", "[kll_sketch]") {
+  const uint16_t k = 200;
+  kll_sketch<double> sketch1(k);
+  kll_sketch<double> sketch2(k);
+  std::default_random_engine rand;
+  std::normal_distribution<double> distr;
+  const int n = k * 3 - 1;
+  for (int i = 0; i < n; ++i) {
+    const double x = distr(rand);
+    sketch1.update(x + 100.0);
+    sketch2.update(x);
+  }
+  const auto delta = kolmogorov_smirnov::delta(sketch1, sketch2);
+  REQUIRE(delta == Approx(1.0).margin(1e-6));
+  REQUIRE(delta <= 1);
+  REQUIRE(kolmogorov_smirnov::test(sketch1, sketch2, 0.05));
+}
+
+TEST_CASE("kolmogorov-smirnov slightly different distributions", "[kll_sketch]") {
+  const uint16_t k = 2000;
+  kll_sketch<double> sketch1(k);
+  kll_sketch<double> sketch2(k);
+  std::default_random_engine rand;
+  std::normal_distribution<double> distr;
+  const int n = k * 3 - 1;
+  for (int i = 0; i < n; ++i) {
+    const double x = distr(rand);
+    sketch1.update(x + 0.05);
+    sketch2.update(x);
+  }
+  const double delta = kolmogorov_smirnov::delta(sketch1, sketch2);
+  REQUIRE(delta == Approx(0.02).margin(0.01));
+  const double threshold = kolmogorov_smirnov::threshold(sketch1, sketch2, 0.05);
+  //std::cout << "delta=" << delta << ", threshold=" << threshold << "\n";
+  REQUIRE_FALSE(delta > threshold);
+  REQUIRE_FALSE(kolmogorov_smirnov::test(sketch1, sketch2, 0.05));
+}
+
+TEST_CASE("kolmogorov-smirnov slightly different distributions high resolution", "[kll_sketch]") {
+  const uint16_t k = 8000;
+  kll_sketch<double> sketch1(k);
+  kll_sketch<double> sketch2(k);
+  std::default_random_engine rand;
+  std::normal_distribution<double> distr;
+  const int n = k * 3 - 1;
+  for (int i = 0; i < n; ++i) {
+    const double x = distr(rand);
+    sketch1.update(x + 0.05);
+    sketch2.update(x);
+  }
+  const double delta = kolmogorov_smirnov::delta(sketch1, sketch2);
+  REQUIRE(delta == Approx(0.02).margin(0.01));
+  const double threshold = kolmogorov_smirnov::threshold(sketch1, sketch2, 0.05);
+  //std::cout << "delta=" << delta << ", threshold=" << threshold << "\n";
+  REQUIRE(delta > threshold);
+  REQUIRE(kolmogorov_smirnov::test(sketch1, sketch2, 0.05));
+}
+
+} /* namespace datasketches */