datasketches 0.2.0 → 0.2.4

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

@@ -35,19 +35,19 @@
 namespace datasketches {
 
 template<typename A>
-HllArray<A>::HllArray(const int lgConfigK, const target_hll_type tgtHllType, bool startFullSize, const A& allocator):
+HllArray<A>::HllArray(uint8_t lgConfigK, target_hll_type tgtHllType, bool startFullSize, const A& allocator):
 HllSketchImpl<A>(lgConfigK, tgtHllType, hll_mode::HLL, startFullSize),
-hipAccum(0.0),
-kxq0(1 << lgConfigK),
-kxq1(0.0),
-hllByteArr(allocator),
-curMin(0),
-numAtCurMin(1 << lgConfigK),
-oooFlag(false)
+hipAccum_(0.0),
+kxq0_(1 << lgConfigK),
+kxq1_(0.0),
+hllByteArr_(allocator),
+curMin_(0),
+numAtCurMin_(1 << lgConfigK),
+oooFlag_(false)
 {}
 
 template<typename A>
-HllArray<A>* HllArray<A>::copyAs(const target_hll_type tgtHllType) const {
+HllArray<A>* HllArray<A>::copyAs(target_hll_type tgtHllType) const {
   if (tgtHllType == this->getTgtHllType()) {
     return static_cast<HllArray*>(copy());
   }
@@ -62,54 +62,54 @@ HllArray<A>* HllArray<A>::copyAs(const target_hll_type tgtHllType) const {
 
 template<typename A>
 HllArray<A>* HllArray<A>::newHll(const void* bytes, size_t len, const A& allocator) {
-  if (len < HllUtil<A>::HLL_BYTE_ARR_START) {
+  if (len < hll_constants::HLL_BYTE_ARR_START) {
     throw std::out_of_range("Input data length insufficient to hold HLL array");
   }
 
   const uint8_t* data = static_cast<const uint8_t*>(bytes);
-  if (data[HllUtil<A>::PREAMBLE_INTS_BYTE] != HllUtil<A>::HLL_PREINTS) {
+  if (data[hll_constants::PREAMBLE_INTS_BYTE] != hll_constants::HLL_PREINTS) {
     throw std::invalid_argument("Incorrect number of preInts in input stream");
   }
-  if (data[HllUtil<A>::SER_VER_BYTE] != HllUtil<A>::SER_VER) {
+  if (data[hll_constants::SER_VER_BYTE] != hll_constants::SER_VER) {
     throw std::invalid_argument("Wrong ser ver in input stream");
   }
-  if (data[HllUtil<A>::FAMILY_BYTE] != HllUtil<A>::FAMILY_ID) {
+  if (data[hll_constants::FAMILY_BYTE] != hll_constants::FAMILY_ID) {
     throw std::invalid_argument("Input array is not an HLL sketch");
   }
 
-  const hll_mode mode = HllSketchImpl<A>::extractCurMode(data[HllUtil<A>::MODE_BYTE]);
+  const hll_mode mode = HllSketchImpl<A>::extractCurMode(data[hll_constants::MODE_BYTE]);
   if (mode != HLL) {
-    throw std::invalid_argument("Calling HLL array construtor with non-HLL mode data");
+    throw std::invalid_argument("Calling HLL array constructor with non-HLL mode data");
   }
 
-  const target_hll_type tgtHllType = HllSketchImpl<A>::extractTgtHllType(data[HllUtil<A>::MODE_BYTE]);
-  const bool oooFlag = ((data[HllUtil<A>::FLAGS_BYTE] & HllUtil<A>::OUT_OF_ORDER_FLAG_MASK) ? true : false);
-  const bool comapctFlag = ((data[HllUtil<A>::FLAGS_BYTE] & HllUtil<A>::COMPACT_FLAG_MASK) ? true : false);
-  const bool startFullSizeFlag = ((data[HllUtil<A>::FLAGS_BYTE] & HllUtil<A>::FULL_SIZE_FLAG_MASK) ? true : false);
+  const target_hll_type tgtHllType = HllSketchImpl<A>::extractTgtHllType(data[hll_constants::MODE_BYTE]);
+  const bool oooFlag = ((data[hll_constants::FLAGS_BYTE] & hll_constants::OUT_OF_ORDER_FLAG_MASK) ? true : false);
+  const bool comapctFlag = ((data[hll_constants::FLAGS_BYTE] & hll_constants::COMPACT_FLAG_MASK) ? true : false);
+  const bool startFullSizeFlag = ((data[hll_constants::FLAGS_BYTE] & hll_constants::FULL_SIZE_FLAG_MASK) ? true : false);
 
-  const int lgK = (int) data[HllUtil<A>::LG_K_BYTE];
-  const int curMin = (int) data[HllUtil<A>::HLL_CUR_MIN_BYTE];
+  const uint8_t lgK = data[hll_constants::LG_K_BYTE];
+  const uint8_t curMin = data[hll_constants::HLL_CUR_MIN_BYTE];
 
-  const int arrayBytes = hllArrBytes(tgtHllType, lgK);
-  if (len < static_cast<size_t>(HllUtil<A>::HLL_BYTE_ARR_START + arrayBytes)) {
+  const uint32_t arrayBytes = hllArrBytes(tgtHllType, lgK);
+  if (len < static_cast<size_t>(hll_constants::HLL_BYTE_ARR_START + arrayBytes)) {
     throw std::out_of_range("Input array too small to hold sketch image");
   }
 
   double hip, kxq0, kxq1;
-  std::memcpy(&hip, data + HllUtil<A>::HIP_ACCUM_DOUBLE, sizeof(double));
-  std::memcpy(&kxq0, data + HllUtil<A>::KXQ0_DOUBLE, sizeof(double));
-  std::memcpy(&kxq1, data + HllUtil<A>::KXQ1_DOUBLE, sizeof(double));
+  std::memcpy(&hip, data + hll_constants::HIP_ACCUM_DOUBLE, sizeof(double));
+  std::memcpy(&kxq0, data + hll_constants::KXQ0_DOUBLE, sizeof(double));
+  std::memcpy(&kxq1, data + hll_constants::KXQ1_DOUBLE, sizeof(double));
 
-  int numAtCurMin, auxCount;
-  std::memcpy(&numAtCurMin, data + HllUtil<A>::CUR_MIN_COUNT_INT, sizeof(int));
-  std::memcpy(&auxCount, data + HllUtil<A>::AUX_COUNT_INT, sizeof(int));
+  uint32_t numAtCurMin, auxCount;
+  std::memcpy(&numAtCurMin, data + hll_constants::CUR_MIN_COUNT_INT, sizeof(int));
+  std::memcpy(&auxCount, data + hll_constants::AUX_COUNT_INT, sizeof(int));
 
   AuxHashMap<A>* auxHashMap = nullptr;
   typedef std::unique_ptr<AuxHashMap<A>, std::function<void(AuxHashMap<A>*)>> aux_hash_map_ptr;
   aux_hash_map_ptr aux_ptr;
   if (auxCount > 0) { // necessarily TgtHllType == HLL_4
-    int auxLgIntArrSize = (int) data[4];
-    const size_t offset = HllUtil<A>::HLL_BYTE_ARR_START + arrayBytes;
+    uint8_t auxLgIntArrSize = data[4];
+    const size_t offset = hll_constants::HLL_BYTE_ARR_START + arrayBytes;
     const uint8_t* auxDataStart = data + offset;
     auxHashMap = AuxHashMap<A>::deserialize(auxDataStart, len - offset, lgK, auxCount, auxLgIntArrSize, comapctFlag, allocator);
     aux_ptr = aux_hash_map_ptr(auxHashMap, auxHashMap->make_deleter());
@@ -123,7 +123,7 @@ HllArray<A>* HllArray<A>::newHll(const void* bytes, size_t len, const A& allocat
   sketch->putKxQ1(kxq1);
   sketch->putNumAtCurMin(numAtCurMin);
 
-  std::memcpy(sketch->hllByteArr.data(), data + HllUtil<A>::HLL_BYTE_ARR_START, arrayBytes);
+  std::memcpy(sketch->hllByteArr_.data(), data + hll_constants::HLL_BYTE_ARR_START, arrayBytes);
 
   if (auxHashMap != nullptr)
     ((Hll4Array<A>*)sketch)->putAuxHashMap(auxHashMap);
@@ -135,30 +135,30 @@ HllArray<A>* HllArray<A>::newHll(const void* bytes, size_t len, const A& allocat
 template<typename A>
 HllArray<A>* HllArray<A>::newHll(std::istream& is, const A& allocator) {
   uint8_t listHeader[8];
-  is.read((char*)listHeader, 8 * sizeof(uint8_t));
+  read(is, listHeader, 8 * sizeof(uint8_t));
 
-  if (listHeader[HllUtil<A>::PREAMBLE_INTS_BYTE] != HllUtil<A>::HLL_PREINTS) {
+  if (listHeader[hll_constants::PREAMBLE_INTS_BYTE] != hll_constants::HLL_PREINTS) {
     throw std::invalid_argument("Incorrect number of preInts in input stream");
   }
-  if (listHeader[HllUtil<A>::SER_VER_BYTE] != HllUtil<A>::SER_VER) {
+  if (listHeader[hll_constants::SER_VER_BYTE] != hll_constants::SER_VER) {
     throw std::invalid_argument("Wrong ser ver in input stream");
   }
-  if (listHeader[HllUtil<A>::FAMILY_BYTE] != HllUtil<A>::FAMILY_ID) {
+  if (listHeader[hll_constants::FAMILY_BYTE] != hll_constants::FAMILY_ID) {
     throw std::invalid_argument("Input stream is not an HLL sketch");
   }
 
-  hll_mode mode = HllSketchImpl<A>::extractCurMode(listHeader[HllUtil<A>::MODE_BYTE]);
+  hll_mode mode = HllSketchImpl<A>::extractCurMode(listHeader[hll_constants::MODE_BYTE]);
   if (mode != HLL) {
     throw std::invalid_argument("Calling HLL construtor with non-HLL mode data");
   }
 
-  const target_hll_type tgtHllType = HllSketchImpl<A>::extractTgtHllType(listHeader[HllUtil<A>::MODE_BYTE]);
-  const bool oooFlag = ((listHeader[HllUtil<A>::FLAGS_BYTE] & HllUtil<A>::OUT_OF_ORDER_FLAG_MASK) ? true : false);
-  const bool comapctFlag = ((listHeader[HllUtil<A>::FLAGS_BYTE] & HllUtil<A>::COMPACT_FLAG_MASK) ? true : false);
-  const bool startFullSizeFlag = ((listHeader[HllUtil<A>::FLAGS_BYTE] & HllUtil<A>::FULL_SIZE_FLAG_MASK) ? true : false);
+  const target_hll_type tgtHllType = HllSketchImpl<A>::extractTgtHllType(listHeader[hll_constants::MODE_BYTE]);
+  const bool oooFlag = ((listHeader[hll_constants::FLAGS_BYTE] & hll_constants::OUT_OF_ORDER_FLAG_MASK) ? true : false);
+  const bool comapctFlag = ((listHeader[hll_constants::FLAGS_BYTE] & hll_constants::COMPACT_FLAG_MASK) ? true : false);
+  const bool startFullSizeFlag = ((listHeader[hll_constants::FLAGS_BYTE] & hll_constants::FULL_SIZE_FLAG_MASK) ? true : false);
 
-  const int lgK = (int) listHeader[HllUtil<A>::LG_K_BYTE];
-  const int curMin = (int) listHeader[HllUtil<A>::HLL_CUR_MIN_BYTE];
+  const uint8_t lgK = listHeader[hll_constants::LG_K_BYTE];
+  const uint8_t curMin = listHeader[hll_constants::HLL_CUR_MIN_BYTE];
 
   HllArray* sketch = HllSketchImplFactory<A>::newHll(lgK, tgtHllType, startFullSizeFlag, allocator);
   typedef std::unique_ptr<HllArray<A>, std::function<void(HllSketchImpl<A>*)>> hll_array_ptr;
@@ -166,23 +166,21 @@ HllArray<A>* HllArray<A>::newHll(std::istream& is, const A& allocator) {
   sketch->putCurMin(curMin);
   sketch->putOutOfOrderFlag(oooFlag);
 
-  double hip, kxq0, kxq1;
-  is.read((char*)&hip, sizeof(hip));
-  is.read((char*)&kxq0, sizeof(kxq0));
-  is.read((char*)&kxq1, sizeof(kxq1));
+  const auto hip = read<double>(is);
+  const auto kxq0 = read<double>(is);
+  const auto kxq1 = read<double>(is);
   if (!oooFlag) sketch->putHipAccum(hip);
   sketch->putKxQ0(kxq0);
   sketch->putKxQ1(kxq1);
 
-  int numAtCurMin, auxCount;
-  is.read((char*)&numAtCurMin, sizeof(numAtCurMin));
-  is.read((char*)&auxCount, sizeof(auxCount));
+  const auto numAtCurMin = read<uint32_t>(is);
+  const auto auxCount = read<uint32_t>(is);
   sketch->putNumAtCurMin(numAtCurMin);
   
-  is.read((char*)sketch->hllByteArr.data(), sketch->getHllByteArrBytes());
+  read(is, sketch->hllByteArr_.data(), sketch->getHllByteArrBytes());
   
   if (auxCount > 0) { // necessarily TgtHllType == HLL_4
-    int auxLgIntArrSize = listHeader[4];
+    uint8_t auxLgIntArrSize = listHeader[4];
     AuxHashMap<A>* auxHashMap = AuxHashMap<A>::deserialize(is, lgK, auxCount, auxLgIntArrSize, comapctFlag, allocator);
     ((Hll4Array<A>*)sketch)->putAuxHashMap(auxHashMap);
   }
@@ -200,31 +198,31 @@ vector_u8<A> HllArray<A>::serialize(bool compact, unsigned header_size_bytes) co
   uint8_t* bytes = byteArr.data() + header_size_bytes;
   AuxHashMap<A>* auxHashMap = getAuxHashMap();
 
-  bytes[HllUtil<A>::PREAMBLE_INTS_BYTE] = static_cast<uint8_t>(getPreInts());
-  bytes[HllUtil<A>::SER_VER_BYTE] = static_cast<uint8_t>(HllUtil<A>::SER_VER);
-  bytes[HllUtil<A>::FAMILY_BYTE] = static_cast<uint8_t>(HllUtil<A>::FAMILY_ID);
-  bytes[HllUtil<A>::LG_K_BYTE] = static_cast<uint8_t>(this->lgConfigK);
-  bytes[HllUtil<A>::LG_ARR_BYTE] = static_cast<uint8_t>(auxHashMap == nullptr ? 0 : auxHashMap->getLgAuxArrInts());
-  bytes[HllUtil<A>::FLAGS_BYTE] = this->makeFlagsByte(compact);
-  bytes[HllUtil<A>::HLL_CUR_MIN_BYTE] = static_cast<uint8_t>(curMin);
-  bytes[HllUtil<A>::MODE_BYTE] = this->makeModeByte();
-
-  std::memcpy(bytes + HllUtil<A>::HIP_ACCUM_DOUBLE, &hipAccum, sizeof(double));
-  std::memcpy(bytes + HllUtil<A>::KXQ0_DOUBLE, &kxq0, sizeof(double));
-  std::memcpy(bytes + HllUtil<A>::KXQ1_DOUBLE, &kxq1, sizeof(double));
-  std::memcpy(bytes + HllUtil<A>::CUR_MIN_COUNT_INT, &numAtCurMin, sizeof(int));
-  const int auxCount = (auxHashMap == nullptr ? 0 : auxHashMap->getAuxCount());
-  std::memcpy(bytes + HllUtil<A>::AUX_COUNT_INT, &auxCount, sizeof(int));
-
-  const int hllByteArrBytes = getHllByteArrBytes();
-  std::memcpy(bytes + getMemDataStart(), hllByteArr.data(), hllByteArrBytes);
+  bytes[hll_constants::PREAMBLE_INTS_BYTE] = static_cast<uint8_t>(getPreInts());
+  bytes[hll_constants::SER_VER_BYTE] = static_cast<uint8_t>(hll_constants::SER_VER);
+  bytes[hll_constants::FAMILY_BYTE] = static_cast<uint8_t>(hll_constants::FAMILY_ID);
+  bytes[hll_constants::LG_K_BYTE] = static_cast<uint8_t>(this->lgConfigK_);
+  bytes[hll_constants::LG_ARR_BYTE] = static_cast<uint8_t>(auxHashMap == nullptr ? 0 : auxHashMap->getLgAuxArrInts());
+  bytes[hll_constants::FLAGS_BYTE] = this->makeFlagsByte(compact);
+  bytes[hll_constants::HLL_CUR_MIN_BYTE] = static_cast<uint8_t>(curMin_);
+  bytes[hll_constants::MODE_BYTE] = this->makeModeByte();
+
+  std::memcpy(bytes + hll_constants::HIP_ACCUM_DOUBLE, &hipAccum_, sizeof(double));
+  std::memcpy(bytes + hll_constants::KXQ0_DOUBLE, &kxq0_, sizeof(double));
+  std::memcpy(bytes + hll_constants::KXQ1_DOUBLE, &kxq1_, sizeof(double));
+  std::memcpy(bytes + hll_constants::CUR_MIN_COUNT_INT, &numAtCurMin_, sizeof(uint32_t));
+  const uint32_t auxCount = (auxHashMap == nullptr ? 0 : auxHashMap->getAuxCount());
+  std::memcpy(bytes + hll_constants::AUX_COUNT_INT, &auxCount, sizeof(uint32_t));
+
+  const uint32_t hllByteArrBytes = getHllByteArrBytes();
+  std::memcpy(bytes + getMemDataStart(), hllByteArr_.data(), hllByteArrBytes);
 
   // aux map if HLL_4
-  if (this->tgtHllType == HLL_4) {
+  if (this->tgtHllType_ == HLL_4) {
     bytes += getMemDataStart() + hllByteArrBytes; // start of auxHashMap
     if (auxHashMap != nullptr) {
       if (compact) {
-        for (uint32_t coupon: *auxHashMap) {
+        for (const uint32_t coupon: *auxHashMap) {
           std::memcpy(bytes, &coupon, sizeof(coupon));
           bytes += sizeof(coupon);
         }
@@ -233,8 +231,8 @@ vector_u8<A> HllArray<A>::serialize(bool compact, unsigned header_size_bytes) co
       }
     } else if (!compact) {
       // if updatable, we write even if currently unused so the binary can be wrapped
-      int auxBytes = 4 << HllUtil<A>::LG_AUX_ARR_INTS[this->lgConfigK];
-      std::fill_n(bytes, auxBytes, 0);
+      uint32_t auxBytes = 4 << hll_constants::LG_AUX_ARR_INTS[this->lgConfigK_];
+      std::fill_n(bytes, auxBytes, static_cast<uint8_t>(0));
     }
   }
 
@@ -242,64 +240,63 @@ vector_u8<A> HllArray<A>::serialize(bool compact, unsigned header_size_bytes) co
 }
 
 template<typename A>
-void HllArray<A>::serialize(std::ostream& os, const bool compact) const {
+void HllArray<A>::serialize(std::ostream& os, bool compact) const {
   // header
-  const uint8_t preInts(getPreInts());
-  os.write((char*)&preInts, sizeof(preInts));
-  const uint8_t serialVersion(HllUtil<A>::SER_VER);
-  os.write((char*)&serialVersion, sizeof(serialVersion));
-  const uint8_t familyId(HllUtil<A>::FAMILY_ID);
-  os.write((char*)&familyId, sizeof(familyId));
-  const uint8_t lgKByte((uint8_t) this->lgConfigK);
-  os.write((char*)&lgKByte, sizeof(lgKByte));
+  const uint8_t preInts = getPreInts();
+  write(os, preInts);
+  const uint8_t serialVersion = hll_constants::SER_VER;
+  write(os, serialVersion);
+  const uint8_t familyId = hll_constants::FAMILY_ID;
+  write(os, familyId);
+  const uint8_t lgKByte = this->lgConfigK_;
+  write(os, lgKByte);
 
   AuxHashMap<A>* auxHashMap = getAuxHashMap();
-  uint8_t lgArrByte(0);
+  uint8_t lgArrByte = 0;
   if (auxHashMap != nullptr) {
     lgArrByte = auxHashMap->getLgAuxArrInts();
   }
-  os.write((char*)&lgArrByte, sizeof(lgArrByte));
+  write(os, lgArrByte);
 
-  const uint8_t flagsByte(this->makeFlagsByte(compact));
-  os.write((char*)&flagsByte, sizeof(flagsByte));
-  const uint8_t curMinByte((uint8_t) curMin);
-  os.write((char*)&curMinByte, sizeof(curMinByte));
-  const uint8_t modeByte(this->makeModeByte());
-  os.write((char*)&modeByte, sizeof(modeByte));
+  const uint8_t flagsByte = this->makeFlagsByte(compact);
+  write(os, flagsByte);
+  write(os, curMin_);
+  const uint8_t modeByte = this->makeModeByte();
+  write(os, modeByte);
 
   // estimator data
-  os.write((char*)&hipAccum, sizeof(hipAccum));
-  os.write((char*)&kxq0, sizeof(kxq0));
-  os.write((char*)&kxq1, sizeof(kxq1));
+  write(os, hipAccum_);
+  write(os, kxq0_);
+  write(os, kxq1_);
 
   // array data
-  os.write((char*)&numAtCurMin, sizeof(numAtCurMin));
+  write(os, numAtCurMin_);
 
-  const int auxCount = (auxHashMap == nullptr ? 0 : auxHashMap->getAuxCount());
-  os.write((char*)&auxCount, sizeof(auxCount));
-  os.write((char*)hllByteArr.data(), getHllByteArrBytes());
+  const uint32_t auxCount = (auxHashMap == nullptr ? 0 : auxHashMap->getAuxCount());
+  write(os, auxCount);
+  write(os, hllByteArr_.data(), getHllByteArrBytes());
 
   // aux map if HLL_4
-  if (this->tgtHllType == HLL_4) {
+  if (this->tgtHllType_ == HLL_4) {
     if (auxHashMap != nullptr) {
       if (compact) {
-        for (uint32_t coupon: *auxHashMap) {
-          os.write((char*)&coupon, sizeof(coupon));
+        for (const uint32_t coupon: *auxHashMap) {
+          write(os, coupon);
         }
       } else {
-        os.write((char*)auxHashMap->getAuxIntArr(), auxHashMap->getUpdatableSizeBytes());
+        write(os, auxHashMap->getAuxIntArr(), auxHashMap->getUpdatableSizeBytes());
       }
     } else if (!compact) {
       // if updatable, we write even if currently unused so the binary can be wrapped      
-      int auxBytes = 4 << HllUtil<A>::LG_AUX_ARR_INTS[this->lgConfigK];
-      std::fill_n(std::ostreambuf_iterator<char>(os), auxBytes, 0);
+      uint32_t auxBytes = 4 << hll_constants::LG_AUX_ARR_INTS[this->lgConfigK_];
+      std::fill_n(std::ostreambuf_iterator<char>(os), auxBytes, static_cast<char>(0));
     }
   }
 }
 
 template<typename A>
 double HllArray<A>::getEstimate() const {
-  if (oooFlag) {
+  if (oooFlag_) {
     return getCompositeEstimate();
   }
   return getHipAccum();
@@ -321,50 +318,50 @@ double HllArray<A>::getEstimate() const {
  * the very small values <= k where curMin = 0 still apply.
  */
 template<typename A>
-double HllArray<A>::getLowerBound(const int numStdDev) const {
+double HllArray<A>::getLowerBound(uint8_t numStdDev) const {
   HllUtil<A>::checkNumStdDev(numStdDev);
-  const int configK = 1 << this->lgConfigK;
-  const double numNonZeros = ((curMin == 0) ? (configK - numAtCurMin) : configK);
+  const uint32_t configK = 1 << this->lgConfigK_;
+  const double numNonZeros = ((curMin_ == 0) ? (configK - numAtCurMin_) : configK);
 
   double estimate;
   double rseFactor;
-  if (oooFlag) {
+  if (oooFlag_) {
     estimate = getCompositeEstimate();
-    rseFactor = HllUtil<A>::HLL_NON_HIP_RSE_FACTOR;
+    rseFactor = hll_constants::HLL_NON_HIP_RSE_FACTOR;
   } else {
-    estimate = hipAccum;
-    rseFactor = HllUtil<A>::HLL_HIP_RSE_FACTOR;
+    estimate = hipAccum_;
+    rseFactor = hll_constants::HLL_HIP_RSE_FACTOR;
   }
 
   double relErr;
-  if (this->lgConfigK > 12) {
+  if (this->lgConfigK_ > 12) {
     relErr = (numStdDev * rseFactor) / sqrt(configK);
   } else {
-    relErr = HllUtil<A>::getRelErr(false, oooFlag, this->lgConfigK, numStdDev);
+    relErr = HllUtil<A>::getRelErr(false, oooFlag_, this->lgConfigK_, numStdDev);
   }
   return fmax(estimate / (1.0 + relErr), numNonZeros);
 }
 
 template<typename A>
-double HllArray<A>::getUpperBound(const int numStdDev) const {
+double HllArray<A>::getUpperBound(uint8_t numStdDev) const {
   HllUtil<A>::checkNumStdDev(numStdDev);
-  const int configK = 1 << this->lgConfigK;
+  const uint32_t configK = 1 << this->lgConfigK_;
 
   double estimate;
   double rseFactor;
-  if (oooFlag) {
+  if (oooFlag_) {
     estimate = getCompositeEstimate();
-    rseFactor = HllUtil<A>::HLL_NON_HIP_RSE_FACTOR;
+    rseFactor = hll_constants::HLL_NON_HIP_RSE_FACTOR;
   } else {
-    estimate = hipAccum;
-    rseFactor = HllUtil<A>::HLL_HIP_RSE_FACTOR;
+    estimate = hipAccum_;
+    rseFactor = hll_constants::HLL_HIP_RSE_FACTOR;
   }
 
   double relErr;
-  if (this->lgConfigK > 12) {
+  if (this->lgConfigK_ > 12) {
     relErr = (-1.0) * (numStdDev * rseFactor) / sqrt(configK);
   } else {
-    relErr = HllUtil<A>::getRelErr(true, oooFlag, this->lgConfigK, numStdDev);
+    relErr = HllUtil<A>::getRelErr(true, oooFlag_, this->lgConfigK_, numStdDev);
   }
   return estimate / (1.0 + relErr);
 }
@@ -378,21 +375,21 @@ double HllArray<A>::getUpperBound(const int numStdDev) const {
 // Original C: again-two-registers.c hhb_get_composite_estimate L1489
 template<typename A>
 double HllArray<A>::getCompositeEstimate() const {
-  const double rawEst = getHllRawEstimate(this->lgConfigK, kxq0 + kxq1);
+  const double rawEst = getHllRawEstimate();
 
-  const double* xArr = CompositeInterpolationXTable<A>::get_x_arr(this->lgConfigK);
-  const int xArrLen = CompositeInterpolationXTable<A>::get_x_arr_length();
-  const double yStride = CompositeInterpolationXTable<A>::get_y_stride(this->lgConfigK);
+  const double* xArr = CompositeInterpolationXTable<A>::get_x_arr(this->lgConfigK_);
+  const uint32_t xArrLen = CompositeInterpolationXTable<A>::get_x_arr_length();
+  const double yStride = CompositeInterpolationXTable<A>::get_y_stride(this->lgConfigK_);
 
   if (rawEst < xArr[0]) {
     return 0;
   }
 
-  const int xArrLenM1 = xArrLen - 1;
+  const uint32_t xArrLenM1 = xArrLen - 1;
 
   if (rawEst > xArr[xArrLenM1]) {
-    double finalY = yStride * xArrLenM1;
-    double factor = finalY / xArr[xArrLenM1];
+    const double finalY = yStride * xArrLenM1;
+    const double factor = finalY / xArr[xArrLenM1];
     return rawEst * factor;
   }
 
@@ -401,10 +398,9 @@ double HllArray<A>::getCompositeEstimate() const {
   // We need to completely avoid the linear_counting estimator if it might have a crazy value.
   // Empirical evidence suggests that the threshold 3*k will keep us safe if 2^4 <= k <= 2^21.
 
-  if (adjEst > (3 << this->lgConfigK)) { return adjEst; }
+  if (adjEst > (3 << this->lgConfigK_)) { return adjEst; }
 
-  const double linEst =
-      getHllBitMapEstimate(this->lgConfigK, curMin, numAtCurMin);
+  const double linEst = getHllBitMapEstimate();
 
   // Bias is created when the value of an estimator is compared with a threshold to decide whether
   // to use that estimator or a different one.
@@ -416,70 +412,70 @@ double HllArray<A>::getCompositeEstimate() const {
   // The following constants comes from empirical measurements of the crossover point
   // between the average error of the linear estimator and the adjusted hll estimator
   double crossOver = 0.64;
-  if (this->lgConfigK == 4)      { crossOver = 0.718; }
-  else if (this->lgConfigK == 5) { crossOver = 0.672; }
+  if (this->lgConfigK_ == 4)      { crossOver = 0.718; }
+  else if (this->lgConfigK_ == 5) { crossOver = 0.672; }
 
-  return (avgEst > (crossOver * (1 << this->lgConfigK))) ? adjEst : linEst;
+  return (avgEst > (crossOver * (1 << this->lgConfigK_))) ? adjEst : linEst;
 }
 
 template<typename A>
 double HllArray<A>::getKxQ0() const {
-  return kxq0;
+  return kxq0_;
 }
 
 template<typename A>
 double HllArray<A>::getKxQ1() const {
-  return kxq1;
+  return kxq1_;
 }
 
 template<typename A>
 double HllArray<A>::getHipAccum() const {
-  return hipAccum;
+  return hipAccum_;
 }
 
 template<typename A>
-int HllArray<A>::getCurMin() const {
-  return curMin;
+uint8_t HllArray<A>::getCurMin() const {
+  return curMin_;
 }
 
 template<typename A>
-int HllArray<A>::getNumAtCurMin() const {
-  return numAtCurMin;
+uint32_t HllArray<A>::getNumAtCurMin() const {
+  return numAtCurMin_;
 }
 
 template<typename A>
-void HllArray<A>::putKxQ0(const double kxq0) {
-  this->kxq0 = kxq0;
+void HllArray<A>::putKxQ0(double kxq0) {
+  kxq0_ = kxq0;
 }
 
 template<typename A>
-void HllArray<A>::putKxQ1(const double kxq1) {
-  this->kxq1 = kxq1;
+void HllArray<A>::putKxQ1(double kxq1) {
+  kxq1_ = kxq1;
 }
 
 template<typename A>
-void HllArray<A>::putHipAccum(const double hipAccum) {
-  this->hipAccum = hipAccum;
+void HllArray<A>::putHipAccum(double hipAccum) {
+  hipAccum_ = hipAccum;
 }
 
 template<typename A>
-void HllArray<A>::putCurMin(const int curMin) {
-  this->curMin = curMin;
+void HllArray<A>::putCurMin(uint8_t curMin) {
+  curMin_ = curMin;
 }
 
 template<typename A>
-void HllArray<A>::putNumAtCurMin(const int numAtCurMin) {
-  this->numAtCurMin = numAtCurMin;
+void HllArray<A>::putNumAtCurMin(uint32_t numAtCurMin) {
+  numAtCurMin_ = numAtCurMin;
 }
 
 template<typename A>
 void HllArray<A>::decNumAtCurMin() {
-  --numAtCurMin;
+  --numAtCurMin_;
 }
 
 template<typename A>
-void HllArray<A>::addToHipAccum(const double delta) {
-  hipAccum += delta;
+void HllArray<A>::addToHipAccum(double delta) {
+  hipAccum_ += delta;
 }
 
 template<typename A>
@@ -489,22 +485,22 @@ bool HllArray<A>::isCompact() const {
 
 template<typename A>
 bool HllArray<A>::isEmpty() const {
-  const int configK = 1 << this->lgConfigK;
+  const uint32_t configK = 1 << this->lgConfigK_;
   return (getCurMin() == 0) && (getNumAtCurMin() == configK);
 }
 
 template<typename A>
 void HllArray<A>::putOutOfOrderFlag(bool flag) {
-  oooFlag = flag;
+  oooFlag_ = flag;
 }
 
 template<typename A>
 bool HllArray<A>::isOutOfOrderFlag() const {
-  return oooFlag;
+  return oooFlag_;
 }
 
 template<typename A>
-int HllArray<A>::hllArrBytes(target_hll_type tgtHllType, int lgConfigK) {
+uint32_t HllArray<A>::hllArrBytes(target_hll_type tgtHllType, uint8_t lgConfigK) {
   switch (tgtHllType) {
   case HLL_4:
     return hll4ArrBytes(lgConfigK);
@@ -518,41 +514,41 @@ int HllArray<A>::hllArrBytes(target_hll_type tgtHllType, int lgConfigK) {
 }
 
 template<typename A>
-int HllArray<A>::hll4ArrBytes(const int lgConfigK) {
+uint32_t HllArray<A>::hll4ArrBytes(uint8_t lgConfigK) {
   return 1 << (lgConfigK - 1);
 }
 
 template<typename A>
-int HllArray<A>::hll6ArrBytes(const int lgConfigK) {
-  const int numSlots = 1 << lgConfigK;
+uint32_t HllArray<A>::hll6ArrBytes(uint8_t lgConfigK) {
+  const uint32_t numSlots = 1 << lgConfigK;
   return ((numSlots * 3) >> 2) + 1;
 }
 
 template<typename A>
-int HllArray<A>::hll8ArrBytes(const int lgConfigK) {
+uint32_t HllArray<A>::hll8ArrBytes(uint8_t lgConfigK) {
   return 1 << lgConfigK;
 }
 
 template<typename A>
-int HllArray<A>::getMemDataStart() const {
-  return HllUtil<A>::HLL_BYTE_ARR_START;
+uint32_t HllArray<A>::getMemDataStart() const {
+  return hll_constants::HLL_BYTE_ARR_START;
 }
 
 template<typename A>
-int HllArray<A>::getUpdatableSerializationBytes() const {
-  return HllUtil<A>::HLL_BYTE_ARR_START + getHllByteArrBytes();
+uint32_t HllArray<A>::getUpdatableSerializationBytes() const {
+  return hll_constants::HLL_BYTE_ARR_START + getHllByteArrBytes();
 }
 
 template<typename A>
-int HllArray<A>::getCompactSerializationBytes() const {
+uint32_t HllArray<A>::getCompactSerializationBytes() const {
   AuxHashMap<A>* auxHashMap = getAuxHashMap();
-  const int auxCountBytes = ((auxHashMap == nullptr) ? 0 : auxHashMap->getCompactSizeBytes());
-  return HllUtil<A>::HLL_BYTE_ARR_START + getHllByteArrBytes() + auxCountBytes;
+  const uint32_t auxCountBytes = ((auxHashMap == nullptr) ? 0 : auxHashMap->getCompactSizeBytes());
+  return hll_constants::HLL_BYTE_ARR_START + getHllByteArrBytes() + auxCountBytes;
 }
 
 template<typename A>
-int HllArray<A>::getPreInts() const {
-  return HllUtil<A>::HLL_PREINTS;
+uint8_t HllArray<A>::getPreInts() const {
+  return hll_constants::HLL_PREINTS;
 }
 
 template<typename A>
@@ -562,14 +558,14 @@ AuxHashMap<A>* HllArray<A>::getAuxHashMap() const {
 
 template<typename A>
 void HllArray<A>::hipAndKxQIncrementalUpdate(uint8_t oldValue, uint8_t newValue) {
-  const int configK = 1 << this->getLgConfigK();
+  const uint32_t configK = 1 << this->getLgConfigK();
   // update hip BEFORE updating kxq
-  if (!oooFlag) hipAccum += configK / (kxq0 + kxq1);
+  if (!oooFlag_) hipAccum_ += configK / (kxq0_ + kxq1_);
   // update kxq0 and kxq1; subtract first, then add
-  if (oldValue < 32) { kxq0 -= INVERSE_POWERS_OF_2[oldValue]; }
-  else               { kxq1 -= INVERSE_POWERS_OF_2[oldValue]; }
-  if (newValue < 32) { kxq0 += INVERSE_POWERS_OF_2[newValue]; }
-  else               { kxq1 += INVERSE_POWERS_OF_2[newValue]; }
+  if (oldValue < 32) { kxq0_ -= INVERSE_POWERS_OF_2[oldValue]; }
+  else               { kxq1_ -= INVERSE_POWERS_OF_2[oldValue]; }
+  if (newValue < 32) { kxq0_ += INVERSE_POWERS_OF_2[newValue]; }
+  else               { kxq1_ += INVERSE_POWERS_OF_2[newValue]; }
 }
 
 /**
@@ -579,91 +575,91 @@ void HllArray<A>::hipAndKxQIncrementalUpdate(uint8_t oldValue, uint8_t newValue)
  */
 //In C: again-two-registers.c hhb_get_improved_linear_counting_estimate L1274
 template<typename A>
-double HllArray<A>::getHllBitMapEstimate(const int lgConfigK, const int curMin, const int numAtCurMin) const {
-  const  int configK = 1 << lgConfigK;
-  const  int numUnhitBuckets =  ((curMin == 0) ? numAtCurMin : 0);
+double HllArray<A>::getHllBitMapEstimate() const {
+  const uint32_t configK = 1 << this->lgConfigK_;
+  const uint32_t numUnhitBuckets = curMin_ == 0 ? numAtCurMin_ : 0;
 
   //This will eventually go away.
   if (numUnhitBuckets == 0) {
     return configK * log(configK / 0.5);
   }
 
-  const int numHitBuckets = configK - numUnhitBuckets;
+  const uint32_t numHitBuckets = configK - numUnhitBuckets;
   return HarmonicNumbers<A>::getBitMapEstimate(configK, numHitBuckets);
 }
 
 //In C: again-two-registers.c hhb_get_raw_estimate L1167
 template<typename A>
-double HllArray<A>::getHllRawEstimate(const int lgConfigK, const double kxqSum) const {
-  const int configK = 1 << lgConfigK;
+double HllArray<A>::getHllRawEstimate() const {
+  const uint32_t configK = 1 << this->lgConfigK_;
   double correctionFactor;
-  if (lgConfigK == 4) { correctionFactor = 0.673; }
-  else if (lgConfigK == 5) { correctionFactor = 0.697; }
-  else if (lgConfigK == 6) { correctionFactor = 0.709; }
+  if (this->lgConfigK_ == 4) { correctionFactor = 0.673; }
+  else if (this->lgConfigK_ == 5) { correctionFactor = 0.697; }
+  else if (this->lgConfigK_ == 6) { correctionFactor = 0.709; }
   else { correctionFactor = 0.7213 / (1.0 + (1.079 / configK)); }
-  const double hyperEst = (correctionFactor * configK * configK) / kxqSum;
+  const double hyperEst = (correctionFactor * configK * configK) / (kxq0_ + kxq1_);
   return hyperEst;
 }
 
 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);
+  return const_iterator(hllByteArr_.data(), 1 << this->lgConfigK_, 0, this->tgtHllType_, nullptr, 0, all);
 }
 
 template<typename A>
 typename HllArray<A>::const_iterator HllArray<A>::end() const {
-  return const_iterator(hllByteArr.data(), 1 << this->lgConfigK, 1 << this->lgConfigK, this->tgtHllType, nullptr, 0, false);
+  return const_iterator(hllByteArr_.data(), 1 << this->lgConfigK_, 1 << this->lgConfigK_, this->tgtHllType_, nullptr, 0, false);
 }
 
 template<typename A>
-HllArray<A>::const_iterator::const_iterator(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):
-array(array), array_size(array_size), index(index), hll_type(hll_type), exceptions(exceptions), offset(offset), all(all)
+HllArray<A>::const_iterator::const_iterator(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):
+array_(array), array_size_(array_size), index_(index), hll_type_(hll_type), exceptions_(exceptions), offset_(offset), all_(all)
 {
-  while (this->index < array_size) {
-    value = get_value(array, this->index, hll_type, exceptions, offset);
-    if (all || value != HllUtil<A>::EMPTY) break;
-    this->index++;
+  while (index_ < array_size_) {
+    value_ = get_value(array_, index_, hll_type_, exceptions_, offset_);
+    if (all_ || value_ != hll_constants::EMPTY) break;
+    ++index_;
   }
 }
 
 template<typename A>
 typename HllArray<A>::const_iterator& HllArray<A>::const_iterator::operator++() {
-  while (++index < array_size) {
-    value = get_value(array, index, hll_type, exceptions, offset);
-    if (all || value != HllUtil<A>::EMPTY) break;
+  while (++index_ < array_size_) {
+    value_ = get_value(array_, index_, hll_type_, exceptions_, offset_);
+    if (all_ || value_ != hll_constants::EMPTY) break;
   }
   return *this;
 }
 
 template<typename A>
 bool HllArray<A>::const_iterator::operator!=(const const_iterator& other) const {
-  return index != other.index;
+  return index_ != other.index_;
 }
 
 template<typename A>
 uint32_t HllArray<A>::const_iterator::operator*() const {
-  return HllUtil<A>::pair(index, value);
+  return HllUtil<A>::pair(index_, value_);
 }
 
 template<typename A>
-uint8_t HllArray<A>::const_iterator::get_value(const uint8_t* array, size_t index, target_hll_type hll_type, const AuxHashMap<A>* exceptions, uint8_t offset) {
+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) {
   if (hll_type == target_hll_type::HLL_4) {
     uint8_t value = array[index >> 1];
     if ((index & 1) > 0) { // odd
         value >>= 4;
     } else {
-      value &= HllUtil<A>::loNibbleMask;
+      value &= hll_constants::loNibbleMask;
     }
-    if (value == HllUtil<A>::AUX_TOKEN) { // exception
+    if (value == hll_constants::AUX_TOKEN) { // exception
       return exceptions->mustFindValueFor(index);
     }
     return value + offset;
   } else if (hll_type == target_hll_type::HLL_6) {
-    const int start_bit = index * 6;
-    const int shift = start_bit & 0x7;
-    const int byte_idx = start_bit >> 3;
+    const size_t start_bit = index * 6;
+    const uint8_t shift = start_bit & 0x7;
+    const size_t byte_idx = start_bit >> 3;
     const uint16_t two_byte_val = (array[byte_idx + 1] << 8) | array[byte_idx];
-    return (two_byte_val >> shift) & HllUtil<A>::VAL_MASK_6;
+    return (two_byte_val >> shift) & hll_constants::VAL_MASK_6;
   }
   // HLL_8
   return array[index];
@@ -671,7 +667,7 @@ uint8_t HllArray<A>::const_iterator::get_value(const uint8_t* array, size_t inde
 
 template<typename A>
 A HllArray<A>::getAllocator() const {
-  return hllByteArr.get_allocator();
+  return hllByteArr_.get_allocator();
 }
 
 }