datasketches 0.2.0 → 0.2.4

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

@@ -31,19 +31,19 @@
 namespace datasketches {
 
 template<typename A>
-CouponList<A>::CouponList(const int lgConfigK, const target_hll_type tgtHllType, const hll_mode mode, const A& allocator):
+CouponList<A>::CouponList(uint8_t lgConfigK, target_hll_type tgtHllType, hll_mode mode, const A& allocator):
 HllSketchImpl<A>(lgConfigK, tgtHllType, mode, false),
-couponCount(0),
-oooFlag(false),
-coupons(1 << (mode == hll_mode::LIST ? HllUtil<A>::LG_INIT_LIST_SIZE : HllUtil<A>::LG_INIT_SET_SIZE), 0, allocator)
+couponCount_(0),
+oooFlag_(false),
+coupons_(1ULL << (mode == hll_mode::LIST ? hll_constants::LG_INIT_LIST_SIZE : hll_constants::LG_INIT_SET_SIZE), 0, allocator)
 {}
 
 template<typename A>
 CouponList<A>::CouponList(const CouponList& that, const target_hll_type tgtHllType):
-HllSketchImpl<A>(that.lgConfigK, tgtHllType, that.mode, false),
-couponCount(that.couponCount),
-oooFlag(that.oooFlag),
-coupons(that.coupons)
+HllSketchImpl<A>(that.lgConfigK_, tgtHllType, that.mode_, false),
+couponCount_(that.couponCount_),
+oooFlag_(that.oooFlag_),
+coupons_(that.coupons_)
 {}
 
 template<typename A>
@@ -58,48 +58,48 @@ std::function<void(HllSketchImpl<A>*)> CouponList<A>::get_deleter() const {
 
 template<typename A>
 CouponList<A>* CouponList<A>::copy() const {
-  ClAlloc cla(coupons.get_allocator());
+  ClAlloc cla(coupons_.get_allocator());
   return new (cla.allocate(1)) CouponList<A>(*this);
 }
 
 template<typename A>
 CouponList<A>* CouponList<A>::copyAs(target_hll_type tgtHllType) const {
-  ClAlloc cla(coupons.get_allocator());
+  ClAlloc cla(coupons_.get_allocator());
   return new (cla.allocate(1)) CouponList<A>(*this, tgtHllType);
 }
 
 template<typename A>
 CouponList<A>* CouponList<A>::newList(const void* bytes, size_t len, const A& allocator) {
-  if (len < HllUtil<A>::LIST_INT_ARR_START) {
+  if (len < hll_constants::LIST_INT_ARR_START) {
     throw std::out_of_range("Input data length insufficient to hold CouponHashSet");
   }
 
   const uint8_t* data = static_cast<const uint8_t*>(bytes);
-  if (data[HllUtil<A>::PREAMBLE_INTS_BYTE] != HllUtil<A>::LIST_PREINTS) {
+  if (data[hll_constants::PREAMBLE_INTS_BYTE] != hll_constants::LIST_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 stream is not an HLL sketch");
   }
 
-  hll_mode mode = HllSketchImpl<A>::extractCurMode(data[HllUtil<A>::MODE_BYTE]);
+  hll_mode mode = HllSketchImpl<A>::extractCurMode(data[hll_constants::MODE_BYTE]);
   if (mode != LIST) {
     throw std::invalid_argument("Calling list constructor with non-list mode data");
   }
 
-  target_hll_type tgtHllType = HllSketchImpl<A>::extractTgtHllType(data[HllUtil<A>::MODE_BYTE]);
+  target_hll_type tgtHllType = HllSketchImpl<A>::extractTgtHllType(data[hll_constants::MODE_BYTE]);
 
-  const int lgK = data[HllUtil<A>::LG_K_BYTE];
-  const bool compact = ((data[HllUtil<A>::FLAGS_BYTE] & HllUtil<A>::COMPACT_FLAG_MASK) ? true : false);
-  const bool oooFlag = ((data[HllUtil<A>::FLAGS_BYTE] & HllUtil<A>::OUT_OF_ORDER_FLAG_MASK) ? true : false);
-  const bool emptyFlag = ((data[HllUtil<A>::FLAGS_BYTE] & HllUtil<A>::EMPTY_FLAG_MASK) ? true : false);
+  const uint8_t lgK = data[hll_constants::LG_K_BYTE];
+  const bool compact = ((data[hll_constants::FLAGS_BYTE] & hll_constants::COMPACT_FLAG_MASK) ? true : false);
+  const bool oooFlag = ((data[hll_constants::FLAGS_BYTE] & hll_constants::OUT_OF_ORDER_FLAG_MASK) ? true : false);
+  const bool emptyFlag = ((data[hll_constants::FLAGS_BYTE] & hll_constants::EMPTY_FLAG_MASK) ? true : false);
 
-  const int couponCount = data[HllUtil<A>::LIST_COUNT_BYTE];
-  const int couponsInArray = (compact ? couponCount : (1 << HllUtil<A>::computeLgArrInts(LIST, couponCount, lgK)));
-  const size_t expectedLength = HllUtil<A>::LIST_INT_ARR_START + (couponsInArray * sizeof(int));
+  const uint32_t couponCount = data[hll_constants::LIST_COUNT_BYTE];
+  const uint32_t couponsInArray = (compact ? couponCount : (1 << HllUtil<A>::computeLgArrInts(LIST, couponCount, lgK)));
+  const size_t expectedLength = hll_constants::LIST_INT_ARR_START + (couponsInArray * sizeof(uint32_t));
   if (len < expectedLength) {
     throw std::out_of_range("Byte array too short for sketch. Expected " + std::to_string(expectedLength)
                                 + ", found: " + std::to_string(len));
@@ -107,12 +107,12 @@ CouponList<A>* CouponList<A>::newList(const void* bytes, size_t len, const A& al
 
   ClAlloc cla(allocator);
   CouponList<A>* sketch = new (cla.allocate(1)) CouponList<A>(lgK, tgtHllType, mode, allocator);
-  sketch->couponCount = couponCount;
+  sketch->couponCount_ = couponCount;
   sketch->putOutOfOrderFlag(oooFlag); // should always be false for LIST
 
   if (!emptyFlag) {
     // only need to read valid coupons, unlike in stream case
-    std::memcpy(sketch->coupons.data(), data + HllUtil<A>::LIST_INT_ARR_START, couponCount * sizeof(int));
+    std::memcpy(sketch->coupons_.data(), data + hll_constants::LIST_INT_ARR_START, couponCount * sizeof(uint32_t));
   }
   
   return sketch;
@@ -121,44 +121,44 @@ CouponList<A>* CouponList<A>::newList(const void* bytes, size_t len, const A& al
 template<typename A>
 CouponList<A>* CouponList<A>::newList(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>::LIST_PREINTS) {
+  if (listHeader[hll_constants::PREAMBLE_INTS_BYTE] != hll_constants::LIST_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 != LIST) {
     throw std::invalid_argument("Calling list constructor with non-list mode data");
   }
 
-  const target_hll_type tgtHllType = HllSketchImpl<A>::extractTgtHllType(listHeader[HllUtil<A>::MODE_BYTE]);
+  const target_hll_type tgtHllType = HllSketchImpl<A>::extractTgtHllType(listHeader[hll_constants::MODE_BYTE]);
 
-  const int lgK = (int) listHeader[HllUtil<A>::LG_K_BYTE];
-  const bool compact = ((listHeader[HllUtil<A>::FLAGS_BYTE] & HllUtil<A>::COMPACT_FLAG_MASK) ? true : false);
-  const bool oooFlag = ((listHeader[HllUtil<A>::FLAGS_BYTE] & HllUtil<A>::OUT_OF_ORDER_FLAG_MASK) ? true : false);
-  const bool emptyFlag = ((listHeader[HllUtil<A>::FLAGS_BYTE] & HllUtil<A>::EMPTY_FLAG_MASK) ? true : false);
+  const uint8_t lgK = listHeader[hll_constants::LG_K_BYTE];
+  const bool compact = ((listHeader[hll_constants::FLAGS_BYTE] & hll_constants::COMPACT_FLAG_MASK) ? true : false);
+  const bool oooFlag = ((listHeader[hll_constants::FLAGS_BYTE] & hll_constants::OUT_OF_ORDER_FLAG_MASK) ? true : false);
+  const bool emptyFlag = ((listHeader[hll_constants::FLAGS_BYTE] & hll_constants::EMPTY_FLAG_MASK) ? true : false);
 
   ClAlloc cla(allocator);
   CouponList<A>* sketch = new (cla.allocate(1)) CouponList<A>(lgK, tgtHllType, mode, allocator);
   using coupon_list_ptr = std::unique_ptr<CouponList<A>, std::function<void(HllSketchImpl<A>*)>>;
   coupon_list_ptr ptr(sketch, sketch->get_deleter());
-  const int couponCount = listHeader[HllUtil<A>::LIST_COUNT_BYTE];
-  sketch->couponCount = couponCount;
+  const uint32_t couponCount = listHeader[hll_constants::LIST_COUNT_BYTE];
+  sketch->couponCount_ = couponCount;
   sketch->putOutOfOrderFlag(oooFlag); // should always be false for LIST
 
   if (!emptyFlag) {
     // For stream processing, need to read entire number written to stream so read
     // pointer ends up set correctly.
     // If not compact, still need to read empty items even though in order.
-    const int numToRead = (compact ? couponCount : sketch->coupons.size());
-    is.read((char*)sketch->coupons.data(), numToRead * sizeof(int));
+    const uint32_t numToRead = (compact ? couponCount : static_cast<uint32_t>(sketch->coupons_.size()));
+    read(is, sketch->coupons_.data(), numToRead * sizeof(uint32_t));
   }
 
   if (!is.good())
@@ -173,17 +173,17 @@ vector_u8<A> CouponList<A>::serialize(bool compact, unsigned header_size_bytes)
   vector_u8<A> byteArr(sketchSizeBytes, 0, getAllocator());
   uint8_t* bytes = byteArr.data() + header_size_bytes;
 
-  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] = count_trailing_zeros_in_u32(coupons.size());
-  bytes[HllUtil<A>::FLAGS_BYTE] = this->makeFlagsByte(compact);
-  bytes[HllUtil<A>::LIST_COUNT_BYTE] = static_cast<uint8_t>(this->mode == LIST ? couponCount : 0);
-  bytes[HllUtil<A>::MODE_BYTE] = this->makeModeByte();
-
-  if (this->mode == SET) {
-    std::memcpy(bytes + HllUtil<A>::HASH_SET_COUNT_INT, &couponCount, sizeof(couponCount));
+  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] = count_trailing_zeros_in_u32(static_cast<uint32_t>(coupons_.size()));
+  bytes[hll_constants::FLAGS_BYTE] = this->makeFlagsByte(compact);
+  bytes[hll_constants::LIST_COUNT_BYTE] = static_cast<uint8_t>(this->mode_ == LIST ? couponCount_ : 0);
+  bytes[hll_constants::MODE_BYTE] = this->makeModeByte();
+
+  if (this->mode_ == SET) {
+    std::memcpy(bytes + hll_constants::HASH_SET_COUNT_INT, &couponCount_, sizeof(couponCount_));
   }
 
   // coupons
@@ -191,12 +191,12 @@ vector_u8<A> CouponList<A>::serialize(bool compact, unsigned header_size_bytes)
   const int sw = (isCompact() ? 2 : 0) | (compact ? 1 : 0);
   switch (sw) {
     case 0: { // src updatable, dst updatable
-      std::memcpy(bytes + getMemDataStart(), coupons.data(), coupons.size() * sizeof(int));
+      std::memcpy(bytes + getMemDataStart(), coupons_.data(), coupons_.size() * sizeof(uint32_t));
       break;
     }
     case 1: { // src updatable, dst compact
       bytes += getMemDataStart(); // reusing pointer for incremental writes
-      for (uint32_t coupon: *this) {
+      for (const uint32_t coupon: *this) {
         std::memcpy(bytes, &coupon, sizeof(coupon));
         bytes += sizeof(coupon);
       }
@@ -213,33 +213,33 @@ vector_u8<A> CouponList<A>::serialize(bool compact, unsigned header_size_bytes)
 template<typename A>
 void CouponList<A>::serialize(std::ostream& os, const 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 lgArrIntsByte(count_trailing_zeros_in_u32(coupons.size()));
-  os.write((char*)&lgArrIntsByte, sizeof(lgArrIntsByte));
-  const uint8_t flagsByte(this->makeFlagsByte(compact));
-  os.write((char*)&flagsByte, sizeof(flagsByte));
-
-  if (this->mode == LIST) {
-    const uint8_t listCount((uint8_t) couponCount);
-    os.write((char*)&listCount, sizeof(listCount));
+  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);
+  const uint8_t lgArrIntsByte = count_trailing_zeros_in_u32(static_cast<uint32_t>(coupons_.size()));
+  write(os, lgArrIntsByte);
+  const uint8_t flagsByte = this->makeFlagsByte(compact);
+  write(os, flagsByte);
+
+  if (this->mode_ == LIST) {
+    const uint8_t listCount = static_cast<uint8_t>(couponCount_);
+    write(os, listCount);
   } else { // mode == SET
-    const uint8_t unused(0);
-    os.write((char*)&unused, sizeof(unused));
+      const uint8_t unused = 0;
+    write(os, unused);
   }
 
-  const uint8_t modeByte(this->makeModeByte());
-  os.write((char*)&modeByte, sizeof(modeByte));
+  const uint8_t modeByte = this->makeModeByte();
+  write(os, modeByte);
 
-  if (this->mode == SET) {
+  if (this->mode_ == SET) {
     // writing as int, already stored as int
-    os.write((char*)&couponCount, sizeof(couponCount));
+    write(os, couponCount_);
   }
 
   // coupons
@@ -247,12 +247,12 @@ void CouponList<A>::serialize(std::ostream& os, const bool compact) const {
   const int sw = (isCompact() ? 2 : 0) | (compact ? 1 : 0);
   switch (sw) {
     case 0: { // src updatable, dst updatable
-      os.write((char*)coupons.data(), coupons.size() * sizeof(int));
+      write(os, coupons_.data(), coupons_.size() * sizeof(uint32_t));
       break;
     }
     case 1: { // src updatable, dst compact
-      for (uint32_t coupon: *this) {
-        os.write((char*)&coupon, sizeof(coupon));
+      for (const uint32_t coupon: *this) {
+        write(os, coupon);
       }
       break;
     }
@@ -265,14 +265,14 @@ void CouponList<A>::serialize(std::ostream& os, const bool compact) const {
 }
 
 template<typename A>
-HllSketchImpl<A>* CouponList<A>::couponUpdate(int coupon) {
-  for (size_t i = 0; i < coupons.size(); ++i) { // search for empty slot
-    const int couponAtIdx = coupons[i];
-    if (couponAtIdx == HllUtil<A>::EMPTY) {
-      coupons[i] = coupon; // the actual update
-      ++couponCount;
-      if (couponCount == static_cast<int>(coupons.size())) { // array full
-        if (this->lgConfigK < 8) {
+HllSketchImpl<A>* CouponList<A>::couponUpdate(uint32_t coupon) {
+  for (size_t i = 0; i < coupons_.size(); ++i) { // search for empty slot
+    const uint32_t couponAtIdx = coupons_[i];
+    if (couponAtIdx == hll_constants::EMPTY) {
+      coupons_[i] = coupon; // the actual update
+      ++couponCount_;
+      if (couponCount_ == static_cast<uint32_t>(coupons_.size())) { // array full
+        if (this->lgConfigK_ < 8) {
           return promoteHeapListOrSetToHll(*this);
         }
         return promoteHeapListToSet(*this);
@@ -293,71 +293,68 @@ double CouponList<A>::getCompositeEstimate() const { return getEstimate(); }
 
 template<typename A>
 double CouponList<A>::getEstimate() const {
-  const int couponCount = getCouponCount();
-  const double est = CubicInterpolation<A>::usingXAndYTables(couponCount);
-  return fmax(est, couponCount);
+  const double est = CubicInterpolation<A>::usingXAndYTables(couponCount_);
+  return fmax(est, couponCount_);
 }
 
 template<typename A>
-double CouponList<A>::getLowerBound(const int numStdDev) const {
+double CouponList<A>::getLowerBound(uint8_t numStdDev) const {
   HllUtil<A>::checkNumStdDev(numStdDev);
-  const int couponCount = getCouponCount();
-  const double est = CubicInterpolation<A>::usingXAndYTables(couponCount);
-  const double tmp = est / (1.0 + (numStdDev * HllUtil<A>::COUPON_RSE));
-  return fmax(tmp, couponCount);
+  const double est = CubicInterpolation<A>::usingXAndYTables(couponCount_);
+  const double tmp = est / (1.0 + (numStdDev * hll_constants::COUPON_RSE));
+  return fmax(tmp, couponCount_);
 }
 
 template<typename A>
-double CouponList<A>::getUpperBound(const int numStdDev) const {
+double CouponList<A>::getUpperBound(uint8_t numStdDev) const {
   HllUtil<A>::checkNumStdDev(numStdDev);
-  const int couponCount = getCouponCount();
-  const double est = CubicInterpolation<A>::usingXAndYTables(couponCount);
-  const double tmp = est / (1.0 - (numStdDev * HllUtil<A>::COUPON_RSE));
-  return fmax(tmp, couponCount);
+  const double est = CubicInterpolation<A>::usingXAndYTables(couponCount_);
+  const double tmp = est / (1.0 - (numStdDev * hll_constants::COUPON_RSE));
+  return fmax(tmp, couponCount_);
 }
 
 template<typename A>
 bool CouponList<A>::isEmpty() const { return getCouponCount() == 0; }
 
 template<typename A>
-int CouponList<A>::getUpdatableSerializationBytes() const {
-  return getMemDataStart() + coupons.size() * sizeof(int);
+uint32_t CouponList<A>::getUpdatableSerializationBytes() const {
+  return getMemDataStart() + static_cast<uint32_t>(coupons_.size()) * sizeof(uint32_t);
 }
 
 template<typename A>
-int CouponList<A>::getCouponCount() const {
-  return couponCount;
+uint32_t CouponList<A>::getCouponCount() const {
+  return couponCount_;
 }
 
 template<typename A>
-int CouponList<A>::getCompactSerializationBytes() const {
-  return getMemDataStart() + (couponCount << 2);
+uint32_t CouponList<A>::getCompactSerializationBytes() const {
+  return getMemDataStart() + (couponCount_ << 2);
 }
 
 template<typename A>
-int CouponList<A>::getMemDataStart() const {
-  return HllUtil<A>::LIST_INT_ARR_START;
+uint32_t CouponList<A>::getMemDataStart() const {
+  return hll_constants::LIST_INT_ARR_START;
 }
 
 template<typename A>
-int CouponList<A>::getPreInts() const {
-  return HllUtil<A>::LIST_PREINTS;
+uint8_t CouponList<A>::getPreInts() const {
+  return hll_constants::LIST_PREINTS;
 }
 
 template<typename A>
 bool CouponList<A>::isCompact() const { return false; }
 
 template<typename A>
-bool CouponList<A>::isOutOfOrderFlag() const { return oooFlag; }
+bool CouponList<A>::isOutOfOrderFlag() const { return oooFlag_; }
 
 template<typename A>
 void CouponList<A>::putOutOfOrderFlag(bool oooFlag) {
-  this->oooFlag = oooFlag;
+  oooFlag_ = oooFlag;
 }
 
 template<typename A>
 A CouponList<A>::getAllocator() const {
-  return coupons.get_allocator();
+  return coupons_.get_allocator();
 }
 
 template<typename A>
@@ -372,12 +369,12 @@ HllSketchImpl<A>* CouponList<A>::promoteHeapListOrSetToHll(CouponList& src) {
 
 template<typename A>
 coupon_iterator<A> CouponList<A>::begin(bool all) const {
-  return coupon_iterator<A>(coupons.data(), coupons.size(), 0, all);
+  return coupon_iterator<A>(coupons_.data(), coupons_.size(), 0, all);
 }
 
 template<typename A>
 coupon_iterator<A> CouponList<A>::end() const {
-  return coupon_iterator<A>(coupons.data(), coupons.size(), coupons.size(), false);
+  return coupon_iterator<A>(coupons_.data(), coupons_.size(), coupons_.size(), false);
 }
 
 }

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

@@ -33,7 +33,7 @@ class HllSketchImplFactory;
 template<typename A>
 class CouponList : public HllSketchImpl<A> {
   public:
-    CouponList(int lgConfigK, target_hll_type tgtHllType, hll_mode mode, const A& allocator);
+    CouponList(uint8_t lgConfigK, target_hll_type tgtHllType, hll_mode mode, const A& allocator);
     CouponList(const CouponList& that, target_hll_type tgtHllType);
 
     static CouponList* newList(const void* bytes, size_t len, const A& allocator);
@@ -47,15 +47,15 @@ class CouponList : public HllSketchImpl<A> {
     virtual CouponList* copy() const;
     virtual CouponList* copyAs(target_hll_type tgtHllType) const;
 
-    virtual HllSketchImpl<A>* couponUpdate(int coupon);
+    virtual HllSketchImpl<A>* couponUpdate(uint32_t coupon);
 
     virtual double getEstimate() const;
     virtual double getCompositeEstimate() const;
-    virtual double getUpperBound(int numStdDev) const;
-    virtual double getLowerBound(int numStdDev) const;
+    virtual double getUpperBound(uint8_t numStdDev) const;
+    virtual double getLowerBound(uint8_t numStdDev) const;
 
     virtual bool isEmpty() const;
-    virtual int getCouponCount() const;
+    virtual uint32_t getCouponCount() const;
 
     coupon_iterator<A> begin(bool all = false) const;
     coupon_iterator<A> end() const;
@@ -63,24 +63,24 @@ class CouponList : public HllSketchImpl<A> {
   protected:
     using ClAlloc = typename std::allocator_traits<A>::template rebind_alloc<CouponList<A>>;
 
-    using vector_int = std::vector<int, typename std::allocator_traits<A>::template rebind_alloc<int>>;
+    using vector_int = std::vector<uint32_t, typename std::allocator_traits<A>::template rebind_alloc<uint32_t>>;
 
     HllSketchImpl<A>* promoteHeapListToSet(CouponList& list);
     HllSketchImpl<A>* promoteHeapListOrSetToHll(CouponList& src);
 
-    virtual int getUpdatableSerializationBytes() const;
-    virtual int getCompactSerializationBytes() const;
-    virtual int getMemDataStart() const;
-    virtual int getPreInts() const;
+    virtual uint32_t getUpdatableSerializationBytes() const;
+    virtual uint32_t getCompactSerializationBytes() const;
+    virtual uint32_t getMemDataStart() const;
+    virtual uint8_t getPreInts() const;
     virtual bool isCompact() const;
     virtual bool isOutOfOrderFlag() const;
     virtual void putOutOfOrderFlag(bool oooFlag);
 
     virtual A getAllocator() const;
 
-    int couponCount;
-    bool oooFlag;
-    vector_int coupons;
+    uint32_t couponCount_;
+    bool oooFlag_;
+    vector_int coupons_;
 
     friend class HllSketchImplFactory<A>;
 };

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

@@ -102,10 +102,8 @@ double CubicInterpolation<A>::usingXAndYTables(const double xArr[], const double
   else if (offset == numEntries-2) { // corner case
     return (interpolateUsingXAndYTables<A>(xArr, yArr, (offset-2), x));
   }
-  else { // main case
-    return (interpolateUsingXAndYTables<A>(xArr, yArr, (offset-1), x));
-  }
-  throw std::logic_error("Exception should be unreachable");
+  // main case
+  return (interpolateUsingXAndYTables<A>(xArr, yArr, (offset-1), x));
 }
 
 // In C: again-two-registers cubic_interpolate_aux L1368

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

@@ -68,7 +68,7 @@ double HarmonicNumbers<A>::harmonicNumber(const uint64_t x_i) {
   if (x_i < NUM_EXACT_HARMONIC_NUMBERS) {
     return tableOfExactHarmonicNumbers[x_i];
   } else {
-    double x = x_i;
+    double x = static_cast<double>(x_i);
     double invSq = 1.0 / (x * x);
     double sum = log(x) + EULER_MASCHERONI_CONSTANT + (1.0 / (2.0 * x));
     /* note: the number of terms included from this series expansion is appropriate