datasketches 0.3.1 → 0.4.0

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

@@ -94,14 +94,14 @@ hll_sketch_alloc<A>::hll_sketch_alloc(HllSketchImpl<A>* that) :
 {}
 
 template<typename A>
-hll_sketch_alloc<A> hll_sketch_alloc<A>::operator=(const hll_sketch_alloc<A>& other) {
+hll_sketch_alloc<A>& hll_sketch_alloc<A>::operator=(const hll_sketch_alloc<A>& other) {
   sketch_impl->get_deleter()(sketch_impl);
   sketch_impl = other.sketch_impl->copy();
   return *this;
 }
 
 template<typename A>
-hll_sketch_alloc<A> hll_sketch_alloc<A>::operator=(hll_sketch_alloc<A>&& other) {
+hll_sketch_alloc<A>& hll_sketch_alloc<A>::operator=(hll_sketch_alloc<A>&& other) {
   std::swap(sketch_impl, other.sketch_impl);
   return *this;
 }
@@ -232,12 +232,12 @@ void hll_sketch_alloc<A>::serialize_updatable(std::ostream& os) const {
 }
 
 template<typename A>
-vector_u8<A> hll_sketch_alloc<A>::serialize_compact(unsigned header_size_bytes) const {
+auto hll_sketch_alloc<A>::serialize_compact(unsigned header_size_bytes) const -> vector_bytes {
   return sketch_impl->serialize(true, header_size_bytes);
 }
 
 template<typename A>
-vector_u8<A> hll_sketch_alloc<A>::serialize_updatable() const {
+auto hll_sketch_alloc<A>::serialize_updatable() const -> vector_bytes {
   return sketch_impl->serialize(false, 0);
 }
 

data/vendor/datasketches-cpp/hll/include/HllSketchImpl.hpp

@@ -30,11 +30,13 @@ namespace datasketches {
 template<typename A>
 class HllSketchImpl {
   public:
+    using vector_bytes = std::vector<uint8_t, typename std::allocator_traits<A>::template rebind_alloc<uint8_t>>;
+
     HllSketchImpl(uint8_t lgConfigK, target_hll_type tgtHllType, hll_mode mode, bool startFullSize);
     virtual ~HllSketchImpl();
 
     virtual void serialize(std::ostream& os, bool compact) const = 0;
-    virtual vector_u8<A> serialize(bool compact, unsigned header_size_bytes) const = 0;
+    virtual vector_bytes serialize(bool compact, unsigned header_size_bytes) const = 0;
 
     virtual HllSketchImpl* copy() const = 0;
     virtual HllSketchImpl* copyAs(target_hll_type tgtHllType) const = 0;

data/vendor/datasketches-cpp/hll/include/HllSketchImplFactory.hpp

@@ -136,38 +136,20 @@ HllSketchImpl<A>* HllSketchImplFactory<A>::reset(HllSketchImpl<A>* impl, bool st
 
 template<typename A>
 Hll4Array<A>* HllSketchImplFactory<A>::convertToHll4(const HllArray<A>& srcHllArr) {
-  const uint8_t lgConfigK = srcHllArr.getLgConfigK();
   using Hll4Alloc = typename std::allocator_traits<A>::template rebind_alloc<Hll4Array<A>>;
-  Hll4Array<A>* hll4Array = new (Hll4Alloc(srcHllArr.getAllocator()).allocate(1))
-      Hll4Array<A>(lgConfigK, srcHllArr.isStartFullSize(), srcHllArr.getAllocator());
-  hll4Array->putOutOfOrderFlag(srcHllArr.isOutOfOrderFlag());
-  hll4Array->mergeHll(srcHllArr);
-  hll4Array->putHipAccum(srcHllArr.getHipAccum());
-  return hll4Array;
+  return new (Hll4Alloc(srcHllArr.getAllocator()).allocate(1)) Hll4Array<A>(srcHllArr);
 }
 
 template<typename A>
 Hll6Array<A>* HllSketchImplFactory<A>::convertToHll6(const HllArray<A>& srcHllArr) {
-  const uint8_t lgConfigK = srcHllArr.getLgConfigK();
   using Hll6Alloc = typename std::allocator_traits<A>::template rebind_alloc<Hll6Array<A>>;
-  Hll6Array<A>* hll6Array = new (Hll6Alloc(srcHllArr.getAllocator()).allocate(1))
-      Hll6Array<A>(lgConfigK, srcHllArr.isStartFullSize(), srcHllArr.getAllocator());
-  hll6Array->putOutOfOrderFlag(srcHllArr.isOutOfOrderFlag());
-  hll6Array->mergeHll(srcHllArr);
-  hll6Array->putHipAccum(srcHllArr.getHipAccum());
-  return hll6Array;
+  return new (Hll6Alloc(srcHllArr.getAllocator()).allocate(1)) Hll6Array<A>(srcHllArr);
 }
 
 template<typename A>
 Hll8Array<A>* HllSketchImplFactory<A>::convertToHll8(const HllArray<A>& srcHllArr) {
-  const uint8_t lgConfigK = srcHllArr.getLgConfigK();
   using Hll8Alloc = typename std::allocator_traits<A>::template rebind_alloc<Hll8Array<A>>;
-  Hll8Array<A>* hll8Array = new (Hll8Alloc(srcHllArr.getAllocator()).allocate(1))
-      Hll8Array<A>(lgConfigK, srcHllArr.isStartFullSize(), srcHllArr.getAllocator());
-  hll8Array->putOutOfOrderFlag(srcHllArr.isOutOfOrderFlag());
-  hll8Array->mergeHll(srcHllArr);
-  hll8Array->putHipAccum(srcHllArr.getHipAccum());
-  return hll8Array;
+  return new (Hll8Alloc(srcHllArr.getAllocator()).allocate(1)) Hll8Array<A>(srcHllArr);
 }
 
 }

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

@@ -131,21 +131,29 @@ void hll_union_alloc<A>::coupon_update(uint32_t coupon) {
 
 template<typename A>
 double hll_union_alloc<A>::get_estimate() const {
+  if (gadget_.sketch_impl->getCurMode() == hll_mode::HLL)
+    static_cast<HllArray<A>*>(gadget_.sketch_impl)->check_rebuild_kxq_cur_min();
   return gadget_.get_estimate();
 }
 
 template<typename A>
 double hll_union_alloc<A>::get_composite_estimate() const {
+  if (gadget_.sketch_impl->getCurMode() == hll_mode::HLL)
+    static_cast<HllArray<A>*>(gadget_.sketch_impl)->check_rebuild_kxq_cur_min();
   return gadget_.get_composite_estimate();
 }
 
 template<typename A>
 double hll_union_alloc<A>::get_lower_bound(uint8_t num_std_dev) const {
+  if (gadget_.sketch_impl->getCurMode() == hll_mode::HLL)
+    static_cast<HllArray<A>*>(gadget_.sketch_impl)->check_rebuild_kxq_cur_min();
   return gadget_.get_lower_bound(num_std_dev);
 }
 
 template<typename A>
 double hll_union_alloc<A>::get_upper_bound(uint8_t num_std_dev) const {
+  if (gadget_.sketch_impl->getCurMode() == hll_mode::HLL)
+    static_cast<HllArray<A>*>(gadget_.sketch_impl)->check_rebuild_kxq_cur_min();
   return gadget_.get_upper_bound(num_std_dev);
 }
 

data/vendor/datasketches-cpp/hll/include/HllUtil.hpp

@@ -124,8 +124,6 @@ public:
   static uint32_t pair(uint32_t slotNo, uint8_t value);
   static uint32_t getLow26(uint32_t coupon);
   static uint8_t getValue(uint32_t coupon);
-  static double invPow2(uint8_t e);
-  static uint8_t ceilingPowerOf2(uint32_t n);
   static uint8_t simpleIntLog2(uint32_t n); // n must be power of 2
   static uint8_t computeLgArrInts(hll_mode mode, uint32_t count, uint8_t lgConfigK);
   static double getRelErr(bool upperBound, bool unioned, uint8_t lgConfigK, uint8_t numStdDev);
@@ -152,12 +150,6 @@ inline void HllUtil<A>::hash(const void* key, size_t keyLen, uint64_t seed, Hash
   MurmurHash3_x64_128(key, keyLen, seed, result);
 }
 
-template<typename A>
-inline double HllUtil<A>::getRelErr(bool upperBound, bool unioned,
-                                    uint8_t lgConfigK, uint8_t numStdDev) {
-  return RelativeErrorTables<A>::getRelErr(upperBound, unioned, lgConfigK, numStdDev);
-}
-
 template<typename A>
 inline uint8_t HllUtil<A>::checkLgK(uint8_t lgK) {
   if ((lgK >= hll_constants::MIN_LOG_K) && (lgK <= hll_constants::MAX_LOG_K)) {
@@ -167,6 +159,20 @@ inline uint8_t HllUtil<A>::checkLgK(uint8_t lgK) {
   }
 }
 
+template<typename A>
+inline double HllUtil<A>::getRelErr(bool upperBound, bool unioned,
+                                    uint8_t lgConfigK, uint8_t numStdDev) {
+  checkLgK(lgConfigK);
+  if (lgConfigK > 12) {
+    const double rseFactor = unioned ?
+        hll_constants::HLL_NON_HIP_RSE_FACTOR : hll_constants::HLL_HIP_RSE_FACTOR;
+    const uint32_t configK = 1 << lgConfigK;
+    return (upperBound ? -1 : 1) * (numStdDev * rseFactor) / sqrt(configK);
+  } else {
+    return RelativeErrorTables<A>::getRelErr(upperBound, unioned, lgConfigK, numStdDev);
+  }
+}
+
 template<typename A>
 inline void HllUtil<A>::checkMemSize(uint64_t minBytes, uint64_t capBytes) {
   if (capBytes < minBytes) {
@@ -196,16 +202,6 @@ inline uint8_t HllUtil<A>::getValue(uint32_t coupon) {
   return coupon >> hll_constants::KEY_BITS_26;
 }
 
-template<typename A>
-inline double HllUtil<A>::invPow2(uint8_t e) {
-  union {
-    long long longVal;
-    double doubleVal;
-  } conv;
-  conv.longVal = (1023L - e) << 52;
-  return conv.doubleVal;
-}
-
 template<typename A>
 inline uint8_t HllUtil<A>::simpleIntLog2(uint32_t n) {
   if (n == 0) {

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

@@ -47,7 +47,7 @@ bool coupon_iterator<A>::operator!=(const coupon_iterator& other) const {
 }
 
 template<typename A>
-uint32_t coupon_iterator<A>::operator*() const {
+auto coupon_iterator<A>::operator*() const -> reference {
   return array_[index_];
 }
 

data/vendor/datasketches-cpp/hll/include/coupon_iterator.hpp

@@ -23,12 +23,18 @@
 namespace datasketches {
 
 template<typename A>
-class coupon_iterator: public std::iterator<std::input_iterator_tag, uint32_t> {
+class coupon_iterator {
 public:
+  using iterator_category = std::input_iterator_tag;
+  using value_type = uint32_t;
+  using difference_type = void;
+  using pointer = uint32_t*;
+  using reference = uint32_t;
+
   coupon_iterator(const uint32_t* array, size_t array_slze, size_t index, bool all);
   coupon_iterator& operator++();
   bool operator!=(const coupon_iterator& other) const;
-  uint32_t operator*() const;
+  reference operator*() const;
 private:
   const uint32_t* array_;
   size_t array_size_;

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

@@ -23,46 +23,22 @@
 #include "common_defs.hpp"
 #include "HllUtil.hpp"
 
-#include <memory>
 #include <iostream>
+#include <memory>
+#include <string>
 #include <vector>
 
 namespace datasketches {
 
-  /**
- * This is a high performance implementation of Phillipe Flajolet&#8217;s HLL sketch but with
- * significantly improved error behavior.  If the ONLY use case for sketching is counting
- * uniques and merging, the HLL sketch is a reasonable choice, although the highest performing in terms of accuracy for
- * storage space consumed is CPC (Compressed Probabilistic Counting). For large enough counts, this HLL version (with HLL_4) can be 2 to
- * 16 times smaller than the Theta sketch family for the same accuracy.
- *
- * <p>This implementation offers three different types of HLL sketch, each with different
- * trade-offs with accuracy, space and performance. These types are specified with the
- * {@link TgtHllType} parameter.
- *
- * <p>In terms of accuracy, all three types, for the same <i>lg_config_k</i>, have the same error
- * distribution as a function of <i>n</i>, the number of unique values fed to the sketch.
- * The configuration parameter <i>lg_config_k</i> is the log-base-2 of <i>K</i>,
- * where <i>K</i> is the number of buckets or slots for the sketch.
- *
- * <p>During warmup, when the sketch has only received a small number of unique items
- * (up to about 10% of <i>K</i>), this implementation leverages a new class of estimator
- * algorithms with significantly better accuracy.
- *
- * <p>This sketch also offers the capability of operating off-heap. Given a WritableMemory object
- * created by the user, the sketch will perform all of its updates and internal phase transitions
- * in that object, which can actually reside either on-heap or off-heap based on how it is
- * configured. In large systems that must update and merge many millions of sketches, having the
- * sketch operate off-heap avoids the serialization and deserialization costs of moving sketches
- * to and from off-heap memory-mapped files, for example, and eliminates big garbage collection
- * delays.
- *
- * author Jon Malkin
- * author Lee Rhodes
- * author Kevin Lang
- */
+// forward declarations
+template<typename A> class hll_sketch_alloc;
+template<typename A> class hll_union_alloc;
+
+/// HLL sketch alias with default allocator
+using hll_sketch = hll_sketch_alloc<std::allocator<uint8_t>>;
+/// HLL union alias with default allocator
+using hll_union = hll_union_alloc<std::allocator<uint8_t>>;
 
-  
 /**
  * Specifies the target type of HLL sketch to be created. It is a target in that the actual
  * allocation of the HLL array is deferred until sufficient number of items have been received by
@@ -99,14 +75,41 @@ enum target_hll_type {
     HLL_8  ///< 8 bits per entry (fastest, fixed size)
 };
 
-template<typename A>
-class HllSketchImpl;
-
-template<typename A>
-class hll_union_alloc;
+/**
+ * This is a high performance implementation of Phillipe Flajolet's HLL sketch but with
+ * significantly improved error behavior.  If the ONLY use case for sketching is counting
+ * uniques and merging, the HLL sketch is a reasonable choice, although the highest performing in terms of accuracy for
+ * storage space consumed is CPC (Compressed Probabilistic Counting). For large enough counts, this HLL version (with HLL_4) can be 2 to
+ * 16 times smaller than the Theta sketch family for the same accuracy.
+ *
+ * <p>This implementation offers three different types of HLL sketch, each with different
+ * trade-offs with accuracy, space and performance. These types are specified with the
+ * {@link target_hll_type} parameter.
+ *
+ * <p>In terms of accuracy, all three types, for the same <i>lg_config_k</i>, have the same error
+ * distribution as a function of <i>n</i>, the number of unique values fed to the sketch.
+ * The configuration parameter <i>lg_config_k</i> is the log-base-2 of <i>K</i>,
+ * where <i>K</i> is the number of buckets or slots for the sketch.
+ *
+ * <p>During warmup, when the sketch has only received a small number of unique items
+ * (up to about 10% of <i>K</i>), this implementation leverages a new class of estimator
+ * algorithms with significantly better accuracy.
+ *
+ * <p>This sketch also offers the capability of operating off-heap. Given a WritableMemory object
+ * created by the user, the sketch will perform all of its updates and internal phase transitions
+ * in that object, which can actually reside either on-heap or off-heap based on how it is
+ * configured. In large systems that must update and merge many millions of sketches, having the
+ * sketch operate off-heap avoids the serialization and deserialization costs of moving sketches
+ * to and from off-heap memory-mapped files, for example, and eliminates big garbage collection
+ * delays.
+ *
+ * author Jon Malkin
+ * author Lee Rhodes
+ * author Kevin Lang
+ */
 
-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>>;
+// forward declaration
+template<typename A> class HllSketchImpl;
 
 template<typename A = std::allocator<uint8_t> >
 class hll_sketch_alloc final {
@@ -118,45 +121,60 @@ class hll_sketch_alloc final {
      * @param start_full_size Indicates whether to start in HLL mode,
      *        keeping memory use constant (if HLL_6 or HLL_8) at the cost of
      *        starting out using much more memory
+     * @param allocator instance of an Allocator
      */
     explicit hll_sketch_alloc(uint8_t lg_config_k, target_hll_type tgt_type = HLL_4, bool start_full_size = false, const A& allocator = A());
 
     /**
      * Copy constructor
+     * @param that sketch to be copied
      */
     hll_sketch_alloc(const hll_sketch_alloc<A>& that);
 
     /**
      * Copy constructor to a new target type
+     * @param that sketch to be copied
+     * @param tgt_type target_hll_type
      */
     hll_sketch_alloc(const hll_sketch_alloc<A>& that, target_hll_type tgt_type);
 
     /**
      * Move constructor
+     * @param that sketch to be moved
      */
     hll_sketch_alloc(hll_sketch_alloc<A>&& that) noexcept;
 
     /**
      * Reconstructs a sketch from a serialized image on a stream.
      * @param is An input stream with a binary image of a sketch
+     * @param allocator instance of an Allocator
      */
     static hll_sketch_alloc deserialize(std::istream& is, const A& allocator = A());
 
     /**
      * Reconstructs a sketch from a serialized image in a byte array.
-     * @param is bytes An input array with a binary image of a sketch
+     * @param bytes An input array with a binary image of a sketch
      * @param len Length of the input array, in bytes
+     * @param allocator instance of an Allocator
      */
     static hll_sketch_alloc deserialize(const void* bytes, size_t len, const A& allocator = A());
 
     //! Class destructor
     virtual ~hll_sketch_alloc();
 
-    //! Copy assignment operator
-    hll_sketch_alloc operator=(const hll_sketch_alloc<A>& other);
+    /**
+     *  Copy assignment operator
+     *  @param other sketch to be copied
+     *  @return reference to this sketch
+     */
+    hll_sketch_alloc& operator=(const hll_sketch_alloc<A>& other);
 
-    //! Move assignment operator
-    hll_sketch_alloc operator=(hll_sketch_alloc<A>&& other);
+    /**
+     * Move assignment operator
+     * @param other sketch to be moved
+     * @return reference to this sketch
+     */
+    hll_sketch_alloc& operator=(hll_sketch_alloc<A>&& other);
 
     /**
      * Resets the sketch to an empty state in coupon collection mode.
@@ -164,18 +182,22 @@ class hll_sketch_alloc final {
      */
     void reset();
 
-    typedef vector_u8<A> vector_bytes; // alias for users
+    // This is a convenience alias for users
+    // The type returned by the following serialize method
+    using vector_bytes = std::vector<uint8_t, typename std::allocator_traits<A>::template rebind_alloc<uint8_t>>;
 
     /**
      * Serializes the sketch to a byte array, compacting data structures
      * where feasible to eliminate unused storage in the serialized image.
      * @param header_size_bytes Allows for PostgreSQL integration
+     * @return serialized sketch in binary form
      */
     vector_bytes serialize_compact(unsigned header_size_bytes = 0) const;
 
     /**
      * Serializes the sketch to a byte array, retaining all internal 
      * data structures in their current form.
+     * @return serialized sketch in binary form
      */
     vector_bytes serialize_updatable() const;
 
@@ -197,7 +219,7 @@ class hll_sketch_alloc final {
      * Human readable summary with optional detail
      * @param summary if true, output the sketch summary
      * @param detail if true, output the internal data array
-     * @param auxDetail if true, output the internal Aux array, if it exists.
+     * @param aux_detail if true, output the internal Aux array, if it exists.
      * @param all if true, outputs all entries including empty ones
      * @return human readable string with optional detail.
      */
@@ -358,7 +380,7 @@ class hll_sketch_alloc final {
      * value can be exceeded in extremely rare cases.  If exceeded, it
      * will be larger by only a few percent.
      *
-     * @param lg_config_k The Log2 of K for the target HLL sketch. This value must be
+     * @param lg_k The Log2 of K for the target HLL sketch. This value must be
      *        between 4 and 21 inclusively.
      * @param tgt_type the desired Hll type
      * @return the maximum size in bytes that this sketch can grow to.
@@ -391,8 +413,6 @@ class hll_sketch_alloc final {
     bool is_out_of_order_flag() const;
     bool is_estimation_mode() const;
 
-    typedef typename std::allocator_traits<A>::template rebind_alloc<hll_sketch_alloc> AllocHllSketch;
-
     HllSketchImpl<A>* sketch_impl;
     friend hll_union_alloc<A>;
 };
@@ -412,8 +432,8 @@ class hll_sketch_alloc final {
  * <p>Although the API for this union operator parallels many of the methods of the
  * <i>HllSketch</i>, the behavior of the union operator has some fundamental differences.
  *
- * <p>First, the user cannot specify the #tgt_hll_type as an input parameter.
- * Instead, it is specified for the sketch returned with #get_result(tgt_hll_tyope).
+ * <p>First, the user cannot specify the #target_hll_type as an input parameter.
+ * Instead, it is specified for the sketch returned with #get_result.
  *
  * <p>Second, the internal effective value of log-base-2 of <i>k</i> for the union operation can
  * change dynamically based on the smallest <i>lg_config_k</i> that the union operation has seen.
@@ -422,7 +442,6 @@ class hll_sketch_alloc final {
  * author Lee Rhodes
  * author Kevin Lang
  */
- 
 template<typename A = std::allocator<uint8_t> >
 class hll_union_alloc {
   public:
@@ -430,6 +449,7 @@ class hll_union_alloc {
      * Construct an hll_union operator with the given maximum log2 of k.
      * @param lg_max_k The maximum size, in log2, of k. The value must
      * be between 7 and 21, inclusive.
+     * @param allocator instance of an Allocator
      */
     explicit hll_union_alloc(uint8_t lg_max_k, const A& allocator = A());
 
@@ -494,21 +514,21 @@ class hll_union_alloc {
 
     /**
      * Returns the result of this union operator with the specified
-     * #tgt_hll_type.
-     * @param The tgt_hll_type enum value of the desired result (Default: HLL_4)
+     * #target_hll_type.
+     * @param tgt_type The tgt_hll_type enum value of the desired result (Default: HLL_4)
      * @return The result of this union with the specified tgt_hll_type
      */
     hll_sketch_alloc<A> get_result(target_hll_type tgt_type = HLL_4) const;
 
     /**
      * Update this union operator with the given sketch.
-     * @param The given sketch.
+     * @param sketch The given sketch.
      */
     void update(const hll_sketch_alloc<A>& sketch);
 
     /**
      * Update this union operator with the given temporary sketch.
-     * @param The given sketch.
+     * @param sketch The given sketch.
      */
     void update(hll_sketch_alloc<A>&& sketch);
   
@@ -608,7 +628,7 @@ class hll_union_alloc {
     * perform the union. This may involve swapping, down-sampling, transforming, and / or
     * copying one of the arguments and may completely replace the internals of the union.
     *
-    * @param incoming_impl the given incoming sketch, which may not be modified.
+    * @param sketch the given incoming sketch, which may not be modified.
     * @param lg_max_k the maximum value of log2 K for this union.
     */
     inline void union_impl(const hll_sketch_alloc<A>& sketch, uint8_t lg_max_k);
@@ -628,12 +648,6 @@ class hll_union_alloc {
     hll_sketch_alloc<A> gadget_;
 };
 
-/// convenience alias for hll_sketch with default allocator
-typedef hll_sketch_alloc<> hll_sketch;
-
-/// convenience alias for hll_union with default allocator
-typedef hll_union_alloc<> hll_union;
-
 } // namespace datasketches
 
 #include "hll.private.hpp"

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

@@ -20,7 +20,6 @@ add_executable(hll_test)
 target_link_libraries(hll_test hll common_test_lib)
 
 set_target_properties(hll_test PROPERTIES
-  CXX_STANDARD 11
   CXX_STANDARD_REQUIRED YES
 )
 
@@ -49,3 +48,17 @@ target_sources(hll_test
     ToFromByteArrayTest.cpp
     IsomorphicTest.cpp
 )
+
+if (SERDE_COMPAT)
+target_sources(hll_test
+  PRIVATE
+   hll_sketch_deserialize_from_java_test.cpp
+)
+endif()
+
+if (GENERATE)
+target_sources(hll_test
+  PRIVATE
+   hll_sketch_serialize_for_java.cpp
+)
+endif()

data/vendor/datasketches-cpp/hll/test/HllUnionTest.cpp

@@ -53,11 +53,16 @@ static void basicUnion(uint64_t n1, uint64_t n2,
   v += n2;
 
   hll_union u(lgMaxK);
-  u.update(std::move(h1));
+  u.update(h1);
   u.update(h2);
 
   hll_sketch result = u.get_result(resultType);
 
+  // ensure we check a direct union estimate, without first caling get_result()
+  u.reset();
+  u.update(std::move(h1));
+  u.update(h2);
+
   // force non-HIP estimates to avoid issues with in- vs out-of-order
   double uEst = result.get_composite_estimate();
   double uUb = result.get_upper_bound(2);
@@ -74,6 +79,7 @@ static void basicUnion(uint64_t n1, uint64_t n2,
   REQUIRE((uEst - uLb) >= 0.0);
 
   REQUIRE(controlEst == uEst);
+  REQUIRE(controlEst == u.get_composite_estimate());
 }
 
 /**

data/vendor/datasketches-cpp/hll/test/ToFromByteArrayTest.cpp

@@ -53,74 +53,6 @@ TEST_CASE("hll to/from byte array: double serialize", "[hll_byte_array]") {
   }
 }
 
-TEST_CASE("hll to/from byte array: deserialize from java", "[hll_byte_array]") {
-  std::string inputPath;
-#ifdef TEST_BINARY_INPUT_PATH
-    inputPath = TEST_BINARY_INPUT_PATH;
-#else
-    inputPath = "test/";
-#endif
-
-  std::ifstream ifs;
-  ifs.open(inputPath + "list_from_java.sk", std::ios::binary);
-  hll_sketch sk = hll_sketch::deserialize(ifs);
-  REQUIRE(sk.is_empty() == false);
-  REQUIRE(sk.get_lg_config_k() == 8);
-  REQUIRE(sk.get_lower_bound(1) == 7.0);
-  REQUIRE(sk.get_estimate() == Approx(7.0).margin(1e-6));
-  REQUIRE(sk.get_upper_bound(1) == Approx(7.000350).margin(1e-5));
-  ifs.close();
-
-  ifs.open(inputPath + "compact_set_from_java.sk", std::ios::binary);
-  sk = hll_sketch::deserialize(ifs);
-  REQUIRE(sk.is_empty() == false);
-  REQUIRE(sk.get_lg_config_k() == 8);
-  REQUIRE(sk.get_lower_bound(1) == 24.0);
-  REQUIRE(sk.get_estimate() == Approx(24.0).margin(1e-5));
-  REQUIRE(sk.get_upper_bound(1) == Approx(24.001200).margin(1e-5));
-  ifs.close();
-
-  ifs.open(inputPath + "updatable_set_from_java.sk", std::ios::binary);
-  sk = hll_sketch::deserialize(ifs);
-  REQUIRE(sk.is_empty() == false);
-  REQUIRE(sk.get_lg_config_k() == 8);
-  REQUIRE(sk.get_lower_bound(1) == 24.0);
-  REQUIRE(sk.get_estimate() == Approx(24.0).margin(1e-5));
-  REQUIRE(sk.get_upper_bound(1) == Approx(24.001200).margin(1e-5));
-  ifs.close();
-
-
-  ifs.open(inputPath + "array6_from_java.sk", std::ios::binary);
-  sk = hll_sketch::deserialize(ifs);
-  REQUIRE(sk.is_empty() == false);
-  REQUIRE(sk.get_lg_config_k() == 8);
-  REQUIRE(sk.get_lower_bound(1) == Approx(9589.968564).margin(1e-5));
-  REQUIRE(sk.get_estimate() == Approx(10089.150211).margin(1e-5));
-  REQUIRE(sk.get_upper_bound(1) == Approx(10642.370492).margin(1e-5));
-  ifs.close();
-
-
-  ifs.open(inputPath + "compact_array4_from_java.sk", std::ios::binary);
-  sk = hll_sketch::deserialize(ifs);
-  REQUIRE(sk.is_empty() == false);
-  REQUIRE(sk.get_lg_config_k() == 8);
-  REQUIRE(sk.get_lower_bound(1) == Approx(9589.968564).margin(1e-5));
-  REQUIRE(sk.get_estimate() == Approx(10089.150211).margin(1e-5));
-  REQUIRE(sk.get_upper_bound(1) == Approx(10642.370492).margin(1e-5));
-
-  ifs.close();
-
-
-  ifs.open(inputPath + "updatable_array4_from_java.sk", std::ios::binary);
-  sk = hll_sketch::deserialize(ifs);
-  REQUIRE(sk.is_empty() == false);
-  REQUIRE(sk.get_lg_config_k() == 8);
-  REQUIRE(sk.get_lower_bound(1) == Approx(9589.968564).margin(1e-5));
-  REQUIRE(sk.get_estimate() == Approx(10089.150211).margin(1e-5));
-  REQUIRE(sk.get_upper_bound(1) == Approx(10642.370492).margin(1e-5));
-  ifs.close();
-}
-
 static void checkSketchEquality(hll_sketch& sk1, hll_sketch& sk2) {
   REQUIRE(sk1.get_lg_config_k() == sk2.get_lg_config_k());
   REQUIRE(sk1.get_lower_bound(1) == sk2.get_lower_bound(1));