datasketches 0.3.2 → 0.4.1

data/vendor/datasketches-cpp/sampling/include/var_opt_sketch.hpp

@@ -26,22 +26,12 @@
 #include <iterator>
 #include <vector>
 
-
-/**
- * This sketch samples data from a stream of items, designed for optimal (minimum) variance when
- * querying the sketch to estimate subset sums of items matchng a provided predicate. Variance
- * optimal (varopt) sampling is related to reservoir sampling, with improved error bounds for
- * subset sum estimation.
- * 
- * author Kevin Lang 
- * author Jon Malkin
- */
 namespace datasketches {
 
 template<typename A> using AllocU8 = typename std::allocator_traits<A>::template rebind_alloc<uint8_t>;
 template<typename A> using vector_u8 = std::vector<uint8_t, AllocU8<A>>;
 
-/**
+/*
  * A struct to hold the result of subset sum queries
  */
 struct subset_summary {
@@ -53,11 +43,23 @@ struct subset_summary {
 
 template <typename T, typename A> class var_opt_union; // forward declaration
 
+/// VarOpt sketch constants
 namespace var_opt_constants {
-    const resize_factor DEFAULT_RESIZE_FACTOR = resize_factor::X8;
-    const uint32_t MAX_K = ((uint32_t) 1 << 31) - 2; 
+  /// default resize factor
+  const resize_factor DEFAULT_RESIZE_FACTOR = resize_factor::X8;
+  /// maximum value of parameter K
+  const uint32_t MAX_K = ((uint32_t) 1 << 31) - 2;
 }
 
+/**
+ * This sketch samples data from a stream of items. Designed for optimal (minimum) variance when
+ * querying the sketch to estimate subset sums of items matching a provided predicate. Variance
+ * optimal (varopt) sampling is related to reservoir sampling, with improved error bounds for
+ * subset sum estimation.
+ *
+ * author Kevin Lang
+ * author Jon Malkin
+ */
 template<
   typename T,
   typename A = std::allocator<T>
@@ -68,15 +70,42 @@ class var_opt_sketch {
     static const resize_factor DEFAULT_RESIZE_FACTOR = var_opt_constants::DEFAULT_RESIZE_FACTOR;
     static const uint32_t MAX_K = var_opt_constants::MAX_K;
 
+    /**
+     * Constructor
+     * @param k sketch size
+     * @param rf resize factor
+     * @param allocator instance of an allocator
+     */
     explicit var_opt_sketch(uint32_t k,
       resize_factor rf = var_opt_constants::DEFAULT_RESIZE_FACTOR,
       const A& allocator = A());
+
+    /**
+     * Copy constructor
+     * @param other sketch to be copied
+     */
     var_opt_sketch(const var_opt_sketch& other);
+
+    /**
+     * Move constructor
+     * @param other sketch to be moved
+     */
     var_opt_sketch(var_opt_sketch&& other) noexcept;
 
     ~var_opt_sketch();
 
+    /**
+     * Copy assignment
+     * @param other sketch to be copied
+     * @return reference to this sketch
+     */
     var_opt_sketch& operator=(const var_opt_sketch& other);
+
+    /**
+     * Move assignment
+     * @param other sketch to be moved
+     * @return reference to this sketch
+     */
     var_opt_sketch& operator=(var_opt_sketch&& other);
 
     /**
@@ -85,7 +114,7 @@ class var_opt_sketch {
      * @param item an item from a stream of items
      * @param weight the weight of the item
      */
-    void update(const T& item, double weight=1.0);
+    void update(const T& item, double weight = 1.0);
 
     /**
      * Updates this sketch with the given data item with the given weight.
@@ -93,7 +122,7 @@ class var_opt_sketch {
      * @param item an item from a stream of items
      * @param weight the weight of the item
      */
-    void update(T&& item, double weight=1.0);
+    void update(T&& item, double weight = 1.0);
 
     /**
      * Returns the configured maximum sample size.
@@ -117,7 +146,7 @@ class var_opt_sketch {
      * Computes an estimated subset sum from the entire stream for objects matching a given
      * predicate. Provides a lower bound, estimate, and upper bound using a target of 2 standard
      * deviations. This is technically a heuristic method and tries to err on the conservative side.
-     * @param P a predicate function
+     * @param predicate a predicate function
      * @return a subset_summary item with estimate, upper and lower bounds,
      *         and total sketch weight
      */
@@ -138,7 +167,7 @@ class var_opt_sketch {
     /**
      * Computes size needed to serialize the current state of the sketch.
      * This version is for fixed-size arithmetic types (integral and floating point).
-     * @param instance of a SerDe
+     * @param sd instance of a SerDe
      * @return size in bytes needed to serialize this sketch
      */
     template<typename TT = T, typename SerDe = serde<T>, typename std::enable_if<std::is_arithmetic<TT>::value, int>::type = 0>
@@ -147,7 +176,7 @@ class var_opt_sketch {
     /**
      * Computes size needed to serialize the current state of the sketch.
      * This version is for all other types and can be expensive since every item needs to be looked at.
-     * @param instance of a SerDe
+     * @param sd instance of a SerDe
      * @return size in bytes needed to serialize this sketch
      */
     template<typename TT = T, typename SerDe = serde<T>, typename std::enable_if<!std::is_arithmetic<TT>::value, int>::type = 0>
@@ -155,7 +184,7 @@ class var_opt_sketch {
 
     // This is a convenience alias for users
     // The type returned by the following serialize method
-    typedef vector_u8<A> vector_bytes;
+    using vector_bytes = vector_u8<A>;
 
     /**
      * This method serializes the sketch as a vector of bytes.
@@ -163,7 +192,7 @@ class var_opt_sketch {
      * It is a blank space of a given size.
      * This header is used in Datasketches PostgreSQL extension.
      * @param header_size_bytes space to reserve in front of the sketch
-     * @param instance of a SerDe
+     * @param sd instance of a SerDe
      */
     template<typename SerDe = serde<T>>
     vector_bytes serialize(unsigned header_size_bytes = 0, const SerDe& sd = SerDe()) const;
@@ -171,7 +200,7 @@ class var_opt_sketch {
     /**
      * This method serializes the sketch into a given stream in a binary form
      * @param os output stream
-     * @param instance of a SerDe
+     * @param sd instance of a SerDe
      */
     template<typename SerDe = serde<T>>
     void serialize(std::ostream& os, const SerDe& sd = SerDe()) const;
@@ -179,8 +208,8 @@ class var_opt_sketch {
     /**
      * This method deserializes a sketch from a given stream.
      * @param is input stream
-     * @param instance of a SerDe
-     * @param instance of an Allocator
+     * @param sd instance of a SerDe
+     * @param allocator instance of an allocator
      * @return an instance of a sketch
      */
     template<typename SerDe = serde<T>>
@@ -190,8 +219,8 @@ class var_opt_sketch {
      * This method deserializes a sketch from a given array of bytes.
      * @param bytes pointer to the array of bytes
      * @param size the size of the array
-     * @param instance of a SerDe
-     * @param instance of an Allocator
+     * @param sd instance of a SerDe
+     * @param allocator instance of an allocator
      * @return an instance of a sketch
      */
     template<typename SerDe = serde<T>>
@@ -205,7 +234,8 @@ class var_opt_sketch {
 
     /**
      * Prints the raw sketch items to a string. Calls items_to_stream() internally.
-     * Only works for type T with a defined operator<<() and
+     * Only works for type T with a defined
+     * std::ostream& operator<<(std::ostream&, const T&) and
      * kept separate from to_string() to allow compilation even if
      * T does not have such an operator defined.
      * @return a string with the sketch items
@@ -213,7 +243,20 @@ class var_opt_sketch {
     string<A> items_to_string() const;
 
     class const_iterator;
+
+    /**
+     * Iterator pointing to the first item in the sketch.
+     * If the sketch is empty, the returned iterator must not be dereferenced or incremented.
+     * @return iterator pointing to the first item in the sketch
+     */
     const_iterator begin() const;
+
+    /**
+     * Iterator pointing to the past-the-end item in the sketch.
+     * The past-the-end item is the hypothetical item that would follow the last item.
+     * It does not point to any item, and must not be dereferenced or incremented.
+     * @return iterator pointing to the past-the-end item in the sketch
+     */
     const_iterator end() const;
 
   private:

data/vendor/datasketches-cpp/sampling/include/var_opt_sketch_impl.hpp

@@ -36,7 +36,7 @@
 
 namespace datasketches {
 
-/**
+/*
  * Implementation code for the VarOpt sketch.
  * 
  * author Kevin Lang 
@@ -895,7 +895,7 @@ void var_opt_sketch<T, A>::update_heavy_r_eq1(O&& item, double weight, bool mark
   grow_candidate_set(weights_[m_slot] + total_wt_r_, 2);
 }
 
-/**
+/*
  * Decreases sketch's value of k by 1, updating stored values as needed.
  *
  * <p>Subject to certain pre-conditions, decreasing k causes tau to increase. This fact is used by
@@ -1685,7 +1685,7 @@ bool var_opt_sketch<T, A>::iterator::get_mark() const {
   return sk_->marks_ == nullptr ? false : sk_->marks_[idx_];
 }
 
-/**
+/*
  * Checks if target sampling allocation is more than 50% of max sampling size.
  * If so, returns max sampling size, otherwise passes through target size.
  */

data/vendor/datasketches-cpp/sampling/include/var_opt_union.hpp

@@ -52,7 +52,6 @@ template<
 class var_opt_union {
 
 public:
-  static const uint32_t MAX_K = ((uint32_t) 1 << 31) - 2;
 
   explicit var_opt_union(uint32_t max_k, const A& allocator = A());
   var_opt_union(const var_opt_union& other);
@@ -91,7 +90,7 @@ public:
   /**
    * Computes size needed to serialize the current state of the union.
    * This version is for all other types and can be expensive since every item needs to be looked at.
-   * @param instance of a SerDe
+   * @param sd instance of a SerDe
    * @return size in bytes needed to serialize this sketch
    */
   template<typename SerDe = serde<T>>
@@ -108,7 +107,7 @@ public:
    * It is a blank space of a given size.
    * This header is used in Datasketches PostgreSQL extension.
    * @param header_size_bytes space to reserve in front of the sketch
-   * @param instance of a SerDe
+   * @param sd instance of a SerDe
    */
   template<typename SerDe = serde<T>>
   vector_bytes serialize(unsigned header_size_bytes = 0, const SerDe& sd = SerDe()) const;
@@ -117,7 +116,7 @@ public:
    * NOTE: This method may be deprecated in a future version.
    * This method serializes the sketch into a given stream in a binary form
    * @param os output stream
-   * @param instance of a SerDe
+   * @param sd instance of a SerDe
    */
   template<typename SerDe = serde<T>>
   void serialize(std::ostream& os, const SerDe& sd = SerDe()) const;
@@ -126,8 +125,8 @@ public:
    * NOTE: This method may be deprecated in a future version.
    * This method deserializes a union from a given stream.
    * @param is input stream
-   * @param instance of a SerDe
-   * @param instance of an Allocator
+   * @param sd instance of a SerDe
+   * @param allocator instance of an Allocator
    * @return an instance of a union
    */
   template<typename SerDe = serde<T>>
@@ -138,8 +137,8 @@ public:
    * This method deserializes a union from a given array of bytes.
    * @param bytes pointer to the array of bytes
    * @param size the size of the array
-   * @param instance of a SerDe
-   * @param instance of an Allocator
+   * @param sd instance of a SerDe
+   * @param allocator instance of an Allocator
    * @return an instance of a union
    */
   template<typename SerDe = serde<T>>
@@ -152,9 +151,9 @@ public:
   string<A> to_string() const;
 
 private:
-  typedef typename std::allocator_traits<A>::template rebind_alloc<var_opt_sketch<T, A>> AllocSketch;
-  typedef typename std::allocator_traits<A>::template rebind_alloc<double> AllocDouble;
-  typedef typename std::allocator_traits<A>::template rebind_alloc<bool> AllocBool;
+  using AllocSketch = typename std::allocator_traits<A>::template rebind_alloc<var_opt_sketch<T, A>>;
+  using AllocDouble = typename std::allocator_traits<A>::template rebind_alloc<double>;
+  using AllocBool = typename std::allocator_traits<A>::template rebind_alloc<bool>;
 
   static const uint8_t PREAMBLE_LONGS_EMPTY = 1;
   static const uint8_t PREAMBLE_LONGS_NON_EMPTY = 4;

data/vendor/datasketches-cpp/sampling/include/var_opt_union_impl.hpp

@@ -146,7 +146,7 @@ var_opt_union<T, A> var_opt_union<T, A>::deserialize(std::istream& is, const Ser
   check_preamble_longs(preamble_longs, flags);
   check_family_and_serialization_version(family_id, serial_version);
 
-  if (max_k == 0 || max_k > MAX_K) {
+  if (max_k == 0 || max_k > var_opt_constants::MAX_K) {
     throw std::invalid_argument("k must be at least 1 and less than 2^31 - 1");
   }
 
@@ -190,7 +190,7 @@ var_opt_union<T, A> var_opt_union<T, A>::deserialize(const void* bytes, size_t s
   check_preamble_longs(preamble_longs, flags);
   check_family_and_serialization_version(family_id, serial_version);
 
-  if (max_k == 0 || max_k > MAX_K) {
+  if (max_k == 0 || max_k > var_opt_constants::MAX_K) {
     throw std::invalid_argument("k must be at least 1 and less than 2^31 - 1");
   }
 
@@ -448,7 +448,7 @@ var_opt_sketch<T, A> var_opt_union<T, A>::get_result() const {
 
 /**
  * When there are no marked items in H, the gadget is mathematically equivalent to a valid
- * varopt sketch. This method simply returns a copy (without perserving marks).
+ * varopt sketch. This method simply returns a copy (without preserving marks).
  *
  * @return A shallow copy of the gadget as valid varopt sketch
  */
@@ -549,7 +549,7 @@ void var_opt_union<T, A>::mark_moving_gadget_coercer(var_opt_sketch<T, A>& sk) c
 
   if (result_h + result_r != result_k) throw std::logic_error("H + R counts must equal k");
   if (std::abs(transferred_weight - outer_tau_numer_) > 1e-10) {
-    throw std::logic_error("uexpected mismatch in transferred weight");
+    throw std::logic_error("unexpected mismatch in transferred weight");
   }
 
   const double result_r_weight = gadget_.total_wt_r_ + transferred_weight;

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

@@ -15,30 +15,77 @@
 # specific language governing permissions and limitations
 # under the License.
 
-add_executable(sampling_test)
+# separate executables for var_opt and ebpps sampling
 
-target_link_libraries(sampling_test sampling common_test_lib)
+# VAR OPT SAMPLING
+add_executable(var_opt_sampling_test)
 
-set_target_properties(sampling_test PROPERTIES
-  CXX_STANDARD 11
+target_link_libraries(var_opt_sampling_test sampling common_test_lib)
+
+set_target_properties(var_opt_sampling_test PROPERTIES
   CXX_STANDARD_REQUIRED YES
 )
 
 file(TO_CMAKE_PATH "${CMAKE_CURRENT_SOURCE_DIR}" SAMPLING_TEST_BINARY_PATH)
 string(APPEND SAMPLING_TEST_BINARY_PATH "/")
-target_compile_definitions(sampling_test
+target_compile_definitions(var_opt_sampling_test
   PRIVATE
     TEST_BINARY_INPUT_PATH="${SAMPLING_TEST_BINARY_PATH}"
 )
 
 add_test(
-  NAME sampling_test
-  COMMAND sampling_test
+  NAME var_opt_sampling_test
+  COMMAND var_opt_sampling_test
 )
 
-target_sources(sampling_test
+target_sources(var_opt_sampling_test
   PRIVATE
   var_opt_sketch_test.cpp
   var_opt_union_test.cpp
   var_opt_allocation_test.cpp
 )
+
+
+# EBPPS SAMPLING
+add_executable(ebpps_sampling_test)
+
+target_link_libraries(ebpps_sampling_test sampling common_test_lib)
+
+set_target_properties(ebpps_sampling_test PROPERTIES
+  CXX_STANDARD_REQUIRED YES
+)
+
+target_compile_definitions(ebpps_sampling_test
+  PRIVATE
+    TEST_BINARY_INPUT_PATH="${SAMPLING_TEST_BINARY_PATH}"
+)
+
+add_test(
+  NAME ebpps_sampling_test
+  COMMAND ebpps_sampling_test
+)
+
+target_sources(ebpps_sampling_test
+  PRIVATE
+  ebpps_sample_test.cpp
+  ebpps_sketch_test.cpp
+  ebpps_allocation_test.cpp
+)
+
+
+# Compatibility
+if (SERDE_COMPAT)
+target_sources(var_opt_sampling_test
+  PRIVATE
+   var_opt_sketch_deserialize_from_java_test.cpp
+   var_opt_union_deserialize_from_java_test.cpp
+)
+endif()
+
+if (GENERATE)
+target_sources(var_opt_sampling_test
+  PRIVATE
+   var_opt_sketch_serialize_for_java.cpp
+   var_opt_union_serialize_for_java.cpp
+)
+endif()

data/vendor/datasketches-cpp/sampling/test/ebpps_allocation_test.cpp

@@ -0,0 +1,96 @@
+/*
+ * 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 <ebpps_sketch.hpp>
+#include <test_type.hpp>
+#include <test_allocator.hpp>
+
+#include <catch2/catch.hpp>
+
+#include <sstream>
+
+namespace datasketches {
+
+using ebpps_test_sketch = ebpps_sketch<test_type, test_allocator<test_type>>;
+using alloc = test_allocator<test_type>;
+
+TEST_CASE("ebpps allocation test", "[ebpps_sketch][test_type]") {
+  test_allocator_total_bytes = 0;
+  test_allocator_net_allocations = 0;
+  {
+    ebpps_test_sketch sk1(10, 0);
+    for (int i = 0; i < 100; ++i)
+      sk1.update(i);
+    auto bytes1 = sk1.serialize(0, test_type_serde());
+    auto sk2 = ebpps_test_sketch::deserialize(bytes1.data(), bytes1.size(), test_type_serde(), 0);
+
+    std::stringstream ss;
+    sk1.serialize(ss, test_type_serde());
+    auto sk3 = ebpps_test_sketch::deserialize(ss, test_type_serde(), alloc(0));
+
+    sk1.merge(sk2); // same size into sk1
+    sk3.merge(sk1); // larger into sk3
+
+    auto bytes2 = sk1.serialize(0, test_type_serde());
+    auto sk4 = ebpps_test_sketch::deserialize(bytes2.data(), bytes2.size(), test_type_serde(), 0);
+  }
+  REQUIRE(test_allocator_total_bytes == 0);
+  REQUIRE(test_allocator_net_allocations == 0);
+}
+
+TEST_CASE( "ebpps merge", "[ebpps_sketch][test_type]") {
+  test_allocator_total_bytes = 0;
+  test_allocator_net_allocations = 0;
+  {
+    uint32_t n = 20;
+    uint32_t k = 5;
+    ebpps_test_sketch sk1(k, 0);
+    ebpps_test_sketch sk2(k, 0);
+
+    // move udpates
+    for (int i = 0; i < (int) n; ++i) {
+      sk1.update(i);
+      sk2.update(-i);
+      sk1.update(n + i); // sk1 heavier than sk2
+    }
+    REQUIRE(sk1.get_n() == 2 * n);
+    REQUIRE(sk2.get_n() == n);
+
+    // move merge -- lighter into heavier
+    sk1.merge(std::move(sk2));
+    REQUIRE(sk1.get_n() == 3 * n);
+
+    // move constructor
+    ebpps_test_sketch sk3(std::move(sk1));
+    REQUIRE(sk3.get_n() == 3 * n);
+
+    // move assignment
+    ebpps_test_sketch sk4(k, 0);
+    sk4 = std::move(sk2);
+    REQUIRE(sk4.get_n() == n);
+
+    // move merge -- heavier into lighter
+    sk4.merge(sk3);
+    REQUIRE(sk4.get_n() == 4 * n);
+  }
+  REQUIRE(test_allocator_total_bytes == 0);
+  REQUIRE(test_allocator_net_allocations == 0);
+}
+
+}

data/vendor/datasketches-cpp/sampling/test/ebpps_sample_test.cpp

@@ -0,0 +1,137 @@
+/*
+ * 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 <ebpps_sample.hpp>
+
+#include <catch2/catch.hpp>
+
+#include <vector>
+#include <string>
+#include <sstream>
+#include <fstream>
+#include <cmath>
+#include <random>
+#include <stdexcept>
+
+namespace datasketches {
+
+static constexpr double EPS = 1e-15;
+
+TEST_CASE("ebpps sample: basic initialization", "[ebpps_sketch]") {
+  ebpps_sample<int> sample = ebpps_sample<int>(0);
+  REQUIRE(sample.get_c() == 0.0);
+  REQUIRE(sample.get_num_retained_items() == 0);
+  REQUIRE(sample.get_sample().size() == 0);
+}
+
+TEST_CASE("ebpps sample: pre-initialized", "[ebpps_sketch]") {
+  double theta = 1.0;
+  ebpps_sample<int> sample = ebpps_sample<int>(-1, theta);
+  REQUIRE(sample.get_c() == theta);
+  REQUIRE(sample.get_num_retained_items() == 1);
+  REQUIRE(sample.get_sample().size() == 1);
+  REQUIRE(sample.has_partial_item() == false);
+  
+  theta = 1e-300;
+  sample = ebpps_sample<int>(-1, theta);
+  REQUIRE(sample.get_c() == theta);
+  REQUIRE(sample.get_num_retained_items() == 1);
+  REQUIRE(sample.get_sample().size() == 0); // assuming the random number is > 1e-300
+  REQUIRE(sample.has_partial_item());
+}
+
+TEST_CASE("ebpps sample: downsampling", "[ebpps_sketch]") {
+  ebpps_sample<char> sample = ebpps_sample<char>('a', 1.0);
+
+  sample.downsample(2.0); // no-op
+  REQUIRE(sample.get_c() == 1.0);
+  REQUIRE(sample.get_num_retained_items() == 1);
+  REQUIRE(sample.has_partial_item() == false);
+
+  // downsample and result in an empty sample
+  random_utils::override_seed(12);
+  std::vector<char> items = {'a', 'b'};
+  optional<char> opt; // empty
+  sample = ebpps_sample<char>(std::move(items), std::move(opt), 1.8);
+  sample.downsample(0.5);
+  REQUIRE(sample.get_c() == 0.9);
+  REQUIRE(sample.get_num_retained_items() == 0);
+  REQUIRE(sample.has_partial_item() == false);
+
+  // downsample and result in a sample with a partial item
+  items = {'a', 'b'};
+  opt.reset();
+  sample = ebpps_sample<char>(std::move(items), std::move(opt), 1.5);
+  sample.downsample(0.5);
+  REQUIRE(sample.get_c() == 0.75);
+  REQUIRE(sample.get_num_retained_items() == 1);
+  REQUIRE(sample.has_partial_item() == true);
+  for (char c : sample) {
+    REQUIRE((c == 'a' || c == 'b'));
+  }
+
+  // downsample to an exact integer c (7.5 * 0.8 = 6.0)
+  items = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
+  opt.emplace('h');
+  auto ref_items = items; // copy to check contents
+  ref_items.emplace_back('h'); // include partial item
+  sample = ebpps_sample<char>(std::move(items), std::move(opt), 7.5);
+  sample.downsample(0.8);
+  REQUIRE(sample.get_c() == 6.0);
+  REQUIRE(sample.get_num_retained_items() == 6);
+  REQUIRE(sample.has_partial_item() == false);
+  for (char c : sample) {
+    REQUIRE(std::find(ref_items.begin(), ref_items.end(), c) != ref_items.end());
+  }
+
+  // downsample to c > 1 with partial item
+  items = ref_items; // includes previous optional item
+  opt.emplace('i');
+  sample = ebpps_sample<char>(std::move(items), std::move(opt), 8.5);
+  REQUIRE(sample.get_partial_item() == 'i');
+  sample.downsample(0.8);
+  REQUIRE(sample.get_c() == Approx(6.8).margin(EPS));
+  REQUIRE(sample.get_num_retained_items() == 7);
+  REQUIRE(sample.has_partial_item() == true);
+  ref_items.emplace_back('i');
+  for (char c : sample) {
+    REQUIRE(std::find(ref_items.begin(), ref_items.end(), c) != ref_items.end());
+  }
+
+  random_utils::override_seed(random_utils::rd());
+}
+
+TEST_CASE("ebpps sample: merge unit samples", "[ebpps_sketch]") {
+  uint32_t k = 8;
+  ebpps_sample<int> sample = ebpps_sample<int>(k);
+  
+  for (uint32_t i = 1; i <= k; ++i) {
+    ebpps_sample<int> s = ebpps_sample<int>(i, 1.0);
+    sample.merge(s);
+    REQUIRE(sample.get_c() == static_cast<double>(i));
+    REQUIRE(sample.get_num_retained_items() == i);
+  }
+
+  sample.reset();
+  REQUIRE(sample.get_c() == 0);
+  REQUIRE(sample.get_num_retained_items() == 0);
+  REQUIRE(sample.has_partial_item() == false);
+}
+
+} // namespace datasketches