datasketches 0.2.1 → 0.2.2

data/vendor/datasketches-cpp/fi/include/reverse_purge_hash_map_impl.hpp

@@ -39,15 +39,15 @@ allocator_(allocator),
 lg_cur_size_(lg_cur_size),
 lg_max_size_(lg_max_size),
 num_active_(0),
-keys_(allocator_.allocate(1 << lg_cur_size)),
+keys_(allocator_.allocate(1ULL << lg_cur_size)),
 values_(nullptr),
 states_(nullptr)
 {
   AllocV av(allocator_);
-  values_ = av.allocate(1 << lg_cur_size);
+  values_ = av.allocate(1ULL << lg_cur_size);
   AllocU16 au16(allocator_);
-  states_ = au16.allocate(1 << lg_cur_size);
-  std::fill(states_, states_ + (1 << lg_cur_size), 0);
+  states_ = au16.allocate(1ULL << lg_cur_size);
+  std::fill(states_, states_ + (1ULL << lg_cur_size), static_cast<uint16_t>(0));
 }
 
 template<typename K, typename V, typename H, typename E, typename A>
@@ -56,14 +56,14 @@ allocator_(other.allocator_),
 lg_cur_size_(other.lg_cur_size_),
 lg_max_size_(other.lg_max_size_),
 num_active_(other.num_active_),
-keys_(allocator_.allocate(1 << lg_cur_size_)),
+keys_(allocator_.allocate(1ULL << lg_cur_size_)),
 values_(nullptr),
 states_(nullptr)
 {
   AllocV av(allocator_);
-  values_ = av.allocate(1 << lg_cur_size_);
+  values_ = av.allocate(1ULL << lg_cur_size_);
   AllocU16 au16(allocator_);
-  states_ = au16.allocate(1 << lg_cur_size_);
+  states_ = au16.allocate(1ULL << lg_cur_size_);
   const uint32_t size = 1 << lg_cur_size_;
   if (num_active_ > 0) {
     auto num = num_active_;
@@ -177,7 +177,7 @@ uint8_t reverse_purge_hash_map<K, V, H, E, A>::get_lg_max_size() const {
 
 template<typename K, typename V, typename H, typename E, typename A>
 uint32_t reverse_purge_hash_map<K, V, H, E, A>::get_capacity() const {
-  return (1 << lg_cur_size_) * LOAD_FACTOR;
+  return static_cast<uint32_t>((1 << lg_cur_size_) * LOAD_FACTOR);
 }
 
 template<typename K, typename V, typename H, typename E, typename A>
@@ -246,7 +246,7 @@ void reverse_purge_hash_map<K, V, H, E, A>::hash_delete(uint32_t delete_index) {
   // if none are found, the status is changed
   states_[delete_index] = 0; // mark as empty
   keys_[delete_index].~K();
-  uint32_t drift = 1;
+  uint16_t drift = 1;
   const uint32_t mask = (1 << lg_cur_size_) - 1;
   uint32_t probe = (delete_index + drift) & mask; // map length must be a power of 2
   // advance until we find a free location replacing locations as needed
@@ -322,7 +322,7 @@ void reverse_purge_hash_map<K, V, H, E, A>::resize(uint8_t lg_new_size) {
   values_ = av.allocate(new_size);
   AllocU16 au16(allocator_);
   states_ = au16.allocate(new_size);
-  std::fill(states_, states_ + new_size, 0);
+  std::fill(states_, states_ + new_size, static_cast<uint16_t>(0));
   num_active_ = 0;
   lg_cur_size_ = lg_new_size;
   for (uint32_t i = 0; i < old_size; i++) {

data/vendor/datasketches-cpp/fi/test/reverse_purge_hash_map_test.cpp

@@ -39,8 +39,8 @@ TEST_CASE("reverse purge hash map: one item", "[frequent_items_sketch]") {
 TEST_CASE("reverse purge hash map: iterator", "[frequent_items_sketch]") {
   reverse_purge_hash_map<int> map(3, 4, std::allocator<int>());
   for (int i = 0; i < 11; i++) map.adjust_or_insert(i, 1); // this should fit with no purge
-  int sum = 0;
-  for (auto &it: map) sum += it.second;
+  uint64_t sum = 0;
+  for (auto it: map) sum += it.second;
   REQUIRE(sum == 11);
 }
 

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_