You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datasketches.apache.org by al...@apache.org on 2022/10/31 21:22:53 UTC
[datasketches-cpp] 01/01: renamed sorted view
This is an automated email from the ASF dual-hosted git repository.
alsay pushed a commit to branch renamed_sorted_view
in repository https://gitbox.apache.org/repos/asf/datasketches-cpp.git
commit 18aaca7e657714d0a5340200e72429b680022bc3
Author: AlexanderSaydakov <Al...@users.noreply.github.com>
AuthorDate: Mon Oct 31 14:22:46 2022 -0700
renamed sorted view
---
common/CMakeLists.txt | 4 ++--
...h_sorted_view.hpp => quantiles_sorted_view.hpp} | 14 ++++++-------
...iew_impl.hpp => quantiles_sorted_view_impl.hpp} | 24 +++++++++++-----------
common/test/CMakeLists.txt | 2 +-
...iew_test.cpp => quantiles_sorted_view_test.cpp} | 12 +++++------
kll/include/kll_sketch.hpp | 11 +++++-----
kll/include/kll_sketch_impl.hpp | 13 ++++++------
quantiles/include/quantiles_sketch.hpp | 10 ++++-----
quantiles/include/quantiles_sketch_impl.hpp | 13 ++++++------
req/include/req_sketch.hpp | 14 ++++++-------
req/include/req_sketch_impl.hpp | 13 ++++++------
11 files changed, 64 insertions(+), 66 deletions(-)
diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index 7ce8df7..f307374 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -43,8 +43,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")
diff --git a/common/include/quantile_sketch_sorted_view.hpp b/common/include/quantiles_sorted_view.hpp
similarity index 92%
rename from common/include/quantile_sketch_sorted_view.hpp
rename to common/include/quantiles_sorted_view.hpp
index 81367d4..fffee87 100755
--- a/common/include/quantile_sketch_sorted_view.hpp
+++ b/common/include/quantiles_sorted_view.hpp
@@ -17,8 +17,8 @@
* 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>
@@ -30,13 +30,13 @@ 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 Comparator& comparator, 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);
@@ -115,9 +115,9 @@ private:
};
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, const Base& begin): Base(it), begin(begin) {}
@@ -157,6 +157,6 @@ private:
} /* namespace datasketches */
-#include "quantile_sketch_sorted_view_impl.hpp"
+#include "quantiles_sorted_view_impl.hpp"
#endif
diff --git a/common/include/quantile_sketch_sorted_view_impl.hpp b/common/include/quantiles_sorted_view_impl.hpp
similarity index 77%
rename from common/include/quantile_sketch_sorted_view_impl.hpp
rename to common/include/quantiles_sorted_view_impl.hpp
index 8e51b25..b6c9206 100755
--- a/common/include/quantile_sketch_sorted_view_impl.hpp
+++ b/common/include/quantiles_sorted_view_impl.hpp
@@ -17,8 +17,8 @@
* under the License.
*/
-#ifndef QUANTILE_SKETCH_SORTED_VIEW_IMPL_HPP_
-#define QUANTILE_SKETCH_SORTED_VIEW_IMPL_HPP_
+#ifndef QUANTILES_SORTED_VIEW_IMPL_HPP_
+#define QUANTILES_SORTED_VIEW_IMPL_HPP_
#include <algorithm>
#include <stdexcept>
@@ -27,7 +27,7 @@
namespace datasketches {
template<typename T, typename C, typename A>
-quantile_sketch_sorted_view<T, C, A>::quantile_sketch_sorted_view(uint32_t num, const C& comparator, const A& allocator):
+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)
@@ -37,7 +37,7 @@ entries_(allocator)
template<typename T, typename C, typename A>
template<typename Iterator>
-void quantile_sketch_sorted_view<T, C, A>::add(Iterator first, Iterator last, uint64_t weight) {
+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) {
@@ -53,7 +53,7 @@ void quantile_sketch_sorted_view<T, C, A>::add(Iterator first, Iterator last, ui
}
template<typename T, typename C, typename A>
-void quantile_sketch_sorted_view<T, C, A>::convert_to_cummulative() {
+void quantiles_sorted_view<T, C, A>::convert_to_cummulative() {
for (auto& entry: entries_) {
total_weight_ += entry.second;
entry.second = total_weight_;
@@ -61,7 +61,7 @@ void quantile_sketch_sorted_view<T, C, A>::convert_to_cummulative() {
}
template<typename T, typename C, typename A>
-double quantile_sketch_sorted_view<T, C, A>::get_rank(const T& item, bool inclusive) const {
+double quantiles_sorted_view<T, C, A>::get_rank(const T& item, bool inclusive) const {
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_));
@@ -72,7 +72,7 @@ double quantile_sketch_sorted_view<T, C, A>::get_rank(const T& item, bool inclus
}
template<typename T, typename C, typename A>
-auto quantile_sketch_sorted_view<T, C, A>::get_quantile(double rank, bool inclusive) const -> quantile_return_type {
+auto quantiles_sorted_view<T, C, A>::get_quantile(double rank, bool inclusive) const -> quantile_return_type {
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())
@@ -82,7 +82,7 @@ auto quantile_sketch_sorted_view<T, C, A>::get_quantile(double rank, bool inclus
}
template<typename T, typename C, typename A>
-auto quantile_sketch_sorted_view<T, C, A>::get_CDF(const T* split_points, uint32_t size, bool inclusive) const -> vector_double {
+auto quantiles_sorted_view<T, C, A>::get_CDF(const T* split_points, uint32_t size, bool inclusive) const -> vector_double {
vector_double buckets(entries_.get_allocator());
if (entries_.size() == 0) return buckets;
check_split_points(split_points, size);
@@ -93,7 +93,7 @@ auto quantile_sketch_sorted_view<T, C, A>::get_CDF(const T* split_points, uint32
}
template<typename T, typename C, typename A>
-auto quantile_sketch_sorted_view<T, C, A>::get_PMF(const T* split_points, uint32_t size, bool inclusive) const -> vector_double {
+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) {
@@ -103,17 +103,17 @@ auto quantile_sketch_sorted_view<T, C, A>::get_PMF(const T* split_points, uint32
}
template<typename T, typename C, typename A>
-auto quantile_sketch_sorted_view<T, C, A>::begin() const -> const_iterator {
+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 quantile_sketch_sorted_view<T, C, A>::end() const -> const_iterator {
+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 quantile_sketch_sorted_view<T, C, A>::size() const {
+size_t quantiles_sorted_view<T, C, A>::size() const {
return entries_.size();
}
diff --git a/common/test/CMakeLists.txt b/common/test/CMakeLists.txt
index 9f32dac..3d2c8c8 100644
--- a/common/test/CMakeLists.txt
+++ b/common/test/CMakeLists.txt
@@ -68,7 +68,7 @@ add_test(
target_sources(common_test
PRIVATE
- quantile_sketch_sorted_view_test.cpp
+ quantiles_sorted_view_test.cpp
)
# now the integration test part
diff --git a/common/test/quantile_sketch_sorted_view_test.cpp b/common/test/quantiles_sorted_view_test.cpp
similarity index 95%
rename from common/test/quantile_sketch_sorted_view_test.cpp
rename to common/test/quantiles_sorted_view_test.cpp
index c3959da..3c7652c 100644
--- a/common/test/quantile_sketch_sorted_view_test.cpp
+++ b/common/test/quantiles_sorted_view_test.cpp
@@ -24,12 +24,12 @@
#include <iostream>
-#include "quantile_sketch_sorted_view.hpp"
+#include "quantiles_sorted_view.hpp"
namespace datasketches {
TEST_CASE("set 0", "sorted view") {
- auto view = quantile_sketch_sorted_view<float, std::less<float>, std::allocator<float>>(1, std::less<float>(), std::allocator<float>());
+ auto view = quantiles_sorted_view<float, std::less<float>, std::allocator<float>>(1, std::less<float>(), std::allocator<float>());
std::vector<float> l0 {10};
view.add(l0.begin(), l0.end(), 1);
view.convert_to_cummulative();
@@ -62,7 +62,7 @@ TEST_CASE("set 0", "sorted view") {
}
TEST_CASE("set 1", "sorted view") {
- auto view = quantile_sketch_sorted_view<float, std::less<float>, std::allocator<float>>(1, std::less<float>(), std::allocator<float>());
+ auto view = quantiles_sorted_view<float, std::less<float>, std::allocator<float>>(1, std::less<float>(), std::allocator<float>());
std::vector<float> l0 {10, 10};
view.add(l0.begin(), l0.end(), 1);
view.convert_to_cummulative();
@@ -105,7 +105,7 @@ TEST_CASE("set 1", "sorted view") {
}
TEST_CASE("set 2", "sorted view") {
- auto view = quantile_sketch_sorted_view<float, std::less<float>, std::allocator<float>>(1, std::less<float>(), std::allocator<float>());
+ auto view = quantiles_sorted_view<float, std::less<float>, std::allocator<float>>(1, std::less<float>(), std::allocator<float>());
std::vector<float> l1 {10, 20, 30, 40};
view.add(l1.begin(), l1.end(), 2);
view.convert_to_cummulative();
@@ -196,7 +196,7 @@ TEST_CASE("set 2", "sorted view") {
}
TEST_CASE("set 3", "sorted view") {
- auto view = quantile_sketch_sorted_view<float, std::less<float>, std::allocator<float>>(8, std::less<float>(), std::allocator<float>());
+ auto view = quantiles_sorted_view<float, std::less<float>, std::allocator<float>>(8, std::less<float>(), std::allocator<float>());
std::vector<float> l1 {10, 20, 20, 30, 30, 30, 40, 50};
view.add(l1.begin(), l1.end(), 2);
view.convert_to_cummulative();
@@ -329,7 +329,7 @@ TEST_CASE("set 3", "sorted view") {
}
TEST_CASE("set 4", "sorted view") {
- auto view = quantile_sketch_sorted_view<float, std::less<float>, std::allocator<float>>(8, std::less<float>(), std::allocator<float>());
+ auto view = quantiles_sorted_view<float, std::less<float>, std::allocator<float>>(8, std::less<float>(), std::allocator<float>());
std::vector<float> l1 {10, 20, 30, 40};
view.add(l1.begin(), l1.end(), 2);
std::vector<float> l0 {10, 20, 30, 40};
diff --git a/kll/include/kll_sketch.hpp b/kll/include/kll_sketch.hpp
index a481c82..f063be6 100644
--- a/kll/include/kll_sketch.hpp
+++ b/kll/include/kll_sketch.hpp
@@ -22,10 +22,11 @@
#include <memory>
#include <vector>
+#include <stdexcept>
#include "common_defs.hpp"
#include "serde.hpp"
-#include "quantile_sketch_sorted_view.hpp"
+#include "quantiles_sorted_view.hpp"
namespace datasketches {
@@ -265,7 +266,7 @@ class kll_sketch {
*
* @return approximate quantile associated with the given rank
*/
- using quantile_return_type = typename quantile_sketch_sorted_view<T, C, A>::quantile_return_type;
+ using quantile_return_type = typename quantiles_sorted_view<T, C, A>::quantile_return_type;
quantile_return_type get_quantile(double rank, bool inclusive = true) const;
/**
@@ -341,7 +342,7 @@ class kll_sketch {
* @return an array of m+1 doubles each of which is an approximation
* to the fraction of the input stream items (the mass) that fall into one of those intervals.
*/
- using vector_double = typename quantile_sketch_sorted_view<T, C, A>::vector_double;
+ using vector_double = typename quantiles_sorted_view<T, C, A>::vector_double;
vector_double get_PMF(const T* split_points, uint32_t size, bool inclusive = true) const;
/**
@@ -494,7 +495,7 @@ class kll_sketch {
const_iterator begin() const;
const_iterator end() const;
- quantile_sketch_sorted_view<T, C, A> get_sorted_view() const;
+ quantiles_sorted_view<T, C, A> get_sorted_view() const;
private:
/* Serialized sketch layout:
@@ -533,7 +534,7 @@ class kll_sketch {
uint32_t items_size_;
T* min_item_;
T* max_item_;
- mutable quantile_sketch_sorted_view<T, C, A>* sorted_view_;
+ mutable quantiles_sorted_view<T, C, A>* sorted_view_;
// for deserialization
class item_deleter;
diff --git a/kll/include/kll_sketch_impl.hpp b/kll/include/kll_sketch_impl.hpp
index 9973fbd..4822098 100644
--- a/kll/include/kll_sketch_impl.hpp
+++ b/kll/include/kll_sketch_impl.hpp
@@ -23,7 +23,6 @@
#include <iostream>
#include <iomanip>
#include <sstream>
-#include <stdexcept>
#include "conditional_forward.hpp"
#include "count_zeros.hpp"
@@ -812,9 +811,9 @@ void kll_sketch<T, C, A>::check_sorting() const {
}
template<typename T, typename C, typename A>
-quantile_sketch_sorted_view<T, C, A> kll_sketch<T, C, A>::get_sorted_view() const {
+quantiles_sorted_view<T, C, A> kll_sketch<T, C, A>::get_sorted_view() const {
const_cast<kll_sketch*>(this)->sort_level_zero(); // allow this side effect
- quantile_sketch_sorted_view<T, C, A> view(get_num_retained(), comparator_, allocator_);
+ quantiles_sorted_view<T, C, A> view(get_num_retained(), comparator_, allocator_);
for (uint8_t level = 0; level < num_levels_; ++level) {
const auto from = items_ + levels_[level];
const auto to = items_ + levels_[level + 1]; // exclusive
@@ -1092,16 +1091,16 @@ class kll_sketch<T, C, A>::items_deleter {
template<typename T, typename C, typename A>
void kll_sketch<T, C, A>::setup_sorted_view() const {
if (sorted_view_ == nullptr) {
- using AllocSortedView = typename std::allocator_traits<A>::template rebind_alloc<quantile_sketch_sorted_view<T, C, A>>;
- sorted_view_ = new (AllocSortedView(allocator_).allocate(1)) quantile_sketch_sorted_view<T, C, A>(get_sorted_view());
+ using AllocSortedView = typename std::allocator_traits<A>::template rebind_alloc<quantiles_sorted_view<T, C, A>>;
+ sorted_view_ = new (AllocSortedView(allocator_).allocate(1)) quantiles_sorted_view<T, C, A>(get_sorted_view());
}
}
template<typename T, typename C, typename A>
void kll_sketch<T, C, A>::reset_sorted_view() {
if (sorted_view_ != nullptr) {
- sorted_view_->~quantile_sketch_sorted_view();
- using AllocSortedView = typename std::allocator_traits<A>::template rebind_alloc<quantile_sketch_sorted_view<T, C, A>>;
+ sorted_view_->~quantiles_sorted_view();
+ using AllocSortedView = typename std::allocator_traits<A>::template rebind_alloc<quantiles_sorted_view<T, C, A>>;
AllocSortedView(allocator_).deallocate(sorted_view_, 1);
sorted_view_ = nullptr;
}
diff --git a/quantiles/include/quantiles_sketch.hpp b/quantiles/include/quantiles_sketch.hpp
index 17f6f48..1141061 100644
--- a/quantiles/include/quantiles_sketch.hpp
+++ b/quantiles/include/quantiles_sketch.hpp
@@ -24,7 +24,7 @@
#include <memory>
#include <vector>
-#include "quantile_sketch_sorted_view.hpp"
+#include "quantiles_sorted_view.hpp"
#include "common_defs.hpp"
#include "serde.hpp"
@@ -151,7 +151,6 @@ public:
using value_type = T;
using allocator_type = Allocator;
using comparator = Comparator;
- using vector_double = std::vector<double, typename std::allocator_traits<Allocator>::template rebind_alloc<double>>;
explicit quantiles_sketch(uint16_t k = quantiles_constants::DEFAULT_K,
const Comparator& comparator = Comparator(), const Allocator& allocator = Allocator());
@@ -254,7 +253,7 @@ public:
*
* @return the approximation to the item at the given rank
*/
- using quantile_return_type = typename quantile_sketch_sorted_view<T, Comparator, Allocator>::quantile_return_type;
+ using quantile_return_type = typename quantiles_sorted_view<T, Comparator, Allocator>::quantile_return_type;
quantile_return_type get_quantile(double rank, bool inclusive = true) const;
/**
@@ -330,6 +329,7 @@ public:
* @return an array of m+1 doubles each of which is an approximation
* to the fraction of the input stream items (the mass) that fall into one of those intervals.
*/
+ using vector_double = typename quantiles_sorted_view<T, Comparator, Allocator>::vector_double;
vector_double get_PMF(const T* split_points, uint32_t size, bool inclusive = true) const;
/**
@@ -456,7 +456,7 @@ public:
const_iterator begin() const;
const_iterator end() const;
- quantile_sketch_sorted_view<T, Comparator, Allocator> get_sorted_view() const;
+ quantiles_sorted_view<T, Comparator, Allocator> get_sorted_view() const;
private:
using Level = std::vector<T, Allocator>;
@@ -497,7 +497,7 @@ private:
VectorLevels levels_;
T* min_item_;
T* max_item_;
- mutable quantile_sketch_sorted_view<T, Comparator, Allocator>* sorted_view_;
+ mutable quantiles_sorted_view<T, Comparator, Allocator>* sorted_view_;
void setup_sorted_view() const; // modifies mutable state
void reset_sorted_view();
diff --git a/quantiles/include/quantiles_sketch_impl.hpp b/quantiles/include/quantiles_sketch_impl.hpp
index 0f4242a..c0a4d7e 100644
--- a/quantiles/include/quantiles_sketch_impl.hpp
+++ b/quantiles/include/quantiles_sketch_impl.hpp
@@ -29,7 +29,6 @@
#include "common_defs.hpp"
#include "count_zeros.hpp"
#include "conditional_forward.hpp"
-#include "quantiles_sketch.hpp"
namespace datasketches {
@@ -740,13 +739,13 @@ double quantiles_sketch<T, C, A>::get_normalized_rank_error(uint16_t k, bool is_
}
template<typename T, typename C, typename A>
-quantile_sketch_sorted_view<T, C, A> quantiles_sketch<T, C, A>::get_sorted_view() const {
+quantiles_sorted_view<T, C, A> quantiles_sketch<T, C, A>::get_sorted_view() const {
// allow side-effect of sorting the base buffer
if (!is_base_buffer_sorted_) {
std::sort(const_cast<Level&>(base_buffer_).begin(), const_cast<Level&>(base_buffer_).end(), comparator_);
const_cast<quantiles_sketch*>(this)->is_base_buffer_sorted_ = true;
}
- quantile_sketch_sorted_view<T, C, A> view(get_num_retained(), comparator_, allocator_);
+ quantiles_sorted_view<T, C, A> view(get_num_retained(), comparator_, allocator_);
uint64_t weight = 1;
view.add(base_buffer_.begin(), base_buffer_.end(), weight);
@@ -1268,16 +1267,16 @@ class quantiles_sketch<T, C, A>::items_deleter {
template<typename T, typename C, typename A>
void quantiles_sketch<T, C, A>::setup_sorted_view() const {
if (sorted_view_ == nullptr) {
- using AllocSortedView = typename std::allocator_traits<A>::template rebind_alloc<quantile_sketch_sorted_view<T, C, A>>;
- sorted_view_ = new (AllocSortedView(allocator_).allocate(1)) quantile_sketch_sorted_view<T, C, A>(get_sorted_view());
+ using AllocSortedView = typename std::allocator_traits<A>::template rebind_alloc<quantiles_sorted_view<T, C, A>>;
+ sorted_view_ = new (AllocSortedView(allocator_).allocate(1)) quantiles_sorted_view<T, C, A>(get_sorted_view());
}
}
template<typename T, typename C, typename A>
void quantiles_sketch<T, C, A>::reset_sorted_view() {
if (sorted_view_ != nullptr) {
- sorted_view_->~quantile_sketch_sorted_view();
- using AllocSortedView = typename std::allocator_traits<A>::template rebind_alloc<quantile_sketch_sorted_view<T, C, A>>;
+ sorted_view_->~quantiles_sorted_view();
+ using AllocSortedView = typename std::allocator_traits<A>::template rebind_alloc<quantiles_sorted_view<T, C, A>>;
AllocSortedView(allocator_).deallocate(sorted_view_, 1);
sorted_view_ = nullptr;
}
diff --git a/req/include/req_sketch.hpp b/req/include/req_sketch.hpp
index 9ade6ce..d37f5da 100755
--- a/req/include/req_sketch.hpp
+++ b/req/include/req_sketch.hpp
@@ -20,11 +20,11 @@
#ifndef REQ_SKETCH_HPP_
#define REQ_SKETCH_HPP_
+#include <stdexcept>
+
#include "req_common.hpp"
#include "req_compactor.hpp"
-#include "quantile_sketch_sorted_view.hpp"
-
-#include <stdexcept>
+#include "quantiles_sorted_view.hpp"
namespace datasketches {
@@ -39,7 +39,6 @@ public:
using comparator = Comparator;
using Compactor = req_compactor<T, Comparator, Allocator>;
using AllocCompactor = typename std::allocator_traits<Allocator>::template rebind_alloc<Compactor>;
- using vector_double = std::vector<double, typename std::allocator_traits<Allocator>::template rebind_alloc<double>>;
/**
* Constructor
@@ -180,6 +179,7 @@ public:
* @return an array of m+1 doubles each of which is an approximation
* to the fraction of the input stream items (the mass) that fall into one of those intervals.
*/
+ using vector_double = typename quantiles_sorted_view<T, Comparator, Allocator>::vector_double;
vector_double get_PMF(const T* split_points, uint32_t size, bool inclusive = true) const;
/**
@@ -214,7 +214,7 @@ public:
*
* @return approximate quantile associated with the given rank
*/
- using quantile_return_type = typename quantile_sketch_sorted_view<T, Comparator, Allocator>::quantile_return_type;
+ using quantile_return_type = typename quantiles_sorted_view<T, Comparator, Allocator>::quantile_return_type;
quantile_return_type get_quantile(double rank, bool inclusive = true) const;
/**
@@ -332,7 +332,7 @@ public:
const_iterator begin() const;
const_iterator end() const;
- quantile_sketch_sorted_view<T, Comparator, Allocator> get_sorted_view() const;
+ quantiles_sorted_view<T, Comparator, Allocator> get_sorted_view() const;
private:
Comparator comparator_;
@@ -345,7 +345,7 @@ private:
std::vector<Compactor, AllocCompactor> compactors_;
T* min_item_;
T* max_item_;
- mutable quantile_sketch_sorted_view<T, Comparator, Allocator>* sorted_view_;
+ mutable quantiles_sorted_view<T, Comparator, Allocator>* sorted_view_;
void setup_sorted_view() const; // modifies mutable state
void reset_sorted_view();
diff --git a/req/include/req_sketch_impl.hpp b/req/include/req_sketch_impl.hpp
index 8580205..e9aa9ed 100755
--- a/req/include/req_sketch_impl.hpp
+++ b/req/include/req_sketch_impl.hpp
@@ -21,7 +21,6 @@
#define REQ_SKETCH_IMPL_HPP_
#include <sstream>
-#include <stdexcept>
namespace datasketches {
@@ -300,11 +299,11 @@ std::vector<T, A> req_sketch<T, C, A>::get_quantiles(const double* ranks, uint32
}
template<typename T, typename C, typename A>
-quantile_sketch_sorted_view<T, C, A> req_sketch<T, C, A>::get_sorted_view() const {
+quantiles_sorted_view<T, C, A> req_sketch<T, C, A>::get_sorted_view() const {
if (!compactors_[0].is_sorted()) {
const_cast<Compactor&>(compactors_[0]).sort(); // allow this side effect
}
- quantile_sketch_sorted_view<T, C, A> view(get_num_retained(), comparator_, allocator_);
+ quantiles_sorted_view<T, C, A> view(get_num_retained(), comparator_, allocator_);
for (auto& compactor: compactors_) {
view.add(compactor.begin(), compactor.end(), 1 << compactor.get_lg_weight());
@@ -791,16 +790,16 @@ auto req_sketch<T, C, A>::end() const -> const_iterator {
template<typename T, typename C, typename A>
void req_sketch<T, C, A>::setup_sorted_view() const {
if (sorted_view_ == nullptr) {
- using AllocSortedView = typename std::allocator_traits<A>::template rebind_alloc<quantile_sketch_sorted_view<T, C, A>>;
- sorted_view_ = new (AllocSortedView(allocator_).allocate(1)) quantile_sketch_sorted_view<T, C, A>(get_sorted_view());
+ using AllocSortedView = typename std::allocator_traits<A>::template rebind_alloc<quantiles_sorted_view<T, C, A>>;
+ sorted_view_ = new (AllocSortedView(allocator_).allocate(1)) quantiles_sorted_view<T, C, A>(get_sorted_view());
}
}
template<typename T, typename C, typename A>
void req_sketch<T, C, A>::reset_sorted_view() {
if (sorted_view_ != nullptr) {
- sorted_view_->~quantile_sketch_sorted_view();
- using AllocSortedView = typename std::allocator_traits<A>::template rebind_alloc<quantile_sketch_sorted_view<T, C, A>>;
+ sorted_view_->~quantiles_sorted_view();
+ using AllocSortedView = typename std::allocator_traits<A>::template rebind_alloc<quantiles_sorted_view<T, C, A>>;
AllocSortedView(allocator_).deallocate(sorted_view_, 1);
sorted_view_ = nullptr;
}
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org