datasketches 0.2.0 → 0.2.4

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

@@ -30,12 +30,12 @@
 namespace datasketches {
 
 template<typename A>
-Hll4Array<A>::Hll4Array(const int lgConfigK, const bool startFullSize, const A& allocator):
+Hll4Array<A>::Hll4Array(uint8_t lgConfigK, bool startFullSize, const A& allocator):
 HllArray<A>(lgConfigK, target_hll_type::HLL_4, startFullSize, allocator),
-auxHashMap(nullptr)
+auxHashMap_(nullptr)
 {
-  const int numBytes = this->hll4ArrBytes(lgConfigK);
-  this->hllByteArr.resize(numBytes, 0);
+  const uint32_t numBytes = this->hll4ArrBytes(lgConfigK);
+  this->hllByteArr_.resize(numBytes, 0);
 }
 
 template<typename A>
@@ -44,18 +44,18 @@ Hll4Array<A>::Hll4Array(const Hll4Array<A>& that) :
 {
   // can determine hllByteArr size in parent class, no need to allocate here
   // but parent class doesn't handle the auxHashMap
-  if (that.auxHashMap != nullptr) {
-    auxHashMap = that.auxHashMap->copy();
+  if (that.auxHashMap_ != nullptr) {
+    auxHashMap_ = that.auxHashMap_->copy();
   } else {
-    auxHashMap = nullptr;
+    auxHashMap_ = nullptr;
   }
 }
 
 template<typename A>
 Hll4Array<A>::~Hll4Array() {
   // hllByteArr deleted in parent
-  if (auxHashMap != nullptr) {
-    AuxHashMap<A>::make_deleter()(auxHashMap);
+  if (auxHashMap_ != nullptr) {
+    AuxHashMap<A>::make_deleter()(auxHashMap_);
   }
 }
 
@@ -78,91 +78,91 @@ Hll4Array<A>* Hll4Array<A>::copy() const {
 }
 
 template<typename A>
-int Hll4Array<A>::getUpdatableSerializationBytes() const {
+uint32_t Hll4Array<A>::getUpdatableSerializationBytes() const {
   AuxHashMap<A>* auxHashMap = getAuxHashMap();
-  int auxBytes;
+  uint32_t auxBytes;
   if (auxHashMap == nullptr) {
-    auxBytes = 4 << HllUtil<A>::LG_AUX_ARR_INTS[this->lgConfigK];
+    auxBytes = 4 << hll_constants::LG_AUX_ARR_INTS[this->lgConfigK_];
   } else {
     auxBytes = 4 << auxHashMap->getLgAuxArrInts();
   }
-  return HllUtil<A>::HLL_BYTE_ARR_START + getHllByteArrBytes() + auxBytes;
+  return hll_constants::HLL_BYTE_ARR_START + getHllByteArrBytes() + auxBytes;
 }
 
 template<typename A>
-int Hll4Array<A>::getHllByteArrBytes() const {
-  return this->hll4ArrBytes(this->lgConfigK);
+uint32_t Hll4Array<A>::getHllByteArrBytes() const {
+  return this->hll4ArrBytes(this->lgConfigK_);
 }
 
 template<typename A>
 AuxHashMap<A>* Hll4Array<A>::getAuxHashMap() const {
-  return auxHashMap;
+  return auxHashMap_;
 }
 
 template<typename A>
 void Hll4Array<A>::putAuxHashMap(AuxHashMap<A>* auxHashMap) {
-  this->auxHashMap = auxHashMap;
+  this->auxHashMap_ = auxHashMap;
 }
 
 template<typename A>
-uint8_t Hll4Array<A>::getSlot(int slotNo) const {
-  const uint8_t byte = this->hllByteArr[slotNo >> 1];
+uint8_t Hll4Array<A>::getSlot(uint32_t slotNo) const {
+  const uint8_t byte = this->hllByteArr_[slotNo >> 1];
   if ((slotNo & 1) > 0) { // odd?
     return byte >> 4;
   }
-  return byte & HllUtil<A>::loNibbleMask;
+  return byte & hll_constants::loNibbleMask;
 }
 
 template<typename A>
 uint8_t Hll4Array<A>::get_value(uint32_t index) const {
   const uint8_t value = getSlot(index);
-  if (value != HllUtil<A>::AUX_TOKEN) return value + this->curMin;
-  return auxHashMap->mustFindValueFor(index);
+  if (value != hll_constants::AUX_TOKEN) return value + this->curMin_;
+  return auxHashMap_->mustFindValueFor(index);
 }
 
 template<typename A>
-HllSketchImpl<A>* Hll4Array<A>::couponUpdate(const int coupon) {
+HllSketchImpl<A>* Hll4Array<A>::couponUpdate(uint32_t coupon) {
   internalCouponUpdate(coupon);
   return this;
 }
 
 template<typename A>
-void Hll4Array<A>::internalCouponUpdate(const int coupon) {
-  const int newValue = HllUtil<A>::getValue(coupon);
-  if (newValue <= this->curMin) {
+void Hll4Array<A>::internalCouponUpdate(uint32_t coupon) {
+  const uint8_t newValue = HllUtil<A>::getValue(coupon);
+  if (newValue <= this->curMin_) {
     return; // quick rejection, but only works for large N
   }
-  const int configKmask = (1 << this->lgConfigK) - 1;
-  const int slotNo = HllUtil<A>::getLow26(coupon) & configKmask;
+  const uint32_t configKmask = (1 << this->lgConfigK_) - 1;
+  const uint32_t slotNo = HllUtil<A>::getLow26(coupon) & configKmask;
   internalHll4Update(slotNo, newValue);
 }
 
 template<typename A>
-void Hll4Array<A>::putSlot(int slotNo, uint8_t newValue) {
-  const int byteno = slotNo >> 1;
-  const uint8_t oldValue = this->hllByteArr[byteno];
+void Hll4Array<A>::putSlot(uint32_t slotNo, uint8_t newValue) {
+  const uint32_t byteno = slotNo >> 1;
+  const uint8_t oldValue = this->hllByteArr_[byteno];
   if ((slotNo & 1) == 0) { // set low nibble
-    this->hllByteArr[byteno]
-      = ((oldValue & HllUtil<A>::hiNibbleMask) | (newValue & HllUtil<A>::loNibbleMask));
+    this->hllByteArr_[byteno]
+      = ((oldValue & hll_constants::hiNibbleMask) | (newValue & hll_constants::loNibbleMask));
   } else { // set high nibble
-    this->hllByteArr[byteno]
-      = ((oldValue & HllUtil<A>::loNibbleMask) | ((newValue << 4) & HllUtil<A>::hiNibbleMask));
+    this->hllByteArr_[byteno]
+      = ((oldValue & hll_constants::loNibbleMask) | ((newValue << 4) & hll_constants::hiNibbleMask));
   }
 }
 
 //In C: two-registers.c Line 836 in "hhb_abstract_set_slot_if_new_value_bigger" non-sparse
 template<typename A>
-void Hll4Array<A>::internalHll4Update(const int slotNo, const int newVal) {
+void Hll4Array<A>::internalHll4Update(uint32_t slotNo, uint8_t newVal) {
 
-  const int rawStoredOldValue = getSlot(slotNo); // could be a 0
+  const uint8_t rawStoredOldValue = getSlot(slotNo); // could be a 0
   // this is provably a LB:
-  const int lbOnOldValue = rawStoredOldValue + this->curMin; // lower bound, could be 0
+  const uint8_t lbOnOldValue = rawStoredOldValue + this->curMin_; // lower bound, could be 0
 
   if (newVal > lbOnOldValue) { // 842
     // Note: if an AUX_TOKEN exists, then auxHashMap must already exist
     // 846: rawStoredOldValue == AUX_TOKEN
-    const int actualOldValue = (rawStoredOldValue < HllUtil<A>::AUX_TOKEN)
-       ? (lbOnOldValue) : (auxHashMap->mustFindValueFor(slotNo));
+    const uint8_t actualOldValue = (rawStoredOldValue < hll_constants::AUX_TOKEN)
+       ? (lbOnOldValue) : (auxHashMap_->mustFindValueFor(slotNo));
 
     if (newVal > actualOldValue) { // 848: actualOldValue could still be 0; newValue > 0
       // we know that the array will change, but we haven't actually updated yet
@@ -170,35 +170,36 @@ void Hll4Array<A>::internalHll4Update(const int slotNo, const int newVal) {
 
       // newVal >= curMin
 
-      const int shiftedNewValue = newVal - this->curMin; // 874
+      const uint8_t shiftedNewValue = newVal - this->curMin_; // 874
       // redundant since we know newVal >= curMin,
       // and lgConfigK bounds do not allow overflowing an int
       //assert(shiftedNewValue >= 0);
 
-      if (rawStoredOldValue == HllUtil<A>::AUX_TOKEN) { // 879
+      if (rawStoredOldValue == hll_constants::AUX_TOKEN) { // 879
         // Given that we have an AUX_TOKEN, there are 4 cases for how to
         // actually modify the data structure
 
-        if (shiftedNewValue >= HllUtil<A>::AUX_TOKEN) { // case 1: 881
+        if (shiftedNewValue >= hll_constants::AUX_TOKEN) { // case 1: 881
           // the byte array already contains aux token
           // This is the case where old and new values are both exceptions.
           // The 4-bit array already is AUX_TOKEN, only need to update auxHashMap
-          auxHashMap->mustReplace(slotNo, newVal);
+          auxHashMap_->mustReplace(slotNo, newVal);
         }
         else { // case 2: 885
           // This is the hypothetical case where the old value is an exception and the new one is not,
           // which is impossible given that curMin has not changed here and newVal > oldValue
         }
       } else { // rawStoredOldValue != AUX_TOKEN
-        if (shiftedNewValue >= HllUtil<A>::AUX_TOKEN) { // case 3: 892
+        if (shiftedNewValue >= hll_constants::AUX_TOKEN) { // case 3: 892
           // This is the case where the old value is not an exception and the new value is.
           // The AUX_TOKEN must be stored in the 4-bit array and the new value
           // added to the exception table
-          putSlot(slotNo, HllUtil<A>::AUX_TOKEN);
-          if (auxHashMap == nullptr) {
-            auxHashMap = AuxHashMap<A>::newAuxHashMap(HllUtil<A>::LG_AUX_ARR_INTS[this->lgConfigK], this->lgConfigK, this->getAllocator());
+          putSlot(slotNo, hll_constants::AUX_TOKEN);
+          if (auxHashMap_ == nullptr) {
+            auxHashMap_ = AuxHashMap<A>::newAuxHashMap(hll_constants::LG_AUX_ARR_INTS[this->lgConfigK_],
+                this->lgConfigK_, this->getAllocator());
           }
-          auxHashMap->mustAdd(slotNo, newVal);
+          auxHashMap_->mustAdd(slotNo, newVal);
         }
         else { // case 4: 897
           // This is the case where neither the old value nor the new value is an exception.
@@ -208,9 +209,9 @@ void Hll4Array<A>::internalHll4Update(const int slotNo, const int newVal) {
       }
 
       // we just increased a pair value, so it might be time to change curMin
-      if (actualOldValue == this->curMin) { // 908
+      if (actualOldValue == this->curMin_) { // 908
         this->decNumAtCurMin();
-        while (this->numAtCurMin == 0) {
+        while (this->numAtCurMin_ == 0) {
           shiftToBiggerCurMin(); // increases curMin by 1, builds a new aux table
           // shifts values in 4-bit table and recounts curMin
         }
@@ -227,29 +228,29 @@ void Hll4Array<A>::internalHll4Update(const int slotNo, const int newVal) {
 // In C: again-two-registers.c Lines 710 "hhb_shift_to_bigger_curmin"
 template<typename A>
 void Hll4Array<A>::shiftToBiggerCurMin() {
-  const int newCurMin = this->curMin + 1;
-  const int configK = 1 << this->lgConfigK;
-  const int configKmask = configK - 1;
+  const uint8_t newCurMin = this->curMin_ + 1;
+  const uint32_t configK = 1 << this->lgConfigK_;
+  const uint32_t configKmask = configK - 1;
 
-  int numAtNewCurMin = 0;
-  int numAuxTokens = 0;
+  uint32_t numAtNewCurMin = 0;
+  uint32_t numAuxTokens = 0;
 
   // Walk through the slots of 4-bit array decrementing stored values by one unless it
   // equals AUX_TOKEN, where it is left alone but counted to be checked later.
   // If oldStoredValue is 0 it is an error.
   // If the decremented value is 0, we increment numAtNewCurMin.
   // Because getNibble is masked to 4 bits oldStoredValue can never be > 15 or negative
-  for (int i = 0; i < configK; i++) { //724
-    int oldStoredValue = getSlot(i);
+  for (uint32_t i = 0; i < configK; i++) { //724
+    uint8_t oldStoredValue = getSlot(i);
     if (oldStoredValue == 0) {
       throw std::runtime_error("Array slots cannot be 0 at this point.");
     }
-    if (oldStoredValue < HllUtil<A>::AUX_TOKEN) {
+    if (oldStoredValue < hll_constants::AUX_TOKEN) {
       putSlot(i, --oldStoredValue);
       if (oldStoredValue == 0) { numAtNewCurMin++; }
     } else { //oldStoredValue == AUX_TOKEN
       numAuxTokens++;
-      if (auxHashMap == nullptr) {
+      if (auxHashMap_ == nullptr) {
         throw std::logic_error("auxHashMap cannot be null at this point");
       }
     }
@@ -258,12 +259,12 @@ void Hll4Array<A>::shiftToBiggerCurMin() {
   // If old AuxHashMap exists, walk through it updating some slots and build a new AuxHashMap
   // if needed.
   AuxHashMap<A>* newAuxMap = nullptr;
-  if (auxHashMap != nullptr) {
-    int slotNum;
-    int oldActualVal;
-    int newShiftedVal;
+  if (auxHashMap_ != nullptr) {
+    uint32_t slotNum;
+    uint8_t oldActualVal;
+    uint8_t newShiftedVal;
 
-    for (auto coupon: *auxHashMap) {
+    for (const auto coupon: *auxHashMap_) {
       slotNum = HllUtil<A>::getLow26(coupon) & configKmask;
       oldActualVal = HllUtil<A>::getValue(coupon);
       newShiftedVal = oldActualVal - newCurMin;
@@ -271,11 +272,11 @@ void Hll4Array<A>::shiftToBiggerCurMin() {
         throw std::logic_error("oldActualVal < newCurMin when incrementing curMin");
       }
 
-      if (getSlot(slotNum) != HllUtil<A>::AUX_TOKEN) {
+      if (getSlot(slotNum) != hll_constants::AUX_TOKEN) {
         throw std::logic_error("getSlot(slotNum) != AUX_TOKEN for item in auxiliary hash map");
       }
       // Array slot != AUX_TOKEN at getSlot(slotNum);
-      if (newShiftedVal < HllUtil<A>::AUX_TOKEN) { // 756
+      if (newShiftedVal < hll_constants::AUX_TOKEN) { // 756
         if (newShiftedVal != 14) {
           throw std::logic_error("newShiftedVal != 14 for item in old auxHashMap despite curMin increment");
         }
@@ -286,7 +287,8 @@ void Hll4Array<A>::shiftToBiggerCurMin() {
       } else { //newShiftedVal >= AUX_TOKEN
         // the former exception remains an exception, so must be added to the newAuxMap
         if (newAuxMap == nullptr) {
-          newAuxMap = AuxHashMap<A>::newAuxHashMap(HllUtil<A>::LG_AUX_ARR_INTS[this->lgConfigK], this->lgConfigK, this->getAllocator());
+          newAuxMap = AuxHashMap<A>::newAuxHashMap(hll_constants::LG_AUX_ARR_INTS[this->lgConfigK_],
+              this->lgConfigK_, this->getAllocator());
         }
         newAuxMap->mustAdd(slotNum, oldActualVal);
       }
@@ -305,28 +307,30 @@ void Hll4Array<A>::shiftToBiggerCurMin() {
     }
   }
 
-  if (auxHashMap != nullptr) {
-    AuxHashMap<A>::make_deleter()(auxHashMap);
+  if (auxHashMap_ != nullptr) {
+    AuxHashMap<A>::make_deleter()(auxHashMap_);
   }
-  auxHashMap = newAuxMap;
+  auxHashMap_ = newAuxMap;
 
-  this->curMin = newCurMin;
-  this->numAtCurMin = numAtNewCurMin;
+  this->curMin_ = newCurMin;
+  this->numAtCurMin_ = numAtNewCurMin;
 }
 
 template<typename A>
 typename HllArray<A>::const_iterator Hll4Array<A>::begin(bool all) const {
-  return typename HllArray<A>::const_iterator(this->hllByteArr.data(), 1 << this->lgConfigK, 0, this->tgtHllType, auxHashMap, this->curMin, all);
+  return typename HllArray<A>::const_iterator(this->hllByteArr_.data(), 1 << this->lgConfigK_, 0, this->tgtHllType_,
+      auxHashMap_, this->curMin_, all);
 }
 
 template<typename A>
 typename HllArray<A>::const_iterator Hll4Array<A>::end() const {
-  return typename HllArray<A>::const_iterator(this->hllByteArr.data(), 1 << this->lgConfigK, 1 << this->lgConfigK, this->tgtHllType, auxHashMap, this->curMin, false);
+  return typename HllArray<A>::const_iterator(this->hllByteArr_.data(), 1 << this->lgConfigK_, 1 << this->lgConfigK_,
+      this->tgtHllType_, auxHashMap_, this->curMin_, false);
 }
 
 template<typename A>
 void Hll4Array<A>::mergeHll(const HllArray<A>& src) {
-  for (auto coupon: src) {
+  for (const auto coupon: src) {
     internalCouponUpdate(coupon);
   }
 }

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

@@ -31,7 +31,7 @@ class Hll4Iterator;
 template<typename A>
 class Hll4Array final : public HllArray<A> {
   public:
-    explicit Hll4Array(int lgConfigK, bool startFullSize, const A& allocator);
+    explicit Hll4Array(uint8_t lgConfigK, bool startFullSize, const A& allocator);
     explicit Hll4Array(const Hll4Array<A>& that);
 
     virtual ~Hll4Array();
@@ -39,14 +39,14 @@ class Hll4Array final : public HllArray<A> {
 
     virtual Hll4Array* copy() const;
 
-    inline uint8_t getSlot(int slotNo) const;
-    inline void putSlot(int slotNo, uint8_t value);
+    inline uint8_t getSlot(uint32_t slotNo) const;
+    inline void putSlot(uint32_t slotNo, uint8_t value);
     inline uint8_t get_value(uint32_t index) const;
 
-    virtual int getUpdatableSerializationBytes() const;
-    virtual int getHllByteArrBytes() const;
+    virtual uint32_t getUpdatableSerializationBytes() const;
+    virtual uint32_t getHllByteArrBytes() const;
 
-    virtual HllSketchImpl<A>* couponUpdate(int coupon) final;
+    virtual HllSketchImpl<A>* couponUpdate(uint32_t coupon) final;
     void mergeHll(const HllArray<A>& src);
 
     virtual AuxHashMap<A>* getAuxHashMap() const;
@@ -57,11 +57,11 @@ class Hll4Array final : public HllArray<A> {
     virtual typename HllArray<A>::const_iterator end() const;
 
   private:
-    void internalCouponUpdate(int coupon);
-    void internalHll4Update(int slotNo, int newVal);
+    void internalCouponUpdate(uint32_t coupon);
+    void internalHll4Update(uint32_t slotNo, uint8_t newVal);
     void shiftToBiggerCurMin();
 
-    AuxHashMap<A>* auxHashMap;
+    AuxHashMap<A>* auxHashMap_;
 };
 
 }

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

@@ -27,11 +27,11 @@
 namespace datasketches {
 
 template<typename A>
-Hll6Array<A>::Hll6Array(const int lgConfigK, const bool startFullSize, const A& allocator):
+Hll6Array<A>::Hll6Array(uint8_t lgConfigK, bool startFullSize, const A& allocator):
 HllArray<A>(lgConfigK, target_hll_type::HLL_6, startFullSize, allocator)
 {
   const int numBytes = this->hll6ArrBytes(lgConfigK);
-  this->hllByteArr.resize(numBytes, 0);
+  this->hllByteArr_.resize(numBytes, 0);
 }
 
 template<typename A>
@@ -53,57 +53,57 @@ Hll6Array<A>* Hll6Array<A>::copy() const {
 }
 
 template<typename A>
-uint8_t Hll6Array<A>::getSlot(int slotNo) const {
-  const int startBit = slotNo * 6;
-  const int shift = startBit & 0x7;
-  const int byteIdx = startBit >> 3;  
-  const uint16_t twoByteVal = (this->hllByteArr[byteIdx + 1] << 8) | this->hllByteArr[byteIdx];
-  return (twoByteVal >> shift) & HllUtil<A>::VAL_MASK_6;
+uint8_t Hll6Array<A>::getSlot(uint32_t slotNo) const {
+  const uint32_t startBit = slotNo * 6;
+  const uint32_t shift = startBit & 0x7;
+  const uint32_t byteIdx = startBit >> 3;  
+  const uint16_t twoByteVal = (this->hllByteArr_[byteIdx + 1] << 8) | this->hllByteArr_[byteIdx];
+  return (twoByteVal >> shift) & hll_constants::VAL_MASK_6;
 }
 
 template<typename A>
-void Hll6Array<A>::putSlot(int slotNo, uint8_t value) {
-  const int startBit = slotNo * 6;
-  const int shift = startBit & 0x7;
-  const int byteIdx = startBit >> 3;
+void Hll6Array<A>::putSlot(uint32_t slotNo, uint8_t value) {
+  const uint32_t startBit = slotNo * 6;
+  const uint32_t shift = startBit & 0x7;
+  const uint32_t byteIdx = startBit >> 3;
   const uint16_t valShifted = (value & 0x3F) << shift;
-  uint16_t curMasked = (this->hllByteArr[byteIdx + 1] << 8) | this->hllByteArr[byteIdx];
-  curMasked &= (~(HllUtil<A>::VAL_MASK_6 << shift));
+  uint16_t curMasked = (this->hllByteArr_[byteIdx + 1] << 8) | this->hllByteArr_[byteIdx];
+  curMasked &= (~(hll_constants::VAL_MASK_6 << shift));
   const uint16_t insert = curMasked | valShifted;
-  this->hllByteArr[byteIdx]     = insert & 0xFF;
-  this->hllByteArr[byteIdx + 1] = (insert & 0xFF00) >> 8;
+  this->hllByteArr_[byteIdx]     = insert & 0xFF;
+  this->hllByteArr_[byteIdx + 1] = (insert & 0xFF00) >> 8;
 }
 
 template<typename A>
-int Hll6Array<A>::getHllByteArrBytes() const {
-  return this->hll6ArrBytes(this->lgConfigK);
+uint32_t Hll6Array<A>::getHllByteArrBytes() const {
+  return this->hll6ArrBytes(this->lgConfigK_);
 }
 
 template<typename A>
-HllSketchImpl<A>* Hll6Array<A>::couponUpdate(const int coupon) {
+HllSketchImpl<A>* Hll6Array<A>::couponUpdate(uint32_t coupon) {
   internalCouponUpdate(coupon);
   return this;
 }
 
 template<typename A>
-void Hll6Array<A>::internalCouponUpdate(const int coupon) {
-  const int configKmask = (1 << this->lgConfigK) - 1;
-  const int slotNo = HllUtil<A>::getLow26(coupon) & configKmask;
-  const int newVal = HllUtil<A>::getValue(coupon);
+void Hll6Array<A>::internalCouponUpdate(uint32_t coupon) {
+  const uint32_t configKmask = (1 << this->lgConfigK_) - 1;
+  const uint32_t slotNo = HllUtil<A>::getLow26(coupon) & configKmask;
+  const uint8_t newVal = HllUtil<A>::getValue(coupon);
 
-  const int curVal = getSlot(slotNo);
+  const uint8_t curVal = getSlot(slotNo);
   if (newVal > curVal) {
     putSlot(slotNo, newVal);
     this->hipAndKxQIncrementalUpdate(curVal, newVal);
     if (curVal == 0) {
-      this->numAtCurMin--; // interpret numAtCurMin as num zeros
+      this->numAtCurMin_--; // interpret numAtCurMin as num zeros
     }
   }
 }
 
 template<typename A>
 void Hll6Array<A>::mergeHll(const HllArray<A>& src) {
-  for (auto coupon: src) {
+  for (const auto coupon: src) {
     internalCouponUpdate(coupon);
   }
 }

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

@@ -30,23 +30,23 @@ class Hll6Iterator;
 template<typename A>
 class Hll6Array final : public HllArray<A> {
   public:
-    Hll6Array(int lgConfigK, bool startFullSize, const A& allocator);
+    Hll6Array(uint8_t lgConfigK, bool startFullSize, const A& allocator);
 
     virtual ~Hll6Array() = default;
     virtual std::function<void(HllSketchImpl<A>*)> get_deleter() const;
 
     virtual Hll6Array* copy() const;
 
-    inline uint8_t getSlot(int slotNo) const;
-    inline void putSlot(int slotNo, uint8_t value);
+    inline uint8_t getSlot(uint32_t slotNo) const;
+    inline void putSlot(uint32_t slotNo, uint8_t value);
 
-    virtual HllSketchImpl<A>* couponUpdate(int coupon) final;
+    virtual HllSketchImpl<A>* couponUpdate(uint32_t coupon) final;
     void mergeHll(const HllArray<A>& src);
 
-    virtual int getHllByteArrBytes() const;
+    virtual uint32_t getHllByteArrBytes() const;
 
   private:
-    void internalCouponUpdate(int coupon);
+    void internalCouponUpdate(uint32_t coupon);
 };
 
 }

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

@@ -25,11 +25,11 @@
 namespace datasketches {
 
 template<typename A>
-Hll8Array<A>::Hll8Array(const int lgConfigK, const bool startFullSize, const A& allocator):
+Hll8Array<A>::Hll8Array(uint8_t lgConfigK, bool startFullSize, const A& allocator):
 HllArray<A>(lgConfigK, target_hll_type::HLL_8, startFullSize, allocator)
 {
   const int numBytes = this->hll8ArrBytes(lgConfigK);
-  this->hllByteArr.resize(numBytes, 0);
+  this->hllByteArr_.resize(numBytes, 0);
 }
 
 template<typename A>
@@ -51,45 +51,45 @@ Hll8Array<A>* Hll8Array<A>::copy() const {
 }
 
 template<typename A>
-uint8_t Hll8Array<A>::getSlot(const int slotNo) const {
-  return this->hllByteArr[slotNo];
+uint8_t Hll8Array<A>::getSlot(uint32_t slotNo) const {
+  return this->hllByteArr_[slotNo];
 }
 
 template<typename A>
-void Hll8Array<A>::putSlot(const int slotNo, uint8_t value) {
-  this->hllByteArr[slotNo] = value;
+void Hll8Array<A>::putSlot(uint32_t slotNo, uint8_t value) {
+  this->hllByteArr_[slotNo] = value;
 }
 
 template<typename A>
-int Hll8Array<A>::getHllByteArrBytes() const {
-  return this->hll8ArrBytes(this->lgConfigK);
+uint32_t Hll8Array<A>::getHllByteArrBytes() const {
+  return this->hll8ArrBytes(this->lgConfigK_);
 }
 
 template<typename A>
-HllSketchImpl<A>* Hll8Array<A>::couponUpdate(int coupon) {
+HllSketchImpl<A>* Hll8Array<A>::couponUpdate(uint32_t coupon) {
   internalCouponUpdate(coupon);
   return this;
 }
 
 template<typename A>
-void Hll8Array<A>::internalCouponUpdate(int coupon) {
-  const int configKmask = (1 << this->lgConfigK) - 1;
-  const int slotNo = HllUtil<A>::getLow26(coupon) & configKmask;
-  const int newVal = HllUtil<A>::getValue(coupon);
+void Hll8Array<A>::internalCouponUpdate(uint32_t coupon) {
+  const uint32_t configKmask = (1 << this->lgConfigK_) - 1;
+  const uint32_t slotNo = HllUtil<A>::getLow26(coupon) & configKmask;
+  const uint8_t newVal = HllUtil<A>::getValue(coupon);
 
-  const int curVal = getSlot(slotNo);
+  const uint8_t curVal = getSlot(slotNo);
   if (newVal > curVal) {
     putSlot(slotNo, newVal);
     this->hipAndKxQIncrementalUpdate(curVal, newVal);
     if (curVal == 0) {
-      this->numAtCurMin--; // interpret numAtCurMin as num zeros
+      this->numAtCurMin_--; // interpret numAtCurMin as num zeros
     }
   }
 }
 
 template<typename A>
 void Hll8Array<A>::mergeList(const CouponList<A>& src) {
-  for (auto coupon: src) {
+  for (const auto coupon: src) {
     internalCouponUpdate(coupon);
   }
 }
@@ -97,45 +97,45 @@ void Hll8Array<A>::mergeList(const CouponList<A>& src) {
 template<typename A>
 void Hll8Array<A>::mergeHll(const HllArray<A>& src) {
   // at this point src_k >= dst_k
-  const int src_k = 1 << src.getLgConfigK();
-  const  int dst_mask = (1 << this->getLgConfigK()) - 1;
+  const uint32_t src_k = 1 << src.getLgConfigK();
+  const uint32_t dst_mask = (1 << this->getLgConfigK()) - 1;
   // duplication below is to avoid a virtual method call in a loop
   if (src.getTgtHllType() == target_hll_type::HLL_8) {
-    for (int i = 0; i < src_k; i++) {
+    for (uint32_t i = 0; i < src_k; i++) {
       const uint8_t new_v = static_cast<const Hll8Array<A>&>(src).getSlot(i);
-      const int j = i & dst_mask;
-      const uint8_t old_v = this->hllByteArr[j];
+      const uint32_t j = i & dst_mask;
+      const uint8_t old_v = this->hllByteArr_[j];
       if (new_v > old_v) {
-        this->hllByteArr[j] = new_v;
+        this->hllByteArr_[j] = new_v;
         this->hipAndKxQIncrementalUpdate(old_v, new_v);
         if (old_v == 0) {
-          this->numAtCurMin--;
+          this->numAtCurMin_--;
         }
       }
     }
   } else if (src.getTgtHllType() == target_hll_type::HLL_6) {
-    for (int i = 0; i < src_k; i++) {
+    for (uint32_t i = 0; i < src_k; i++) {
       const uint8_t new_v = static_cast<const Hll6Array<A>&>(src).getSlot(i);
-      const int j = i & dst_mask;
-      const uint8_t old_v = this->hllByteArr[j];
+      const uint32_t j = i & dst_mask;
+      const uint8_t old_v = this->hllByteArr_[j];
       if (new_v > old_v) {
-        this->hllByteArr[j] = new_v;
+        this->hllByteArr_[j] = new_v;
         this->hipAndKxQIncrementalUpdate(old_v, new_v);
         if (old_v == 0) {
-          this->numAtCurMin--;
+          this->numAtCurMin_--;
         }
       }
     }
   } else { // HLL_4
-    for (int i = 0; i < src_k; i++) {
+    for (uint32_t i = 0; i < src_k; i++) {
       const uint8_t new_v = static_cast<const Hll4Array<A>&>(src).get_value(i);
-      const int j = i & dst_mask;
-      const uint8_t old_v = this->hllByteArr[j];
+      const uint32_t j = i & dst_mask;
+      const uint8_t old_v = this->hllByteArr_[j];
       if (new_v > old_v) {
-        this->hllByteArr[j] = new_v;
+        this->hllByteArr_[j] = new_v;
         this->hipAndKxQIncrementalUpdate(old_v, new_v);
         if (old_v == 0) {
-          this->numAtCurMin--;
+          this->numAtCurMin_--;
         }
       }
     }