datasketches 0.2.3 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea00e444de6dc1bebc2b8cf878a250f08717d55eaa55f63f6bec28f4be2af00d
-  data.tar.gz: 161b9089e3b8d0dbd99cfb6cc0af463934c42ba85f4788a08306369966f28571
+  metadata.gz: cf1ea0f9f2d12b0e46c2d4c7dec21f41992e711e73eca68ea1ef03a4bb711077
+  data.tar.gz: 92f56b63da0254962be47d8d3e00a6950a271053bf3152167f95e6fdb99528e6
 SHA512:
-  metadata.gz: '09eede1e6e4c0fe57c0116c4e8873670192fea845783687ca34890bd9358af9dd19a535774ab7dd667055cf6acd0d3913f044dcf2274e0ec092b33307250a74a'
-  data.tar.gz: b8bcaeb7af0d27e836f21941663229a2750922914c4f31f4ffbd6e3c3876320f9ce92916eb9730e02227b87e8f244bc08e5bc38541bf4ef4e3485203fff01942
+  metadata.gz: 5841d4a70f1e852faa150f57ebfefc7b975de020782c41eebdad87a01d016be9bdf86f86173600632bf6f56300df0c9c4196251aa5df02a47ecd357ac844ef80
+  data.tar.gz: d6ae7c811e0e2c2008b912e29f86d1b99491c74cd878790dfd800811a007f0dbf9c49bb59db30345450ff82673381f2c036a84a57dc44a6f6751610d9be2ee88

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 0.2.6 (2022-07-13)
+
+- Updated DataSketches to 3.5.0
+
+## 0.2.5 (2022-05-21)
+
+- Updated DataSketches to 3.4.0
+
+## 0.2.4 (2021-12-28)
+
+- Updated DataSketches to 3.3.0
+
 ## 0.2.3 (2021-09-29)
 
 - Updated DataSketches to 3.2.0

data/README.md

