datasketches 0.3.1 → 0.3.2

data/vendor/datasketches-cpp/hll/include/HllArray-internal.hpp

@@ -43,20 +43,44 @@ kxq1_(0.0),
 hllByteArr_(allocator),
 curMin_(0),
 numAtCurMin_(1 << lgConfigK),
-oooFlag_(false)
+oooFlag_(false),
+rebuild_kxq_curmin_(false)
+{}
+
+template<typename A>
+HllArray<A>::HllArray(const HllArray& other, target_hll_type tgtHllType) :
+  HllSketchImpl<A>(other.getLgConfigK(), tgtHllType, hll_mode::HLL, other.isStartFullSize()),
+  // remaining fields are initialized to empty sketch defaults
+  // and left to subclass constructor to populate
+  hipAccum_(0.0),
+  kxq0_(1 << other.getLgConfigK()),
+  kxq1_(0.0),
+  hllByteArr_(other.getAllocator()),
+  curMin_(0),
+  numAtCurMin_(1 << other.getLgConfigK()),
+  oooFlag_(false),
+  rebuild_kxq_curmin_(false)
 {}
 
 template<typename A>
 HllArray<A>* HllArray<A>::copyAs(target_hll_type tgtHllType) const {
-  if (tgtHllType == this->getTgtHllType()) {
+  // we may need to recompute KxQ and curMin data for a union gadget,
+  // so only use a direct copy if we have a valid sketch
+  if (tgtHllType == this->getTgtHllType() && !this->isRebuildKxqCurminFlag()) {
     return static_cast<HllArray*>(copy());
   }
-  if (tgtHllType == target_hll_type::HLL_4) {
-    return HllSketchImplFactory<A>::convertToHll4(*this);
-  } else if (tgtHllType == target_hll_type::HLL_6) {
-    return HllSketchImplFactory<A>::convertToHll6(*this);
-  } else { // tgtHllType == HLL_8
-    return HllSketchImplFactory<A>::convertToHll8(*this);
+  
+  // the factory methods replay the coupons and will always rebuild
+  // the sketch in a consistent way
+  switch (tgtHllType) {
+    case target_hll_type::HLL_4:
+      return HllSketchImplFactory<A>::convertToHll4(*this);
+    case target_hll_type::HLL_6:
+      return HllSketchImplFactory<A>::convertToHll6(*this);
+    case target_hll_type::HLL_8:
+      return HllSketchImplFactory<A>::convertToHll8(*this);
+    default:
+      throw std::invalid_argument("Invalid target HLL type"); 
   }
 }
 
@@ -299,7 +323,7 @@ double HllArray<A>::getEstimate() const {
   if (oooFlag_) {
     return getCompositeEstimate();
   }
-  return getHipAccum();
+  return hipAccum_;
 }
 
 // HLL UPPER AND LOWER BOUNDS
@@ -322,54 +346,20 @@ double HllArray<A>::getLowerBound(uint8_t numStdDev) const {
   HllUtil<A>::checkNumStdDev(numStdDev);
   const uint32_t configK = 1 << this->lgConfigK_;
   const double numNonZeros = ((curMin_ == 0) ? (configK - numAtCurMin_) : configK);
-
-  double estimate;
-  double rseFactor;
-  if (oooFlag_) {
-    estimate = getCompositeEstimate();
-    rseFactor = hll_constants::HLL_NON_HIP_RSE_FACTOR;
-  } else {
-    estimate = hipAccum_;
-    rseFactor = hll_constants::HLL_HIP_RSE_FACTOR;
-  }
-
-  double relErr;
-  if (this->lgConfigK_ > 12) {
-    relErr = (numStdDev * rseFactor) / sqrt(configK);
-  } else {
-    relErr = HllUtil<A>::getRelErr(false, oooFlag_, this->lgConfigK_, numStdDev);
-  }
-  return fmax(estimate / (1.0 + relErr), numNonZeros);
+  const double relErr = HllUtil<A>::getRelErr(false, this->oooFlag_, this->lgConfigK_, numStdDev);
+  return fmax(getEstimate() / (1.0 + relErr), numNonZeros);
 }
 
 template<typename A>
 double HllArray<A>::getUpperBound(uint8_t numStdDev) const {
   HllUtil<A>::checkNumStdDev(numStdDev);
-  const uint32_t configK = 1 << this->lgConfigK_;
-
-  double estimate;
-  double rseFactor;
-  if (oooFlag_) {
-    estimate = getCompositeEstimate();
-    rseFactor = hll_constants::HLL_NON_HIP_RSE_FACTOR;
-  } else {
-    estimate = hipAccum_;
-    rseFactor = hll_constants::HLL_HIP_RSE_FACTOR;
-  }
-
-  double relErr;
-  if (this->lgConfigK_ > 12) {
-    relErr = (-1.0) * (numStdDev * rseFactor) / sqrt(configK);
-  } else {
-    relErr = HllUtil<A>::getRelErr(true, oooFlag_, this->lgConfigK_, numStdDev);
-  }
-  return estimate / (1.0 + relErr);
+  const double relErr = HllUtil<A>::getRelErr(true, this->oooFlag_, this->lgConfigK_, numStdDev);
+  return getEstimate() / (1.0 + relErr);
 }
 
 /**
  * This is the (non-HIP) estimator.
  * It is called "composite" because multiple estimators are pasted together.
- * @param absHllArr an instance of the AbstractHllArray class.
  * @return the composite estimate
  */
 // Original C: again-two-registers.c hhb_get_composite_estimate L1489
@@ -468,16 +458,6 @@ void HllArray<A>::putNumAtCurMin(uint32_t numAtCurMin) {
   numAtCurMin_ = numAtCurMin;
 }
 
-template<typename A>
-void HllArray<A>::decNumAtCurMin() {
-  --numAtCurMin_;
-}
-
-template<typename A>
-void HllArray<A>::addToHipAccum(double delta) {
-  hipAccum_ += delta;
-}
-
 template<typename A>
 bool HllArray<A>::isCompact() const {
   return false;
@@ -486,7 +466,7 @@ bool HllArray<A>::isCompact() const {
 template<typename A>
 bool HllArray<A>::isEmpty() const {
   const uint32_t configK = 1 << this->lgConfigK_;
-  return (getCurMin() == 0) && (getNumAtCurMin() == configK);
+  return (curMin_ == 0) && (numAtCurMin_ == configK);
 }
 
 template<typename A>
@@ -556,6 +536,11 @@ AuxHashMap<A>* HllArray<A>::getAuxHashMap() const {
   return nullptr;
 }
 
+template<typename A>
+const vector_u8<A>& HllArray<A>::getHllArray() const {
+  return hllByteArr_;
+}
+
 template<typename A>
 void HllArray<A>::hipAndKxQIncrementalUpdate(uint8_t oldValue, uint8_t newValue) {
   const uint32_t configK = 1 << this->getLgConfigK();
@@ -601,6 +586,52 @@ double HllArray<A>::getHllRawEstimate() const {
   return hyperEst;
 }
 
+template<typename A>
+void HllArray<A>::setRebuildKxqCurminFlag(bool rebuild) {
+  rebuild_kxq_curmin_ = rebuild;
+}
+
+template<typename A>
+bool HllArray<A>::isRebuildKxqCurminFlag() const {
+  return rebuild_kxq_curmin_;
+}
+
+template<typename A>
+void HllArray<A>::check_rebuild_kxq_cur_min() {
+  if (!rebuild_kxq_curmin_) { return; }
+
+  uint8_t cur_min = 64;
+  uint32_t num_at_cur_min = 0;
+  double kxq0 = 1 << this->lgConfigK_;
+  double kxq1 = 0;
+
+  auto it = this->begin(true); // want all points to adjust cur_min
+  const auto end = this->end();
+  while (it != end) {
+    uint8_t v = HllUtil<A>::getValue(*it);
+    if (v > 0) {
+      if (v < 32) { kxq0 += INVERSE_POWERS_OF_2[v] - 1.0; }
+      else        { kxq1 += INVERSE_POWERS_OF_2[v] - 1.0; }
+    }
+    if (v > cur_min) { ++it; continue; }
+    if (v < cur_min) {
+      cur_min = v;
+      num_at_cur_min = 1;
+    } else {
+      ++num_at_cur_min;
+    }    
+    ++it;
+  }
+
+  kxq0_ = kxq0;
+  kxq1_ = kxq1;
+  curMin_ = cur_min;
+  numAtCurMin_ = num_at_cur_min;
+  rebuild_kxq_curmin_ = false;
+  // HipAccum is not affected
+
+}
+
 template<typename A>
 typename HllArray<A>::const_iterator HllArray<A>::begin(bool all) const {
   return const_iterator(hllByteArr_.data(), 1 << this->lgConfigK_, 0, this->tgtHllType_, nullptr, 0, all);
@@ -637,12 +668,14 @@ bool HllArray<A>::const_iterator::operator!=(const const_iterator& other) const
 }
 
 template<typename A>
-uint32_t HllArray<A>::const_iterator::operator*() const {
+auto HllArray<A>::const_iterator::operator*() const -> reference {
   return HllUtil<A>::pair(index_, value_);
 }
 
 template<typename A>
 uint8_t HllArray<A>::const_iterator::get_value(const uint8_t* array, uint32_t index, target_hll_type hll_type, const AuxHashMap<A>* exceptions, uint8_t offset) {
+  // TODO: we should be able to improve efficiency here by reading multiple bytes at a time
+  //       for HLL4 and HLL6
   if (hll_type == target_hll_type::HLL_4) {
     uint8_t value = array[index >> 1];
     if ((index & 1) > 0) { // odd

data/vendor/datasketches-cpp/hll/include/HllArray.hpp

@@ -32,6 +32,7 @@ template<typename A>
 class HllArray : public HllSketchImpl<A> {
   public:
     HllArray(uint8_t lgConfigK, target_hll_type tgtHllType, bool startFullSize, const A& allocator);
+    explicit HllArray(const HllArray& other, target_hll_type tgtHllType);
 
     static HllArray* newHll(const void* bytes, size_t len, const A& allocator);
     static HllArray* newHll(std::istream& is, const A& allocator);
@@ -52,10 +53,6 @@ class HllArray : public HllSketchImpl<A> {
     virtual double getLowerBound(uint8_t numStdDev) const;
     virtual double getUpperBound(uint8_t numStdDev) const;
 
-    inline void addToHipAccum(double delta);
-
-    inline void decNumAtCurMin();
-
     inline uint8_t getCurMin() const;
     inline uint32_t getNumAtCurMin() const;
     inline double getHipAccum() const;
@@ -90,12 +87,18 @@ class HllArray : public HllSketchImpl<A> {
 
     virtual AuxHashMap<A>* getAuxHashMap() const;
 
+    void setRebuildKxqCurminFlag(bool rebuild);
+    bool isRebuildKxqCurminFlag() const;
+    void check_rebuild_kxq_cur_min();
+
     class const_iterator;
     virtual const_iterator begin(bool all = false) const;
     virtual const_iterator end() const;
 
     virtual A getAllocator() const;
 
+    const vector_u8<A>& getHllArray() const;
+
   protected:
     void hipAndKxQIncrementalUpdate(uint8_t oldValue, uint8_t newValue);
     double getHllBitMapEstimate() const;
@@ -108,17 +111,24 @@ class HllArray : public HllSketchImpl<A> {
     uint8_t curMin_; //always zero for Hll6 and Hll8, only tracked by Hll4Array
     uint32_t numAtCurMin_; //interpreted as num zeros when curMin == 0
     bool oooFlag_; //Out-Of-Order Flag
+    bool rebuild_kxq_curmin_; // flag to recompute
 
     friend class HllSketchImplFactory<A>;
 };
 
 template<typename A>
-class HllArray<A>::const_iterator: public std::iterator<std::input_iterator_tag, uint32_t> {
+class HllArray<A>::const_iterator {
 public:
+  using iterator_category = std::input_iterator_tag;
+  using value_type = uint32_t;
+  using difference_type = void;
+  using pointer = uint32_t*;
+  using reference = uint32_t;
+
   const_iterator(const uint8_t* array, uint32_t array_slze, uint32_t index, target_hll_type hll_type, const AuxHashMap<A>* exceptions, uint8_t offset, bool all);
   const_iterator& operator++();
   bool operator!=(const const_iterator& other) const;
-  uint32_t operator*() const;
+  reference operator*() const;
 private:
   const uint8_t* array_;
   uint32_t array_size_;

data/vendor/datasketches-cpp/hll/include/HllSketchImplFactory.hpp

@@ -136,38 +136,20 @@ HllSketchImpl<A>* HllSketchImplFactory<A>::reset(HllSketchImpl<A>* impl, bool st
 
 template<typename A>
 Hll4Array<A>* HllSketchImplFactory<A>::convertToHll4(const HllArray<A>& srcHllArr) {
-  const uint8_t lgConfigK = srcHllArr.getLgConfigK();
   using Hll4Alloc = typename std::allocator_traits<A>::template rebind_alloc<Hll4Array<A>>;
-  Hll4Array<A>* hll4Array = new (Hll4Alloc(srcHllArr.getAllocator()).allocate(1))
-      Hll4Array<A>(lgConfigK, srcHllArr.isStartFullSize(), srcHllArr.getAllocator());
-  hll4Array->putOutOfOrderFlag(srcHllArr.isOutOfOrderFlag());
-  hll4Array->mergeHll(srcHllArr);
-  hll4Array->putHipAccum(srcHllArr.getHipAccum());
-  return hll4Array;
+  return new (Hll4Alloc(srcHllArr.getAllocator()).allocate(1)) Hll4Array<A>(srcHllArr);
 }
 
 template<typename A>
 Hll6Array<A>* HllSketchImplFactory<A>::convertToHll6(const HllArray<A>& srcHllArr) {
-  const uint8_t lgConfigK = srcHllArr.getLgConfigK();
   using Hll6Alloc = typename std::allocator_traits<A>::template rebind_alloc<Hll6Array<A>>;
-  Hll6Array<A>* hll6Array = new (Hll6Alloc(srcHllArr.getAllocator()).allocate(1))
-      Hll6Array<A>(lgConfigK, srcHllArr.isStartFullSize(), srcHllArr.getAllocator());
-  hll6Array->putOutOfOrderFlag(srcHllArr.isOutOfOrderFlag());
-  hll6Array->mergeHll(srcHllArr);
-  hll6Array->putHipAccum(srcHllArr.getHipAccum());
-  return hll6Array;
+  return new (Hll6Alloc(srcHllArr.getAllocator()).allocate(1)) Hll6Array<A>(srcHllArr);
 }
 
 template<typename A>
 Hll8Array<A>* HllSketchImplFactory<A>::convertToHll8(const HllArray<A>& srcHllArr) {
-  const uint8_t lgConfigK = srcHllArr.getLgConfigK();
   using Hll8Alloc = typename std::allocator_traits<A>::template rebind_alloc<Hll8Array<A>>;
-  Hll8Array<A>* hll8Array = new (Hll8Alloc(srcHllArr.getAllocator()).allocate(1))
-      Hll8Array<A>(lgConfigK, srcHllArr.isStartFullSize(), srcHllArr.getAllocator());
-  hll8Array->putOutOfOrderFlag(srcHllArr.isOutOfOrderFlag());
-  hll8Array->mergeHll(srcHllArr);
-  hll8Array->putHipAccum(srcHllArr.getHipAccum());
-  return hll8Array;
+  return new (Hll8Alloc(srcHllArr.getAllocator()).allocate(1)) Hll8Array<A>(srcHllArr);
 }
 
 }

data/vendor/datasketches-cpp/hll/include/HllUnion-internal.hpp

@@ -131,21 +131,29 @@ void hll_union_alloc<A>::coupon_update(uint32_t coupon) {
 
 template<typename A>
 double hll_union_alloc<A>::get_estimate() const {
+  if (gadget_.sketch_impl->getCurMode() == hll_mode::HLL)
+    static_cast<HllArray<A>*>(gadget_.sketch_impl)->check_rebuild_kxq_cur_min();
   return gadget_.get_estimate();
 }
 
 template<typename A>
 double hll_union_alloc<A>::get_composite_estimate() const {
+  if (gadget_.sketch_impl->getCurMode() == hll_mode::HLL)
+    static_cast<HllArray<A>*>(gadget_.sketch_impl)->check_rebuild_kxq_cur_min();
   return gadget_.get_composite_estimate();
 }
 
 template<typename A>
 double hll_union_alloc<A>::get_lower_bound(uint8_t num_std_dev) const {
+  if (gadget_.sketch_impl->getCurMode() == hll_mode::HLL)
+    static_cast<HllArray<A>*>(gadget_.sketch_impl)->check_rebuild_kxq_cur_min();
   return gadget_.get_lower_bound(num_std_dev);
 }
 
 template<typename A>
 double hll_union_alloc<A>::get_upper_bound(uint8_t num_std_dev) const {
+  if (gadget_.sketch_impl->getCurMode() == hll_mode::HLL)
+    static_cast<HllArray<A>*>(gadget_.sketch_impl)->check_rebuild_kxq_cur_min();
   return gadget_.get_upper_bound(num_std_dev);
 }
 

data/vendor/datasketches-cpp/hll/include/HllUtil.hpp

@@ -152,12 +152,6 @@ inline void HllUtil<A>::hash(const void* key, size_t keyLen, uint64_t seed, Hash
   MurmurHash3_x64_128(key, keyLen, seed, result);
 }
 
-template<typename A>
-inline double HllUtil<A>::getRelErr(bool upperBound, bool unioned,
-                                    uint8_t lgConfigK, uint8_t numStdDev) {
-  return RelativeErrorTables<A>::getRelErr(upperBound, unioned, lgConfigK, numStdDev);
-}
-
 template<typename A>
 inline uint8_t HllUtil<A>::checkLgK(uint8_t lgK) {
   if ((lgK >= hll_constants::MIN_LOG_K) && (lgK <= hll_constants::MAX_LOG_K)) {
@@ -167,6 +161,20 @@ inline uint8_t HllUtil<A>::checkLgK(uint8_t lgK) {
   }
 }
 
+template<typename A>
+inline double HllUtil<A>::getRelErr(bool upperBound, bool unioned,
+                                    uint8_t lgConfigK, uint8_t numStdDev) {
+  checkLgK(lgConfigK);
+  if (lgConfigK > 12) {
+    const double rseFactor = unioned ?
+        hll_constants::HLL_NON_HIP_RSE_FACTOR : hll_constants::HLL_HIP_RSE_FACTOR;
+    const uint32_t configK = 1 << lgConfigK;
+    return (upperBound ? -1 : 1) * (numStdDev * rseFactor) / sqrt(configK);
+  } else {
+    return RelativeErrorTables<A>::getRelErr(upperBound, unioned, lgConfigK, numStdDev);
+  }
+}
+
 template<typename A>
 inline void HllUtil<A>::checkMemSize(uint64_t minBytes, uint64_t capBytes) {
   if (capBytes < minBytes) {

data/vendor/datasketches-cpp/hll/include/coupon_iterator-internal.hpp

@@ -47,7 +47,7 @@ bool coupon_iterator<A>::operator!=(const coupon_iterator& other) const {
 }
 
 template<typename A>
-uint32_t coupon_iterator<A>::operator*() const {
+auto coupon_iterator<A>::operator*() const -> reference {
   return array_[index_];
 }
 

data/vendor/datasketches-cpp/hll/include/coupon_iterator.hpp

@@ -23,12 +23,18 @@
 namespace datasketches {
 
 template<typename A>
-class coupon_iterator: public std::iterator<std::input_iterator_tag, uint32_t> {
+class coupon_iterator {
 public:
+  using iterator_category = std::input_iterator_tag;
+  using value_type = uint32_t;
+  using difference_type = void;
+  using pointer = uint32_t*;
+  using reference = uint32_t;
+
   coupon_iterator(const uint32_t* array, size_t array_slze, size_t index, bool all);
   coupon_iterator& operator++();
   bool operator!=(const coupon_iterator& other) const;
-  uint32_t operator*() const;
+  reference operator*() const;
 private:
   const uint32_t* array_;
   size_t array_size_;

data/vendor/datasketches-cpp/hll/include/hll.hpp

@@ -23,8 +23,9 @@
 #include "common_defs.hpp"
 #include "HllUtil.hpp"
 
-#include <memory>
 #include <iostream>
+#include <memory>
+#include <string>
 #include <vector>
 
 namespace datasketches {
@@ -144,7 +145,7 @@ class hll_sketch_alloc final {
 
     /**
      * Reconstructs a sketch from a serialized image in a byte array.
-     * @param is bytes An input array with a binary image of a sketch
+     * @param bytes An input array with a binary image of a sketch
      * @param len Length of the input array, in bytes
      */
     static hll_sketch_alloc deserialize(const void* bytes, size_t len, const A& allocator = A());
@@ -197,7 +198,7 @@ class hll_sketch_alloc final {
      * Human readable summary with optional detail
      * @param summary if true, output the sketch summary
      * @param detail if true, output the internal data array
-     * @param auxDetail if true, output the internal Aux array, if it exists.
+     * @param aux_detail if true, output the internal Aux array, if it exists.
      * @param all if true, outputs all entries including empty ones
      * @return human readable string with optional detail.
      */
@@ -358,7 +359,7 @@ class hll_sketch_alloc final {
      * value can be exceeded in extremely rare cases.  If exceeded, it
      * will be larger by only a few percent.
      *
-     * @param lg_config_k The Log2 of K for the target HLL sketch. This value must be
+     * @param lg_k The Log2 of K for the target HLL sketch. This value must be
      *        between 4 and 21 inclusively.
      * @param tgt_type the desired Hll type
      * @return the maximum size in bytes that this sketch can grow to.
@@ -495,20 +496,20 @@ class hll_union_alloc {
     /**
      * Returns the result of this union operator with the specified
      * #tgt_hll_type.
-     * @param The tgt_hll_type enum value of the desired result (Default: HLL_4)
+     * @param tgt_type The tgt_hll_type enum value of the desired result (Default: HLL_4)
      * @return The result of this union with the specified tgt_hll_type
      */
     hll_sketch_alloc<A> get_result(target_hll_type tgt_type = HLL_4) const;
 
     /**
      * Update this union operator with the given sketch.
-     * @param The given sketch.
+     * @param sketch The given sketch.
      */
     void update(const hll_sketch_alloc<A>& sketch);
 
     /**
      * Update this union operator with the given temporary sketch.
-     * @param The given sketch.
+     * @param sketch The given sketch.
      */
     void update(hll_sketch_alloc<A>&& sketch);
   
@@ -608,7 +609,7 @@ class hll_union_alloc {
     * perform the union. This may involve swapping, down-sampling, transforming, and / or
     * copying one of the arguments and may completely replace the internals of the union.
     *
-    * @param incoming_impl the given incoming sketch, which may not be modified.
+    * @param sketch the given incoming sketch, which may not be modified.
     * @param lg_max_k the maximum value of log2 K for this union.
     */
     inline void union_impl(const hll_sketch_alloc<A>& sketch, uint8_t lg_max_k);

data/vendor/datasketches-cpp/hll/test/HllUnionTest.cpp

@@ -53,11 +53,16 @@ static void basicUnion(uint64_t n1, uint64_t n2,
   v += n2;
 
   hll_union u(lgMaxK);
-  u.update(std::move(h1));
+  u.update(h1);
   u.update(h2);
 
   hll_sketch result = u.get_result(resultType);
 
+  // ensure we check a direct union estimate, without first caling get_result()
+  u.reset();
+  u.update(std::move(h1));
+  u.update(h2);
+
   // force non-HIP estimates to avoid issues with in- vs out-of-order
   double uEst = result.get_composite_estimate();
   double uUb = result.get_upper_bound(2);
@@ -74,6 +79,7 @@ static void basicUnion(uint64_t n1, uint64_t n2,
   REQUIRE((uEst - uLb) >= 0.0);
 
   REQUIRE(controlEst == uEst);
+  REQUIRE(controlEst == u.get_composite_estimate());
 }
 
 /**

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

@@ -20,7 +20,6 @@
 #ifndef KLL_HELPER_HPP_
 #define KLL_HELPER_HPP_
 
-#include <random>
 #include <stdexcept>
 
 namespace datasketches {

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

@@ -586,16 +586,21 @@ class kll_sketch {
 };
 
 template<typename T, typename C, typename A>
-class kll_sketch<T, C, A>::const_iterator: public std::iterator<std::input_iterator_tag, T> {
+class kll_sketch<T, C, A>::const_iterator {
 public:
+  using iterator_category = std::input_iterator_tag;
   using value_type = std::pair<const T&, const uint64_t>;
+  using difference_type = void;
+  using pointer = const return_value_holder<value_type>;
+  using reference = const value_type;
+
   friend class kll_sketch<T, C, A>;
   const_iterator& operator++();
   const_iterator& operator++(int);
   bool operator==(const const_iterator& other) const;
   bool operator!=(const const_iterator& other) const;
-  const value_type operator*() const;
-  const return_value_holder<value_type> operator->() const;
+  reference operator*() const;
+  pointer operator->() const;
 private:
   const T* items;
   const uint32_t* levels;

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

@@ -1105,12 +1105,12 @@ bool kll_sketch<T, C, A>::const_iterator::operator!=(const const_iterator& other
 }
 
 template<typename T, typename C, typename A>
-auto kll_sketch<T, C, A>::const_iterator::operator*() const -> const value_type {
+auto kll_sketch<T, C, A>::const_iterator::operator*() const -> reference {
   return value_type(items[index], weight);
 }
 
 template<typename T, typename C, typename A>
-auto kll_sketch<T, C, A>::const_iterator::operator->() const -> const return_value_holder<value_type> {
+auto kll_sketch<T, C, A>::const_iterator::operator->() const -> pointer {
   return **this;
 }
 

data/vendor/datasketches-cpp/kll/test/kll_sketch_test.cpp

@@ -242,7 +242,7 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
           FAIL("checking rank vs CDF for value " + std::to_string(i));
         }
         subtotal_pmf += pmf[i];
-        if (abs(ranks[i] - subtotal_pmf) > NUMERIC_NOISE_TOLERANCE) {
+        if (std::abs(ranks[i] - subtotal_pmf) > NUMERIC_NOISE_TOLERANCE) {
           FAIL("CDF vs PMF for value " + std::to_string(i));
         }
       }
@@ -257,7 +257,7 @@ TEST_CASE("kll sketch", "[kll_sketch]") {
           FAIL("checking rank vs CDF for value " + std::to_string(i));
         }
         subtotal_pmf += pmf[i];
-        if (abs(ranks[i] - subtotal_pmf) > NUMERIC_NOISE_TOLERANCE) {
+        if (std::abs(ranks[i] - subtotal_pmf) > NUMERIC_NOISE_TOLERANCE) {
           FAIL("CDF vs PMF for value " + std::to_string(i));
         }
       }

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

@@ -42,9 +42,12 @@ target_link_libraries(python
     cpc
     fi
     theta
+    tuple
     sampling
     req
     quantiles
+    count
+    density
     pybind11::module
 )
 
@@ -72,10 +75,13 @@ target_sources(python
     src/cpc_wrapper.cpp
     src/fi_wrapper.cpp
     src/theta_wrapper.cpp
+    src/tuple_wrapper.cpp
     src/vo_wrapper.cpp
     src/req_wrapper.cpp
     src/quantiles_wrapper.cpp
+    src/density_wrapper.cpp
     src/ks_wrapper.cpp
+    src/count_wrapper.cpp
     src/vector_of_kll.cpp
     src/py_serde.cpp
 )

data/vendor/datasketches-cpp/python/README.md

@@ -12,15 +12,15 @@ This package provides a variety of sketches as described below. Wherever a speci
 
 ## Building and Installation
 
-Once cloned, the library can be installed by running `python3 -m pip install .` in the project root directory -- not the python subdirectory -- which will also install the necessary dependencies, namely numpy and [pybind11[global]](https://github.com/pybind/pybind11).
+Once cloned, the library can be installed by running `python3 -m pip install .` in the project root directory -- not the python subdirectory -- which will also install the necessary dependencies, namely NumPy and [pybind11[global]](https://github.com/pybind/pybind11).
 
-If you prefer to call the `setup.py` build script directly, which is discoraged, you must first install `pybind11[global]`, as well as any other dependencies listed under the build-system section in `pyproject.toml`.
+If you prefer to call the `setup.py` build script directly, which is discouraged, you must first install `pybind11[global]`, as well as any other dependencies listed under the build-system section in `pyproject.toml`.
 
 The library is also available from PyPI via `python3 -m pip install datasketches`.
 
 ## Usage
 
-Having installed the library, loading the Apache Datasketches Library in Python is simple: `import datasketches`.
+Having installed the library, loading the Apache DataSketches Library in Python is simple: `import datasketches`.
 
 The unit tests are mostly structured in a tutorial style and can be used as a reference example for how to feed data into and query the different types of sketches.
 
@@ -76,10 +76,10 @@ The only developer-specific instructions relate to running unit tests.
 
 ### Unit tests
 
-The Python unit tests are run via `tox`, with no arguments, from the project root directory -- not the python subdirectory. Tox creates a temporary virtual environment in which to build and run the unit tests. In the event you are missing the necessary pacakge, tox may be installed with `python3 -m pip install --upgrade tox`.
+The Python unit tests are run via `tox`, with no arguments, from the project root directory -- not the python subdirectory. Tox creates a temporary virtual environment in which to build and run the unit tests. In the event you are missing the necessary package, tox may be installed with `python3 -m pip install --upgrade tox`.
 
 ## License
 
-The Apache DataSketches Library is distrubted under an Apache 2.0 License.
+The Apache DataSketches Library is distributed under the Apache 2.0 License.
 
 There may be precompiled binaries provided as a convenience and distributed through PyPI via [https://pypi.org/project/datasketches/] contain compiled code from [pybind11](https://github.com/pybind/pybind11), which is distributed under a BSD license.