datasketches 0.2.4 → 0.2.5

data/vendor/datasketches-cpp/theta/test/theta_sketch_test.cpp

@@ -21,6 +21,7 @@
 #include <fstream>
 #include <sstream>
 #include <vector>
+#include <stdexcept>
 
 #include <catch.hpp>
 #include <theta_sketch.hpp>
@@ -394,7 +395,13 @@ TEST_CASE("theta sketch: serialize deserialize stream and bytes equivalence", "[
   }
 }
 
-TEST_CASE("theta sketch: deserialize compact single item buffer overrun", "[theta_sketch]") {
+TEST_CASE("theta sketch: deserialize empty buffer overrun", "[theta_sketch]") {
+  update_theta_sketch update_sketch = update_theta_sketch::builder().build();
+  auto bytes = update_sketch.compact().serialize();
+  REQUIRE_THROWS_AS(compact_theta_sketch::deserialize(bytes.data(), bytes.size() - 1), std::out_of_range);
+}
+
+TEST_CASE("theta sketch: deserialize single item buffer overrun", "[theta_sketch]") {
   update_theta_sketch update_sketch = update_theta_sketch::builder().build();
   update_sketch.update(1);
   auto bytes = update_sketch.compact().serialize();
@@ -402,6 +409,27 @@ TEST_CASE("theta sketch: deserialize compact single item buffer overrun", "[thet
   REQUIRE_THROWS_AS(compact_theta_sketch::deserialize(bytes.data(), bytes.size() - 1), std::out_of_range);
 }
 
+TEST_CASE("theta sketch: deserialize exact mode buffer overrun", "[theta_sketch]") {
+  update_theta_sketch update_sketch = update_theta_sketch::builder().build();
+  for (int i = 0; i < 1000; ++i) update_sketch.update(i);
+  auto bytes = update_sketch.compact().serialize();
+  REQUIRE_THROWS_AS(compact_theta_sketch::deserialize(bytes.data(), 7), std::out_of_range);
+  REQUIRE_THROWS_AS(compact_theta_sketch::deserialize(bytes.data(), 8), std::out_of_range);
+  REQUIRE_THROWS_AS(compact_theta_sketch::deserialize(bytes.data(), 16), std::out_of_range);
+  REQUIRE_THROWS_AS(compact_theta_sketch::deserialize(bytes.data(), bytes.size() - 1), std::out_of_range);
+}
+
+TEST_CASE("theta sketch: deserialize estimation mode buffer overrun", "[theta_sketch]") {
+  update_theta_sketch update_sketch = update_theta_sketch::builder().build();
+  for (int i = 0; i < 10000; ++i) update_sketch.update(i);
+  auto bytes = update_sketch.compact().serialize();
+  REQUIRE_THROWS_AS(compact_theta_sketch::deserialize(bytes.data(), 7), std::out_of_range);
+  REQUIRE_THROWS_AS(compact_theta_sketch::deserialize(bytes.data(), 8), std::out_of_range);
+  REQUIRE_THROWS_AS(compact_theta_sketch::deserialize(bytes.data(), 16), std::out_of_range);
+  REQUIRE_THROWS_AS(compact_theta_sketch::deserialize(bytes.data(), 24), std::out_of_range);
+  REQUIRE_THROWS_AS(compact_theta_sketch::deserialize(bytes.data(), bytes.size() - 1), std::out_of_range);
+}
+
 TEST_CASE("theta sketch: conversion constructor and wrapped compact", "[theta_sketch]") {
   update_theta_sketch update_sketch = update_theta_sketch::builder().build();
   const int n = 8192;

data/vendor/datasketches-cpp/theta/test/theta_union_test.cpp

@@ -21,6 +21,8 @@
 
 #include <theta_union.hpp>
 
+#include <stdexcept>
+
 namespace datasketches {
 
 TEST_CASE("theta union: empty", "[theta_union]") {

data/vendor/datasketches-cpp/tuple/include/tuple_sketch.hpp

@@ -398,9 +398,23 @@ public:
   virtual uint32_t get_num_retained() const;
   virtual uint16_t get_seed_hash() const;
 
+  /**
+   * This method serializes the sketch into a given stream in a binary form
+   * @param os output stream
+   * @param instance of a SerDe
+   */
   template<typename SerDe = serde<Summary>>
   void serialize(std::ostream& os, const SerDe& sd = SerDe()) const;
 
+  /**
+   * This method serializes the sketch as a vector of bytes.
+   * An optional header can be reserved in front of the sketch.
+   * It is a blank space of a given size.
+   * This header is used in Datasketches PostgreSQL extension.
+   * @param header_size_bytes space to reserve in front of the sketch
+   * @param instance of a SerDe
+   * @return serialized sketch as a vector of bytes
+   */
   template<typename SerDe = serde<Summary>>
   vector_bytes serialize(unsigned header_size_bytes = 0, const SerDe& sd = SerDe()) const;
 
@@ -414,6 +428,7 @@ public:
    * @param is input stream
    * @param seed the seed for the hash function that was used to create the sketch
    * @param instance of a SerDe
+   * @param instance of an Allocator
    * @return an instance of a sketch
    */
   template<typename SerDe = serde<Summary>>
@@ -426,6 +441,7 @@ public:
    * @param size the size of the array
    * @param seed the seed for the hash function that was used to create the sketch
    * @param instance of a SerDe
+   * @param instance of an Allocator
    * @return an instance of the sketch
    */
   template<typename SerDe = serde<Summary>>

data/vendor/datasketches-cpp/tuple/include/tuple_sketch_impl.hpp

@@ -18,6 +18,7 @@
  */
 
 #include <sstream>
+#include <stdexcept>
 
 #include "binomial_bounds.hpp"
 #include "theta_helpers.hpp"

data/vendor/datasketches-cpp/tuple/test/tuple_a_not_b_test.cpp

@@ -22,6 +22,7 @@
 #include <catch.hpp>
 #include <tuple_a_not_b.hpp>
 #include <theta_sketch.hpp>
+#include <stdexcept>
 
 namespace datasketches {
 

data/vendor/datasketches-cpp/tuple/test/tuple_intersection_test.cpp

@@ -22,6 +22,7 @@
 #include <catch.hpp>
 #include <tuple_intersection.hpp>
 #include <theta_sketch.hpp>
+#include <stdexcept>
 
 namespace datasketches {
 

data/vendor/datasketches-cpp/tuple/test/tuple_union_test.cpp

@@ -18,6 +18,7 @@
  */
 
 #include <iostream>
+#include <stdexcept>
 
 #include <catch.hpp>
 #include <tuple_union.hpp>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datasketches
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-28 00:00:00.000000000 Z
+date: 2022-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -62,7 +62,11 @@ files:
 - vendor/datasketches-cpp/common/include/conditional_forward.hpp
 - vendor/datasketches-cpp/common/include/count_zeros.hpp
 - vendor/datasketches-cpp/common/include/inv_pow2_table.hpp
+- vendor/datasketches-cpp/common/include/kolmogorov_smirnov.hpp
+- vendor/datasketches-cpp/common/include/kolmogorov_smirnov_impl.hpp
 - vendor/datasketches-cpp/common/include/memory_operations.hpp
+- vendor/datasketches-cpp/common/include/quantile_sketch_sorted_view.hpp
+- vendor/datasketches-cpp/common/include/quantile_sketch_sorted_view_impl.hpp
 - vendor/datasketches-cpp/common/include/serde.hpp
 - vendor/datasketches-cpp/common/test/CMakeLists.txt
 - vendor/datasketches-cpp/common/test/catch.hpp
@@ -157,12 +161,8 @@ files:
 - vendor/datasketches-cpp/kll/CMakeLists.txt
 - vendor/datasketches-cpp/kll/include/kll_helper.hpp
 - vendor/datasketches-cpp/kll/include/kll_helper_impl.hpp
-- vendor/datasketches-cpp/kll/include/kll_quantile_calculator.hpp
-- vendor/datasketches-cpp/kll/include/kll_quantile_calculator_impl.hpp
 - vendor/datasketches-cpp/kll/include/kll_sketch.hpp
 - vendor/datasketches-cpp/kll/include/kll_sketch_impl.hpp
-- vendor/datasketches-cpp/kll/include/kolmogorov_smirnov.hpp
-- vendor/datasketches-cpp/kll/include/kolmogorov_smirnov_impl.hpp
 - vendor/datasketches-cpp/kll/test/CMakeLists.txt
 - vendor/datasketches-cpp/kll/test/kll_sketch_custom_type_test.cpp
 - vendor/datasketches-cpp/kll/test/kll_sketch_float_one_item_v1.sk
@@ -185,6 +185,8 @@ files:
 - vendor/datasketches-cpp/python/src/fi_wrapper.cpp
 - vendor/datasketches-cpp/python/src/hll_wrapper.cpp
 - vendor/datasketches-cpp/python/src/kll_wrapper.cpp
+- vendor/datasketches-cpp/python/src/ks_wrapper.cpp
+- vendor/datasketches-cpp/python/src/quantiles_wrapper.cpp
 - vendor/datasketches-cpp/python/src/req_wrapper.cpp
 - vendor/datasketches-cpp/python/src/theta_wrapper.cpp
 - vendor/datasketches-cpp/python/src/vector_of_kll.cpp
@@ -194,16 +196,30 @@ files:
 - vendor/datasketches-cpp/python/tests/fi_test.py
 - vendor/datasketches-cpp/python/tests/hll_test.py
 - vendor/datasketches-cpp/python/tests/kll_test.py
+- vendor/datasketches-cpp/python/tests/quantiles_test.py
 - vendor/datasketches-cpp/python/tests/req_test.py
 - vendor/datasketches-cpp/python/tests/theta_test.py
 - vendor/datasketches-cpp/python/tests/vector_of_kll_test.py
 - vendor/datasketches-cpp/python/tests/vo_test.py
+- vendor/datasketches-cpp/quantiles/CMakeLists.txt
+- vendor/datasketches-cpp/quantiles/include/quantiles_sketch.hpp
+- vendor/datasketches-cpp/quantiles/include/quantiles_sketch_impl.hpp
+- vendor/datasketches-cpp/quantiles/test/CMakeLists.txt
+- vendor/datasketches-cpp/quantiles/test/Qk128_n1000_v0.3.0.sk
+- vendor/datasketches-cpp/quantiles/test/Qk128_n1000_v0.6.0.sk
+- vendor/datasketches-cpp/quantiles/test/Qk128_n1000_v0.8.0.sk
+- vendor/datasketches-cpp/quantiles/test/Qk128_n1000_v0.8.3.sk
+- vendor/datasketches-cpp/quantiles/test/Qk128_n50_v0.3.0.sk
+- vendor/datasketches-cpp/quantiles/test/Qk128_n50_v0.6.0.sk
+- vendor/datasketches-cpp/quantiles/test/Qk128_n50_v0.8.0.sk
+- vendor/datasketches-cpp/quantiles/test/Qk128_n50_v0.8.3.sk
+- vendor/datasketches-cpp/quantiles/test/kolmogorov_smirnov_test.cpp
+- vendor/datasketches-cpp/quantiles/test/quantiles_compatibility_test.cpp
+- vendor/datasketches-cpp/quantiles/test/quantiles_sketch_test.cpp
 - vendor/datasketches-cpp/req/CMakeLists.txt
 - vendor/datasketches-cpp/req/include/req_common.hpp
 - vendor/datasketches-cpp/req/include/req_compactor.hpp
 - vendor/datasketches-cpp/req/include/req_compactor_impl.hpp
-- vendor/datasketches-cpp/req/include/req_quantile_calculator.hpp
-- vendor/datasketches-cpp/req/include/req_quantile_calculator_impl.hpp
 - vendor/datasketches-cpp/req/include/req_sketch.hpp
 - vendor/datasketches-cpp/req/include/req_sketch_impl.hpp
 - vendor/datasketches-cpp/req/test/CMakeLists.txt
@@ -319,7 +335,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Sketch data structures for Ruby

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

@@ -1,75 +0,0 @@
-/*
- * 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 KLL_QUANTILE_CALCULATOR_HPP_
-#define KLL_QUANTILE_CALCULATOR_HPP_
-
-#include <memory>
-
-namespace datasketches {
-
-// forward declaration
-template<typename T, typename C, typename S, typename A> class kll_sketch;
-
-template <typename T, typename C, typename A>
-class kll_quantile_calculator {
-  public:
-    using Entry = std::pair<T, uint64_t>;
-    using AllocEntry = typename std::allocator_traits<A>::template rebind_alloc<Entry>;
-    using Container = std::vector<Entry, AllocEntry>;
-    using const_iterator = typename Container::const_iterator;
-
-    template<typename S>
-    kll_quantile_calculator(const kll_sketch<T, C, S, A>& sketch);
-
-    T get_quantile(double fraction) const;
-    const_iterator begin() const;
-    const_iterator end() const;
-
-  private:
-    using AllocU32 = typename std::allocator_traits<A>::template rebind_alloc<uint32_t>;
-    using vector_u32 = std::vector<uint32_t, AllocU32>;
-    uint64_t n_;
-    vector_u32 levels_;
-    Container entries_;
-
-    void populate_from_sketch(const T* items, const uint32_t* levels, uint8_t num_levels);
-    T approximately_answer_positional_query(uint64_t pos) const;
-    void convert_to_preceding_cummulative();
-    uint32_t chunk_containing_pos(uint64_t pos) const;
-    uint32_t search_for_chunk_containing_pos(uint64_t pos, uint64_t l, uint64_t r) const;
-    static void merge_sorted_blocks(Container& entries, const uint32_t* levels, uint8_t num_levels, uint32_t num_items);
-    static void merge_sorted_blocks_direct(Container& orig, Container& temp, const uint32_t* levels, uint8_t starting_level, uint8_t num_levels);
-    static void merge_sorted_blocks_reversed(Container& orig, Container& temp, const uint32_t* levels, uint8_t starting_level, uint8_t num_levels);
-    static uint64_t pos_of_phi(double phi, uint64_t n);
-
-    template<typename Comparator>
-    struct compare_pair_by_first {
-      template<typename Entry1, typename Entry2>
-      bool operator()(Entry1&& a, Entry2&& b) const {
-        return Comparator()(std::forward<Entry1>(a).first, std::forward<Entry2>(b).first);
-      }
-    };
-};
-
-} /* namespace datasketches */
-
-#include "kll_quantile_calculator_impl.hpp"
-
-#endif // KLL_QUANTILE_CALCULATOR_HPP_

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

@@ -1,184 +0,0 @@
-/*
- * 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 KLL_QUANTILE_CALCULATOR_IMPL_HPP_
-#define KLL_QUANTILE_CALCULATOR_IMPL_HPP_
-
-#include <memory>
-#include <cmath>
-#include <algorithm>
-
-#include "kll_helper.hpp"
-
-namespace datasketches {
-
-template<typename T, typename C, typename A>
-template<typename S>
-kll_quantile_calculator<T, C, A>::kll_quantile_calculator(const kll_sketch<T, C, S, A>& sketch):
-n_(sketch.n_), levels_(sketch.num_levels_ + 1, 0, sketch.allocator_), entries_(sketch.allocator_)
-{
-  const uint32_t num_items = sketch.levels_[sketch.num_levels_] - sketch.levels_[0];
-  if (num_items > 0) {
-    entries_.reserve(num_items);
-    populate_from_sketch(sketch.items_, sketch.levels_.data(), sketch.num_levels_);
-    if (!sketch.is_level_zero_sorted_) std::sort(entries_.begin(), entries_.begin() + levels_[1], compare_pair_by_first<C>());
-    merge_sorted_blocks(entries_, levels_.data(), static_cast<uint8_t>(levels_.size()) - 1, num_items);
-    if (!is_sorted(entries_.begin(), entries_.end(), compare_pair_by_first<C>())) throw std::logic_error("entries must be sorted");
-    convert_to_preceding_cummulative();
-  }
-}
-
-template<typename T, typename C, typename A>
-T kll_quantile_calculator<T, C, A>::get_quantile(double fraction) const {
-  return approximately_answer_positional_query(pos_of_phi(fraction, n_));
-}
-
-template<typename T, typename C, typename A>
-auto kll_quantile_calculator<T, C, A>::begin() const -> const_iterator {
-  return entries_.begin();
-}
-
-template<typename T, typename C, typename A>
-auto kll_quantile_calculator<T, C, A>::end() const -> const_iterator {
-  return entries_.end();
-}
-
-template<typename T, typename C, typename A>
-void kll_quantile_calculator<T, C, A>::populate_from_sketch(const T* items, const uint32_t* levels, uint8_t num_levels) {
-  size_t src_level = 0;
-  size_t dst_level = 0;
-  uint64_t weight = 1;
-  uint32_t offset = levels[0];
-  while (src_level < num_levels) {
-    const uint32_t from_index(levels[src_level] - offset);
-    const uint32_t to_index(levels[src_level + 1] - offset); // exclusive
-    if (from_index < to_index) { // skip empty levels
-      for (uint32_t i = from_index; i < to_index; ++i) {
-        entries_.push_back(Entry(items[i + offset], weight));
-      }
-      levels_[dst_level] = from_index;
-      levels_[dst_level + 1] = to_index;
-      dst_level++;
-    }
-    src_level++;
-    weight *= 2;
-  }
-  if (levels_.size() > static_cast<size_t>(dst_level + 1)) levels_.resize(dst_level + 1);
-}
-
-template<typename T, typename C, typename A>
-T kll_quantile_calculator<T, C, A>::approximately_answer_positional_query(uint64_t pos) const {
-  if (pos >= n_) throw std::logic_error("position out of range");
-  const uint32_t num_items = levels_[levels_.size() - 1];
-  if (pos > entries_[num_items - 1].second) return entries_[num_items - 1].first;
-  const uint32_t index = chunk_containing_pos(pos);
-  return entries_[index].first;
-}
-
-template<typename T, typename C, typename A>
-void kll_quantile_calculator<T, C, A>::convert_to_preceding_cummulative() {
-  uint64_t subtotal = 0;
-  for (auto& entry: entries_) {
-    const uint64_t new_subtotal = subtotal + entry.second;
-    entry.second = subtotal;
-    subtotal = new_subtotal;
-  }
-}
-
-template<typename T, typename C, typename A>
-uint64_t kll_quantile_calculator<T, C, A>::pos_of_phi(double phi, uint64_t n) {
-  const uint64_t pos = static_cast<uint64_t>(std::floor(phi * n));
-  return (pos == n) ? n - 1 : pos;
-}
-
-template<typename T, typename C, typename A>
-uint32_t kll_quantile_calculator<T, C, A>::chunk_containing_pos(uint64_t pos) const {
-  if (entries_.size() < 1) throw std::logic_error("array too short");
-  if (pos < entries_[0].second) throw std::logic_error("position too small");
-  if (pos > entries_[entries_.size() - 1].second) throw std::logic_error("position too large");
-  return search_for_chunk_containing_pos(pos, 0, entries_.size());
-}
-
-template<typename T, typename C, typename A>
-uint32_t kll_quantile_calculator<T, C, A>::search_for_chunk_containing_pos(uint64_t pos, uint64_t l, uint64_t r) const {
-  if (l + 1 == r) {
-    return static_cast<uint32_t>(l);
-  }
-  const uint64_t m = l + (r - l) / 2;
-  if (entries_[m].second <= pos) {
-    return search_for_chunk_containing_pos(pos, m, r);
-  }
-  return search_for_chunk_containing_pos(pos, l, m);
-}
-
-template<typename T, typename C, typename A>
-void kll_quantile_calculator<T, C, A>::merge_sorted_blocks(Container& entries, const uint32_t* levels, uint8_t num_levels, uint32_t num_items) {
-  if (num_levels == 1) return;
-  Container temporary(entries.get_allocator());
-  temporary.reserve(num_items);
-  merge_sorted_blocks_direct(entries, temporary, levels, 0, num_levels);
-}
-
-template<typename T, typename C, typename A>
-void kll_quantile_calculator<T, C, A>::merge_sorted_blocks_direct(Container& orig, Container& temp, const uint32_t* levels,
-    uint8_t starting_level, uint8_t num_levels) {
-  if (num_levels == 1) return;
-  const uint8_t num_levels_1 = num_levels / 2;
-  const uint8_t num_levels_2 = num_levels - num_levels_1;
-  const uint8_t starting_level_1 = starting_level;
-  const uint8_t starting_level_2 = starting_level + num_levels_1;
-  const auto initial_size = temp.size();
-  merge_sorted_blocks_reversed(orig, temp, levels, starting_level_1, num_levels_1);
-  merge_sorted_blocks_reversed(orig, temp, levels, starting_level_2, num_levels_2);
-  const uint32_t num_items_1 = levels[starting_level_1 + num_levels_1] - levels[starting_level_1];
-  const auto chunk_begin = temp.begin() + initial_size;
-  std::merge(
-    std::make_move_iterator(chunk_begin), std::make_move_iterator(chunk_begin + num_items_1),
-    std::make_move_iterator(chunk_begin + num_items_1), std::make_move_iterator(temp.end()),
-    orig.begin() + levels[starting_level], compare_pair_by_first<C>()
-  );
-  temp.erase(chunk_begin, temp.end());
-}
-
-template<typename T, typename C, typename A>
-void kll_quantile_calculator<T, C, A>::merge_sorted_blocks_reversed(Container& orig, Container& temp, const uint32_t* levels,
-    uint8_t starting_level, uint8_t num_levels) {
-  if (num_levels == 1) {
-    std::move(orig.begin() + levels[starting_level], orig.begin() + levels[starting_level + 1], std::back_inserter(temp));
-    return;
-  }
-  const uint8_t num_levels_1 = num_levels / 2;
-  const uint8_t num_levels_2 = num_levels - num_levels_1;
-  const uint8_t starting_level_1 = starting_level;
-  const uint8_t starting_level_2 = starting_level + num_levels_1;
-  merge_sorted_blocks_direct(orig, temp, levels, starting_level_1, num_levels_1);
-  merge_sorted_blocks_direct(orig, temp, levels, starting_level_2, num_levels_2);
-  std::merge(
-    std::make_move_iterator(orig.begin() + levels[starting_level_1]),
-    std::make_move_iterator(orig.begin() + levels[starting_level_1 + num_levels_1]),
-    std::make_move_iterator(orig.begin() + levels[starting_level_2]),
-    std::make_move_iterator(orig.begin() + levels[starting_level_2 + num_levels_2]),
-    std::back_inserter(temp),
-    compare_pair_by_first<C>()
-  );
-}
-
-} /* namespace datasketches */
-
-#endif // KLL_QUANTILE_CALCULATOR_IMPL_HPP_

data/vendor/datasketches-cpp/req/include/req_quantile_calculator.hpp

@@ -1,69 +0,0 @@
-/*
- * 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 REQ_QUANTILE_CALCULATOR_HPP_
-#define REQ_QUANTILE_CALCULATOR_HPP_
-
-#include <functional>
-
-namespace datasketches {
-
-template<
-  typename T,
-  typename Comparator,
-  typename Allocator
->
-class req_quantile_calculator {
-public:
-  req_quantile_calculator(uint64_t n, const Allocator& allocator);
-
-  void add(const T* begin, const T* end, uint8_t lg_weight);
-
-  template<bool inclusive>
-  void convert_to_cummulative();
-
-  const T* get_quantile(double rank) const;
-
-private:
-  using Entry = std::pair<const T*, uint64_t>;
-  using AllocEntry = typename std::allocator_traits<Allocator>::template rebind_alloc<Entry>;
-  using Container = std::vector<Entry, AllocEntry>;
-
-  template<typename C>
-  struct compare_pairs_by_first_ptr {
-    bool operator()(const Entry& a, const Entry& b) {
-      return C()(*a.first, *b.first);
-    }
-  };
-
-  struct compare_pairs_by_second {
-    bool operator()(const Entry& a, const Entry& b) {
-      return a.second < b.second;
-    }
-  };
-
-  uint64_t n_;
-  Container entries_;
-};
-
-} /* namespace datasketches */
-
-#include "req_quantile_calculator_impl.hpp"
-
-#endif

data/vendor/datasketches-cpp/req/include/req_quantile_calculator_impl.hpp

@@ -1,60 +0,0 @@
-/*
- * 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 REQ_QUANTILE_CALCULATOR_IMPL_HPP_
-#define REQ_QUANTILE_CALCULATOR_IMPL_HPP_
-
-namespace datasketches {
-
-template<typename T, typename C, typename A>
-req_quantile_calculator<T, C, A>::req_quantile_calculator(uint64_t n, const A& allocator):
-n_(n),
-entries_(allocator)
-{}
-
-template<typename T, typename C, typename A>
-void req_quantile_calculator<T, C, A>::add(const T* begin, const T* end, uint8_t lg_weight) {
-  if (entries_.capacity() < entries_.size() + std::distance(begin, end)) entries_.reserve(entries_.size() + std::distance(begin, end));
-  const size_t size_before = entries_.size();
-  for (auto it = begin; it != end; ++it) entries_.push_back(Entry(it, 1 << lg_weight));
-  if (size_before > 0) std::inplace_merge(entries_.begin(), entries_.begin() + size_before, entries_.end(), compare_pairs_by_first_ptr<C>());
-}
-
-template<typename T, typename C, typename A>
-template<bool inclusive>
-void req_quantile_calculator<T, C, A>::convert_to_cummulative() {
-  uint64_t subtotal = 0;
-  for (auto& entry: entries_) {
-    const uint64_t new_subtotal = subtotal + entry.second;
-    entry.second = inclusive ? new_subtotal : subtotal;
-    subtotal = new_subtotal;
-  }
-}
-
-template<typename T, typename C, typename A>
-const T* req_quantile_calculator<T, C, A>::get_quantile(double rank) const {
-  uint64_t weight = static_cast<uint64_t>(rank * n_);
-  auto it = std::lower_bound(entries_.begin(), entries_.end(), Entry(nullptr, weight), compare_pairs_by_second());
-  if (it == entries_.end()) return entries_[entries_.size() - 1].first;
-  return it->first;
-}
-
-} /* namespace datasketches */
-
-#endif