@@ -1,15 +1,15 @@
-# DataSketches
+# DataSketches Ruby
 
 [DataSketches](https://datasketches.apache.org/) - sketch data structures - for Ruby
 
-[![Build Status](https://github.com/ankane/datasketches/workflows/build/badge.svg?branch=master)](https://github.com/ankane/datasketches/actions)
+[![Build Status](https://github.com/ankane/datasketches-ruby/workflows/build/badge.svg?branch=master)](https://github.com/ankane/datasketches-ruby/actions)
 
 ## Installation
 
 Add this line to your application’s Gemfile:
 
 ```ruby
-gem 'datasketches'
+gem "datasketches"
 ```
 
 ## Sketch Families
@@ -292,22 +292,22 @@ This library is modeled after the DataSketches [Python API](https://github.com/a
 
 ## History
 
-View the [changelog](https://github.com/ankane/datasketches/blob/master/CHANGELOG.md)
+View the [changelog](https://github.com/ankane/datasketches-ruby/blob/master/CHANGELOG.md)
 
 ## Contributing
 
 Everyone is encouraged to help improve this project. Here are a few ways you can help:
 
-- [Report bugs](https://github.com/ankane/datasketches/issues)
-- Fix bugs and [submit pull requests](https://github.com/ankane/datasketches/pulls)
+- [Report bugs](https://github.com/ankane/datasketches-ruby/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/datasketches-ruby/pulls)
 - Write, clarify, or fix documentation
 - Suggest or add new features
 
 To get started with development:
 
 ```sh
-git clone --recursive https://github.com/ankane/datasketches.git
-cd datasketches
+git clone --recursive https://github.com/ankane/datasketches-ruby.git
+cd datasketches-ruby
 bundle install
 bundle exec rake compile
 bundle exec rake test

data/ext/datasketches/kll_wrapper.cpp

@@ -33,7 +33,11 @@ void bind_kll_sketch(Rice::Module& m, const char* name) {
     .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("quantile", &kll_sketch<T>::get_quantile)
+    .define_method(
+      "quantile",
+      [](kll_sketch<T>& self, double fraction) {
+        return self.get_quantile(fraction);
+      })
     .define_method(
       "quantiles",
       [](kll_sketch<T>& self, Rice::Object obj) {
@@ -51,12 +55,12 @@ void bind_kll_sketch(Rice::Module& m, const char* name) {
       })
     .define_method(
       "pmf",
-      [](kll_sketch<T>& self, std::vector<T> split_points) {
+      [](kll_sketch<T>& self, const std::vector<T>& split_points) {
         return self.get_PMF(&split_points[0], split_points.size());
       })
     .define_method(
       "cdf",
-      [](kll_sketch<T>& self, std::vector<T> split_points) {
+      [](kll_sketch<T>& self, const std::vector<T>& split_points) {
         return self.get_CDF(&split_points[0], split_points.size());
       })
     .define_method(

data/ext/datasketches/theta_wrapper.cpp

@@ -20,10 +20,26 @@ using Rice::Arg;
 
 void init_theta(Rice::Module& m) {
   Rice::define_class_under<theta_sketch>(m, "ThetaSketch")
-    .define_method("empty?", &theta_sketch::is_empty)
-    .define_method("estimate", &theta_sketch::get_estimate)
-    .define_method("lower_bound", &theta_sketch::get_lower_bound)
-    .define_method("upper_bound", &theta_sketch::get_upper_bound);
+    .define_method(
+      "empty?",
+      [](theta_sketch& self) {
+        return self.is_empty();
+      })
+    .define_method(
+      "estimate",
+      [](theta_sketch& self) {
+        return self.get_estimate();
+      })
+    .define_method(
+      "lower_bound",
+      [](theta_sketch& self, uint8_t num_std_devs) {
+        return self.get_lower_bound(num_std_devs);
+      })
+    .define_method(
+      "upper_bound",
+      [](theta_sketch& self, uint8_t num_std_devs) {
+        return self.get_upper_bound(num_std_devs);
+      });
 
   Rice::define_class_under<compact_theta_sketch, theta_sketch>(m, "CompactThetaSketch")
     .define_singleton_function(

data/lib/datasketches/version.rb

@@ -1,3 +1,3 @@
 module DataSketches
-  VERSION = "0.2.3"
+  VERSION = "0.2.6"
 end

data/vendor/datasketches-cpp/CMakeLists.txt

@@ -15,9 +15,9 @@
 # specific language governing permissions and limitations
 # under the License.
 
-cmake_minimum_required(VERSION 3.12.0)
+cmake_minimum_required(VERSION 3.16.0)
 project(DataSketches
-        VERSION 0.12.0
+        VERSION 3.5.0
         LANGUAGES CXX)
 
 include(GNUInstallDirs)
@@ -106,12 +106,13 @@ add_subdirectory(theta)
 add_subdirectory(sampling)
 add_subdirectory(tuple)
 add_subdirectory(req)
+add_subdirectory(quantiles)
 
 if (WITH_PYTHON)
   add_subdirectory(python)
 endif()
 
-target_link_libraries(datasketches INTERFACE hll cpc kll fi theta sampling)
+target_link_libraries(datasketches INTERFACE hll cpc kll fi theta sampling req quantiles)
 
 if (COVERAGE)
   find_program(LCOV_PATH NAMES "lcov")
@@ -126,11 +127,30 @@ endif()
 
 # # Installation
 install(TARGETS datasketches
-  EXPORT ${PROJCT_NAME}
+  EXPORT ${PROJECT_NAME}
   PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/DataSketches
   INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/DataSketches
 )
 
+# Packaging
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file(
+    "${CMAKE_CURRENT_BINARY_DIR}/DataSketchesConfigVersion.cmake"
+    VERSION ${PROJECT_VERSION}
+    COMPATIBILITY SameMajorVersion
+)
+configure_package_config_file(
+    cmake/DataSketchesConfig.cmake.in
+    "${CMAKE_CURRENT_BINARY_DIR}/DataSketchesConfig.cmake"
+    INSTALL_DESTINATION lib/DataSketches/cmake
+    PATH_VARS CMAKE_INSTALL_INCLUDEDIR
+)
+install(EXPORT ${PROJECT_NAME} DESTINATION lib/DataSketches/cmake)
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/DataSketchesConfigVersion.cmake"
+              "${CMAKE_CURRENT_BINARY_DIR}/DataSketchesConfig.cmake"
+        DESTINATION lib/DataSketches/cmake)
+
+
 #set(CPACK_PROJECT_NAME ${PROJECT_NAME})
 #set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
-#include(CPack)
+include(CPack)

data/vendor/datasketches-cpp/MANIFEST.in

@@ -9,11 +9,14 @@ global-exclude .git*
 
 recursive-include python/pybind11 *
 
+graft cmake
 graft common
 graft cpc
 graft fi
 graft hll
 graft kll
+graft req
 graft theta
+graft tuple
 graft sampling
 graft python

data/vendor/datasketches-cpp/NOTICE

@@ -1,11 +1,12 @@
-Apache DataSketches-cpp
-Copyright 2020-2021 The Apache Software Foundation
+Apache DataSketches C++ and Python
+Copyright 2022 The Apache Software Foundation
 
-Copyright 2015-2018 Yahoo
-Copyright 2019 Verizon Media
+Copyright 2015-2018 Yahoo Inc.
+Copyright 2019-2020 Verizon Media
+Copyright 2021 Yahoo Inc.
 
 This product includes software developed at
 The Apache Software Foundation (http://www.apache.org/).
 
 Prior to moving to ASF, the software for this project was developed at
-Yahoo (now Verizon Media) (https://developer.yahoo.com).
+Yahoo Inc. (https://developer.yahoo.com).

data/vendor/datasketches-cpp/README.md

@@ -25,18 +25,85 @@ Installing the latest cmake on OSX: brew install cmake
 Building and running unit tests using cmake for OSX and Linux:
 
 ```
-	$ cd build
-	$ cmake ..
-	$ make
-	$ make test
+    $ cmake -S . -B build/Release -DCMAKE_BUILD_TYPE=Release
+    $ cmake --build build/Release -t all test
 ```
 
 Building and running unit tests using cmake for Windows from the command line:
 
 ```
-	$ cd build
-	$ cmake ..
-	$ cd ..
-	$ cmake --build build --config Release
-	$ cmake --build build --config Release --target RUN_TESTS
+    $ cd build
+    $ cmake ..
+    $ cd ..
+    $ cmake --build build --config Release
+    $ cmake --build build --config Release --target RUN_TESTS
 ```
+
+To install a local distribution (OSX and Linux), use the following command. The
+CMAKE_INSTALL_PREFIX variable controls the destination. If not specified, it 
+defaults to installing in /usr (/usr/include, /usr/lib, etc). In the command below,
+the installation will be in /tmp/install/DataSketches (/tmp/install/DataSketches/include,
+/tmp/install/DataSketches/lib, etc)
+
+```
+    $ cmake -S . -B build/Release -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/tmp/install/DataSketches
+    $ cmake --build build/Release -t install
+```
+
+To generate an installable package using cmake's built in cpack packaging tool,
+use the following command. The type of packaging is controlled by the CPACK_GENERATOR
+variable (semi-colon separated list). Cmake usually supports packaging types such as RPM,
+DEB, STGZ, TGZ, TZ, ZIP, etc.
+
+```
+    $ cmake3 -S . -B build/Release -DCMAKE_BUILD_TYPE=Release -DCPACK_GENERATOR="RPM;STGZ;TGZ" 
+    $ cmake3 --build build/Release -t package
+```
+
+The DataSketches project can be included in other projects' CMakeLists.txt files in one of two ways.
+If DataSketches has been installed on the host (using an RPM, DEB, "make install" into /usr/local, or some 
+way, then CMake's `find_package` command can be used like this:
+
+```
+    find_package(DataSketches 3.2 REQUIRED)
+    target_link_library(my_dependent_target PUBLIC ${DATASKETCHES_LIB})
+```
+
+When used with find_package, DataSketches exports several variables, including
+
+   - `DATASKETCHES_VERSION`: The version number of the datasketches package that was imported.
+   - `DATASKETCHES_INCLUDE_DIR`: The directory that should be added to access DataSketches include files.
+   Because cmake automatically includes the interface directories for included target libraries when
+   using `target_link_library`, under normal circumstances there will be no need to include this directly.
+   - `DATASKETCHES_LIB`: The name of the DataSketches target to include as a dependency. Projects pulling
+   in DataSketches should reference this with `target_link_library` in order to set up all the correct dependencies 
+   and include paths.
+
+If you don't have DataSketches installed locally, dependent projects can pull it directly
+from GitHub using CMake's `ExternalProject` module. The code would look something like this:
+
+```
+    cmake_policy(SET CMP0097 NEW)
+    include(ExternalProject)
+    ExternalProject_Add(datasketches
+        GIT_REPOSITORY https://github.com/apache/datasketches-cpp.git
+        GIT_TAG 3.2.0
+        GIT_SHALLOW true
+        GIT_SUBMODULES ""
+        INSTALL_DIR /tmp/datasketches-prefix
+        CMAKE_ARGS -DBUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DCMAKE_INSTALL_PREFIX=/tmp/datasketches-prefix
+
+        # Override the install command to add DESTDIR
+        # This is necessary to work around an oddity in the RPM (but not other) package
+        # generation, as CMake otherwise picks up the Datasketch files when building
+        # an RPM for a dependent package. (RPM scans the directory for files in addition to installing
+        # those files referenced in an "install" rule in the cmake file)
+        INSTALL_COMMAND env DESTDIR= ${CMAKE_COMMAND} --build . --target install
+    )
+    ExternalProject_Get_property(datasketches INSTALL_DIR)
+    set(datasketches_INSTALL_DIR ${INSTALL_DIR})
+    message("Source dir of datasketches = ${datasketches_INSTALL_DIR}")
+    target_include_directories(my_dependent_target 
+                                PRIVATE ${datasketches_INSTALL_DIR}/include/DataSketches)
+    add_dependencies(my_dependent_target datasketches)
+```

data/vendor/datasketches-cpp/cmake/DataSketchesConfig.cmake.in

@@ -0,0 +1,10 @@
+set(DATASKETCHES_VERSION "@PROJECT_VERSION@")
+
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/DataSketches.cmake")
+
+set_and_check(DATASKETCHES_INCLUDE_DIR "@PACKAGE_CMAKE_INSTALL_INCLUDEDIR@/DataSketches")
+set(DATASKETCHES_LIB "datasketches")
+
+check_required_components("@PROJECT_NAME@")

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

@@ -29,17 +29,22 @@ target_include_directories(common
 
 target_compile_features(common INTERFACE cxx_std_11)
 
-target_sources(common
-  INTERFACE
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/common_defs.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/memory_operations.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/MurmurHash3.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/serde.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/count_zeros.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/inv_pow2_table.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/binomial_bounds.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/conditional_back_inserter.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/conditional_forward.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/ceiling_power_of_2.hpp
-)
+install(TARGETS common EXPORT ${PROJECT_NAME})
 
+install(FILES 
+			include/common_defs.hpp
+			include/memory_operations.hpp
+			include/MurmurHash3.h
+			include/serde.hpp
+			include/count_zeros.hpp
+			include/inv_pow2_table.hpp
+			include/binomial_bounds.hpp
+			include/conditional_back_inserter.hpp
+			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/kolmogorov_smirnov.hpp
+			include/kolmogorov_smirnov_impl.hpp
+  DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/DataSketches")

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

@@ -22,6 +22,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <stdexcept>
 
 /*
  * This class enables the estimation of error bounds given a sample set size, the sampling

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

@@ -24,6 +24,8 @@
 #include <string>
 #include <memory>
 #include <iostream>
+#include <random>
+#include <chrono>
 
 namespace datasketches {
 
@@ -34,6 +36,18 @@ enum resize_factor { X1 = 0, X2, X4, X8 };
 template<typename A> using AllocChar = typename std::allocator_traits<A>::template rebind_alloc<char>;
 template<typename A> using string = std::basic_string<char, std::char_traits<char>, AllocChar<A>>;
 
+// random bit
+static std::independent_bits_engine<std::mt19937, 1, uint32_t>
+  random_bit(static_cast<uint32_t>(std::chrono::system_clock::now().time_since_epoch().count()));
+
+// common random declarations
+namespace random_utils {
+  static std::random_device rd; // possibly unsafe in MinGW with GCC < 9.2
+  static std::mt19937_64 rand(rd());
+  static std::uniform_real_distribution<> next_double(0.0, 1.0);
+}
+
+
 // utility function to hide unused compiler warning
 // usually has no additional cost
 template<typename T> void unused(T&&...) {}

data/vendor/datasketches-cpp/{kll → common}/include/kolmogorov_smirnov.hpp

@@ -25,7 +25,8 @@ namespace datasketches {
 class kolmogorov_smirnov {
 public:
   /**
-   * Computes the raw delta area between two KLL quantile sketches for the Kolmogorov-Smirnov Test.
+   * Computes the raw delta area between two quantile sketches for the Kolmogorov-Smirnov Test.
+   * Will work for a type-matched pair of KLL or Quantiles sketches of the same parameterized type T.
    * @param sketch1 KLL sketch 1
    * @param sketch2 KLL sketch 2
    * @return the raw delta between two KLL quantile sketches
@@ -37,6 +38,7 @@ public:
    * 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>
+   * Will work for a type-matched pair of KLL or Quantiles sketches of the same parameterized type T.
    * @param sketch1 KLL sketch 1
    * @param sketch2 KLL sketch 2
    * @param p Target p-value. Typically .001 to .1, e.g., .05.
@@ -46,7 +48,8 @@ public:
   static double threshold(const Sketch& sketch1, const Sketch& sketch2, double p);
 
   /**
-   * Performs the Kolmogorov-Smirnov Test between two KLL quantiles sketches.
+   * Performs the Kolmogorov-Smirnov Test between two quantile sketches.
+   * Will work for a type-matched pair of KLL or Quantiles sketches of the same parameterized type T.
    * 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
@@ -57,7 +60,6 @@ public:
    */
   template<typename Sketch>
   static bool test(const Sketch& sketch1, const Sketch& sketch2, double p);
-
 };
 
 } /* namespace datasketches */

data/vendor/datasketches-cpp/{kll → common}/include/kolmogorov_smirnov_impl.hpp

@@ -20,39 +20,36 @@
 #ifndef KOLMOGOROV_SMIRNOV_IMPL_HPP_
 #define KOLMOGOROV_SMIRNOV_IMPL_HPP_
 
-namespace datasketches {
+#include <cmath>
+#include <algorithm>
 
-// 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);
-}
+namespace datasketches {
 
 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();
+  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 it1 = view1.begin();
+  auto it2 = view2.begin();
   const auto n1 = sketch1.get_n();
   const auto n2 = sketch2.get_n();
   double delta = 0;
-  while (it1 != calc1.end() && it2 != calc2.end()) {
+  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;
     delta = std::max(delta, std::abs(norm_cum_wt1 - norm_cum_wt2));
-    if (Comparator()((*it1).first, (*it2).first)) {
+    if (comparator((*it1).first, (*it2).first)) {
       ++it1;
-    } else if (Comparator()((*it2).first, (*it1).first)) {
+    } 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;
+  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;
   delta = std::max(delta, std::abs(norm_cum_wt1 - norm_cum_wt2));
   return delta;
 }

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

@@ -0,0 +1,121 @@
+/*
+ * 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 QUANTILE_SKETCH_SORTED_VIEW_HPP_
+#define QUANTILE_SKETCH_SORTED_VIEW_HPP_
+
+#include <functional>
+
+namespace datasketches {
+
+template<
+  typename T,
+  typename Comparator, // strict weak ordering function (see C++ named requirements: Compare)
+  typename Allocator
+>
+class quantile_sketch_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);
+
+  template<typename Iterator>
+  void add(Iterator begin, Iterator end, uint64_t weight);
+
+  template<bool inclusive>
+  void convert_to_cummulative();
+
+  class const_iterator;
+  const_iterator begin() const;
+  const_iterator end() const;
+
+  size_t size() const;
+
+  // makes sense only with cumulative weight
+  using quantile_return_type = typename std::conditional<std::is_arithmetic<T>::value, T, const T&>::type;
+  quantile_return_type get_quantile(double rank) const;
+
+private:
+  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 {
+    bool operator()(const Entry& a, const Entry& b) const {
+      return Comparator()(deref_helper(a.first), deref_helper(b.first));
+    }
+  };
+
+  struct compare_pairs_by_second {
+    bool operator()(const Entry& a, const Entry& b) const {
+      return a.second < b.second;
+    }
+  };
+
+  template<typename TT = T, typename std::enable_if<std::is_arithmetic<TT>::value, int>::type = 0>
+  static inline T ref_helper(const T& t) { return t; }
+
+  template<typename TT = T, typename std::enable_if<!std::is_arithmetic<TT>::value, int>::type = 0>
+  static inline const T* ref_helper(const T& t) { return std::addressof(t); }
+
+  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(0, weight); }
+
+  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 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 {
+public:
+  using Base = typename quantile_sketch_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) {}
+
+  template<typename TT = T, typename std::enable_if<std::is_arithmetic<TT>::value, int>::type = 0>
+  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_;
+  };
+
+  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; }
+};
+
+} /* namespace datasketches */
+
+#include "quantile_sketch_sorted_view_impl.hpp"
+
+#endif