datasketches 0.2.0 → 0.2.4

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

@@ -26,15 +26,15 @@
 namespace datasketches {
 
 template<typename A>
-AuxHashMap<A>::AuxHashMap(int lgAuxArrInts, int lgConfigK, const A& allocator):
+AuxHashMap<A>::AuxHashMap(uint8_t lgAuxArrInts, uint8_t lgConfigK, const A& allocator):
 lgConfigK(lgConfigK),
 lgAuxArrInts(lgAuxArrInts),
 auxCount(0),
-entries(1 << lgAuxArrInts, 0, allocator)
+entries(1ULL << lgAuxArrInts, 0, allocator)
 {}
 
 template<typename A>
-AuxHashMap<A>* AuxHashMap<A>::newAuxHashMap(int lgAuxArrInts, int lgConfigK, const A& allocator) {
+AuxHashMap<A>* AuxHashMap<A>::newAuxHashMap(uint8_t lgAuxArrInts, uint8_t lgConfigK, const A& allocator) {
   return new (ahmAlloc(allocator).allocate(1)) AuxHashMap<A>(lgAuxArrInts, lgConfigK, allocator);
 }
 
@@ -45,42 +45,42 @@ AuxHashMap<A>* AuxHashMap<A>::newAuxHashMap(const AuxHashMap& that) {
 
 template<typename A>
 AuxHashMap<A>* AuxHashMap<A>::deserialize(const void* bytes, size_t len,
-                                          int lgConfigK,
-                                          int auxCount, int lgAuxArrInts,
+                                          uint8_t lgConfigK,
+                                          uint32_t auxCount, uint8_t lgAuxArrInts,
                                           bool srcCompact, const A& allocator) {
-  int lgArrInts = lgAuxArrInts;
+  uint8_t lgArrInts = lgAuxArrInts;
   if (srcCompact) { // early compact versions didn't use LgArr byte field so ignore input
     lgArrInts = HllUtil<A>::computeLgArrInts(HLL, auxCount, lgConfigK);
   } else { // updatable
     lgArrInts = lgAuxArrInts;
   }
   
-  int configKmask = (1 << lgConfigK) - 1;
+  const uint32_t configKmask = (1 << lgConfigK) - 1;
 
   AuxHashMap<A>* auxHashMap;
-  const int* auxPtr = static_cast<const int*>(bytes);
+  const uint32_t* auxPtr = static_cast<const uint32_t*>(bytes);
   if (srcCompact) {
     if (len < auxCount * sizeof(int)) {
       throw std::out_of_range("Input array too small to hold AuxHashMap image");
     }
     auxHashMap = new (ahmAlloc(allocator).allocate(1)) AuxHashMap<A>(lgArrInts, lgConfigK, allocator);
-    for (int i = 0; i < auxCount; ++i) {
-      int pair = auxPtr[i];
-      int slotNo = HllUtil<A>::getLow26(pair) & configKmask;
-      int value = HllUtil<A>::getValue(pair);
+    for (uint32_t i = 0; i < auxCount; ++i) {
+      const uint32_t pair = auxPtr[i];
+      const uint32_t slotNo = HllUtil<A>::getLow26(pair) & configKmask;
+      const uint8_t value = HllUtil<A>::getValue(pair);
       auxHashMap->mustAdd(slotNo, value);
     }
   } else { // updatable
-    int itemsToRead = 1 << lgAuxArrInts;
-    if (len < itemsToRead * sizeof(int)) {
+    uint32_t itemsToRead = 1 << lgAuxArrInts;
+    if (len < itemsToRead * sizeof(uint32_t)) {
       throw std::out_of_range("Input array too small to hold AuxHashMap image");
     }
     auxHashMap = new (ahmAlloc(allocator).allocate(1)) AuxHashMap<A>(lgArrInts, lgConfigK, allocator);
-    for (int i = 0; i < itemsToRead; ++i) {
-      int pair = auxPtr[i];
-      if (pair == HllUtil<A>::EMPTY) { continue; }
-      int slotNo = HllUtil<A>::getLow26(pair) & configKmask;
-      int value = HllUtil<A>::getValue(pair);
+    for (uint32_t i = 0; i < itemsToRead; ++i) {
+      const uint32_t pair = auxPtr[i];
+      if (pair == hll_constants::EMPTY) { continue; }
+      const uint32_t slotNo = HllUtil<A>::getLow26(pair) & configKmask;
+      const uint8_t value = HllUtil<A>::getValue(pair);
       auxHashMap->mustAdd(slotNo, value);
     }
   }
@@ -94,10 +94,10 @@ AuxHashMap<A>* AuxHashMap<A>::deserialize(const void* bytes, size_t len,
 }
 
 template<typename A>
-AuxHashMap<A>* AuxHashMap<A>::deserialize(std::istream& is, const int lgConfigK,
-                                          const int auxCount, const int lgAuxArrInts,
-                                          const bool srcCompact, const A& allocator) {
-  int lgArrInts = lgAuxArrInts;
+AuxHashMap<A>* AuxHashMap<A>::deserialize(std::istream& is, uint8_t lgConfigK,
+                                          uint32_t auxCount, uint8_t lgAuxArrInts,
+                                          bool srcCompact, const A& allocator) {
+  uint8_t lgArrInts = lgAuxArrInts;
   if (srcCompact) { // early compact versions didn't use LgArr byte field so ignore input
     lgArrInts = HllUtil<A>::computeLgArrInts(HLL, auxCount, lgConfigK);
   } else { // updatable
@@ -108,24 +108,22 @@ AuxHashMap<A>* AuxHashMap<A>::deserialize(std::istream& is, const int lgConfigK,
   typedef std::unique_ptr<AuxHashMap<A>, std::function<void(AuxHashMap<A>*)>> aux_hash_map_ptr;
   aux_hash_map_ptr aux_ptr(auxHashMap, auxHashMap->make_deleter());
 
-  int configKmask = (1 << lgConfigK) - 1;
+  const uint32_t configKmask = (1 << lgConfigK) - 1;
 
   if (srcCompact) {
-    int pair;
-    for (int i = 0; i < auxCount; ++i) {
-      is.read((char*)&pair, sizeof(pair));
-      int slotNo = HllUtil<A>::getLow26(pair) & configKmask;
-      int value = HllUtil<A>::getValue(pair);
+    for (uint32_t i = 0; i < auxCount; ++i) {
+      const auto pair = read<int>(is);
+      uint32_t slotNo = HllUtil<A>::getLow26(pair) & configKmask;
+      uint8_t value = HllUtil<A>::getValue(pair);
       auxHashMap->mustAdd(slotNo, value);
     }
   } else { // updatable
-    int itemsToRead = 1 << lgAuxArrInts;
-    int pair;
-    for (int i = 0; i < itemsToRead; ++i) {
-      is.read((char*)&pair, sizeof(pair));
-      if (pair == HllUtil<A>::EMPTY) { continue; }
-      int slotNo = HllUtil<A>::getLow26(pair) & configKmask;
-      int value = HllUtil<A>::getValue(pair);
+    const uint32_t itemsToRead = 1 << lgAuxArrInts;
+    for (uint32_t i = 0; i < itemsToRead; ++i) {
+      const auto pair = read<int>(is);
+      if (pair == hll_constants::EMPTY) { continue; }
+      const uint32_t slotNo = HllUtil<A>::getLow26(pair) & configKmask;
+      const uint8_t value = HllUtil<A>::getValue(pair);
       auxHashMap->mustAdd(slotNo, value);
     }
   }
@@ -153,34 +151,34 @@ AuxHashMap<A>* AuxHashMap<A>::copy() const {
 }
 
 template<typename A>
-int AuxHashMap<A>::getAuxCount() const {
+uint32_t AuxHashMap<A>::getAuxCount() const {
   return auxCount;
 }
 
 template<typename A>
-int* AuxHashMap<A>::getAuxIntArr(){
+uint32_t* AuxHashMap<A>::getAuxIntArr(){
   return entries.data();
 }
 
 template<typename A>
-int AuxHashMap<A>::getLgAuxArrInts() const {
+uint8_t AuxHashMap<A>::getLgAuxArrInts() const {
   return lgAuxArrInts;
 }
 
 template<typename A>
-int AuxHashMap<A>::getCompactSizeBytes() const {
+uint32_t AuxHashMap<A>::getCompactSizeBytes() const {
   return auxCount << 2;
 }
 
 template<typename A>
-int AuxHashMap<A>::getUpdatableSizeBytes() const {
+uint32_t AuxHashMap<A>::getUpdatableSizeBytes() const {
   return 4 << lgAuxArrInts;
 }
 
 template<typename A>
-void AuxHashMap<A>::mustAdd(const int slotNo, const int value) {
-  const int index = find(entries.data(), lgAuxArrInts, lgConfigK, slotNo);
-  const int entry_pair = HllUtil<A>::pair(slotNo, value);
+void AuxHashMap<A>::mustAdd(uint32_t slotNo, uint8_t value) {
+  const int32_t index = find(entries.data(), lgAuxArrInts, lgConfigK, slotNo);
+  const uint32_t entry_pair = HllUtil<A>::pair(slotNo, value);
   if (index >= 0) {
     throw std::invalid_argument("Found a slotNo that should not be there: SlotNo: "
                                 + std::to_string(slotNo) + ", Value: " + std::to_string(value));
@@ -193,8 +191,8 @@ void AuxHashMap<A>::mustAdd(const int slotNo, const int value) {
 }
 
 template<typename A>
-int AuxHashMap<A>::mustFindValueFor(const int slotNo) const {
-  const int index = find(entries.data(), lgAuxArrInts, lgConfigK, slotNo);
+uint8_t AuxHashMap<A>::mustFindValueFor(uint32_t slotNo) const {
+  const int32_t index = find(entries.data(), lgAuxArrInts, lgConfigK, slotNo);
   if (index >= 0) {
     return HllUtil<A>::getValue(entries[index]);
   }
@@ -203,8 +201,8 @@ int AuxHashMap<A>::mustFindValueFor(const int slotNo) const {
 }
 
 template<typename A>
-void AuxHashMap<A>::mustReplace(const int slotNo, const int value) {
-  const int idx = find(entries.data(), lgAuxArrInts, lgConfigK, slotNo);
+void AuxHashMap<A>::mustReplace(uint32_t slotNo, uint8_t value) {
+  const int32_t idx = find(entries.data(), lgAuxArrInts, lgConfigK, slotNo);
   if (idx >= 0) {
     entries[idx] = HllUtil<A>::pair(slotNo, value);
     return;
@@ -216,7 +214,7 @@ void AuxHashMap<A>::mustReplace(const int slotNo, const int value) {
 
 template<typename A>
 void AuxHashMap<A>::checkGrow() {
-  if ((HllUtil<A>::RESIZE_DENOM * auxCount) > (HllUtil<A>::RESIZE_NUMER * (1 << lgAuxArrInts))) {
+  if ((hll_constants::RESIZE_DENOM * auxCount) > (hll_constants::RESIZE_NUMER * (1 << lgAuxArrInts))) {
     growAuxSpace();
   }
 }
@@ -227,10 +225,10 @@ void AuxHashMap<A>::growAuxSpace() {
   const int newArrLen = 1 << ++lgAuxArrInts;
   vector_int entries_new(newArrLen, 0, entries.get_allocator());
   for (size_t i = 0; i < entries.size(); ++i) {
-    const int fetched = entries[i];
-    if (fetched != HllUtil<A>::EMPTY) {
+    const uint32_t fetched = entries[i];
+    if (fetched != hll_constants::EMPTY) {
       // find empty in new array
-      const int idx = find(entries_new.data(), lgAuxArrInts, lgConfigK, fetched & configKmask);
+      const int32_t idx = find(entries_new.data(), lgAuxArrInts, lgConfigK, fetched & configKmask);
       entries_new[~idx] = fetched;
     }
   }
@@ -243,21 +241,20 @@ void AuxHashMap<A>::growAuxSpace() {
 //Continues searching.
 //If the probe comes back to original index, throws an exception.
 template<typename A>
-int AuxHashMap<A>::find(const int* auxArr, const int lgAuxArrInts, const int lgConfigK,
-                        const int slotNo) {
-  const int auxArrMask = (1 << lgAuxArrInts) - 1;
-  const int configKmask = (1 << lgConfigK) - 1;
-  int probe = slotNo & auxArrMask;
-  const  int loopIndex = probe;
+int32_t AuxHashMap<A>::find(const uint32_t* auxArr, uint8_t lgAuxArrInts, uint8_t lgConfigK, uint32_t slotNo) {
+  const uint32_t auxArrMask = (1 << lgAuxArrInts) - 1;
+  const uint32_t configKmask = (1 << lgConfigK) - 1;
+  uint32_t probe = slotNo & auxArrMask;
+  const uint32_t loopIndex = probe;
   do {
-    const int arrVal = auxArr[probe];
-    if (arrVal == HllUtil<A>::EMPTY) { //Compares on entire entry
+    const uint32_t arrVal = auxArr[probe];
+    if (arrVal == hll_constants::EMPTY) { //Compares on entire entry
       return ~probe; //empty
     }
     else if (slotNo == (arrVal & configKmask)) { //Compares only on slotNo
       return probe; //found given slotNo, return probe = index into aux array
     }
-    const int stride = (slotNo >> lgAuxArrInts) | 1;
+    const uint32_t stride = (slotNo >> lgAuxArrInts) | 1;
     probe = (probe + stride) & auxArrMask;
   } while (probe != loopIndex);
   throw std::runtime_error("Key not found and no empty slots!");
@@ -265,12 +262,12 @@ int AuxHashMap<A>::find(const int* auxArr, const int lgAuxArrInts, const int lgC
 
 template<typename A>
 coupon_iterator<A> AuxHashMap<A>::begin(bool all) const {
-  return coupon_iterator<A>(entries.data(), 1 << lgAuxArrInts, 0, all);
+  return coupon_iterator<A>(entries.data(), 1ULL << lgAuxArrInts, 0, all);
 }
 
 template<typename A>
 coupon_iterator<A> AuxHashMap<A>::end() const {
-  return coupon_iterator<A>(entries.data(), 1 << lgAuxArrInts, 1 << lgAuxArrInts, false);
+  return coupon_iterator<A>(entries.data(), 1ULL << lgAuxArrInts, 1ULL << lgAuxArrInts, false);
 }
 
 }

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

@@ -31,49 +31,49 @@ namespace datasketches {
 template<typename A>
 class AuxHashMap final {
   public:
-    AuxHashMap(int lgAuxArrInts, int lgConfigK, const A& allocator);
-    static AuxHashMap* newAuxHashMap(int lgAuxArrInts, int lgConfigK, const A& allocator);
+    AuxHashMap(uint8_t lgAuxArrInts, uint8_t lgConfigK, const A& allocator);
+    static AuxHashMap* newAuxHashMap(uint8_t lgAuxArrInts, uint8_t lgConfigK, const A& allocator);
     static AuxHashMap* newAuxHashMap(const AuxHashMap<A>& that);
 
     static AuxHashMap* deserialize(const void* bytes, size_t len,
-                                   int lgConfigK,
-                                   int auxCount, int lgAuxArrInts,
+                                   uint8_t lgConfigK,
+                                   uint32_t auxCount, uint8_t lgAuxArrInts,
                                    bool srcCompact, const A& allocator);
-    static AuxHashMap* deserialize(std::istream& is, int lgConfigK,
-                                   int auxCount, int lgAuxArrInts,
+    static AuxHashMap* deserialize(std::istream& is, uint8_t lgConfigK,
+                                   uint32_t auxCount, uint8_t lgAuxArrInts,
                                    bool srcCompact, const A& allocator);
     virtual ~AuxHashMap() = default;
     static std::function<void(AuxHashMap<A>*)> make_deleter();
     
     AuxHashMap* copy() const;
-    int getUpdatableSizeBytes() const;
-    int getCompactSizeBytes() const;
+    uint32_t getUpdatableSizeBytes() const;
+    uint32_t getCompactSizeBytes() const;
 
-    int getAuxCount() const;
-    int* getAuxIntArr();
-    int getLgAuxArrInts() const;
+    uint32_t getAuxCount() const;
+    uint32_t* getAuxIntArr();
+    uint8_t getLgAuxArrInts() const;
 
     coupon_iterator<A> begin(bool all = false) const;
     coupon_iterator<A> end() const;
 
-    void mustAdd(int slotNo, int value);
-    int mustFindValueFor(int slotNo) const;
-    void mustReplace(int slotNo, int value);
+    void mustAdd(uint32_t slotNo, uint8_t value);
+    uint8_t mustFindValueFor(uint32_t slotNo) const;
+    void mustReplace(uint32_t slotNo, uint8_t value);
 
   private:
     typedef typename std::allocator_traits<A>::template rebind_alloc<AuxHashMap<A>> ahmAlloc;
 
-    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>>;
 
     // static so it can be used when resizing
-    static int find(const int* auxArr, int lgAuxArrInts, int lgConfigK, int slotNo);
+    static int32_t find(const uint32_t* auxArr, uint8_t lgAuxArrInts, uint8_t lgConfigK, uint32_t slotNo);
 
     void checkGrow();
     void growAuxSpace();
 
-    const int lgConfigK;
-    int lgAuxArrInts;
-    int auxCount;
+    const uint8_t lgConfigK;
+    uint8_t lgAuxArrInts;
+    uint32_t auxCount;
     vector_int entries;
 };
 

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

@@ -27,30 +27,30 @@
 
 namespace datasketches {
 
-static const int numXArrValues = 257;
+static const uint32_t numXArrValues = 257;
 
 /**
  * 18 Values, index 0 is LgK = 4, index 17 is LgK = 21.
  */
-static const int yStrides[] =
+static const uint32_t yStrides[] =
   {1, 2, 3, 5, 10, 20, 40, 80, 160, 320, 640, 1280, 2560, 5120, 10240, 20480, 40960, 81920};
 
 template<typename A>
-int CompositeInterpolationXTable<A>::get_y_stride(const int logK) {
-  if (logK < HllUtil<A>::MIN_LOG_K || logK > HllUtil<A>::MAX_LOG_K) {
-    throw std::invalid_argument("logK must be in range [" + std::to_string(HllUtil<A>::MIN_LOG_K)
-                                + ", " + std::to_string(HllUtil<A>::MAX_LOG_K) + "]. Found: "
+uint32_t CompositeInterpolationXTable<A>::get_y_stride(uint8_t logK) {
+  if (logK < hll_constants::MIN_LOG_K || logK > hll_constants::MAX_LOG_K) {
+    throw std::invalid_argument("logK must be in range [" + std::to_string(hll_constants::MIN_LOG_K)
+                                + ", " + std::to_string(hll_constants::MAX_LOG_K) + "]. Found: "
                                 + std::to_string(logK));
   }
-  return yStrides[logK - HllUtil<A>::MIN_LOG_K];
+  return yStrides[logK - hll_constants::MIN_LOG_K];
 }
 
 template<typename A>
-int CompositeInterpolationXTable<A>::get_x_arr_length() {
+uint32_t CompositeInterpolationXTable<A>::get_x_arr_length() {
   return numXArrValues;
 }
 
-static const double xArr[18][numXArrValues] = {
+static const double xArray[18][numXArrValues] = {
 {
   10.767999803534, 11.237701481774, 11.722738717438, 12.223246391222,
   12.739366773787, 13.271184824495, 13.818759686650, 14.382159835785,
@@ -797,15 +797,15 @@ static const double xArr[18][numXArrValues] = {
 };
 
 template<typename A>
-const double* CompositeInterpolationXTable<A>::get_x_arr(const int logK) {
-  if (logK < HllUtil<A>::MIN_LOG_K || logK > HllUtil<A>::MAX_LOG_K) {
-    throw std::invalid_argument("logK must be in range [" + std::to_string(HllUtil<A>::MIN_LOG_K)
-                                + ", " + std::to_string(HllUtil<A>::MAX_LOG_K) + "]. Found: "
+const double* CompositeInterpolationXTable<A>::get_x_arr(uint8_t logK) {
+  if (logK < hll_constants::MIN_LOG_K || logK > hll_constants::MAX_LOG_K) {
+    throw std::invalid_argument("logK must be in range [" + std::to_string(hll_constants::MIN_LOG_K)
+                                + ", " + std::to_string(hll_constants::MAX_LOG_K) + "]. Found: "
                                 + std::to_string(logK));
   }
-  return xArr[logK - HllUtil<A>::MIN_LOG_K];
+  return xArray[logK - hll_constants::MIN_LOG_K];
 }
 
 }
 
-#endif // _COMPOSITEINTERPOLATIONXTABLE_INTERNAL_HPP_
+#endif // _COMPOSITEINTERPOLATIONXTABLE_INTERNAL_HPP_

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

@@ -27,10 +27,10 @@ namespace datasketches {
 template<typename A = std::allocator<uint8_t>>
 class CompositeInterpolationXTable {
   public:
-    static int get_y_stride(int logK);
+    static uint32_t get_y_stride(uint8_t logK);
 
-    static const double* get_x_arr(int logK);
-    static int get_x_arr_length();
+    static const double* get_x_arr(uint8_t logK);
+    static uint32_t get_x_arr_length();
 };
 
 }