datasketches 0.2.7 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a7fef851c11ba93a002a6215f76170b973628f8b1f0a89fb89a5e655f6a421a
-  data.tar.gz: a590d7cde413596640f8bf169db67742696d7e304097be8bc0820244ed32ebd5
+  metadata.gz: d8db863a37a8fa081bff6bf269666cdff6d4e8a4cf860a0fafac235858709f62
+  data.tar.gz: a858071aae33a8aeb5d92cec1f4fdf4cc3cb5d12b07ed629152c953674c06dff
 SHA512:
-  metadata.gz: dea9986097b4e9e4c7aba8b6f69108dce21caa2f6fa1e8723a9bf8be2077b925507bf84bd92bc794c1831285963f8ecb8f4739797c3246a15a438a82816043d6
-  data.tar.gz: 64f2ed1ed4656c09057892ae493a9a2c7178b3090dd84c24105b9e2f16d45f9aaed728c2bb6154e6518e018bbd240f5c2e562fa2edbee397b5deccb8b1dd11f5
+  metadata.gz: 03acf7acb3ecb617713d3549e289ed5829f55bd65a52c28eaf1a603cc2e9e577f7d7ffdebd230b01d259d1116ebbef06640a1a9b1d00baa8d0e970cd31357923
+  data.tar.gz: eb4730c27379a392b330cbdf9cf17d6d1207307e46ca2c0203b1e4eab237218115824249646f5916737af01b96b3451a373ce51c2020576af49a1da31a5070b5

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.3.0 (2022-12-08)
+
+- Updated DataSketches to 4.0.0
+- Dropped support for Ruby < 2.7
+
 ## 0.2.7 (2022-11-05)
 
 - Updated DataSketches to 3.5.1

data/ext/datasketches/kll_wrapper.cpp

