datasketches 0.4.3 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d80465f08285b46a56497ab21c0b77afa47eb183f49d463548113480a86a0128
-  data.tar.gz: 0e88f707d65bb9b40790c6e9a3a378395cddcc5ebd4ff367fc2f31523b6efc77
+  metadata.gz: 427f1c95c4dc0782a7003f24b155b39d0b01560e57ff2046785d3254e79250c0
+  data.tar.gz: 820d72e4c907cb7d59bd808d2b837692032f038dac06cf96d0767531cc68370e
 SHA512:
-  metadata.gz: 7b19e71cfeccb68714641f6a0cf84e24939f658dc52d328bd5cb05af8433e9622cfe4e4b51a1ed90929be273b1024989261cceae0447a7a328734a1e1c239509
-  data.tar.gz: ba51c3c7512c91bf77f6a309a28e4b2e7914812faa4bef78362eeecdc06ebcf4faaaf80931f63688acfe3ee5e27ebd1d325c9848ad3f14fc96181ea6cbf1b909
+  metadata.gz: 03abee1fa7222628c3e3b00c9fed91218abf17a9dd8116aa6c55e37112a33506c11333533580a3804ce764bbce17ac4db08450e3cf82a52a36e924abd2391762
+  data.tar.gz: e838d14d5f43706dd85a51a45074e224131bc0ecd9157dfc350b2f990c6d54b9338dfb48fc0ad14d86f2d74ef2b855a385e4a67aa3be6e173bf5610887e18e04

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.4.4 (2025-01-15)
+
+- Updated DataSketches to 5.2.0
+
 ## 0.4.3 (2024-08-02)
 
 - Updated DataSketches to 5.1.0

data/ext/datasketches/vo_wrapper.cpp

