datasketches 0.3.1 → 0.4.0

data/vendor/datasketches-cpp/density/test/density_sketch_test.cpp

@@ -0,0 +1,244 @@
+/*
+ * 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.
+ */
+
+#include <cmath>
+#include <catch2/catch.hpp>
+
+#include <density_sketch.hpp>
+
+namespace datasketches {
+
+TEST_CASE("density sketch: empty", "[density_sketch]") {
+  density_sketch<float> sketch(10, 3);
+  REQUIRE(sketch.is_empty());
+  REQUIRE_THROWS_AS(sketch.get_estimate({0, 0, 0}), std::runtime_error);
+}
+
+TEST_CASE("density sketch: one item", "[density_sketch]") {
+  density_sketch<float> sketch(10, 3);
+
+  // dimension mismatch
+  REQUIRE_THROWS_AS(sketch.update(std::vector<float>({0, 0})), std::invalid_argument);
+
+  sketch.update(std::vector<float>({0, 0, 0}));
+  REQUIRE_FALSE(sketch.is_empty());
+  REQUIRE_FALSE(sketch.is_estimation_mode());
+  REQUIRE(sketch.get_estimate({0, 0, 0}) == 1);
+  REQUIRE(sketch.get_estimate({0.01, 0.01, 0.01}) > 0.95);
+  REQUIRE(sketch.get_estimate({1, 1, 1}) < 0.05);
+}
+
+TEST_CASE("density sketch: merge", "[density_sketch]") {
+  density_sketch<float> sketch1(10, 4);
+  sketch1.update(std::vector<float>({0, 0, 0, 0}));
+  sketch1.update(std::vector<float>({1, 2, 3, 4}));
+
+  density_sketch<float> sketch2(10, 4);
+  sketch2.update(std::vector<float>({5, 6, 7, 8}));
+
+  sketch1.merge(sketch2);
+
+  REQUIRE(sketch1.get_n() == 3);
+  REQUIRE(sketch1.get_num_retained() == 3);
+}
+
+TEST_CASE("density sketch: iterator", "[density_sketch]") {
+  density_sketch<float> sketch(10, 3);
+  unsigned n = 1000;
+  for (unsigned i = 1; i <= n; ++i) sketch.update(std::vector<float>(3, i));
+  REQUIRE(sketch.get_n() == n);
+  REQUIRE(sketch.is_estimation_mode());
+  //std::cout << sketch.to_string(true, true);
+  unsigned count = 0;
+  for (auto pair: sketch) {
+    ++count;
+    // just to assert something about the output
+    REQUIRE(pair.first.size() == sketch.get_dim());
+  }
+  REQUIRE(count == sketch.get_num_retained());
+}
+
+// spherical kernel for testing, returns 1 for vectors within radius and 0 otherwise
+template<typename T>
+struct spherical_kernel {
+  spherical_kernel(T radius = 1.0) : _radius_squared(radius * radius) {}
+  T operator()(const std::vector<T>& v1, const std::vector<T>& v2) const {
+    return std::inner_product(v1.begin(), v1.end(), v2.begin(), 0.0, std::plus<T>(), [](T a, T b){return (a-b)*(a-b);}) <= _radius_squared ? 1.0 : 0.0;
+  }
+  private:
+    T _radius_squared;
+};
+
+TEST_CASE("custom kernel", "[density_sketch]") {
+  density_sketch<float, spherical_kernel<float>> sketch(10, 3, spherical_kernel<float>(0.5));
+
+  // update with (1,1,1) and test points inside and outside the kernel
+  sketch.update(std::vector<float>(3, 1.0));
+  REQUIRE(sketch.get_estimate(std::vector<float>(3, 1.001)) == 1.0);
+  REQUIRE(sketch.get_estimate(std::vector<float>(3, 2.0)) == 0.0);
+
+  // rest of test follows iterator test above
+  unsigned n = 1000;
+  for (unsigned i = 2; i <= n; ++i) sketch.update(std::vector<float>(3, i));
+  REQUIRE(sketch.get_n() == n);
+  REQUIRE(sketch.is_estimation_mode());
+  unsigned count = 0;
+  for (auto pair: sketch) {
+    ++count;
+    // just to assert something about the output
+    REQUIRE(pair.first.size() == sketch.get_dim());
+  }
+  REQUIRE(count == sketch.get_num_retained());
+}
+
+TEST_CASE("serialize empty", "[density_sketch]") {
+  density_sketch<double> sk(10, 2);
+  auto bytes = sk.serialize();
+  auto sk2 = density_sketch<double>::deserialize(bytes.data(), bytes.size());
+  REQUIRE(sk2.is_empty());
+  REQUIRE(!sk2.is_estimation_mode());
+  REQUIRE(sk.get_k() == sk2.get_k());
+  REQUIRE(sk.get_dim() == sk2.get_dim());
+  REQUIRE(sk.get_n() == sk2.get_n());
+  REQUIRE(sk.get_num_retained() == sk2.get_num_retained());
+
+  std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
+  sk.serialize(s);
+  auto sk3 = density_sketch<double>::deserialize(s);
+  REQUIRE(sk3.is_empty());
+  REQUIRE(!sk3.is_estimation_mode());
+  REQUIRE(sk.get_k() == sk3.get_k());
+  REQUIRE(sk.get_dim() == sk3.get_dim());
+  REQUIRE(sk.get_n() == sk3.get_n());
+  REQUIRE(sk.get_num_retained() == sk3.get_num_retained());
+}
+
+TEST_CASE("serialize bytes", "[density_sketch]") {
+  uint16_t k = 10;
+  uint32_t dim = 3;
+  density_sketch<double> sk(k, dim);
+
+  for (uint16_t i = 0; i < k; ++i) {
+    double val = static_cast<double>(i);
+    sk.update(std::vector<double>({val, std::sqrt(val), -val}));
+  }
+  REQUIRE(!sk.is_estimation_mode());
+
+  // exact mode
+  auto bytes = sk.serialize();
+  auto sk2 = density_sketch<double>::deserialize(bytes.data(), bytes.size());
+  REQUIRE(!sk2.is_empty());
+  REQUIRE(!sk2.is_estimation_mode());
+  REQUIRE(sk.get_k() == sk2.get_k());
+  REQUIRE(sk.get_dim() == sk2.get_dim());
+  REQUIRE(sk.get_n() == sk2.get_n());
+  REQUIRE(sk.get_num_retained() == sk2.get_num_retained());
+  auto it1 = sk.begin();
+  auto it2 = sk2.begin();
+  while (it1 != sk.end()) {
+    REQUIRE(it1->first[0] == it2->first[0]);
+    REQUIRE(it1->second == it2->second);
+    ++it1;
+    ++it2;
+  }
+
+  // estimation mode
+  size_t n = 1031;
+  for (uint32_t i = k; i < n; ++i) {
+    double val = static_cast<double>(i);
+    sk.update(std::vector<double>({val, std::sqrt(val), -val}));
+  }
+  REQUIRE(sk.is_estimation_mode());
+
+  bytes = sk.serialize();
+  sk2 = density_sketch<double>::deserialize(bytes.data(), bytes.size());
+  REQUIRE(!sk2.is_empty());
+  REQUIRE(sk2.is_estimation_mode());
+  REQUIRE(sk.get_k() == sk2.get_k());
+  REQUIRE(sk.get_dim() == sk2.get_dim());
+  REQUIRE(sk.get_n() == sk2.get_n());
+  REQUIRE(sk.get_num_retained() == sk2.get_num_retained());
+  it1 = sk.begin();
+  it2 = sk2.begin();
+  while (it1 != sk.end()) {
+    REQUIRE(it1->first[0] == it2->first[0]);
+    REQUIRE(it1->second == it2->second);
+    ++it1;
+    ++it2;
+  }
+}
+
+TEST_CASE("serialize stream", "[density_sketch]") {
+  uint16_t k = 10;
+  uint32_t dim = 3;
+  density_sketch<float> sk(k, dim);
+
+  for (uint16_t i = 0; i < k; ++i) {
+    float val = static_cast<float>(i);
+    sk.update(std::vector<float>({val, std::sin(val), std::cos(val)}));
+  }
+  REQUIRE(!sk.is_estimation_mode());
+
+  // exact mode
+  std::stringstream s(std::ios::in | std::ios::out | std::ios::binary);
+  sk.serialize(s);
+  auto sk2 = density_sketch<float>::deserialize(s);
+  REQUIRE(!sk2.is_empty());
+  REQUIRE(!sk2.is_estimation_mode());
+  REQUIRE(sk.get_k() == sk2.get_k());
+  REQUIRE(sk.get_dim() == sk2.get_dim());
+  REQUIRE(sk.get_n() == sk2.get_n());
+  REQUIRE(sk.get_num_retained() == sk2.get_num_retained());
+  auto it1 = sk.begin();
+  auto it2 = sk2.begin();
+  while (it1 != sk.end()) {
+    REQUIRE(it1->first[0] == it2->first[0]);
+    REQUIRE(it1->second == it2->second);
+    ++it1;
+    ++it2;
+  }
+
+  // estimation mode
+  size_t n = 1031;
+  for (uint32_t i = k; i < n; ++i) {
+    float val = static_cast<float>(i);
+    sk.update(std::vector<float>({val, std::sqrt(val), -val}));
+  }
+  REQUIRE(sk.is_estimation_mode());
+
+  std::stringstream s2(std::ios::in | std::ios::out | std::ios::binary);
+  sk.serialize(s2);
+  sk2 = density_sketch<float>::deserialize(s2);
+  REQUIRE(!sk2.is_empty());
+  REQUIRE(sk2.is_estimation_mode());
+  REQUIRE(sk.get_k() == sk2.get_k());
+  REQUIRE(sk.get_dim() == sk2.get_dim());
+  REQUIRE(sk.get_n() == sk2.get_n());
+  REQUIRE(sk.get_num_retained() == sk2.get_num_retained());
+  it1 = sk.begin();
+  it2 = sk2.begin();
+  while (it1 != sk.end()) {
+    REQUIRE(it1->first[0] == it2->first[0]);
+    REQUIRE(it1->second == it2->second);
+    ++it1;
+    ++it2;
+  }
+}
+
+} /* namespace datasketches */

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

