datasketches 0.1.2 → 0.2.3

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

@@ -28,43 +28,42 @@ namespace datasketches {
 template<typename A>
 class AuxHashMap;
 
-template<typename A = std::allocator<char>>
+template<typename A>
 class HllArray : public HllSketchImpl<A> {
   public:
-    explicit HllArray(int lgConfigK, target_hll_type tgtHllType, bool startFullSize);
-    explicit HllArray(const HllArray<A>& that);
+    HllArray(uint8_t lgConfigK, target_hll_type tgtHllType, bool startFullSize, const A& allocator);
 
-    static HllArray* newHll(const void* bytes, size_t len);
-    static HllArray* newHll(std::istream& is);
+    static HllArray* newHll(const void* bytes, size_t len, const A& allocator);
+    static HllArray* newHll(std::istream& is, const A& allocator);
 
     virtual vector_u8<A> serialize(bool compact, unsigned header_size_bytes) const;
     virtual void serialize(std::ostream& os, bool compact) const;
 
-    virtual ~HllArray();
+    virtual ~HllArray() = default;
     virtual std::function<void(HllSketchImpl<A>*)> get_deleter() const = 0;
 
     virtual HllArray* copy() const = 0;
     virtual HllArray* copyAs(target_hll_type tgtHllType) const;
 
-    virtual HllSketchImpl<A>* couponUpdate(int coupon) = 0;
+    virtual HllSketchImpl<A>* couponUpdate(uint32_t coupon) = 0;
 
     virtual double getEstimate() const;
     virtual double getCompositeEstimate() const;
-    virtual double getLowerBound(int numStdDev) const;
-    virtual double getUpperBound(int numStdDev) const;
+    virtual double getLowerBound(uint8_t numStdDev) const;
+    virtual double getUpperBound(uint8_t numStdDev) const;
 
     inline void addToHipAccum(double delta);
 
     inline void decNumAtCurMin();
 
-    inline int getCurMin() const;
-    inline int getNumAtCurMin() const;
+    inline uint8_t getCurMin() const;
+    inline uint32_t getNumAtCurMin() const;
     inline double getHipAccum() const;
 
-    virtual int getHllByteArrBytes() const = 0;
+    virtual uint32_t getHllByteArrBytes() const = 0;
 
-    virtual int getUpdatableSerializationBytes() const;
-    virtual int getCompactSerializationBytes() const;
+    virtual uint32_t getUpdatableSerializationBytes() const;
+    virtual uint32_t getCompactSerializationBytes() const;
 
     virtual bool isOutOfOrderFlag() const;
     virtual bool isEmpty() const;
@@ -75,19 +74,19 @@ class HllArray : public HllSketchImpl<A> {
     inline double getKxQ0() const;
     inline double getKxQ1() const;
 
-    virtual int getMemDataStart() const;
-    virtual int getPreInts() const;
+    virtual uint32_t getMemDataStart() const;
+    virtual uint8_t getPreInts() const;
 
-    void putCurMin(int curMin);
+    void putCurMin(uint8_t curMin);
     void putHipAccum(double hipAccum);
     inline void putKxQ0(double kxq0);
     inline void putKxQ1(double kxq1);
-    void putNumAtCurMin(int numAtCurMin);
+    void putNumAtCurMin(uint32_t numAtCurMin);
 
-    static int hllArrBytes(target_hll_type tgtHllType, int lgConfigK);
-    static int hll4ArrBytes(int lgConfigK);
-    static int hll6ArrBytes(int lgConfigK);
-    static int hll8ArrBytes(int lgConfigK);
+    static uint32_t hllArrBytes(target_hll_type tgtHllType, uint8_t lgConfigK);
+    static uint32_t hll4ArrBytes(uint8_t lgConfigK);
+    static uint32_t hll6ArrBytes(uint8_t lgConfigK);
+    static uint32_t hll8ArrBytes(uint8_t lgConfigK);
 
     virtual AuxHashMap<A>* getAuxHashMap() const;
 
@@ -95,18 +94,20 @@ class HllArray : public HllSketchImpl<A> {
     virtual const_iterator begin(bool all = false) const;
     virtual const_iterator end() const;
 
+    virtual A getAllocator() const;
+
   protected:
     void hipAndKxQIncrementalUpdate(uint8_t oldValue, uint8_t newValue);
-    double getHllBitMapEstimate(int lgConfigK, int curMin, int numAtCurMin) const;
-    double getHllRawEstimate(int lgConfigK, double kxqSum) const;
+    double getHllBitMapEstimate() const;
+    double getHllRawEstimate() const;
 
-    double hipAccum;
-    double kxq0;
-    double kxq1;
-    uint8_t* hllByteArr; //init by sub-classes
-    int curMin; //always zero for Hll6 and Hll8, only tracked by Hll4Array
-    int numAtCurMin; //interpreted as num zeros when curMin == 0
-    bool oooFlag; //Out-Of-Order Flag
+    double hipAccum_;
+    double kxq0_;
+    double kxq1_;
+    vector_u8<A> hllByteArr_; //init by sub-classes
+    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
 
     friend class HllSketchImplFactory<A>;
 };
@@ -114,21 +115,20 @@ class HllArray : public HllSketchImpl<A> {
 template<typename A>
 class HllArray<A>::const_iterator: public std::iterator<std::input_iterator_tag, uint32_t> {
 public:
-  const_iterator(const uint8_t* array, size_t array_slze, size_t index, target_hll_type hll_type, const AuxHashMap<A>* exceptions, uint8_t offset, bool all);
-  //const_iterator(const uint8_t* array, size_t array_slze, size_t index, target_hll_type hll_type, const AuxHashMap<A>* exceptions, uint8_t offset);
+  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;
 private:
-  const uint8_t* array;
-  size_t array_size;
-  size_t index;
-  target_hll_type hll_type;
-  const AuxHashMap<A>* exceptions;
-  uint8_t offset;
-  bool all;
-  uint8_t value; // cached value to avoid computing in operator++ and in operator*()
-  static inline uint8_t get_value(const uint8_t* array, size_t index, target_hll_type hll_type, const AuxHashMap<A>* exceptions, uint8_t offset);
+  const uint8_t* array_;
+  uint32_t array_size_;
+  uint32_t index_;
+  target_hll_type hll_type_;
+  const AuxHashMap<A>* exceptions_;
+  uint8_t offset_;
+  bool all_;
+  uint8_t value_; // cached value to avoid computing in operator++ and in operator*()
+  static inline uint8_t get_value(const uint8_t* array, uint32_t index, target_hll_type hll_type, const AuxHashMap<A>* exceptions, uint8_t offset);
 };
 
 }

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

@@ -42,28 +42,26 @@ typedef union {
 } longDoubleUnion;
 
 template<typename A>
-hll_sketch_alloc<A>::hll_sketch_alloc(int lg_config_k, target_hll_type tgt_type, bool start_full_size) {
+hll_sketch_alloc<A>::hll_sketch_alloc(uint8_t lg_config_k, target_hll_type tgt_type, bool start_full_size, const A& allocator) {
   HllUtil<A>::checkLgK(lg_config_k);
   if (start_full_size) {
-    sketch_impl = HllSketchImplFactory<A>::newHll(lg_config_k, tgt_type, start_full_size);
+    sketch_impl = HllSketchImplFactory<A>::newHll(lg_config_k, tgt_type, start_full_size, allocator);
   } else {
     typedef typename std::allocator_traits<A>::template rebind_alloc<CouponList<A>> clAlloc;
-    sketch_impl = new (clAlloc().allocate(1)) CouponList<A>(lg_config_k, tgt_type, hll_mode::LIST);
+    sketch_impl = new (clAlloc(allocator).allocate(1)) CouponList<A>(lg_config_k, tgt_type, hll_mode::LIST, allocator);
   }
 }
 
 template<typename A>
-hll_sketch_alloc<A> hll_sketch_alloc<A>::deserialize(std::istream& is) {
-  HllSketchImpl<A>* impl = HllSketchImplFactory<A>::deserialize(is);
-  hll_sketch_alloc<A> sketch(impl);
-  return sketch;
+hll_sketch_alloc<A> hll_sketch_alloc<A>::deserialize(std::istream& is, const A& allocator) {
+  HllSketchImpl<A>* impl = HllSketchImplFactory<A>::deserialize(is, allocator);
+  return hll_sketch_alloc<A>(impl);
 }
 
 template<typename A>
-hll_sketch_alloc<A> hll_sketch_alloc<A>::deserialize(const void* bytes, size_t len) {
-  HllSketchImpl<A>* impl = HllSketchImplFactory<A>::deserialize(bytes, len);
-  hll_sketch_alloc<A> sketch(impl);
-  return sketch;
+hll_sketch_alloc<A> hll_sketch_alloc<A>::deserialize(const void* bytes, size_t len, const A& allocator) {
+  HllSketchImpl<A>* impl = HllSketchImplFactory<A>::deserialize(bytes, len, allocator);
+  return hll_sketch_alloc<A>(impl);
 }
 
 template<typename A>
@@ -124,7 +122,7 @@ void hll_sketch_alloc<A>::update(const std::string& datum) {
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const uint64_t datum) {
+void hll_sketch_alloc<A>::update(uint64_t datum) {
   // no sign extension with 64 bits so no need to cast to signed value
   HashState hashResult;
   HllUtil<A>::hash(&datum, sizeof(uint64_t), DEFAULT_SEED, hashResult);
@@ -132,53 +130,53 @@ void hll_sketch_alloc<A>::update(const uint64_t datum) {
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const uint32_t datum) {
+void hll_sketch_alloc<A>::update(uint32_t datum) {
   update(static_cast<int32_t>(datum));
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const uint16_t datum) {
+void hll_sketch_alloc<A>::update(uint16_t datum) {
   update(static_cast<int16_t>(datum));
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const uint8_t datum) {
+void hll_sketch_alloc<A>::update(uint8_t datum) {
   update(static_cast<int8_t>(datum));
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const int64_t datum) {
+void hll_sketch_alloc<A>::update(int64_t datum) {
   HashState hashResult;
   HllUtil<A>::hash(&datum, sizeof(int64_t), DEFAULT_SEED, hashResult);
   coupon_update(HllUtil<A>::coupon(hashResult));
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const int32_t datum) {
-  int64_t val = static_cast<int64_t>(datum);
+void hll_sketch_alloc<A>::update(int32_t datum) {
+  const int64_t val = static_cast<int64_t>(datum);
   HashState hashResult;
   HllUtil<A>::hash(&val, sizeof(int64_t), DEFAULT_SEED, hashResult);
   coupon_update(HllUtil<A>::coupon(hashResult));
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const int16_t datum) {
-  int64_t val = static_cast<int64_t>(datum);
+void hll_sketch_alloc<A>::update(int16_t datum) {
+  const int64_t val = static_cast<int64_t>(datum);
   HashState hashResult;
   HllUtil<A>::hash(&val, sizeof(int64_t), DEFAULT_SEED, hashResult);
   coupon_update(HllUtil<A>::coupon(hashResult));
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const int8_t datum) {
-  int64_t val = static_cast<int64_t>(datum);
+void hll_sketch_alloc<A>::update(int8_t datum) {
+  const int64_t val = static_cast<int64_t>(datum);
   HashState hashResult;
   HllUtil<A>::hash(&val, sizeof(int64_t), DEFAULT_SEED, hashResult);
   coupon_update(HllUtil<A>::coupon(hashResult));
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const double datum) {
+void hll_sketch_alloc<A>::update(double datum) {
   longDoubleUnion d;
   d.doubleBytes = static_cast<double>(datum);
   if (datum == 0.0) {
@@ -192,7 +190,7 @@ void hll_sketch_alloc<A>::update(const double datum) {
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const float datum) {
+void hll_sketch_alloc<A>::update(float datum) {
   longDoubleUnion d;
   d.doubleBytes = static_cast<double>(datum);
   if (datum == 0.0) {
@@ -206,7 +204,7 @@ void hll_sketch_alloc<A>::update(const float datum) {
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::update(const void* data, const size_t lengthBytes) {
+void hll_sketch_alloc<A>::update(const void* data, size_t lengthBytes) {
   if (data == nullptr) { return; }
   HashState hashResult;
   HllUtil<A>::hash(data, lengthBytes, DEFAULT_SEED, hashResult);
@@ -214,8 +212,8 @@ void hll_sketch_alloc<A>::update(const void* data, const size_t lengthBytes) {
 }
 
 template<typename A>
-void hll_sketch_alloc<A>::coupon_update(int coupon) {
-  if (coupon == HllUtil<A>::EMPTY) { return; }
+void hll_sketch_alloc<A>::coupon_update(uint32_t coupon) {
+  if (coupon == hll_constants::EMPTY) { return; }
   HllSketchImpl<A>* result = this->sketch_impl->couponUpdate(coupon);
   if (result != this->sketch_impl) {
     this->sketch_impl->get_deleter()(this->sketch_impl);
@@ -354,12 +352,12 @@ double hll_sketch_alloc<A>::get_composite_estimate() const {
 }
 
 template<typename A>
-double hll_sketch_alloc<A>::get_lower_bound(int numStdDev) const {
+double hll_sketch_alloc<A>::get_lower_bound(uint8_t numStdDev) const {
   return sketch_impl->getLowerBound(numStdDev);
 }
 
 template<typename A>
-double hll_sketch_alloc<A>::get_upper_bound(int numStdDev) const {
+double hll_sketch_alloc<A>::get_upper_bound(uint8_t numStdDev) const {
   return sketch_impl->getUpperBound(numStdDev);
 }
 
@@ -369,7 +367,7 @@ hll_mode hll_sketch_alloc<A>::get_current_mode() const {
 }
 
 template<typename A>
-int hll_sketch_alloc<A>::get_lg_config_k() const {
+uint8_t hll_sketch_alloc<A>::get_lg_config_k() const {
   return sketch_impl->getLgConfigK();
 }
 
@@ -389,12 +387,12 @@ bool hll_sketch_alloc<A>::is_estimation_mode() const {
 }
 
 template<typename A>
-int hll_sketch_alloc<A>::get_updatable_serialization_bytes() const {
+uint32_t hll_sketch_alloc<A>::get_updatable_serialization_bytes() const {
   return sketch_impl->getUpdatableSerializationBytes();
 }
 
 template<typename A>
-int hll_sketch_alloc<A>::get_compact_serialization_bytes() const {
+uint32_t hll_sketch_alloc<A>::get_compact_serialization_bytes() const {
   return sketch_impl->getCompactSerializationBytes();
 }
 
@@ -437,23 +435,23 @@ std::string hll_sketch_alloc<A>::mode_as_string() const {
 }
 
 template<typename A>
-int hll_sketch_alloc<A>::get_max_updatable_serialization_bytes(const int lg_config_k,
+uint32_t hll_sketch_alloc<A>::get_max_updatable_serialization_bytes(uint8_t lg_config_k,
     const target_hll_type tgtHllType) {
-  int arrBytes;
+  uint32_t arrBytes;
   if (tgtHllType == target_hll_type::HLL_4) {
-    const int auxBytes = 4 << HllUtil<A>::LG_AUX_ARR_INTS[lg_config_k];
+    const uint32_t auxBytes = 4 << hll_constants::LG_AUX_ARR_INTS[lg_config_k];
     arrBytes = HllArray<A>::hll4ArrBytes(lg_config_k) + auxBytes;
   } else if (tgtHllType == target_hll_type::HLL_6) {
     arrBytes = HllArray<A>::hll6ArrBytes(lg_config_k);
   } else { //HLL_8
     arrBytes = HllArray<A>::hll8ArrBytes(lg_config_k);
   }
-  return HllUtil<A>::HLL_BYTE_ARR_START + arrBytes;
+  return hll_constants::HLL_BYTE_ARR_START + arrBytes;
 }
 
 template<typename A>
-double hll_sketch_alloc<A>::get_rel_err(const bool upperBound, const bool unioned,
-                           const int lg_config_k, const int numStdDev) {
+double hll_sketch_alloc<A>::get_rel_err(bool upperBound, bool unioned,
+                           uint8_t lg_config_k, uint8_t numStdDev) {
   return HllUtil<A>::getRelErr(upperBound, unioned, lg_config_k, numStdDev);
 }
 

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

@@ -26,12 +26,12 @@
 namespace datasketches {
 
 template<typename A>
-HllSketchImpl<A>::HllSketchImpl(const int lgConfigK, const target_hll_type tgtHllType,
-                                const hll_mode mode, const bool startFullSize)
-  : lgConfigK(lgConfigK),
-    tgtHllType(tgtHllType),
-    mode(mode),
-    startFullSize(startFullSize)
+HllSketchImpl<A>::HllSketchImpl(uint8_t lgConfigK, target_hll_type tgtHllType,
+                                hll_mode mode, bool startFullSize)
+  : lgConfigK_(lgConfigK),
+    tgtHllType_(tgtHllType),
+    mode_(mode),
+    startFullSize_(startFullSize)
 {
 }
 
@@ -40,7 +40,7 @@ HllSketchImpl<A>::~HllSketchImpl() {
 }
 
 template<typename A>
-target_hll_type HllSketchImpl<A>::extractTgtHllType(const uint8_t modeByte) {
+target_hll_type HllSketchImpl<A>::extractTgtHllType(uint8_t modeByte) {
   switch ((modeByte >> 2) & 0x3) {
   case 0:
     return target_hll_type::HLL_4;
@@ -54,7 +54,7 @@ target_hll_type HllSketchImpl<A>::extractTgtHllType(const uint8_t modeByte) {
 }
 
 template<typename A>
-hll_mode HllSketchImpl<A>::extractCurMode(const uint8_t modeByte) {
+hll_mode HllSketchImpl<A>::extractCurMode(uint8_t modeByte) {
   switch (modeByte & 0x3) {
   case 0:
     return hll_mode::LIST;
@@ -68,12 +68,12 @@ hll_mode HllSketchImpl<A>::extractCurMode(const uint8_t modeByte) {
 }
 
 template<typename A>
-uint8_t HllSketchImpl<A>::makeFlagsByte(const bool compact) const {
-  uint8_t flags(0);
-  flags |= (isEmpty() ? HllUtil<A>::EMPTY_FLAG_MASK : 0);
-  flags |= (compact ? HllUtil<A>::COMPACT_FLAG_MASK : 0);
-  flags |= (isOutOfOrderFlag() ? HllUtil<A>::OUT_OF_ORDER_FLAG_MASK : 0);
-  flags |= (startFullSize ? HllUtil<A>::FULL_SIZE_FLAG_MASK : 0);
+uint8_t HllSketchImpl<A>::makeFlagsByte(bool compact) const {
+  uint8_t flags = 0;
+  flags |= (isEmpty() ? hll_constants::EMPTY_FLAG_MASK : 0);
+  flags |= (compact ? hll_constants::COMPACT_FLAG_MASK : 0);
+  flags |= (isOutOfOrderFlag() ? hll_constants::OUT_OF_ORDER_FLAG_MASK : 0);
+  flags |= (startFullSize_ ? hll_constants::FULL_SIZE_FLAG_MASK : 0);
   return flags;
 }
 
@@ -92,7 +92,7 @@ template<typename A>
 uint8_t HllSketchImpl<A>::makeModeByte() const {
   uint8_t byte = 0;
 
-  switch (mode) {
+  switch (mode_) {
   case LIST:
     byte = 0;
     break;
@@ -104,7 +104,7 @@ uint8_t HllSketchImpl<A>::makeModeByte() const {
     break;
   }
 
-  switch (tgtHllType) {
+  switch (tgtHllType_) {
   case HLL_4:
     byte |= (0 << 2);  // for completeness
     break;
@@ -121,27 +121,27 @@ uint8_t HllSketchImpl<A>::makeModeByte() const {
 
 template<typename A>
 HllSketchImpl<A>* HllSketchImpl<A>::reset() {
-  return HllSketchImplFactory<A>::reset(this, startFullSize);
+  return HllSketchImplFactory<A>::reset(this, startFullSize_);
 }
 
 template<typename A>
 target_hll_type HllSketchImpl<A>::getTgtHllType() const {
-  return tgtHllType;
+  return tgtHllType_;
 }
 
 template<typename A>
-int HllSketchImpl<A>::getLgConfigK() const {
-  return lgConfigK;
+uint8_t HllSketchImpl<A>::getLgConfigK() const {
+  return lgConfigK_;
 }
 
 template<typename A>
 hll_mode HllSketchImpl<A>::getCurMode() const {
-  return mode;
+  return mode_;
 }
 
 template<typename A>
 bool HllSketchImpl<A>::isStartFullSize() const {
-  return startFullSize;
+  return startFullSize_;
 }
 
 }

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

@@ -27,10 +27,10 @@
 
 namespace datasketches {
 
-template<typename A = std::allocator<char>>
+template<typename A>
 class HllSketchImpl {
   public:
-    HllSketchImpl(int lgConfigK, target_hll_type tgtHllType, hll_mode mode, bool startFullSize);
+    HllSketchImpl(uint8_t lgConfigK, target_hll_type tgtHllType, hll_mode mode, bool startFullSize);
     virtual ~HllSketchImpl();
 
     virtual void serialize(std::ostream& os, bool compact) const = 0;
@@ -42,30 +42,31 @@ class HllSketchImpl {
 
     virtual std::function<void(HllSketchImpl<A>*)> get_deleter() const = 0;
 
-    virtual HllSketchImpl* couponUpdate(int coupon) = 0;
+    virtual HllSketchImpl* couponUpdate(uint32_t coupon) = 0;
 
     hll_mode getCurMode() const;
 
     virtual double getEstimate() const = 0;
     virtual double getCompositeEstimate() const = 0;
-    virtual double getUpperBound(int numStdDev) const = 0;
-    virtual double getLowerBound(int numStdDev) const = 0;
+    virtual double getUpperBound(uint8_t numStdDev) const = 0;
+    virtual double getLowerBound(uint8_t numStdDev) const = 0;
 
-    inline int getLgConfigK() const;
+    inline uint8_t getLgConfigK() const;
 
-    virtual int getMemDataStart() const = 0;
+    virtual uint32_t getMemDataStart() const = 0;
 
-    virtual int getPreInts() const = 0;
+    virtual uint8_t getPreInts() const = 0;
 
     target_hll_type getTgtHllType() const;
 
-    virtual int getUpdatableSerializationBytes() const = 0;
-    virtual int getCompactSerializationBytes() const = 0;
+    virtual uint32_t getUpdatableSerializationBytes() const = 0;
+    virtual uint32_t getCompactSerializationBytes() const = 0;
 
     virtual bool isCompact() const = 0;
     virtual bool isEmpty() const = 0;
     virtual bool isOutOfOrderFlag() const = 0;
     virtual void putOutOfOrderFlag(bool oooFlag) = 0;
+    virtual A getAllocator() const = 0;
     bool isStartFullSize() const;
 
   protected:
@@ -74,10 +75,10 @@ class HllSketchImpl {
     uint8_t makeFlagsByte(bool compact) const;
     uint8_t makeModeByte() const;
 
-    const int lgConfigK;
-    const target_hll_type tgtHllType;
-    const hll_mode mode;
-    const bool startFullSize;
+    const uint8_t lgConfigK_;
+    const target_hll_type tgtHllType_;
+    const hll_mode mode_;
+    const bool startFullSize_;
 };
 
 }