datasketches 0.2.0 → 0.2.4

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

@@ -110,14 +110,14 @@ public:
    * @return the lower bound of the approximate Clopper-Pearson confidence interval for the
    * unknown success probability.
    */
-  static inline double approximate_lower_bound_on_p(long n, long k, double num_std_devs) {
+  static inline double approximate_lower_bound_on_p(uint64_t n, uint64_t k, double num_std_devs) {
     check_inputs(n, k);
     if (n == 0) { return 0.0; } // the coin was never flipped, so we know nothing
     else if (k == 0) { return 0.0; }
     else if (k == 1) { return (exact_lower_bound_on_p_k_eq_1(n, delta_of_num_stdevs(num_std_devs))); }
     else if (k == n) { return (exact_lower_bound_on_p_k_eq_n(n, delta_of_num_stdevs(num_std_devs))); }
     else {
-      double x = abramowitz_stegun_formula_26p5p22((n - k) + 1, k, (-1.0 * num_std_devs));
+      double x = abramowitz_stegun_formula_26p5p22((n - k) + 1.0, static_cast<double>(k), (-1.0 * num_std_devs));
       return (1.0 - x); // which is p
     }
   }
@@ -145,18 +145,18 @@ public:
    * @return the upper bound of the approximate Clopper-Pearson confidence interval for the
    * unknown success probability.
    */
-  static inline double approximate_upper_bound_on_p(long n, long k, double num_std_devs) {
+  static inline double approximate_upper_bound_on_p(uint64_t n, uint64_t k, double num_std_devs) {
     check_inputs(n, k);
     if (n == 0) { return 1.0; } // the coin was never flipped, so we know nothing
     else if (k == n) { return 1.0; }
     else if (k == (n - 1)) {
-      return (exactU_upper_bound_on_p_k_eq_minusone(n, delta_of_num_stdevs(num_std_devs)));
+      return (exact_upper_bound_on_p_k_eq_minusone(n, delta_of_num_stdevs(num_std_devs)));
     }
     else if (k == 0) {
       return (exact_upper_bound_on_p_k_eq_zero(n, delta_of_num_stdevs(num_std_devs)));
     }
     else {
-      double x = abramowitz_stegun_formula_26p5p22(n - k, k + 1, num_std_devs);
+      double x = abramowitz_stegun_formula_26p5p22(static_cast<double>(n - k), k + 1.0, num_std_devs);
       return (1.0 - x); // which is p
     }
   }
@@ -167,7 +167,7 @@ public:
    * @param k is the number of successes. Must be non-negative, and cannot exceed n.
    * @return the estimate of the unknown binomial proportion.
    */
-  static inline double estimate_unknown_p(long n, long k) {
+  static inline double estimate_unknown_p(uint64_t n, uint64_t k) {
     check_inputs(n, k);
     if (n == 0) { return 0.5; } // the coin was never flipped, so we know nothing
     else { return ((double) k / (double) n); }
@@ -193,9 +193,7 @@ public:
   }
 
 private:
-  static inline void check_inputs(long n, long k) {
-    if (n < 0) { throw std::invalid_argument("N must be non-negative"); }
-    if (k < 0) { throw std::invalid_argument("K must be non-negative"); }
+  static inline void check_inputs(uint64_t n, uint64_t k) {
     if (k > n) { throw std::invalid_argument("K cannot exceed N"); }
   }
 
@@ -251,8 +249,7 @@ private:
   // and it is worth keeping it that way so that it will always be easy to verify
   // that the formula was typed in correctly.
 
-  static inline double abramowitz_stegun_formula_26p5p22(double a, double b,
-      double yp) {
+  static inline double abramowitz_stegun_formula_26p5p22(double a, double b, double yp) {
     const double b2m1 = (2.0 * b) - 1.0;
     const double a2m1 = (2.0 * a) - 1.0;
     const double lambda = ((yp * yp) - 3.0) / 6.0;
@@ -268,19 +265,19 @@ private:
 
   // Formulas for some special cases.
 
-  static inline double exact_upper_bound_on_p_k_eq_zero(double n, double delta) {
+  static inline double exact_upper_bound_on_p_k_eq_zero(uint64_t n, double delta) {
     return (1.0 - pow(delta, (1.0 / n)));
   }
 
-  static inline double exact_lower_bound_on_p_k_eq_n(double n, double delta) {
+  static inline double exact_lower_bound_on_p_k_eq_n(uint64_t n, double delta) {
     return (pow(delta, (1.0 / n)));
   }
 
-  static inline double exact_lower_bound_on_p_k_eq_1(double n, double delta) {
+  static inline double exact_lower_bound_on_p_k_eq_1(uint64_t n, double delta) {
     return (1.0 - pow((1.0 - delta), (1.0 / n)));
   }
 
-  static inline double exactU_upper_bound_on_p_k_eq_minusone(double n, double delta) {
+  static inline double exact_upper_bound_on_p_k_eq_minusone(uint64_t n, double delta) {
     return (pow((1.0 - delta), (1.0 / n)));
   }
 

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

@@ -23,11 +23,14 @@
 #include <cstdint>
 #include <string>
 #include <memory>
+#include <iostream>
 
 namespace datasketches {
 
 static const uint64_t DEFAULT_SEED = 9001;
 
+enum resize_factor { X1 = 0, X2, X4, X8 };
+
 template<typename A> using AllocChar = typename std::allocator_traits<A>::template rebind_alloc<char>;
 template<typename A> using string = std::basic_string<char, std::char_traits<char>, AllocChar<A>>;
 
@@ -46,6 +49,29 @@ constexpr uint8_t lg_size_from_count(uint32_t n, double load_factor) {
   return log2(n) + ((n > static_cast<uint32_t>((1 << (log2(n) + 1)) * load_factor)) ? 2 : 1);
 }
 
+// stream helpers to hide casts
+template<typename T>
+static inline T read(std::istream& is) {
+  T value;
+  is.read(reinterpret_cast<char*>(&value), sizeof(T));
+  return value;
+}
+
+template<typename T>
+static inline void read(std::istream& is, T* ptr, size_t size_bytes) {
+  is.read(reinterpret_cast<char*>(ptr), size_bytes);
+}
+
+template<typename T>
+static inline void write(std::ostream& os, T& value) {
+  os.write(reinterpret_cast<const char*>(&value), sizeof(T));
+}
+
+template<typename T>
+static inline void write(std::ostream& os, const T* ptr, size_t size_bytes) {
+  os.write(reinterpret_cast<const char*>(ptr), size_bytes);
+}
+
 } // namespace
 
 #endif // _COMMON_DEFS_HPP_

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

@@ -38,29 +38,41 @@ fwd_type<T1, T2> conditional_forward(T2&& value) {
 // Forward container as iterators
 
 template<typename Container>
-auto forward_begin(Container&& c) ->
-typename std::enable_if<std::is_lvalue_reference<Container>::value, decltype(c.begin())>::type
+auto forward_begin(Container&& c) -> typename std::enable_if<
+  std::is_lvalue_reference<Container>::value ||
+  std::is_same<typename std::remove_reference<Container>::type::const_iterator, decltype(c.begin())>::value,
+  decltype(c.begin())
+>::type
 {
   return c.begin();
 }
 
 template<typename Container>
-auto forward_begin(Container&& c) ->
-typename std::enable_if<!std::is_lvalue_reference<Container>::value, decltype(std::make_move_iterator(c.begin()))>::type
+auto forward_begin(Container&& c) -> typename std::enable_if<
+  !std::is_lvalue_reference<Container>::value &&
+  !std::is_same<typename std::remove_reference<Container>::type::const_iterator, decltype(c.begin())>::value,
+  decltype(std::make_move_iterator(c.begin()))
+>::type
 {
   return std::make_move_iterator(c.begin());
 }
 
 template<typename Container>
-auto forward_end(Container&& c) ->
-typename std::enable_if<std::is_lvalue_reference<Container>::value, decltype(c.end())>::type
+auto forward_end(Container&& c) -> typename std::enable_if<
+  std::is_lvalue_reference<Container>::value ||
+  std::is_same<typename std::remove_reference<Container>::type::const_iterator, decltype(c.begin())>::value,
+  decltype(c.end())
+>::type
 {
   return c.end();
 }
 
 template<typename Container>
-auto forward_end(Container&& c) ->
-typename std::enable_if<!std::is_lvalue_reference<Container>::value, decltype(std::make_move_iterator(c.end()))>::type
+auto forward_end(Container&& c) -> typename std::enable_if<
+  !std::is_lvalue_reference<Container>::value &&
+  !std::is_same<typename std::remove_reference<Container>::type::const_iterator, decltype(c.begin())>::value,
+  decltype(std::make_move_iterator(c.end()))
+>::type
 {
   return std::make_move_iterator(c.end());
 }

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

@@ -94,7 +94,7 @@ static inline uint8_t count_leading_zeros_in_u64(uint64_t input) {
 static inline uint8_t count_trailing_zeros_in_u32(uint32_t input) {
   for (int i = 0; i < 4; i++) {
     const int byte = input & 0xff;
-    if (byte != 0) return (i << 3) + byte_trailing_zeros_table[byte];
+    if (byte != 0) return static_cast<uint8_t>((i << 3) + byte_trailing_zeros_table[byte]);
     input >>= 8;
   }
   return 32;
@@ -103,7 +103,7 @@ static inline uint8_t count_trailing_zeros_in_u32(uint32_t input) {
 static inline uint8_t count_trailing_zeros_in_u64(uint64_t input) {
   for (int i = 0; i < 8; i++) {
     const int byte = input & 0xff;
-    if (byte != 0) return (i << 3) + byte_trailing_zeros_table[byte];
+    if (byte != 0) return static_cast<uint8_t>((i << 3) + byte_trailing_zeros_table[byte]);
     input >>= 8;
   }
   return 64;

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

@@ -51,7 +51,7 @@ struct serde<T, typename std::enable_if<std::is_arithmetic<T>::value>::type> {
     bool failure = false;
     try {
       os.write(reinterpret_cast<const char*>(items), sizeof(T) * num);
-    } catch (std::ostream::failure& e) {
+    } catch (std::ostream::failure&) {
       failure = true;
     }
     if (failure || !os.good()) {
@@ -62,7 +62,7 @@ struct serde<T, typename std::enable_if<std::is_arithmetic<T>::value>::type> {
     bool failure = false;
     try {
       is.read((char*)items, sizeof(T) * num);
-    } catch (std::istream::failure& e) {
+    } catch (std::istream::failure&) {
       failure = true;
     }
     if (failure || !is.good()) {
@@ -99,11 +99,11 @@ struct serde<std::string> {
     bool failure = false;
     try {
       for (; i < num && os.good(); i++) {
-        uint32_t length = items[i].size();
+        uint32_t length = static_cast<uint32_t>(items[i].size());
         os.write((char*)&length, sizeof(length));
         os.write(items[i].c_str(), length);
       }
-    } catch (std::ostream::failure& e) {
+    } catch (std::ostream::failure&) {
       failure = true;
     }
     if (failure || !os.good()) {
@@ -121,12 +121,12 @@ struct serde<std::string> {
         std::string str;
         str.reserve(length);
         for (uint32_t j = 0; j < length; j++) {
-          str.push_back(is.get());
+          str.push_back(static_cast<char>(is.get()));
         }
         if (!is.good()) { break; }
         new (&items[i]) std::string(std::move(str));
       }
-    } catch (std::istream::failure& e) {
+    } catch (std::istream::failure&) {
       failure = true;
     }
     if (failure || !is.good()) {
@@ -143,7 +143,7 @@ struct serde<std::string> {
   size_t serialize(void* ptr, size_t capacity, const std::string* items, unsigned num) const {
     size_t bytes_written = 0;
     for (unsigned i = 0; i < num; ++i) {
-      const uint32_t length = items[i].size();
+      const uint32_t length = static_cast<uint32_t>(items[i].size());
       const size_t new_bytes = length + sizeof(length);
       check_memory_size(bytes_written + new_bytes, capacity);
       memcpy(ptr, &length, sizeof(length));

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

@@ -32,43 +32,23 @@ target_include_directories(cpc
 target_link_libraries(cpc INTERFACE common)
 target_compile_features(cpc INTERFACE cxx_std_11)
 
-set(cpc_HEADERS "")
-list(APPEND cpc_HEADERS "include/compression_data.hpp")
-list(APPEND cpc_HEADERS "include/cpc_common.hpp")
-list(APPEND cpc_HEADERS "include/cpc_compressor.hpp")
-list(APPEND cpc_HEADERS "include/cpc_compressor_impl.hpp")
-list(APPEND cpc_HEADERS "include/cpc_confidence.hpp")
-list(APPEND cpc_HEADERS "include/cpc_sketch.hpp")
-list(APPEND cpc_HEADERS "include/cpc_sketch_impl.hpp")
-list(APPEND cpc_HEADERS "include/cpc_union.hpp")
-list(APPEND cpc_HEADERS "include/cpc_union_impl.hpp")
-list(APPEND cpc_HEADERS "include/cpc_util.hpp")
-list(APPEND cpc_HEADERS "include/icon_estimator.hpp")
-list(APPEND cpc_HEADERS "include/kxp_byte_lookup.hpp")
-list(APPEND cpc_HEADERS "include/u32_table.hpp")
-list(APPEND cpc_HEADERS "include/u32_table_impl.hpp")
-
 install(TARGETS cpc
   EXPORT ${PROJECT_NAME}
 )
 
-install(FILES ${cpc_HEADERS}
+install(FILES 
+			include/compression_data.hpp
+			include/cpc_common.hpp
+			include/cpc_compressor.hpp
+			include/cpc_compressor_impl.hpp
+			include/cpc_confidence.hpp
+			include/cpc_sketch.hpp
+			include/cpc_sketch_impl.hpp
+			include/cpc_union.hpp
+			include/cpc_union_impl.hpp
+			include/cpc_util.hpp
+			include/icon_estimator.hpp
+			include/kxp_byte_lookup.hpp
+			include/u32_table.hpp
+			include/u32_table_impl.hpp
   DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/DataSketches")
-
-target_sources(cpc
-  INTERFACE
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/compression_data.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_common.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_compressor.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_compressor_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_confidence.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_sketch.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_sketch_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_union.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_union_impl.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/cpc_util.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/icon_estimator.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/kxp_byte_lookup.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/u32_table.hpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/include/u32_table_impl.hpp
-)

data/vendor/datasketches-cpp/cpc/include/cpc_common.hpp

@@ -26,9 +26,16 @@
 
 namespace datasketches {
 
-static const uint8_t CPC_MIN_LG_K = 4;
-static const uint8_t CPC_MAX_LG_K = 26;
-static const uint8_t CPC_DEFAULT_LG_K = 11;
+namespace cpc_constants {
+    const uint8_t MIN_LG_K = 4;
+    const uint8_t MAX_LG_K = 26;
+    const uint8_t DEFAULT_LG_K = 11;
+}
+
+// TODO: Redundant and deprecated. Will be removed in next major version release.
+static const uint8_t CPC_MIN_LG_K = cpc_constants::MIN_LG_K;
+static const uint8_t CPC_MAX_LG_K = cpc_constants::MAX_LG_K;
+static const uint8_t CPC_DEFAULT_LG_K = cpc_constants::DEFAULT_LG_K;
 
 template<typename A> using AllocU8 = typename std::allocator_traits<A>::template rebind_alloc<uint8_t>;
 template<typename A> using AllocU16 = typename std::allocator_traits<A>::template rebind_alloc<uint16_t>;

data/vendor/datasketches-cpp/cpc/include/cpc_compressor.hpp

@@ -48,44 +48,44 @@ template<typename A>
 class cpc_compressor {
 public:
   void compress(const cpc_sketch_alloc<A>& source, compressed_state<A>& target) const;
-  void uncompress(const compressed_state<A>& source, uncompressed_state<A>& target, uint8_t lg_k, uint64_t num_coupons) const;
+  void uncompress(const compressed_state<A>& source, uncompressed_state<A>& target, uint8_t lg_k, uint32_t num_coupons) const;
 
   // methods below are public for testing
 
   // This returns the number of compressed words that were actually used. It is the caller's
   // responsibility to ensure that the compressed_words array is long enough to prevent over-run.
-  size_t low_level_compress_bytes(
+  uint32_t low_level_compress_bytes(
       const uint8_t* byte_array, // input
-      size_t num_bytes_to_encode,
+      uint32_t num_bytes_to_encode,
       const uint16_t* encoding_table,
       uint32_t* compressed_words  // output
   ) const;
 
   void low_level_uncompress_bytes(
       uint8_t* byte_array, // output
-      size_t num_bytes_to_decode,
+      uint32_t num_bytes_to_decode,
       const uint16_t* decoding_table,
       const uint32_t* compressed_words,
-      size_t num_compressed_words // input
+      uint32_t num_compressed_words // input
   ) const;
 
   // Here "pairs" refers to row-column pairs that specify
   // the positions of surprising values in the bit matrix.
 
   // returns the number of compressedWords actually used
-  size_t low_level_compress_pairs(
+  uint32_t low_level_compress_pairs(
       const uint32_t* pair_array, // input
-      size_t num_pairs_to_encode,
-      size_t num_base_bits,
+      uint32_t num_pairs_to_encode,
+      uint8_t num_base_bits,
       uint32_t* compressed_words // output
   ) const;
 
   void low_level_uncompress_pairs(
       uint32_t* pair_array, // output
-      size_t num_pairs_to_decode,
-      size_t num_base_bits,
+      uint32_t num_pairs_to_decode,
+      uint8_t num_base_bits,
       const uint32_t* compressed_words, // input
-      size_t num_compressed_words // input
+      uint32_t num_compressed_words // input
   ) const;
 
 private:
@@ -122,22 +122,22 @@ private:
   void uncompress_pinned_flavor(const compressed_state<A>& source, uncompressed_state<A>& target, uint8_t lg_k, uint32_t num_coupons) const;
   void uncompress_sliding_flavor(const compressed_state<A>& source, uncompressed_state<A>& target, uint8_t lg_k, uint32_t num_coupons) const;
 
-  uint8_t* make_inverse_permutation(const uint8_t* permu, int length);
-  uint16_t* make_decoding_table(const uint16_t* encoding_table, int num_byte_values);
+  uint8_t* make_inverse_permutation(const uint8_t* permu, unsigned length);
+  uint16_t* make_decoding_table(const uint16_t* encoding_table, unsigned num_byte_values);
   void validate_decoding_table(const uint16_t* decoding_table, const uint16_t* encoding_table) const;
 
   void compress_surprising_values(const vector_u32<A>& pairs, uint8_t lg_k, compressed_state<A>& result) const;
   void compress_sliding_window(const uint8_t* window, uint8_t lg_k, uint32_t num_coupons, compressed_state<A>& target) const;
 
-  vector_u32<A> uncompress_surprising_values(const uint32_t* data, size_t data_words, size_t num_pairs, uint8_t lg_k, const A& allocator) const;
-  void uncompress_sliding_window(const uint32_t* data, size_t data_words, vector_u8<A>& window, uint8_t lg_k, uint32_t num_coupons) const;
+  vector_u32<A> uncompress_surprising_values(const uint32_t* data, uint32_t data_words, uint32_t num_pairs, uint8_t lg_k, const A& allocator) const;
+  void uncompress_sliding_window(const uint32_t* data, uint32_t data_words, vector_u8<A>& window, uint8_t lg_k, uint32_t num_coupons) const;
 
-  static size_t safe_length_for_compressed_pair_buf(uint64_t k, size_t num_pairs, size_t num_base_bits);
-  static size_t safe_length_for_compressed_window_buf(uint64_t k);
-  static uint8_t determine_pseudo_phase(uint8_t lg_k, uint64_t c);
+  static size_t safe_length_for_compressed_pair_buf(uint32_t k, uint32_t num_pairs, uint8_t num_base_bits);
+  static size_t safe_length_for_compressed_window_buf(uint32_t k);
+  static uint8_t determine_pseudo_phase(uint8_t lg_k, uint32_t c);
 
   static inline vector_u32<A> tricky_get_pairs_from_window(const uint8_t* window, uint32_t k, uint32_t num_pairs_to_get, uint32_t empty_space, const A& allocator);
-  static inline uint64_t golomb_choose_number_of_base_bits(uint64_t k, uint64_t count);
+  static inline uint8_t golomb_choose_number_of_base_bits(uint32_t k, uint64_t count);
 };
 
 } /* namespace datasketches */