@@ -26,43 +26,43 @@ namespace Rice::detail
 template<typename T>
 void bind_kll_sketch(Rice::Module& m, const char* name) {
   Rice::define_class_under<kll_sketch<T>>(m, name)
-    .define_constructor(Rice::Constructor<kll_sketch<T>, uint16_t>(), Rice::Arg("k")=kll_sketch<T>::DEFAULT_K)
+    .define_constructor(Rice::Constructor<kll_sketch<T>, uint16_t>(), Rice::Arg("k")=datasketches::kll_constants::DEFAULT_K)
     .define_method("empty?", &kll_sketch<T>::is_empty)
     .define_method("n", &kll_sketch<T>::get_n)
     .define_method("num_retained", &kll_sketch<T>::get_num_retained)
     .define_method("estimation_mode?", &kll_sketch<T>::is_estimation_mode)
-    .define_method("min_value", &kll_sketch<T>::get_min_value)
-    .define_method("max_value", &kll_sketch<T>::get_max_value)
+    .define_method("min_value", &kll_sketch<T>::get_min_item)
+    .define_method("max_value", &kll_sketch<T>::get_max_item)
     .define_method(
       "quantile",
-      [](kll_sketch<T>& self, double fraction) {
-        return self.get_quantile(fraction);
-      })
+      [](kll_sketch<T>& self, double rank, bool inclusive) {
+        return self.get_quantile(rank, inclusive);
+      }, Rice::Arg("rank"), Rice::Arg("inclusive")=false)
     .define_method(
       "quantiles",
-      [](kll_sketch<T>& self, Rice::Object obj) {
+      [](kll_sketch<T>& self, Rice::Object obj, bool inclusive) {
         if (obj.is_a(rb_cArray)) {
-          auto fractions = Rice::detail::From_Ruby<std::vector<double>>().convert(obj);
-          return self.get_quantiles(&fractions[0], fractions.size());
+          auto ranks = Rice::detail::From_Ruby<std::vector<double>>().convert(obj);
+          return self.get_quantiles(&ranks[0], ranks.size(), inclusive);
         } else {
-          return self.get_quantiles(Rice::detail::From_Ruby<size_t>().convert(obj));
+          return self.get_quantiles(Rice::detail::From_Ruby<size_t>().convert(obj), inclusive);
         }
-      })
+      }, Rice::Arg("obj"), Rice::Arg("inclusive")=false)
     .define_method(
       "rank",
-      [](kll_sketch<T>& self, const T item) {
-        return self.get_rank(item);
-      })
+      [](kll_sketch<T>& self, const T item, bool inclusive) {
+        return self.get_rank(item, inclusive);
+      }, Rice::Arg("item"), Rice::Arg("inclusive")=false)
     .define_method(
       "pmf",
-      [](kll_sketch<T>& self, const std::vector<T>& split_points) {
-        return self.get_PMF(&split_points[0], split_points.size());
-      })
+      [](kll_sketch<T>& self, const std::vector<T>& split_points, bool inclusive) {
+        return self.get_PMF(&split_points[0], split_points.size(), inclusive);
+      }, Rice::Arg("split_points"), Rice::Arg("inclusive")=false)
     .define_method(
       "cdf",
-      [](kll_sketch<T>& self, const std::vector<T>& split_points) {
-        return self.get_CDF(&split_points[0], split_points.size());
-      })
+      [](kll_sketch<T>& self, const std::vector<T>& split_points, bool inclusive) {
+        return self.get_CDF(&split_points[0], split_points.size(), inclusive);
+      }, Rice::Arg("split_points"), Rice::Arg("inclusive")=false)
     .define_method(
       "merge",
       [](kll_sketch<T>& self, const kll_sketch<T>& other) {

data/ext/datasketches/theta_wrapper.cpp

@@ -59,7 +59,7 @@ void init_theta(Rice::Module& m) {
         builder.set_seed(seed);
         return builder.build();
       },
-      Arg("lg_k")=update_theta_sketch::builder::DEFAULT_LG_K, Arg("p")=1.0, Arg("seed")=DEFAULT_SEED)
+      Arg("lg_k")=datasketches::theta_constants::DEFAULT_LG_K, Arg("p")=1.0, Arg("seed")=DEFAULT_SEED)
     .define_method("compact", &update_theta_sketch::compact, Arg("ordered")=true)
     .define_method(
       "update",
@@ -88,7 +88,7 @@ void init_theta(Rice::Module& m) {
         builder.set_seed(seed);
         return builder.build();
       },
-      Arg("lg_k")=update_theta_sketch::builder::DEFAULT_LG_K, Arg("p")=1.0, Arg("seed")=DEFAULT_SEED)
+      Arg("lg_k")=datasketches::theta_constants::DEFAULT_LG_K, Arg("p")=1.0, Arg("seed")=DEFAULT_SEED)
     .define_method("update", &theta_union::update<const theta_sketch&>)
     .define_method("result", &theta_union::get_result, Arg("ordered")=true);
 

data/lib/datasketches/version.rb

@@ -1,3 +1,3 @@
 module DataSketches
-  VERSION = "0.2.7"
+  VERSION = "0.3.0"
 end

data/vendor/datasketches-cpp/CMakeLists.txt

@@ -16,10 +16,18 @@
 # under the License.
 
 cmake_minimum_required(VERSION 3.16.0)
+
+string(TIMESTAMP DT %Y%m%d UTC)
+string(TIMESTAMP HHMM %H%M UTC)
+configure_file(version.cfg.in version.cfg @ONLY)
+file(STRINGS ${CMAKE_CURRENT_BINARY_DIR}/version.cfg BASE_VERSION)
+
 project(DataSketches
-        VERSION 3.5.1
+        VERSION ${BASE_VERSION}
         LANGUAGES CXX)
 
+message("Configuring DataSketches version ${BASE_VERSION}")
+
 include(GNUInstallDirs)
 include(CMakeDependentOption)
 