@@ -32,15 +32,19 @@
 
 namespace datasketches {
 
-/*
+/// Frequent items error type
+enum frequent_items_error_type {
+  NO_FALSE_POSITIVES, ///< include an item in the result list if get_lower_bound(item) &gt; threshold
+  NO_FALSE_NEGATIVES ///< include an item in the result list if get_upper_bound(item) &gt; threshold
+};
+
+/**
+ * Frequent Items sketch.
+ *
  * Based on Java implementation here:
  * https://github.com/apache/datasketches-java/blob/master/src/main/java/org/apache/datasketches/frequencies/ItemsSketch.java
- * author Alexander Saydakov
+ * @author Alexander Saydakov
  */
-
-enum frequent_items_error_type { NO_FALSE_POSITIVES, NO_FALSE_NEGATIVES };
-
-// type W for weight must be an arithmetic type (integral or floating point)
 template<
   typename T,
   typename W = uint64_t,
@@ -49,6 +53,7 @@ template<
   typename A = std::allocator<T>
 >
 class frequent_items_sketch {
+  static_assert(std::is_arithmetic<W>::value, "Arithmetic type expected");
 public:
 
   static const uint8_t LG_MIN_MAP_SIZE = 3;
@@ -194,7 +199,7 @@ public:
    * There may be items omitted from the set with true frequencies greater than the
    * threshold (false negatives).</p>
    *
-   * @param error_type determines whether no false positives or no false negatives are desired.
+   * @param err_type determines whether no false positives or no false negatives are desired.
    * @return an array of frequent items
    */
   vector_row get_frequent_items(frequent_items_error_type err_type) const;
@@ -217,7 +222,7 @@ public:
    * There may be items omitted from the set with true frequencies greater than the
    * threshold (false negatives).</p>
    *
-   * @param error_type determines whether no false positives or no false negatives are desired.
+   * @param err_type determines whether no false positives or no false negatives are desired.
    * @param threshold to include items in the result list
    * @return an array of frequent items
    */
@@ -293,7 +298,9 @@ private:
   static const uint8_t PREAMBLE_LONGS_EMPTY = 1;
   static const uint8_t PREAMBLE_LONGS_NONEMPTY = 4;
   static constexpr double EPSILON_FACTOR = 3.5;
-  enum flags { IS_EMPTY };
+  // due to a mistake different bits were used in C++ and Java to indicate empty sketch
+  // therefore both are set and checked for compatibility with historical binary format
+  enum flags { IS_EMPTY_1 = 0, IS_EMPTY_2 = 2 };
   W total_weight;
   W offset;
   reverse_purge_hash_map<T, W, H, E, A> map;
@@ -318,14 +325,19 @@ private:
   class items_deleter;
 };
 
+/// Row in the output from #get_frequent_items
 template<typename T, typename W, typename H, typename E, typename A>
 class frequent_items_sketch<T, W, H, E, A>::row {
 public:
   row(const T* item, W weight, W offset):
     item(item), weight(weight), offset(offset) {}
+  /// @return item
   const T& get_item() const { return *item; }
+  /// @return frequency (weight) estimate
   W get_estimate() const { return weight + offset; }
+  /// @return estimate lower bound
   W get_lower_bound() const { return weight; }
+  /// @return estimate upper bound
   W get_upper_bound() const { return weight + offset; }
 private:
   const T* item;

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

@@ -174,7 +174,8 @@ void frequent_items_sketch<T, W, H, E, A>::serialize(std::ostream& os, const Ser
   const uint8_t lg_cur_size = map.get_lg_cur_size();
   write(os, lg_cur_size);
   const uint8_t flags_byte(
-    (is_empty() ? 1 << flags::IS_EMPTY : 0)
+      (is_empty() ? 1 << flags::IS_EMPTY_1 : 0)
+    | (is_empty() ? 1 << flags::IS_EMPTY_2 : 0)
   );
   write(os, flags_byte);
   const uint16_t unused16 = 0;
@@ -234,7 +235,8 @@ auto frequent_items_sketch<T, W, H, E, A>::serialize(unsigned header_size_bytes,
   const uint8_t lg_cur_size = map.get_lg_cur_size();
   ptr += copy_to_mem(lg_cur_size, ptr);
   const uint8_t flags_byte(
-    (is_empty() ? 1 << flags::IS_EMPTY : 0)
+      (is_empty() ? 1 << flags::IS_EMPTY_1 : 0)
+    | (is_empty() ? 1 << flags::IS_EMPTY_2 : 0)
   );
   ptr += copy_to_mem(flags_byte, ptr);
   ptr += sizeof(uint16_t); // unused
@@ -298,7 +300,7 @@ frequent_items_sketch<T, W, H, E, A> frequent_items_sketch<T, W, H, E, A>::deser
   const auto flags_byte = read<uint8_t>(is);
   read<uint16_t>(is); // unused
 
-  const bool is_empty = flags_byte & (1 << flags::IS_EMPTY);
+  const bool is_empty = (flags_byte & (1 << flags::IS_EMPTY_1)) | (flags_byte & (1 << flags::IS_EMPTY_2));
 
   check_preamble_longs(preamble_longs, is_empty);
   check_serial_version(serial_version);
@@ -352,7 +354,7 @@ frequent_items_sketch<T, W, H, E, A> frequent_items_sketch<T, W, H, E, A>::deser
   ptr += copy_from_mem(ptr, flags_byte);
   ptr += sizeof(uint16_t); // unused
 
-  const bool is_empty = flags_byte & (1 << flags::IS_EMPTY);
+  const bool is_empty = (flags_byte & (1 << flags::IS_EMPTY_1)) | (flags_byte & (1 << flags::IS_EMPTY_2));
 
   check_preamble_longs(preamble_longs, is_empty);
   check_serial_version(serial_version);

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

@@ -91,8 +91,14 @@ private:
 
 // This iterator uses strides based on golden ratio to avoid clustering during merge
 template<typename K, typename V, typename H, typename E, typename A>
-class reverse_purge_hash_map<K, V, H, E, A>::iterator: public std::iterator<std::input_iterator_tag, K> {
+class reverse_purge_hash_map<K, V, H, E, A>::iterator {
 public:
+  using iterator_category = std::input_iterator_tag;
+  using value_type = std::pair<K&, V>;
+  using difference_type = void;
+  using pointer = void;
+  using reference = const value_type;
+
   friend class reverse_purge_hash_map<K, V, H, E, A>;
   iterator& operator++() {
     ++count;
@@ -107,8 +113,8 @@ public:
   iterator operator++(int) { iterator tmp(*this); operator++(); return tmp; }
   bool operator==(const iterator& rhs) const { return count == rhs.count; }
   bool operator!=(const iterator& rhs) const { return count != rhs.count; }
-  const std::pair<K&, V> operator*() const {
-    return std::pair<K&, V>(map->keys_[index], map->values_[index]);
+  reference operator*() const {
+    return value_type(map->keys_[index], map->values_[index]);
   }
 private:
   static constexpr double GOLDEN_RATIO_RECIPROCAL = 0.6180339887498949; // = (sqrt(5) - 1) / 2

data/vendor/datasketches-cpp/fi/test/CMakeLists.txt

@@ -20,7 +20,6 @@ add_executable(fi_test)
 target_link_libraries(fi_test fi common_test_lib)
 
 set_target_properties(fi_test PROPERTIES
-  CXX_STANDARD 11
   CXX_STANDARD_REQUIRED YES
 )
 
@@ -42,3 +41,17 @@ target_sources(fi_test
     frequent_items_sketch_test.cpp
     frequent_items_sketch_custom_type_test.cpp
 )
+
+if (SERDE_COMPAT)
+target_sources(fi_test
+  PRIVATE
+   frequent_items_sketch_deserialize_from_java_test.cpp
+)
+endif()
+
+if (GENERATE)
+target_sources(fi_test
+  PRIVATE
+   frequent_items_sketch_serialize_for_java.cpp
+)
+endif()

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

@@ -0,0 +1,95 @@
+/*
+ * 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.
+ */
+
+#include <catch2/catch.hpp>
+#include <fstream>
+#include <frequent_items_sketch.hpp>
+
+namespace datasketches {
+
+// assume the binary sketches for this test have been generated by datasketches-java code
+// in the subdirectory called "java" in the root directory of this project
+static std::string testBinaryInputPath = std::string(TEST_BINARY_INPUT_PATH) + "../../java/";
+
+TEST_CASE("frequent longs", "[serde_compat]") {
+  const unsigned n_arr[] = {0, 1, 10, 100, 1000, 10000, 100000, 1000000};
+  for (const unsigned n: n_arr) {
+    std::ifstream is;
+    is.exceptions(std::ios::failbit | std::ios::badbit);
+    is.open(testBinaryInputPath + "frequent_long_n" + std::to_string(n) + "_java.sk", std::ios::binary);
+    const auto sketch = frequent_items_sketch<int64_t>::deserialize(is);
+    REQUIRE(sketch.is_empty() == (n == 0));
+    if (n > 10) {
+      REQUIRE(sketch.get_maximum_error() > 0);
+    } else {
+      REQUIRE(sketch.get_maximum_error() == 0);
+    }
+    REQUIRE(sketch.get_total_weight() == n);
+  }
+}
+
+TEST_CASE("frequent strings", "[serde_compat]") {
+  const unsigned n_arr[] = {0, 1, 10, 100, 1000, 10000, 100000, 1000000};
+  for (const unsigned n: n_arr) {
+    std::ifstream is;
+    is.exceptions(std::ios::failbit | std::ios::badbit);
+    is.open(testBinaryInputPath + "frequent_string_n" + std::to_string(n) + "_java.sk", std::ios::binary);
+    const auto sketch = frequent_items_sketch<std::string>::deserialize(is);
+    REQUIRE(sketch.is_empty() == (n == 0));
+    if (n > 10) {
+      REQUIRE(sketch.get_maximum_error() > 0);
+    } else {
+      REQUIRE(sketch.get_maximum_error() == 0);
+    }
+    REQUIRE(sketch.get_total_weight() == n);
+  }
+}
+
+TEST_CASE("frequent strings ascii", "[serde_compat]") {
+  std::ifstream is;
+  is.exceptions(std::ios::failbit | std::ios::badbit);
+  is.open(testBinaryInputPath + "frequent_string_ascii_java.sk", std::ios::binary);
+  const auto sketch = frequent_items_sketch<std::string>::deserialize(is);
+  REQUIRE_FALSE(sketch.is_empty());
+  REQUIRE(sketch.get_maximum_error() == 0);
+  REQUIRE(sketch.get_total_weight() == 10);
+  REQUIRE(sketch.get_estimate("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa") == 1);
+  REQUIRE(sketch.get_estimate("bbbbbbbbbbbbbbbbbbbbbbbbbbbbb") == 2);
+  REQUIRE(sketch.get_estimate("ccccccccccccccccccccccccccccc") == 3);
+  REQUIRE(sketch.get_estimate("ddddddddddddddddddddddddddddd") == 4);
+}
+
+TEST_CASE("frequent strings utf8", "[serde_compat]") {
+  std::ifstream is;
+  is.exceptions(std::ios::failbit | std::ios::badbit);
+  is.open(testBinaryInputPath + "frequent_string_utf8_java.sk", std::ios::binary);
+  const auto sketch = frequent_items_sketch<std::string>::deserialize(is);
+  REQUIRE_FALSE(sketch.is_empty());
+  REQUIRE(sketch.get_maximum_error() == 0);
+  REQUIRE(sketch.get_total_weight() == 28);
+  REQUIRE(sketch.get_estimate("абвгд") == 1);
+  REQUIRE(sketch.get_estimate("еёжзи") == 2);
+  REQUIRE(sketch.get_estimate("йклмн") == 3);
+  REQUIRE(sketch.get_estimate("опрст") == 4);
+  REQUIRE(sketch.get_estimate("уфхцч") == 5);
+  REQUIRE(sketch.get_estimate("шщъыь") == 6);
+  REQUIRE(sketch.get_estimate("эюя") == 7);
+}
+
+} /* namespace datasketches */

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

@@ -0,0 +1,83 @@
+/*
+ * 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.
+ */
+
+#include <catch2/catch.hpp>
+#include <fstream>
+#include <frequent_items_sketch.hpp>
+
+namespace datasketches {
+
+TEST_CASE("frequent longs sketch generate", "[serialize_for_java]") {
+  const unsigned n_arr[] = {0, 1, 10, 100, 1000, 10000, 100000, 1000000};
+  for (const unsigned n: n_arr) {
+    frequent_items_sketch<long> sketch(6);
+    for (unsigned i = 1; i <= n; ++i) sketch.update(i);
+    REQUIRE(sketch.is_empty() == (n == 0));
+    if (n > 10) {
+      REQUIRE(sketch.get_maximum_error() > 0);
+    } else {
+      REQUIRE(sketch.get_maximum_error() == 0);
+    }
+    REQUIRE(sketch.get_total_weight() == n);
+    std::ofstream os("frequent_long_n" + std::to_string(n) + "_cpp.sk", std::ios::binary);
+    sketch.serialize(os);
+  }
+}
+
+TEST_CASE("frequent strings sketch generate", "[serialize_for_java]") {
+  const unsigned n_arr[] = {0, 1, 10, 100, 1000, 10000, 100000, 1000000};
+  for (const unsigned n: n_arr) {
+    frequent_items_sketch<std::string> sketch(6);
+    for (unsigned i = 1; i <= n; ++i) sketch.update(std::to_string(i));
+    REQUIRE(sketch.is_empty() == (n == 0));
+    if (n > 10) {
+      REQUIRE(sketch.get_maximum_error() > 0);
+    } else {
+      REQUIRE(sketch.get_maximum_error() == 0);
+    }
+    REQUIRE(sketch.get_total_weight() == n);
+    std::ofstream os("frequent_string_n" + std::to_string(n) + "_cpp.sk", std::ios::binary);
+    sketch.serialize(os);
+  }
+}
+
+TEST_CASE("frequent strings sketch ascii", "[serialize_for_java]") {
+  frequent_items_sketch<std::string> sketch(6);
+  sketch.update("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 1);
+  sketch.update("bbbbbbbbbbbbbbbbbbbbbbbbbbbbb", 2);
+  sketch.update("ccccccccccccccccccccccccccccc", 3);
+  sketch.update("ddddddddddddddddddddddddddddd", 4);
+  std::ofstream os("frequent_string_ascii_cpp.sk", std::ios::binary);
+  sketch.serialize(os);
+}
+
+TEST_CASE("frequent strings sketch utf8", "[serialize_for_java]") {
+  frequent_items_sketch<std::string> sketch(6);
+  sketch.update("абвгд", 1);
+  sketch.update("еёжзи", 2);
+  sketch.update("йклмн", 3);
+  sketch.update("опрст", 4);
+  sketch.update("уфхцч", 5);
+  sketch.update("шщъыь", 6);
+  sketch.update("эюя", 7);
+  std::ofstream os("frequent_string_utf8_cpp.sk", std::ios::binary);
+  sketch.serialize(os);
+}
+
+} /* namespace datasketches */

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

@@ -70,6 +70,7 @@ TEST_CASE("frequent items: several items, no resize, no purge", "[frequent_items
   REQUIRE(sketch.get_estimate("b") == 3);
   REQUIRE(sketch.get_estimate("c") == 2);
   REQUIRE(sketch.get_estimate("d") == 1);
+  REQUIRE(sketch.get_maximum_error() == 0);
 }
 
 TEST_CASE("frequent items: several items, with resize, no purge", "[frequent_items_sketch]") {
@@ -96,6 +97,7 @@ TEST_CASE("frequent items: several items, with resize, no purge", "[frequent_ite
   REQUIRE(sketch.get_estimate("b") == 3);
   REQUIRE(sketch.get_estimate("c") == 2);
   REQUIRE(sketch.get_estimate("d") == 1);
+  REQUIRE(sketch.get_maximum_error() == 0);
 }
 
 TEST_CASE("frequent items: estimation mode", "[frequent_items_sketch]") {
@@ -149,6 +151,7 @@ TEST_CASE("frequent items: merge exact mode", "[frequent_items_sketch]") {
   REQUIRE(sketch1.get_estimate(2) == 3);
   REQUIRE(sketch1.get_estimate(3) == 2);
   REQUIRE(sketch1.get_estimate(4) == 1);
+  REQUIRE(sketch1.get_maximum_error() == 0);
 }
 
 TEST_CASE("frequent items: merge estimation mode", "[frequent_items_sketch]") {
@@ -199,48 +202,6 @@ TEST_CASE("frequent items: merge estimation mode", "[frequent_items_sketch]") {
   REQUIRE(9 <= items[1].get_estimate()); // always overestimated
 }
 
-TEST_CASE("frequent items: deserialize from java long", "[frequent_items_sketch]") {
-  std::ifstream is;
-  is.exceptions(std::ios::failbit | std::ios::badbit);
-  is.open(testBinaryInputPath + "longs_sketch_from_java.sk", std::ios::binary);
-  auto sketch = frequent_items_sketch<long long>::deserialize(is);
-  REQUIRE_FALSE(sketch.is_empty());
-  REQUIRE(sketch.get_total_weight() == 4);
-  REQUIRE(sketch.get_num_active_items() == 4);
-  REQUIRE(sketch.get_estimate(1) == 1);
-  REQUIRE(sketch.get_estimate(2) == 1);
-  REQUIRE(sketch.get_estimate(3) == 1);
-  REQUIRE(sketch.get_estimate(4) == 1);
-}
-
-TEST_CASE("frequent items: deserialize from java string", "[frequent_items_sketch]") {
-  std::ifstream is;
-  is.exceptions(std::ios::failbit | std::ios::badbit);
-  is.open(testBinaryInputPath + "items_sketch_string_from_java.sk", std::ios::binary);
-  auto sketch = frequent_items_sketch<std::string>::deserialize(is);
-  REQUIRE_FALSE(sketch.is_empty());
-  REQUIRE(sketch.get_total_weight() == 4);
-  REQUIRE(sketch.get_num_active_items() == 4);
-  REQUIRE(sketch.get_estimate("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa") == 1);
-  REQUIRE(sketch.get_estimate("bbbbbbbbbbbbbbbbbbbbbbbbbbbbb") == 1);
-  REQUIRE(sketch.get_estimate("ccccccccccccccccccccccccccccc") == 1);
-  REQUIRE(sketch.get_estimate("ddddddddddddddddddddddddddddd") == 1);
-}
-
-TEST_CASE("frequent items: deserialize from java string, utf-8", "[frequent_items_sketch]") {
-  std::ifstream is;
-  is.exceptions(std::ios::failbit | std::ios::badbit);
-  is.open(testBinaryInputPath + "items_sketch_string_utf8_from_java.sk", std::ios::binary);
-  auto sketch = frequent_items_sketch<std::string>::deserialize(is);
-  REQUIRE_FALSE(sketch.is_empty());
-  REQUIRE(sketch.get_total_weight() == 10);
-  REQUIRE(sketch.get_num_active_items() == 4);
-  REQUIRE(sketch.get_estimate("абвгд") == 1);
-  REQUIRE(sketch.get_estimate("еёжзи") == 2);
-  REQUIRE(sketch.get_estimate("йклмн") == 3);
-  REQUIRE(sketch.get_estimate("опрст") == 4);
-}
-
 TEST_CASE("frequent items: deserialize long64 stream", "[frequent_items_sketch]") {
   frequent_items_sketch<long long> sketch1(3);
   sketch1.update(1, 1);

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

@@ -169,9 +169,9 @@ CouponList<A>* CouponList<A>::newList(std::istream& is, const A& allocator) {
 }
 
 template<typename A>
-vector_u8<A> CouponList<A>::serialize(bool compact, unsigned header_size_bytes) const {
+auto CouponList<A>::serialize(bool compact, unsigned header_size_bytes) const -> vector_bytes {
   const size_t sketchSizeBytes = (compact ? getCompactSerializationBytes() : getUpdatableSerializationBytes()) + header_size_bytes;
-  vector_u8<A> byteArr(sketchSizeBytes, 0, getAllocator());
+  vector_bytes byteArr(sketchSizeBytes, 0, getAllocator());
   uint8_t* bytes = byteArr.data() + header_size_bytes;
 
   bytes[hll_constants::PREAMBLE_INTS_BYTE] = static_cast<uint8_t>(getPreInts());