@@ -8,7 +8,7 @@ using datasketches::var_opt_sketch;
 
 template<typename T>
 void bind_vo_sketch(Rice::Module &m, const char* name) {
-  Rice::define_class_under<var_opt_sketch<T>>(m, "VarOptSketch")
+  Rice::define_class_under<var_opt_sketch<T>>(m, name)
     .define_constructor(Rice::Constructor<var_opt_sketch<T>, uint32_t>())
     .define_method("k", &var_opt_sketch<T>::get_k)
     .define_method("n", &var_opt_sketch<T>::get_n)

data/lib/datasketches/version.rb

@@ -1,3 +1,3 @@
 module DataSketches
-  VERSION = "0.4.3"
+  VERSION = "0.4.4"
 end

data/vendor/datasketches-cpp/CMakeLists.txt

@@ -119,6 +119,7 @@ add_subdirectory(quantiles)
 add_subdirectory(count)
 add_subdirectory(density)
 add_subdirectory(tdigest)
+add_subdirectory(filters)
 
 if (WITH_PYTHON)
   add_subdirectory(python)

data/vendor/datasketches-cpp/LICENSE

@@ -207,9 +207,9 @@ APPENDIX A: How to apply the Apache License to your work.
 
 APPENDIX B: Additional licenses relevant to this product.
 
-    This product includes a number of source files with code that has been 
-    adapted from 3rd party sources including sources that may be subject 
-    to different copyright notices and license terms. Your use of 
+    This product includes a number of source files with code that has been
+    adapted from 3rd party sources including sources that may be subject
+    to different copyright notices and license terms. Your use of
     the source code for these subcomponents is subject to the terms and
     conditions of the following licenses.
 
@@ -221,7 +221,7 @@ APPENDIX B: Additional licenses relevant to this product.
        https://github.com/catchorg/Catch2/blob/v2.x/LICENSE.txt
 
     Boost Software License - Version 1.0 - August 17th, 2003
-    
+
     Permission is hereby granted, free of charge, to any person or organization
     obtaining a copy of the software and accompanying documentation covered by
     this license (the "Software") to use, reproduce, display, distribute,
@@ -248,6 +248,35 @@ APPENDIX B: Additional licenses relevant to this product.
     Found in the Catch2 unit test code that is downloaded from github.com as part
     of CMake configuration if configured to build tests.
 
+    =============================================================
+    MIT License
+    =============================================================
+
+    Original source:
+      https://github.com/stbrumme/xxhash/blob/master/LICENSE
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the Software
+    is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included
+    in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+    INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+    PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+    Code Location:
+      common/include/xxhash64.h
+    Original source code:
+      Copyright (c) 2018 Stephan Brumme
+      https://github.com/stbrumme/xxhash/blob/master/xxhash64.h
 
     =============================================================
     Public Domain
@@ -255,7 +284,7 @@ APPENDIX B: Additional licenses relevant to this product.
     Original source code:
        https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp
        Placed in the Public Domain by Austin Appleby
-    
+
     Code Locations:
       common/include/MurmurHash3.h
     that is adapted from the above.
@@ -263,8 +292,7 @@ APPENDIX B: Additional licenses relevant to this product.
     Original source code:
       * https://graphics.stanford.edu/~seander/bithacks.html
       * Placed in the Public Domain by Sean Eron Anderson
-      
+
     Code Locations:
       * common/include/ceiling_power_of_2.hpp
     that is adapted from the above.
-  

data/vendor/datasketches-cpp/NOTICE

@@ -1,9 +1,9 @@
 Apache DataSketches C++
-Copyright 2024 The Apache Software Foundation
+Copyright 2025 The Apache Software Foundation
 
 Copyright 2015-2018 Yahoo Inc.
 Copyright 2019-2020 Verizon Media
-Copyright 2021 Yahoo Inc.
+Copyright 2021- Yahoo Inc.
 
 This product includes software developed at
 The Apache Software Foundation (http://www.apache.org/).

data/vendor/datasketches-cpp/common/CMakeLists.txt

@@ -31,7 +31,7 @@ target_include_directories(common
 
 install(TARGETS common EXPORT ${PROJECT_NAME})
 
-install(FILES 
+install(FILES
 			${CMAKE_CURRENT_BINARY_DIR}/include/version.hpp
       include/binomial_bounds.hpp
       include/bounds_binomial_proportions.hpp
@@ -49,4 +49,5 @@ install(FILES
       include/quantiles_sorted_view_impl.hpp
 			include/quantiles_sorted_view.hpp
       include/serde.hpp
+      include/xxhash64.h
   DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/DataSketches")

data/vendor/datasketches-cpp/common/include/common_defs.hpp

@@ -42,6 +42,7 @@ namespace random_utils {
   static std::random_device rd; // possibly unsafe in MinGW with GCC < 9.2
   static thread_local std::mt19937_64 rand(rd());
   static thread_local std::uniform_real_distribution<> next_double(0.0, 1.0);
+  static thread_local std::uniform_int_distribution<uint64_t> next_uint64(0, UINT64_MAX);
 
   // thread-safe random bit
   static thread_local std::independent_bits_engine<std::mt19937, 1, uint32_t>

data/vendor/datasketches-cpp/common/include/quantiles_sorted_view_impl.hpp

@@ -86,19 +86,17 @@ auto quantiles_sorted_view<T, C, A>::get_quantile(double rank, bool inclusive) c
 template<typename T, typename C, typename A>
 auto quantiles_sorted_view<T, C, A>::get_CDF(const T* split_points, uint32_t size, bool inclusive) const -> vector_double {
   if (entries_.empty()) throw std::runtime_error("operation is undefined for an empty sketch");
-  vector_double buckets(entries_.get_allocator());
-  if (entries_.size() == 0) return buckets;
   check_split_points(split_points, size);
-  buckets.reserve(size + 1);
-  for (uint32_t i = 0; i < size; ++i) buckets.push_back(get_rank(split_points[i], inclusive));
-  buckets.push_back(1);
-  return buckets;
+  vector_double ranks(entries_.get_allocator());
+  ranks.reserve(size + 1);
+  for (uint32_t i = 0; i < size; ++i) ranks.push_back(get_rank(split_points[i], inclusive));
+  ranks.push_back(1);
+  return ranks;
 }
 
 template<typename T, typename C, typename A>
 auto quantiles_sorted_view<T, C, A>::get_PMF(const T* split_points, uint32_t size, bool inclusive) const -> vector_double {
   auto buckets = get_CDF(split_points, size, inclusive);
-  if (buckets.size() == 0) return buckets;
   for (uint32_t i = size; i > 0; --i) {
     buckets[i] -= buckets[i - 1];
   }

data/vendor/datasketches-cpp/common/include/xxhash64.h

@@ -0,0 +1,202 @@
+// //////////////////////////////////////////////////////////
+// xxhash64.h
+// Copyright (c) 2016 Stephan Brumme. All rights reserved.
+// see http://create.stephan-brumme.com/disclaimer.html
+//
+
+#pragma once
+#include <stdint.h> // for uint32_t and uint64_t
+
+/// XXHash (64 bit), based on Yann Collet's descriptions, see http://cyan4973.github.io/xxHash/
+/** How to use:
+    uint64_t myseed = 0;
+    XXHash64 myhash(myseed);
+    myhash.add(pointerToSomeBytes,     numberOfBytes);
+    myhash.add(pointerToSomeMoreBytes, numberOfMoreBytes); // call add() as often as you like to ...
+    // and compute hash:
+    uint64_t result = myhash.hash();
+
+    // or all of the above in one single line:
+    uint64_t result2 = XXHash64::hash(mypointer, numBytes, myseed);
+
+    Note: my code is NOT endian-aware !
+**/
+class XXHash64
+{
+public:
+  /// create new XXHash (64 bit)
+  /** @param seed your seed value, even zero is a valid seed **/
+  explicit XXHash64(uint64_t seed)
+  {
+    state[0] = seed + Prime1 + Prime2;
+    state[1] = seed + Prime2;
+    state[2] = seed;
+    state[3] = seed - Prime1;
+    bufferSize  = 0;
+    totalLength = 0;
+  }
+
+  /// add a chunk of bytes
+  /** @param  input  pointer to a continuous block of data
+      @param  length number of bytes
+      @return false if parameters are invalid / zero **/
+  bool add(const void* input, uint64_t length)
+  {
+    // no data ?
+    if (!input || length == 0)
+      return false;
+
+    totalLength += length;
+    // byte-wise access
+    const unsigned char* data = (const unsigned char*)input;
+
+    // unprocessed old data plus new data still fit in temporary buffer ?
+    if (bufferSize + length < MaxBufferSize)
+    {
+      // just add new data
+      while (length-- > 0)
+        buffer[bufferSize++] = *data++;
+      return true;
+    }
+
+    // point beyond last byte
+    const unsigned char* stop      = data + length;
+    const unsigned char* stopBlock = stop - MaxBufferSize;
+
+    // some data left from previous update ?
+    if (bufferSize > 0)
+    {
+      // make sure temporary buffer is full (16 bytes)
+      while (bufferSize < MaxBufferSize)
+        buffer[bufferSize++] = *data++;
+
+      // process these 32 bytes (4x8)
+      process(buffer, state[0], state[1], state[2], state[3]);
+    }
+
+    // copying state to local variables helps optimizer A LOT
+    uint64_t s0 = state[0], s1 = state[1], s2 = state[2], s3 = state[3];
+    // 32 bytes at once
+    while (data <= stopBlock)
+    {
+      // local variables s0..s3 instead of state[0]..state[3] are much faster
+      process(data, s0, s1, s2, s3);
+      data += 32;
+    }
+    // copy back
+    state[0] = s0; state[1] = s1; state[2] = s2; state[3] = s3;
+
+    // copy remainder to temporary buffer
+    bufferSize = stop - data;
+    for (uint64_t i = 0; i < bufferSize; i++)
+      buffer[i] = data[i];
+
+    // done
+    return true;
+  }
+
+  /// get current hash
+  /** @return 64 bit XXHash **/
+  uint64_t hash() const
+  {
+    // fold 256 bit state into one single 64 bit value
+    uint64_t result;
+    if (totalLength >= MaxBufferSize)
+    {
+      result = rotateLeft(state[0],  1) +
+               rotateLeft(state[1],  7) +
+               rotateLeft(state[2], 12) +
+               rotateLeft(state[3], 18);
+      result = (result ^ processSingle(0, state[0])) * Prime1 + Prime4;
+      result = (result ^ processSingle(0, state[1])) * Prime1 + Prime4;
+      result = (result ^ processSingle(0, state[2])) * Prime1 + Prime4;
+      result = (result ^ processSingle(0, state[3])) * Prime1 + Prime4;
+    }
+    else
+    {
+      // internal state wasn't set in add(), therefore original seed is still stored in state2
+      result = state[2] + Prime5;
+    }
+
+    result += totalLength;
+
+    // process remaining bytes in temporary buffer
+    const unsigned char* data = buffer;
+    // point beyond last byte
+    const unsigned char* stop = data + bufferSize;
+
+    // at least 8 bytes left ? => eat 8 bytes per step
+    for (; data + 8 <= stop; data += 8)
+      result = rotateLeft(result ^ processSingle(0, *(uint64_t*)data), 27) * Prime1 + Prime4;
+
+    // 4 bytes left ? => eat those
+    if (data + 4 <= stop)
+    {
+      result = rotateLeft(result ^ (*(uint32_t*)data) * Prime1,   23) * Prime2 + Prime3;
+      data  += 4;
+    }
+
+    // take care of remaining 0..3 bytes, eat 1 byte per step
+    while (data != stop)
+      result = rotateLeft(result ^ (*data++) * Prime5,            11) * Prime1;
+
+    // mix bits
+    result ^= result >> 33;
+    result *= Prime2;
+    result ^= result >> 29;
+    result *= Prime3;
+    result ^= result >> 32;
+    return result;
+  }
+
+
+  /// combine constructor, add() and hash() in one static function (C style)
+  /** @param  input  pointer to a continuous block of data
+      @param  length number of bytes
+      @param  seed your seed value, e.g. zero is a valid seed
+      @return 64 bit XXHash **/
+  static uint64_t hash(const void* input, uint64_t length, uint64_t seed)
+  {
+    XXHash64 hasher(seed);
+    hasher.add(input, length);
+      return hasher.hash();
+  }
+
+private:
+  /// magic constants :-)
+  static const uint64_t Prime1 = 11400714785074694791ULL;
+  static const uint64_t Prime2 = 14029467366897019727ULL;
+  static const uint64_t Prime3 =  1609587929392839161ULL;
+  static const uint64_t Prime4 =  9650029242287828579ULL;
+  static const uint64_t Prime5 =  2870177450012600261ULL;
+
+  /// temporarily store up to 31 bytes between multiple add() calls
+  static const uint64_t MaxBufferSize = 31+1;
+
+  uint64_t      state[4];
+  unsigned char buffer[MaxBufferSize];
+  uint64_t      bufferSize;
+  uint64_t      totalLength;
+
+  /// rotate bits, should compile to a single CPU instruction (ROL)
+  static inline uint64_t rotateLeft(uint64_t x, unsigned char bits)
+  {
+    return (x << bits) | (x >> (64 - bits));
+  }
+
+  /// process a single 64 bit value
+  static inline uint64_t processSingle(uint64_t previous, uint64_t input)
+  {
+    return rotateLeft(previous + input * Prime2, 31) * Prime1;
+  }
+
+  /// process a block of 4x4 bytes, this is the main part of the XXHash32 algorithm
+  static inline void process(const void* data, uint64_t& state0, uint64_t& state1, uint64_t& state2, uint64_t& state3)
+  {
+    const uint64_t* block = (const uint64_t*) data;
+    state0 = processSingle(state0, block[0]);
+    state1 = processSingle(state1, block[1]);
+    state2 = processSingle(state2, block[2]);
+    state3 = processSingle(state3, block[3]);
+  }
+};

data/vendor/datasketches-cpp/filters/CMakeLists.txt

@@ -0,0 +1,43 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+add_library(filters INTERFACE)
+
+add_library(${PROJECT_NAME}::FILTERS ALIAS filters)
+
+if (BUILD_TESTS)
+  add_subdirectory(test)
+endif()
+
+target_include_directories(filters
+  INTERFACE
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>
+)
+
+target_link_libraries(filters INTERFACE common)
+
+install(TARGETS filters
+  EXPORT ${PROJECT_NAME}
+)
+
+install(FILES
+		include/bloom_filter.hpp
+		include/bloom_filter_impl.hpp
+    include/bloom_filter_builder_impl.hpp
+		include/bit_array_ops.hpp
+  DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/DataSketches")

data/vendor/datasketches-cpp/filters/include/bit_array_ops.hpp

@@ -0,0 +1,180 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef _BIT_ARRAY_OPS_HPP_
+#define _BIT_ARRAY_OPS_HPP_
+
+#include <bitset>
+
+namespace datasketches {
+
+/**
+ * This class comprises methods that operate one or more arrays of bits (uint8_t*) to
+ * provide bit array operations. The class does not take ownership of memory and operates On
+ * arrays in-place. Sizes of the arrays, in bytes, are passed in as arguments.
+ *
+ * None of the methods in this class perform bounds checks. The caller is responsible for ensuring
+ * that indices are within the array bounds.
+ *
+ * Implementation assumes the actual arrays are multiples of 64 bits in length.
+ */
+namespace bit_array_ops {
+
+  /**
+   * Get the value of a bit at the given index.
+   * @param array the array of bits
+   * @param index the index of the bit to get
+   * @return the value of the bit at the given index.
+   */
+  static inline bool get_bit(uint8_t* array, uint64_t index) {
+    return (array[index >> 3] & (1 << (index & 7))) != 0;
+  }
+
+  /**
+   * Set the bit at the given index to 1.
+   * @param array the array of bits
+   * @param index the index of the bit to set.
+   */
+  static inline void set_bit(uint8_t* array, uint64_t index) {
+    array[index >> 3] |= (1 << (index & 7));
+  }
+
+  /**
+   * Set the bit at the given index to 0.
+   * @param array the array of bits
+   * @param index the index of the bit to clear.
+   */
+  static inline void clear_bit(uint8_t* array, uint64_t index) {
+    array[index >> 3] &= ~(1 << (index & 7));
+  }
+
+  /**
+   * Assign the value of the bit at the given index.
+   * @param array the array of bits
+   * @param index the index of the bit to set.
+   */
+  static inline void assign_bit(uint8_t* array, uint64_t index, bool value) {
+    // read-only checks handled by set_bit() and clear_bit()
+    if (value) {
+      set_bit(array, index);
+    } else {
+      clear_bit(array, index);
+    }
+  }
+
+  /**
+   * Gets the value of a bit at the specified index and sets it to true
+   * @param array the array of bits
+   * @param index the index of the bit to get and set
+   * @return the value of the bit at the specified index
+   */
+  static inline bool get_and_set_bit(uint8_t* array, uint64_t index) {
+    const uint64_t offset = index >> 3;
+    const uint8_t mask = 1 << (index & 7);
+    if ((array[offset] & mask) != 0) {
+      return true;
+    } else {
+      array[offset] |= mask;
+      return false;
+    }
+  }
+
+  /**
+   * @brief Gets the number of bits set in the bit array.
+   * @param array the array of bits
+   * @param length_bytes the length of the array, in bytes
+   * @return the number of bits set in the bit array.
+   */
+  static inline uint64_t count_num_bits_set(uint8_t* array, uint64_t length_bytes) {
+    uint64_t num_bits_set = 0;
+
+    // we rounded up to a multiple of 64 so we know we can use 64-bit operations
+    const uint64_t* array64 = reinterpret_cast<const uint64_t*>(array);
+    // Calculate the number of 64-bit chunks
+    uint64_t num_longs = length_bytes / 8; // 8 bytes per 64 bits
+    for (uint64_t i = 0; i < num_longs; ++i) {
+      // Wrap the 64-bit chunk with std::bitset for easy bit counting
+      std::bitset<64> bits(array64[i]);
+      num_bits_set += bits.count();
+    }
+    return num_bits_set;
+  }
+
+  /**
+   * Performs a union operation on one bit array with another bit array.
+   * This operation modifies the tgt bit array to be the union of its original bits and the bits of the src array.
+   * The union operation is equivalent to a bitwise OR operation between the two arrays.
+   *
+   * @param tgt the array of bits into which the results are written
+   * @param src the array of bits to union into tgt
+   * @param length_bytes the length of the two arrays, in bytes
+   * @return the number of bits set in the resulting array
+   */
+  static inline uint64_t union_with(uint8_t* tgt, const uint8_t* src, uint64_t length_bytes) {
+    uint64_t num_bits_set = 0;
+    for (uint64_t i = 0; i < length_bytes; ++i) {
+      tgt[i] |= src[i];
+      std::bitset<8> bits(tgt[i]);
+      num_bits_set += bits.count();
+    }
+    return num_bits_set;
+  }
+
+  /**
+   * Performs an intersection operation on one bit array with another bit array.
+   * This operation modifies the tgt bit array to contain only the bits that are set in both that array and the src array.
+   * The intersection operation is equivalent to a bitwise AND operation between the two arrays.
+   *
+   * @param tgt the array of bits into which the results are written
+   * @param src the array of bits to intersect with tgt
+   * @param length_bytes the length of the two arrays, in bytes
+   * @return the number of bits set in the resulting array
+   */
+  static inline uint64_t intersect(uint8_t* tgt, const uint8_t* src, uint64_t length_bytes) {
+    uint64_t num_bits_set = 0;
+    for (uint64_t i = 0; i < length_bytes; ++i) {
+      tgt[i] &= src[i];
+      std::bitset<8> bits(tgt[i]);
+      num_bits_set += bits.count();
+    }
+    return num_bits_set;
+  }
+
+  /**
+   * Inverts the bits of this bit array.
+   * This operation modifies the bit array by flipping all its bits; 0s become 1s and 1s become 0s.
+   * @param array the array of bits
+   * @param length_bytes the length of the array, in bytes
+   * @return the number of bits set in the resulting array
+   */
+  static inline uint64_t invert(uint8_t* array, uint64_t length_bytes) {
+    uint64_t num_bits_set = 0;
+    for (uint64_t i = 0; i < length_bytes; ++i) {
+      array[i] = ~array[i];
+      std::bitset<8> bits(array[i]);
+      num_bits_set += bits.count();
+    }
+    return num_bits_set;
+  }
+
+} // namespace bit_array_ops
+
+} // namespace datasketches
+
+#endif // _BIT_ARRAY_OPS_HPP_