datasketches 0.2.3 → 0.2.6

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

@@ -32,29 +32,14 @@ target_include_directories(req
 target_link_libraries(req INTERFACE common)
 target_compile_features(req INTERFACE cxx_std_11)
 
-set(req_HEADERS "")
-list(APPEND req_HEADERS "include/req_common.hpp")
-list(APPEND req_HEADERS "include/req_sketch.hpp")
-list(APPEND req_HEADERS "include/req_sketch_impl.hpp")
-list(APPEND req_HEADERS "include/req_compactor.hpp")
-list(APPEND req_HEADERS "include/req_compactor_impl.hpp")
-list(APPEND req_HEADERS "include/req_quantile_calculator.hpp")
-list(APPEND req_HEADERS "include/req_quantile_calculator_impl.hpp")
-
 install(TARGETS req
   EXPORT ${PROJECT_NAME}
 )
 
-install(FILES ${req_HEADERS}
+install(FILES 
+		include/req_common.hpp
+		include/req_sketch.hpp
+		include/req_sketch_impl.hpp
+		include/req_compactor.hpp
+		include/req_compactor_impl.hpp
   DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/DataSketches")
-
-target_sources(req
-  INTERFACE
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/req_common.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/req_sketch.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/req_sketch_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/req_compactor.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/req_compactor_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/req_quantile_calculator.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/req_quantile_calculator_impl.hpp
-)

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

@@ -21,17 +21,12 @@
 #define REQ_COMMON_HPP_
 
 #include <random>
-#include <chrono>
 
 #include "serde.hpp"
 #include "common_defs.hpp"
 
 namespace datasketches {
 
-// TODO: have a common random bit with KLL
-static std::independent_bits_engine<std::mt19937, 1, unsigned>
-  req_random_bit(static_cast<unsigned>(std::chrono::system_clock::now().time_since_epoch().count()));
-
 namespace req_constants {
   static const uint16_t MIN_K = 4;
   static const uint8_t INIT_NUM_SECTIONS = 3;

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

@@ -38,6 +38,9 @@ public:
   req_compactor& operator=(const req_compactor& other);
   req_compactor& operator=(req_compactor&& other);
 
+  template<typename TT, typename CC, typename AA>
+  req_compactor(const req_compactor<TT, CC, AA>& other, const Allocator& allocator);
+
   bool is_sorted() const;
   uint32_t get_num_items() const;
   uint32_t get_nom_capacity() const;
@@ -128,6 +131,9 @@ private:
   template<typename S>
   static std::pair<std::unique_ptr<T, items_deleter>, size_t> deserialize_items(const void* bytes, size_t size, const S& serde, const Allocator& allocator, uint32_t num);
 
+  // for type converting constructor
+  template<typename TT, typename CC, typename AA>
+  friend class req_compactor;
 };
 
 } /* namespace datasketches */

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

@@ -26,6 +26,7 @@
 
 #include "count_zeros.hpp"
 #include "conditional_forward.hpp"
+#include "common_defs.hpp"
 
 #include <iomanip>
 
@@ -131,6 +132,33 @@ req_compactor<T, C, A>& req_compactor<T, C, A>::operator=(req_compactor&& other)
   return *this;
 }
 
+template<typename T, typename C, typename A>
+template<typename TT, typename CC, typename AA>
+req_compactor<T, C, A>::req_compactor(const req_compactor<TT, CC, AA>& other, const A& allocator):
+allocator_(allocator),
+lg_weight_(other.lg_weight_),
+hra_(other.hra_),
+coin_(other.coin_),
+sorted_(other.sorted_),
+section_size_raw_(other.section_size_raw_),
+section_size_(other.section_size_),
+num_sections_(other.num_sections_),
+state_(other.state_),
+num_items_(other.num_items_),
+capacity_(other.capacity_),
+items_(nullptr)
+{
+  if (other.items_ != nullptr) {
+    items_ = allocator_.allocate(capacity_);
+    const uint32_t from = hra_ ? capacity_ - num_items_ : 0;
+    const uint32_t to = hra_ ? capacity_ : num_items_;
+    for (uint32_t i = from; i < to; ++i) new (items_ + i) T(other.items_[i]);
+    if (sorted_ && !std::is_sorted(items_ + from, items_ + to, C())) {
+      throw std::logic_error("items must be sorted");
+    }
+  }
+}
+
 template<typename T, typename C, typename A>
 bool req_compactor<T, C, A>::is_sorted() const {
   return sorted_;
@@ -245,7 +273,7 @@ std::pair<uint32_t, uint32_t> req_compactor<T, C, A>::compact(req_compactor& nex
   if (compaction_range.second - compaction_range.first < 2) throw std::logic_error("compaction range error");
 
   if ((state_ & 1) == 1) { coin_ = !coin_; } // for odd flip coin;
-  else { coin_ = req_random_bit(); } // random coin flip
+  else { coin_ = random_bit(); } // random coin flip
 
   const auto num = (compaction_range.second - compaction_range.first) / 2;
   next.ensure_space(num);
@@ -451,7 +479,7 @@ req_compactor<T, C, A>::req_compactor(bool hra, uint8_t lg_weight, bool sorted,
 allocator_(allocator),
 lg_weight_(lg_weight),
 hra_(hra),
-coin_(req_random_bit()),
+coin_(random_bit()),
 sorted_(sorted),
 section_size_raw_(section_size_raw),
 section_size_(nearest_even(section_size_raw)),

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

@@ -22,22 +22,25 @@
 
 #include "req_common.hpp"
 #include "req_compactor.hpp"
-#include "req_quantile_calculator.hpp"
+#include "quantile_sketch_sorted_view.hpp"
+
+#include <stdexcept>
 
 namespace datasketches {
 
 template<
   typename T,
-  typename Comparator = std::less<T>,
-  typename SerDe = serde<T>,
+  typename Comparator = std::less<T>, // strict weak ordering function (see C++ named requirements: Compare)
+  typename S = serde<T>, // deprecated, to be removed in the next major version
   typename Allocator = std::allocator<T>
 >
 class req_sketch {
 public:
+  using value_type = T;
+  using comparator = Comparator;
   using Compactor = req_compactor<T, Comparator, Allocator>;
   using AllocCompactor = typename std::allocator_traits<Allocator>::template rebind_alloc<Compactor>;
-  using AllocDouble = typename std::allocator_traits<Allocator>::template rebind_alloc<double>;
-  using vector_double = std::vector<double, AllocDouble>;
+  using vector_double = std::vector<double, typename std::allocator_traits<Allocator>::template rebind_alloc<double>>;
 
   /**
    * Constructor
@@ -55,6 +58,14 @@ public:
   req_sketch& operator=(const req_sketch& other);
   req_sketch& operator=(req_sketch&& other);
 
+  /*
+   * Type converting constructor.
+   * @param other sketch of a different type
+   * @param allocator instance of an Allocator
+   */
+  template<typename TT, typename CC, typename SS, typename AA>
+  explicit req_sketch(const req_sketch<TT, CC, SS, AA>& other, const Allocator& allocator = Allocator());
+
   /**
    * Returns configured parameter K
    * @return parameter K
@@ -113,6 +124,12 @@ public:
    */
   const T& get_max_value() const;
 
+  /**
+   * Returns an instance of the comparator for this sketch.
+   * @return comparator
+   */
+  Comparator get_comparator() const;
+
   /**
    * Returns an approximation to the normalized (fractional) rank of the given item from 0 to 1 inclusive.
    * With the template parameter inclusive=true the weight of the given item is included into the rank.
@@ -123,7 +140,6 @@ public:
    * @param item to be ranked
    * @return an approximate rank of the given item
    */
-
   template<bool inclusive = false>
   double get_rank(const T& item) const;
 
@@ -135,9 +151,10 @@ public:
    *
    * @param split_points an array of <i>m</i> unique, monotonically increasing values
    * that divide the input domain into <i>m+1</i> consecutive disjoint intervals.
-   * The definition of an "interval" is inclusive of the left split point (or minimum value) and
-   * exclusive of the right split point, with the exception that the last interval will include
-   * the maximum value.
+   * If the template parameter inclusive=false, the definition of an "interval" is inclusive of the left split point and exclusive of the right
+   * split point, with the exception that the last interval will include the maximum value.
+   * If the template parameter inclusive=true, the definition of an "interval" is exclusive of the left split point and inclusive of the right
+   * split point.
    * It is not necessary to include either the min or max values in these split points.
    *
    * @return an array of m+1 doubles each of which is an approximation
@@ -178,8 +195,9 @@ public:
    * @param rank the given normalized rank
    * @return approximate quantile given the normalized rank
    */
+  using quantile_return_type = typename quantile_sketch_sorted_view<T, Comparator, Allocator>::quantile_return_type;
   template<bool inclusive = false>
-  const T& get_quantile(double rank) const;
+  quantile_return_type get_quantile(double rank) const;
 
   /**
    * Returns an array of quantiles that correspond to the given array of normalized ranks.
@@ -221,24 +239,28 @@ public:
   /**
    * Computes size needed to serialize the current state of the sketch.
    * This version is for fixed-size arithmetic types (integral and floating point).
+   * @param instance of a SerDe
    * @return size in bytes needed to serialize this sketch
    */
-  template<typename TT = T, typename std::enable_if<std::is_arithmetic<TT>::value, int>::type = 0>
-  size_t get_serialized_size_bytes() const;
+  template<typename TT = T, typename SerDe = S, typename std::enable_if<std::is_arithmetic<TT>::value, int>::type = 0>
+  size_t get_serialized_size_bytes(const SerDe& sd = SerDe()) const;
 
   /**
    * Computes size needed to serialize the current state of the sketch.
    * This version is for all other types and can be expensive since every item needs to be looked at.
+   * @param instance of a SerDe
    * @return size in bytes needed to serialize this sketch
    */
-  template<typename TT = T, typename std::enable_if<!std::is_arithmetic<TT>::value, int>::type = 0>
-  size_t get_serialized_size_bytes() const;
+  template<typename TT = T, typename SerDe = S, typename std::enable_if<!std::is_arithmetic<TT>::value, int>::type = 0>
+  size_t get_serialized_size_bytes(const SerDe& sd = SerDe()) const;
 
   /**
    * This method serializes the sketch into a given stream in a binary form
    * @param os output stream
+   * @param instance of a SerDe
    */
-  void serialize(std::ostream& os) const;
+  template<typename SerDe = S>
+  void serialize(std::ostream& os, const SerDe& sd = SerDe()) const;
 
   // This is a convenience alias for users
   // The type returned by the following serialize method
@@ -250,24 +272,53 @@ public:
    * 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
    */
-  vector_bytes serialize(unsigned header_size_bytes = 0) const;
+  template<typename SerDe = S>
+  vector_bytes serialize(unsigned header_size_bytes = 0, const SerDe& sd = SerDe()) const;
 
   /**
    * This method deserializes a sketch from a given stream.
    * @param is input stream
+   * @param instance of an Allocator
    * @return an instance of a sketch
+   *
+   * Deprecated, to be removed in the next major version
    */
   static req_sketch deserialize(std::istream& is, const Allocator& allocator = Allocator());
 
+  /**
+   * This method deserializes a sketch from a given stream.
+   * @param is input stream
+   * @param instance of a SerDe
+   * @param instance of an Allocator
+   * @return an instance of a sketch
+   */
+  template<typename SerDe = S>
+  static req_sketch deserialize(std::istream& is, const SerDe& sd = SerDe(), const Allocator& allocator = Allocator());
+
   /**
    * This method deserializes a sketch from a given array of bytes.
    * @param bytes pointer to the array of bytes
    * @param size the size of the array
+   * @param instance of an Allocator
    * @return an instance of a sketch
+   *
+   * Deprecated, to be removed in the next major version
    */
   static req_sketch deserialize(const void* bytes, size_t size, const Allocator& allocator = Allocator());
 
+  /**
+   * This method deserializes a sketch from a given array of bytes.
+   * @param bytes pointer to the array of bytes
+   * @param size the size of the array
+   * @param instance of a SerDe
+   * @param instance of an Allocator
+   * @return an instance of a sketch
+   */
+  template<typename SerDe = S>
+  static req_sketch deserialize(const void* bytes, size_t size, const SerDe& sd = SerDe(), const Allocator& allocator = Allocator());
+
   /**
    * Prints a summary of the sketch.
    * @param print_levels if true include information about levels
@@ -279,6 +330,9 @@ public:
   const_iterator begin() const;
   const_iterator end() const;
 
+  template<bool inclusive = false>
+  quantile_sketch_sorted_view<T, Comparator, Allocator> get_sorted_view(bool cumulative) const;
+
 private:
   Allocator allocator_;
   uint16_t k_;
@@ -310,13 +364,6 @@ private:
   static double get_rank_ub(uint16_t k, uint8_t num_levels, double rank, uint8_t num_std_dev, uint64_t n, bool hra);
   static bool is_exact_rank(uint16_t k, uint8_t num_levels, double rank, uint64_t n, bool hra);
 
-  using QuantileCalculator = req_quantile_calculator<T, Comparator, Allocator>;
-  using AllocCalc = typename std::allocator_traits<Allocator>::template rebind_alloc<QuantileCalculator>;
-  class calculator_deleter;
-  using QuantileCalculatorPtr = typename std::unique_ptr<QuantileCalculator, calculator_deleter>;
-  template<bool inclusive>
-  QuantileCalculatorPtr get_quantile_calculator() const;
-
   // for deserialization
   class item_deleter;
   req_sketch(uint16_t k, bool hra, uint64_t n, std::unique_ptr<T, item_deleter> min_value, std::unique_ptr<T, item_deleter> max_value, std::vector<Compactor, AllocCompactor>&& compactors);
@@ -369,6 +416,9 @@ private:
     }
   }
 
+  // for type converting constructor
+  template<typename TT, typename CC, typename SS, typename AA>
+  friend class req_sketch;
 };
 
 template<typename T, typename C, typename S, typename A>