data/vendor/datasketches-cpp/MANIFEST.in

@@ -1,11 +1,27 @@
+# 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.
+
 global-include CMakeLists.txt
 global-include *.cpp
 global-include *.c
 global-include *.hpp
 global-include *.h
 global-include *.bin
-
-global-exclude .git*
+global-include *.in
 
 graft cmake
 graft common
@@ -18,3 +34,6 @@ graft theta
 graft tuple
 graft sampling
 graft python
+
+# exclusions appear after including subdirectories
+prune build

data/vendor/datasketches-cpp/common/CMakeLists.txt

@@ -17,6 +17,8 @@
 
 add_library(common INTERFACE)
 
+configure_file(include/version.hpp.in include/version.hpp @ONLY)
+
 if (BUILD_TESTS)
   add_subdirectory(test)
 endif()
@@ -32,6 +34,7 @@ target_compile_features(common INTERFACE cxx_std_11)
 install(TARGETS common EXPORT ${PROJECT_NAME})
 
 install(FILES 
+			${CMAKE_CURRENT_BINARY_DIR}/include/version.hpp
 			include/common_defs.hpp
 			include/memory_operations.hpp
 			include/MurmurHash3.h
@@ -43,8 +46,8 @@ install(FILES
 			include/conditional_forward.hpp
 			include/ceiling_power_of_2.hpp
 			include/bounds_binomial_proportions.hpp
-			include/quantile_sketch_sorted_view.hpp
-			include/quantile_sketch_sorted_view_impl.hpp
+			include/quantiles_sorted_view.hpp
+			include/quantiles_sorted_view_impl.hpp
 			include/kolmogorov_smirnov.hpp
 			include/kolmogorov_smirnov_impl.hpp
   DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/DataSketches")

data/vendor/datasketches-cpp/common/include/common_defs.hpp

@@ -86,6 +86,16 @@ static inline void write(std::ostream& os, const T* ptr, size_t size_bytes) {
   os.write(reinterpret_cast<const char*>(ptr), size_bytes);
 }
 
+// wrapper for iterators to implement operator-> returning temporary value
+template<typename T>
+class return_value_holder {
+public:
+  return_value_holder(T value): value_(value) {}
+  const T* operator->() const { return std::addressof(value_); }
+private:
+  T value_;
+};
+
 } // namespace
 
 #endif // _COMMON_DEFS_HPP_

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

@@ -28,16 +28,16 @@ namespace datasketches {
 template<typename Sketch>
 double kolmogorov_smirnov::delta(const Sketch& sketch1, const Sketch& sketch2) {
   auto comparator = sketch1.get_comparator(); // assuming the same comparator in sketch2
-  auto view1 = sketch1.get_sorted_view(true);
-  auto view2 = sketch2.get_sorted_view(true);
+  auto view1 = sketch1.get_sorted_view();
+  auto view2 = sketch2.get_sorted_view();
   auto it1 = view1.begin();
   auto it2 = view2.begin();
   const auto n1 = sketch1.get_n();
   const auto n2 = sketch2.get_n();
   double delta = 0;
   while (it1 != view1.end() && it2 != view2.end()) {
-    const double norm_cum_wt1 = static_cast<double>((*it1).second) / n1;
-    const double norm_cum_wt2 = static_cast<double>((*it2).second) / n2;
+    const double norm_cum_wt1 = static_cast<double>(it1.get_cumulative_weight(false)) / n1;
+    const double norm_cum_wt2 = static_cast<double>(it2.get_cumulative_weight(false)) / n2;
     delta = std::max(delta, std::abs(norm_cum_wt1 - norm_cum_wt2));
     if (comparator((*it1).first, (*it2).first)) {
       ++it1;
@@ -48,8 +48,8 @@ double kolmogorov_smirnov::delta(const Sketch& sketch1, const Sketch& sketch2) {
       ++it2;
     }
   }
-  const double norm_cum_wt1 = it1 == view1.end() ? 1 : static_cast<double>((*it1).second) / n1;
-  const double norm_cum_wt2 = it2 == view2.end() ? 1 : static_cast<double>((*it2).second) / n2;
+  const double norm_cum_wt1 = it1 == view1.end() ? 1 : static_cast<double>(it1.get_cumulative_weight(false)) / n1;
+  const double norm_cum_wt2 = it2 == view2.end() ? 1 : static_cast<double>(it2.get_cumulative_weight(false)) / n2;
   delta = std::max(delta, std::abs(norm_cum_wt1 - norm_cum_wt2));
   return delta;
 }

data/vendor/datasketches-cpp/common/include/memory_operations.hpp

@@ -23,6 +23,7 @@
 #include <memory>
 #include <exception>
 #include <iostream>
+#include <string>
 
 namespace datasketches {
 

data/vendor/datasketches-cpp/common/include/{quantile_sketch_sorted_view.hpp → quantiles_sorted_view.hpp}

@@ -17,10 +17,13 @@
  * under the License.
  */
 
-#ifndef QUANTILE_SKETCH_SORTED_VIEW_HPP_
-#define QUANTILE_SKETCH_SORTED_VIEW_HPP_
+#ifndef QUANTILES_SORTED_VIEW_HPP_
+#define QUANTILES_SORTED_VIEW_HPP_
 
 #include <functional>
+#include <cmath>
+
+#include "common_defs.hpp"
 
 namespace datasketches {
 
@@ -29,18 +32,17 @@ template<
   typename Comparator, // strict weak ordering function (see C++ named requirements: Compare)
   typename Allocator
 >
-class quantile_sketch_sorted_view {
+class quantiles_sorted_view {
 public:
   using Entry = typename std::conditional<std::is_arithmetic<T>::value, std::pair<T, uint64_t>, std::pair<const T*, uint64_t>>::type;
   using AllocEntry = typename std::allocator_traits<Allocator>::template rebind_alloc<Entry>;
   using Container = std::vector<Entry, AllocEntry>;
 
-  quantile_sketch_sorted_view(uint32_t num, const Allocator& allocator);
+  quantiles_sorted_view(uint32_t num, const Comparator& comparator, const Allocator& allocator);
 
   template<typename Iterator>
   void add(Iterator begin, Iterator end, uint64_t weight);
 
-  template<bool inclusive>
   void convert_to_cummulative();
 
   class const_iterator;
@@ -49,18 +51,29 @@ public:
 
   size_t size() const;
 
-  // makes sense only with cumulative weight
+  double get_rank(const T& item, bool inclusive = true) const;
+
   using quantile_return_type = typename std::conditional<std::is_arithmetic<T>::value, T, const T&>::type;
-  quantile_return_type get_quantile(double rank) const;
+  quantile_return_type get_quantile(double rank, bool inclusive = true) const;
+
+  using vector_double = std::vector<double, typename std::allocator_traits<Allocator>::template rebind_alloc<double>>;
+  vector_double get_CDF(const T* split_points, uint32_t size, bool inclusive = true) const;
+  vector_double get_PMF(const T* split_points, uint32_t size, bool inclusive = true) const;
 
 private:
+  Comparator comparator_;
+  uint64_t total_weight_;
+  Container entries_;
+
   static inline const T& deref_helper(const T* t) { return *t; }
   static inline T deref_helper(T t) { return t; }
 
   struct compare_pairs_by_first {
+    explicit compare_pairs_by_first(const Comparator& comparator): comparator_(comparator) {}
     bool operator()(const Entry& a, const Entry& b) const {
-      return Comparator()(deref_helper(a.first), deref_helper(b.first));
+      return comparator_(deref_helper(a.first), deref_helper(b.first));
     }
+    Comparator comparator_;
   };
 
   struct compare_pairs_by_second {
@@ -81,41 +94,63 @@ private:
   template<typename TT = T, typename std::enable_if<!std::is_arithmetic<TT>::value, int>::type = 0>
   static inline Entry make_dummy_entry(uint64_t weight) { return Entry(nullptr, weight); }
 
-  uint64_t total_weight_;
-  Container entries_;
+  template<typename TT = T, typename std::enable_if<std::is_floating_point<TT>::value, int>::type = 0>
+  static inline void check_split_points(const T* items, uint32_t size) {
+    for (uint32_t i = 0; i < size ; i++) {
+      if (std::isnan(items[i])) {
+        throw std::invalid_argument("Values must not be NaN");
+      }
+      if ((i < (size - 1)) && !(Comparator()(items[i], items[i + 1]))) {
+        throw std::invalid_argument("Values must be unique and monotonically increasing");
+      }
+    }
+  }
+
+  template<typename TT = T, typename std::enable_if<!std::is_floating_point<TT>::value, int>::type = 0>
+  static inline void check_split_points(const T* items, uint32_t size) {
+    for (uint32_t i = 0; i < size ; i++) {
+      if ((i < (size - 1)) && !(Comparator()(items[i], items[i + 1]))) {
+        throw std::invalid_argument("Items must be unique and monotonically increasing");
+      }
+    }
+  }
 };
 
 template<typename T, typename C, typename A>
-class quantile_sketch_sorted_view<T, C, A>::const_iterator: public quantile_sketch_sorted_view<T, C, A>::Container::const_iterator {
+class quantiles_sorted_view<T, C, A>::const_iterator: public quantiles_sorted_view<T, C, A>::Container::const_iterator {
 public:
-  using Base = typename quantile_sketch_sorted_view<T, C, A>::Container::const_iterator;
+  using Base = typename quantiles_sorted_view<T, C, A>::Container::const_iterator;
   using value_type = typename std::conditional<std::is_arithmetic<T>::value, typename Base::value_type, std::pair<const T&, const uint64_t>>::type;
 
-  const_iterator(const Base& it): Base(it) {}
+  const_iterator(const Base& it, const Base& begin): Base(it), begin(begin) {}
 
   template<typename TT = T, typename std::enable_if<std::is_arithmetic<TT>::value, int>::type = 0>
-  value_type operator*() const { return Base::operator*(); }
+  const value_type operator*() const { return Base::operator*(); }
 
   template<typename TT = T, typename std::enable_if<!std::is_arithmetic<TT>::value, int>::type = 0>
-  value_type operator*() const { return value_type(*(Base::operator*().first), Base::operator*().second); }
-
-  class return_value_holder {
-  public:
-    return_value_holder(value_type value): value_(value) {}
-    const value_type* operator->() const { return &value_; }
-  private:
-    value_type value_;
-  };
+  const value_type operator*() const { return value_type(*(Base::operator*().first), Base::operator*().second); }
 
   template<typename TT = T, typename std::enable_if<std::is_arithmetic<TT>::value, int>::type = 0>
   const value_type* operator->() const { return Base::operator->(); }
 
   template<typename TT = T, typename std::enable_if<!std::is_arithmetic<TT>::value, int>::type = 0>
-  return_value_holder operator->() const { return **this; }
+  const return_value_holder<value_type> operator->() const { return **this; }
+
+  uint64_t get_weight() const {
+    if (*this == begin) return Base::operator*().second;
+    return Base::operator*().second - (*this - 1).operator*().second;
+  }
+
+  uint64_t get_cumulative_weight(bool inclusive = true) const {
+    return inclusive ? Base::operator*().second : Base::operator*().second - get_weight();
+  }
+
+private:
+  Base begin;
 };
 
 } /* namespace datasketches */
 
-#include "quantile_sketch_sorted_view_impl.hpp"
+#include "quantiles_sorted_view_impl.hpp"
 
 #endif

data/vendor/datasketches-cpp/common/include/quantiles_sorted_view_impl.hpp

@@ -0,0 +1,125 @@
+/*
+ * 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 QUANTILES_SORTED_VIEW_IMPL_HPP_
+#define QUANTILES_SORTED_VIEW_IMPL_HPP_
+
+#include <algorithm>
+#include <stdexcept>
+#include <cmath>
+
+namespace datasketches {
+
+template<typename T, typename C, typename A>
+quantiles_sorted_view<T, C, A>::quantiles_sorted_view(uint32_t num, const C& comparator, const A& allocator):
+comparator_(comparator),
+total_weight_(0),
+entries_(allocator)
+{
+  entries_.reserve(num);
+}
+
+template<typename T, typename C, typename A>
+template<typename Iterator>
+void quantiles_sorted_view<T, C, A>::add(Iterator first, Iterator last, uint64_t weight) {
+  const size_t size_before = entries_.size();
+  for (auto it = first; it != last; ++it) entries_.push_back(Entry(ref_helper(*it), weight));
+  if (size_before > 0) {
+    Container tmp(entries_.get_allocator());
+    tmp.reserve(entries_.capacity());
+    std::merge(
+        entries_.begin(), entries_.begin() + size_before,
+        entries_.begin() + size_before, entries_.end(),
+        std::back_inserter(tmp), compare_pairs_by_first(comparator_)
+    );
+    std::swap(tmp, entries_);
+  }
+}
+
+template<typename T, typename C, typename A>
+void quantiles_sorted_view<T, C, A>::convert_to_cummulative() {
+  for (auto& entry: entries_) {
+    total_weight_ += entry.second;
+    entry.second = total_weight_;
+  }
+}
+
+template<typename T, typename C, typename A>
+double quantiles_sorted_view<T, C, A>::get_rank(const T& item, bool inclusive) const {
+  if (entries_.empty()) throw std::runtime_error("operation is undefined for an empty sketch");
+  auto it = inclusive ?
+      std::upper_bound(entries_.begin(), entries_.end(), Entry(ref_helper(item), 0), compare_pairs_by_first(comparator_))
+    : std::lower_bound(entries_.begin(), entries_.end(), Entry(ref_helper(item), 0), compare_pairs_by_first(comparator_));
+  // we need item just before
+  if (it == entries_.begin()) return 0;
+  --it;
+  return static_cast<double>(it->second) / total_weight_;
+}
+
+template<typename T, typename C, typename A>
+auto quantiles_sorted_view<T, C, A>::get_quantile(double rank, bool inclusive) const -> quantile_return_type {
+  if (entries_.empty()) throw std::runtime_error("operation is undefined for an empty sketch");
+  uint64_t weight = inclusive ? std::ceil(rank * total_weight_) : rank * total_weight_;
+  auto it = inclusive ?
+      std::lower_bound(entries_.begin(), entries_.end(), make_dummy_entry<T>(weight), compare_pairs_by_second())
+    : std::upper_bound(entries_.begin(), entries_.end(), make_dummy_entry<T>(weight), compare_pairs_by_second());
+  if (it == entries_.end()) return deref_helper(entries_[entries_.size() - 1].first);
+  return deref_helper(it->first);
+}
+
+template<typename T, typename C, typename A>
+auto quantiles_sorted_view<T, C, A>::get_CDF(const T* split_points, uint32_t size, bool inclusive) const -> vector_double {
+  if (entries_.empty()) throw std::runtime_error("operation is undefined for an empty sketch");
+  vector_double buckets(entries_.get_allocator());
+  if (entries_.size() == 0) return buckets;
+  check_split_points(split_points, size);
+  buckets.reserve(size + 1);
+  for (uint32_t i = 0; i < size; ++i) buckets.push_back(get_rank(split_points[i], inclusive));
+  buckets.push_back(1);
+  return buckets;
+}
+
+template<typename T, typename C, typename A>
+auto quantiles_sorted_view<T, C, A>::get_PMF(const T* split_points, uint32_t size, bool inclusive) const -> vector_double {
+  auto buckets = get_CDF(split_points, size, inclusive);
+  if (buckets.size() == 0) return buckets;
+  for (uint32_t i = size; i > 0; --i) {
+    buckets[i] -= buckets[i - 1];
+  }
+  return buckets;
+}
+
+template<typename T, typename C, typename A>
+auto quantiles_sorted_view<T, C, A>::begin() const -> const_iterator {
+  return const_iterator(entries_.begin(), entries_.begin());
+}
+
+template<typename T, typename C, typename A>
+auto quantiles_sorted_view<T, C, A>::end() const -> const_iterator {
+  return const_iterator(entries_.end(), entries_.begin());
+}
+
+template<typename T, typename C, typename A>
+size_t quantiles_sorted_view<T, C, A>::size() const {
+  return entries_.size();
+}
+
+} /* namespace datasketches */
+
+#endif

data/vendor/datasketches-cpp/common/include/version.hpp.in

@@ -0,0 +1,36 @@
+/*
+ * 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 _VERSION_HPP_
+#define _VERSION_HPP_
+
+namespace datasketches {
+
+// the configured options and settings for DataSketches
+constexpr int VERSION_MAJOR {@DataSketches_VERSION_MAJOR@};
+constexpr int VERSION_MINOR {@DataSketches_VERSION_MINOR@};
+constexpr int VERSION_PATCH {@DataSketches_VERSION_PATCH@};
+constexpr int VERSION_TWEAK {@DataSketches_VERSION_TWEAK@};
+
+constexpr auto VERSION_STR = "@DataSketches_VERSION@";
+constexpr auto SOURCE_URL = "https://github.com/apache/datasketches-cpp";
+
+}
+
+#endif // _VERSION_HPP_

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

@@ -19,7 +19,7 @@
 # and an integration test using the other parts of the library.
 
 # common dependencies for tests
-add_library(common_test OBJECT "")
+add_library(common_test_lib OBJECT "")
 
 include(FetchContent)
 
@@ -31,19 +31,19 @@ FetchContent_Declare(
 
 FetchContent_MakeAvailable(Catch2)
 
-target_link_libraries(common_test PUBLIC Catch2::Catch2)
+target_link_libraries(common_test_lib PUBLIC Catch2::Catch2)
 
-set_target_properties(common_test PROPERTIES
+set_target_properties(common_test_lib PROPERTIES
   CXX_STANDARD 11
   CXX_STANDARD_REQUIRED YES
 )
 
-target_include_directories(common_test
+target_include_directories(common_test_lib
   INTERFACE
     ${CMAKE_CURRENT_SOURCE_DIR}
 )
 
-target_sources(common_test
+target_sources(common_test_lib
   INTERFACE
     ${CMAKE_CURRENT_SOURCE_DIR}/test_allocator.hpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_type.hpp
@@ -52,10 +52,29 @@ target_sources(common_test
     ${CMAKE_CURRENT_SOURCE_DIR}/test_allocator.cpp
 )
 
+add_executable(common_test)
+
+target_link_libraries(common_test common common_test_lib)
+
+set_target_properties(common_test PROPERTIES
+  CXX_STANDARD 11
+  CXX_STANDARD_REQUIRED YES
+)
+
+add_test(
+  NAME common_test
+  COMMAND common_test
+)
+
+target_sources(common_test
+  PRIVATE
+    quantiles_sorted_view_test.cpp
+)
+
 # now the integration test part
 add_executable(integration_test)
 
-target_link_libraries(integration_test cpc fi hll kll req sampling theta tuple common_test)
+target_link_libraries(integration_test cpc fi hll kll req sampling theta tuple common_test_lib)
 
 set_target_properties(integration_test PROPERTIES
   CXX_STANDARD 11