datasketches 0.5.2 → 0.5.3

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

@@ -43,7 +43,16 @@ static const uint8_t FAMILY_ID = 7;
 static const uint8_t EMPTY_FLAG_MASK          = 4;
 static const uint8_t COMPACT_FLAG_MASK        = 8;
 static const uint8_t OUT_OF_ORDER_FLAG_MASK   = 16;
-static const uint8_t FULL_SIZE_FLAG_MASK      = 32;
+// Bit 32 is RESERVED and must not be written or interpreted.
+// It was formerly FULL_SIZE_FLAG_MASK here, while datasketches-java uses the same bit as
+// REBUILD_CURMIN_NUM_KXQ_MASK for its union gadget. The two meanings collided across
+// implementations, so this side no longer writes or reads it. Do not reuse: bits 64 and 128
+// are free.
+static const uint8_t RESERVED_FLAG_MASK_32    = 32;
+// Deprecated alias for the bit above, retained for source compatibility. Do not use.
+// Added 2026-09-07 (#521), first shipping in the release after 5.2.0. No [[deprecated]]:
+// this library targets C++11, so the alias warns no one.
+static const uint8_t FULL_SIZE_FLAG_MASK      = RESERVED_FLAG_MASK_32;
 
 static const uint32_t PREAMBLE_INTS_BYTE = 0;
 static const uint32_t SER_VER_BYTE       = 1;
@@ -82,8 +91,8 @@ static const uint32_t EMPTY = 0;
 static const uint8_t MIN_LOG_K = 4;
 static const uint8_t MAX_LOG_K = 21;
 
-static const double HLL_HIP_RSE_FACTOR = 0.8325546; // sqrt(ln(2))
-static const double HLL_NON_HIP_RSE_FACTOR = 1.03896; // sqrt((3 * ln(2)) - 1)
+static const double HLL_HIP_RSE_FACTOR = 0.8325546111576977; // sqrt(ln(2))
+static const double HLL_NON_HIP_RSE_FACTOR = 1.0389617614136892; // sqrt((3 * ln(2)) - 1)
 static const double COUPON_RSE_FACTOR = 0.409; // at transition point not the asymptote
 static const double COUPON_RSE = COUPON_RSE_FACTOR / (1 << 13);
 

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

@@ -28,7 +28,7 @@ template<typename A>
 coupon_iterator<A>::coupon_iterator(const uint32_t* array, size_t array_size, size_t index, bool all):
 array_(array), array_size_(array_size), index_(index), all_(all) {
   while (index_ < array_size_) {
-    if (all_ || array_[index_] != hll_constants::EMPTY) break;
+    if (all_ || array_[index_] != hll_constants::EMPTY) { break; }
     ++index_;
   }
 }
@@ -36,7 +36,7 @@ array_(array), array_size_(array_size), index_(index), all_(all) {
 template<typename A>
 coupon_iterator<A>& coupon_iterator<A>::operator++() {
   while (++index_ < array_size_) {
-    if (all_ || array_[index_] != hll_constants::EMPTY) break;
+    if (all_ || array_[index_] != hll_constants::EMPTY) { break; }
   }
   return *this;
 }

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

@@ -20,6 +20,9 @@
 #ifndef _INTARRAYPAIRITERATOR_HPP_
 #define _INTARRAYPAIRITERATOR_HPP_
 
+#include <cstdint>
+#include <iterator>
+
 namespace datasketches {
 
 template<typename A>

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

@@ -120,7 +120,10 @@ class hll_sketch_alloc final {
      * @param tgt_type The HLL mode to use, if/when the sketch reaches that state
      * @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
+     *        starting out using much more memory. This is a property of this
+     *        constructor call only: it is not retained by the sketch and is not
+     *        serialized, so reset() returns to coupon collection mode unless
+     *        reset(true) is used.
      * @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());
@@ -160,7 +163,7 @@ class hll_sketch_alloc final {
     static hll_sketch_alloc deserialize(const void* bytes, size_t len, const A& allocator = A());
 
     //! Class destructor
-    virtual ~hll_sketch_alloc();
+    ~hll_sketch_alloc();
 
     /**
      *  Copy assignment operator
@@ -177,10 +180,14 @@ class hll_sketch_alloc final {
     hll_sketch_alloc& operator=(hll_sketch_alloc<A>&& other);
 
     /**
-     * Resets the sketch to an empty state in coupon collection mode.
+     * Resets the sketch to an empty state.
      * Does not re-use existing internal objects.
+     * @param full_size if true, reset to an empty full-size HLL array, as
+     *        the start_full_size constructor argument does; otherwise reset to
+     *        coupon collection mode. Full size is not remembered across a reset
+     *        or a serialization round trip, so it must be requested each time.
      */
-    void reset();
+    void reset(bool full_size = false);
 
     // This is a convenience alias for users
     // The type returned by the following serialize method

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

@@ -1,3 +1,22 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
 #ifndef _HLL_PRIVATE_HPP_
 #define _HLL_PRIVATE_HPP_
 

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

@@ -42,6 +42,8 @@ target_sources(hll_test
     CouponListTest.cpp
     CrossCountingTest.cpp
     HllArrayTest.cpp
+    HllFullSizeTest.cpp
+    HllKxqRebuildTest.cpp
     HllSketchTest.cpp
     HllUnionTest.cpp
     TablesTest.cpp

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

@@ -24,6 +24,7 @@
 #include <string>
 #include <exception>
 #include <stdexcept>
+#include <vector>
 
 #include "hll.hpp"
 #include "CouponList.hpp"
@@ -180,4 +181,67 @@ TEST_CASE("coupon list: check corrupt stream data", "[coupon_list]") {
   REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
 }
 
+TEST_CASE("coupon list: rejects malformed coupon count in bytes", "[coupon_list]") {
+  // Reject declared LIST counts at or beyond the fixed LIST capacity.
+  uint8_t lgK = 8;
+  hll_sketch sk1(lgK);
+  sk1.update(1);
+  sk1.update(2);
+  const auto validBytes = sk1.serialize_compact();
+
+  const uint8_t listCapacity = static_cast<uint8_t>(1u << hll_constants::LG_INIT_LIST_SIZE);
+  const uint8_t malformedCount = listCapacity;
+  auto sketchBytes = validBytes;
+  // Keep the input long enough to validate the declared LIST count.
+  const size_t requiredLen = hll_constants::LIST_INT_ARR_START
+                             + malformedCount * sizeof(uint32_t);
+  if (sketchBytes.size() < requiredLen) {
+    sketchBytes.resize(requiredLen, 0);
+  }
+  sketchBytes[hll_constants::LIST_COUNT_BYTE] = malformedCount;
+
+  REQUIRE_THROWS_AS(
+      hll_sketch::deserialize(sketchBytes.data(), sketchBytes.size()),
+      std::invalid_argument);
+  REQUIRE_THROWS_AS(
+      CouponList<std::allocator<uint8_t>>::newList(
+          sketchBytes.data(), sketchBytes.size(), std::allocator<uint8_t>()),
+      std::invalid_argument);
+}
+
+TEST_CASE("coupon list: rejects malformed coupon count in stream", "[coupon_list]") {
+  uint8_t lgK = 8;
+  hll_sketch sk1(lgK);
+  sk1.update(1);
+  sk1.update(2);
+
+  const uint8_t listCapacity = static_cast<uint8_t>(1u << hll_constants::LG_INIT_LIST_SIZE);
+  const uint8_t malformedCount = listCapacity;
+  std::stringstream ss(std::ios::in | std::ios::out | std::ios::binary);
+  sk1.serialize_compact(ss);
+
+  const size_t requiredLen = hll_constants::LIST_INT_ARR_START
+                             + malformedCount * sizeof(uint32_t);
+  // Keep the stream long enough to validate the declared LIST count.
+  ss.seekp(0, std::ios::end);
+  const auto endPos = static_cast<size_t>(ss.tellp());
+  if (endPos < requiredLen) {
+    std::vector<char> pad(requiredLen - endPos, 0);
+    ss.write(pad.data(), pad.size());
+  }
+
+  ss.seekp(hll_constants::LIST_COUNT_BYTE);
+  ss.put(static_cast<char>(malformedCount));
+
+  ss.clear();
+  ss.seekg(0);
+  REQUIRE_THROWS_AS(hll_sketch::deserialize(ss), std::invalid_argument);
+
+  ss.clear();
+  ss.seekg(0);
+  REQUIRE_THROWS_AS(
+      CouponList<std::allocator<uint8_t>>::newList(ss, std::allocator<uint8_t>()),
+      std::invalid_argument);
+}
+
 } /* namespace datasketches */

data/vendor/datasketches-cpp/hll/test/HllFullSizeTest.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 <catch2/catch.hpp>
+
+#include "hll.hpp"
+
+namespace datasketches {
+
+// preamble byte 0 is preInts, which identifies the current mode
+static const uint8_t LIST_PREINTS = 2;
+static const uint8_t HLL_PREINTS = 10;
+// preamble byte 5 is the flags byte; bit 32 is reserved and must never be written
+static const size_t FLAGS_BYTE = 5;
+static const uint8_t RESERVED_BIT_32 = 32;
+
+static uint8_t preints_of(const hll_sketch& sk) {
+  return sk.serialize_compact()[0];
+}
+
+static hll_sketch make(uint8_t lg_k, target_hll_type type, bool full_size, uint64_t n) {
+  hll_sketch sk(lg_k, type, full_size);
+  for (uint64_t i = 0; i < n; ++i) sk.update(i);
+  return sk;
+}
+
+TEST_CASE("hll full size: reserved bit 32 is never written", "[hll_full_size]") {
+  for (auto type: {HLL_4, HLL_6, HLL_8}) {
+    for (bool full_size: {false, true}) {
+      for (uint64_t n: {uint64_t(0), uint64_t(5), uint64_t(5000)}) {
+        const hll_sketch sk = make(8, type, full_size, n);
+        REQUIRE((sk.serialize_compact()[FLAGS_BYTE] & RESERVED_BIT_32) == 0);
+        REQUIRE((sk.serialize_updatable()[FLAGS_BYTE] & RESERVED_BIT_32) == 0);
+      }
+    }
+  }
+}
+
+TEST_CASE("hll full size: start_full_size starts in HLL mode", "[hll_full_size]") {
+  REQUIRE(preints_of(make(8, HLL_8, true, 0)) == HLL_PREINTS);
+  REQUIRE(preints_of(make(8, HLL_8, false, 0)) == LIST_PREINTS);
+}
+
+TEST_CASE("hll full size: reset takes the mode as an argument", "[hll_full_size]") {
+  for (auto type: {HLL_4, HLL_6, HLL_8}) {
+    // full size is not remembered: a plain reset() returns to coupon collection mode
+    hll_sketch sk = make(8, type, true, 5000);
+    sk.reset();
+    REQUIRE(sk.is_empty());
+    REQUIRE(sk.get_estimate() == 0.0);
+    REQUIRE(preints_of(sk) == LIST_PREINTS);
+
+    // ...and must be asked for explicitly
+    hll_sketch sk2 = make(8, type, false, 5000);
+    sk2.reset(true);
+    REQUIRE(sk2.is_empty());
+    REQUIRE(sk2.get_estimate() == 0.0);
+    REQUIRE(preints_of(sk2) == HLL_PREINTS);
+    REQUIRE(sk2.get_lg_config_k() == 8);
+    REQUIRE(sk2.get_target_type() == type);
+
+    // reset(false) is the same as reset()
+    hll_sketch sk3 = make(8, type, true, 5000);
+    sk3.reset(false);
+    REQUIRE(preints_of(sk3) == LIST_PREINTS);
+  }
+}
+
+TEST_CASE("hll full size: a reset sketch is usable again", "[hll_full_size]") {
+  hll_sketch sk = make(8, HLL_8, false, 100);
+  sk.reset(true);
+  for (uint64_t i = 0; i < 1000; ++i) sk.update(i);
+  REQUIRE_FALSE(sk.is_empty());
+  REQUIRE(sk.get_estimate() == Approx(1000).epsilon(0.2));
+}
+
+TEST_CASE("hll full size: an image with the reserved bit set is read as if it were clear",
+          "[hll_full_size]") {
+  // an image produced by another implementation may have bit 32 set: datasketches-java uses it
+  // as its union rebuild flag. It must not change how this implementation reads the sketch.
+  for (auto type: {HLL_4, HLL_6, HLL_8}) {
+    const hll_sketch sk = make(8, type, false, 5000);
+    auto bytes = sk.serialize_updatable();
+    auto tampered = bytes;
+    tampered[FLAGS_BYTE] |= RESERVED_BIT_32;
+
+    const hll_sketch clean = hll_sketch::deserialize(bytes.data(), bytes.size());
+    hll_sketch tainted = hll_sketch::deserialize(tampered.data(), tampered.size());
+
+    REQUIRE(tainted.get_estimate() == clean.get_estimate());
+    REQUIRE(tainted.serialize_updatable() == bytes); // the bit is not propagated back out
+    tainted.reset();
+    REQUIRE(preints_of(tainted) == LIST_PREINTS);    // and does not alter reset() behaviour
+  }
+}
+
+TEST_CASE("hll full size: a union never inherits full size from an input sketch",
+          "[hll_full_size]") {
+  // the gadget is an internal detail; unioning a full-size sketch must not change how the
+  // union resets, nor put the reserved bit into the union's result
+  const hll_sketch full = make(8, HLL_8, true, 5000);
+
+  hll_union u(8);
+  u.update(full);
+  const hll_sketch result = u.get_result(HLL_8);
+  REQUIRE((result.serialize_compact()[FLAGS_BYTE] & RESERVED_BIT_32) == 0);
+  REQUIRE((result.serialize_updatable()[FLAGS_BYTE] & RESERVED_BIT_32) == 0);
+
+  u.reset();
+  REQUIRE(u.is_empty());
+  REQUIRE(preints_of(u.get_result(HLL_8)) == LIST_PREINTS);
+
+  // same through the rvalue overload, which moves the sketch into the gadget
+  hll_union u2(8);
+  u2.update(make(8, HLL_8, true, 5000));
+  u2.reset();
+  REQUIRE(u2.is_empty());
+  REQUIRE(preints_of(u2.get_result(HLL_8)) == LIST_PREINTS);
+}
+
+} /* namespace datasketches */

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

@@ -0,0 +1,150 @@
+/*
+ * 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 <cmath>
+#include <cstring>
+#include <limits>
+
+#include "hll.hpp"
+#include "fdlibm_log.hpp"
+
+namespace datasketches {
+
+// offsets into the HLL updatable image
+static const size_t CUR_MIN_BYTE = 6;
+static const size_t NUM_AT_CUR_MIN_INT = 32;
+static const size_t HLL_BYTE_ARR_START = 40;
+
+static hll_sketch make(uint8_t lg_k, target_hll_type type, uint64_t lo, uint64_t hi) {
+  hll_sketch sk(lg_k, type);
+  for (uint64_t i = lo; i < hi; ++i) sk.update(i);
+  return sk;
+}
+static uint32_t num_at_cur_min_of(const hll_sketch::vector_bytes& img) {
+  uint32_t v; std::memcpy(&v, img.data() + NUM_AT_CUR_MIN_INT, sizeof(v)); return v;
+}
+
+TEST_CASE("hll kxq rebuild: union result is merge-order independent", "[hll_kxq]") {
+  // C stays in SET mode, so this exercises the coupon-update path into a gadget with a
+  // deferred rebuild pending, which is where the stored curMin/numAtCurMin used to drift
+  const hll_sketch a = make(12, HLL_4, 20000, 30364);
+  const hll_sketch b = make(10, HLL_8, 5000, 14699);
+  const hll_sketch c = make(17, HLL_4, 70000, 72598);
+  const hll_sketch* in[3] = {&a, &b, &c};
+
+  auto run = [&](int i, int j, int k) {
+    hll_union u(7);
+    u.update(*in[i]); u.update(*in[j]); u.update(*in[k]);
+    return u.get_result(HLL_8).serialize_updatable();
+  };
+  const auto ref = run(0, 1, 2);
+  REQUIRE(run(0, 2, 1) == ref);
+  REQUIRE(run(1, 0, 2) == ref);
+  REQUIRE(run(1, 2, 0) == ref);
+  REQUIRE(run(2, 0, 1) == ref);
+  REQUIRE(run(2, 1, 0) == ref);
+}
+
+TEST_CASE("hll kxq rebuild: reading an estimate does not change a later result",
+          "[hll_kxq]") {
+  // the rebuild is lazy; when it fires must not be observable in the serialized image
+  const hll_sketch p = make(13, HLL_8, 0, 50000);
+  const hll_sketch q = make(13, HLL_8, 50000, 100000);
+
+  for (uint8_t lg_max_k: {uint8_t(7), uint8_t(8), uint8_t(9)}) {
+    hll_union peeked(lg_max_k);
+    peeked.update(p); peeked.update(q);
+    (void) peeked.get_estimate();                       // forces the rebuild here
+    for (uint64_t v = 9000000; v < 9400000; ++v) peeked.update(v);
+
+    hll_union plain(lg_max_k);
+    plain.update(p); plain.update(q);
+    for (uint64_t v = 9000000; v < 9400000; ++v) plain.update(v);
+
+    REQUIRE(peeked.get_result(HLL_8).serialize_updatable()
+            == plain.get_result(HLL_8).serialize_updatable());
+  }
+}
+
+TEST_CASE("hll kxq rebuild: stored curMin and numAtCurMin agree with the registers",
+          "[hll_kxq]") {
+  // HLL_8 convention: curMin is always 0 and numAtCurMin counts the zero registers
+  const hll_sketch a = make(15, HLL_8, 0, 100000);
+  const hll_sketch b = make(8, HLL_8, 100000, 200000);
+  hll_union u(8);
+  u.update(a); u.update(b);
+  const auto img = u.get_result(HLL_8).serialize_updatable();
+
+  uint32_t zeros = 0;
+  for (size_t i = HLL_BYTE_ARR_START; i < img.size(); ++i) if (img[i] == 0) ++zeros;
+
+  REQUIRE(img[CUR_MIN_BYTE] == 0);
+  REQUIRE(num_at_cur_min_of(img) == zeros);
+}
+
+TEST_CASE("hll kxq rebuild: relative error constants are full precision", "[hll_kxq]") {
+  // lg_k > 12 uses the closed form rather than the interpolation table, so a constant
+  // truncated to seven digits is directly observable in the bounds
+  const double hip = std::sqrt(std::log(2.0));                 // sqrt(ln 2)
+  const double non_hip = std::sqrt((3.0 * std::log(2.0)) - 1.0); // sqrt(3 ln 2 - 1)
+
+  for (uint8_t lg_k: {uint8_t(13), uint8_t(16), uint8_t(21)}) {
+    const double k = static_cast<double>(1 << lg_k);
+    for (uint8_t sd = 1; sd <= 3; ++sd) {
+      const double got_hip = hll_union::get_rel_err(false, false, lg_k, sd);
+      const double got_non = hll_union::get_rel_err(false, true, lg_k, sd);
+      REQUIRE(got_hip == Approx(sd * hip / std::sqrt(k)).epsilon(1e-15));
+      REQUIRE(got_non == Approx(sd * non_hip / std::sqrt(k)).epsilon(1e-15));
+    }
+  }
+}
+
+TEST_CASE("hll kxq rebuild: log matches the fdlibm reference", "[hll_kxq]") {
+  // the linear counting estimator subtracts two nearby harmonic numbers, which amplifies a
+  // 1 ULP difference in log() by more than an order of magnitude. Pin log() to fdlibm, the
+  // function datasketches-java's StrictMath.log is specified to be. These expected values
+  // were taken from Java; the platform libm differs from every one of them.
+  struct { int x; uint64_t bits; } expected[] = {
+    {     48, 0x400ef8383c50bb74ULL},
+    {     74, 0x4011375cd6fcab1cULL},
+    {    185, 0x4014e1a4f518c72cULL},
+    {    196, 0x40151cca16d7bba8ULL},
+    {    299, 0x4016cd411481a020ULL},
+    {    308, 0x4016eb9f470ac0b8ULL},
+    {    334, 0x40173e9bbe951e9cULL},
+    {    343, 0x401759d602a5c3c2ULL},
+    {   1261, 0x401c8f031e7e1220ULL},
+  };
+  for (const auto& e: expected) {
+    const double got = fdlibm::log(static_cast<double>(e.x));
+    uint64_t bits; std::memcpy(&bits, &got, sizeof(bits));
+    REQUIRE(bits == e.bits);
+  }
+
+  // edge cases: fdlibm produces these by dividing by a zero constant, which MSVC rejects at
+  // compile time, so they are returned directly. Pin the values.
+  REQUIRE(fdlibm::log(0.0) == -std::numeric_limits<double>::infinity());
+  REQUIRE(fdlibm::log(-0.0) == -std::numeric_limits<double>::infinity());
+  REQUIRE(std::isnan(fdlibm::log(-1.0)));
+  REQUIRE(fdlibm::log(1.0) == 0.0);
+  REQUIRE(fdlibm::log(5e-320) == Approx(-735.2178).epsilon(1e-6)); // subnormal scaling path
+}
+
+} /* namespace datasketches */

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

@@ -298,7 +298,7 @@ TEST_CASE("hll sketch: deserialize list mode buffer overrun", "[hll_sketch]") {
     REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 7, 0), std::out_of_range);
     REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1, 0), std::out_of_range);
 
-    // ckeck for leaks on stream exceptions
+    // check for leaks on stream exceptions
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
@@ -325,7 +325,7 @@ TEST_CASE("hll sketch: deserialize set mode buffer overrun", "[hll_sketch]") {
     REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 7, 0), std::out_of_range);
     REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1, 0), std::out_of_range);
 
-    // ckeck for leaks on stream exceptions
+    // check for leaks on stream exceptions
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);
@@ -355,7 +355,7 @@ TEST_CASE("hll sketch: deserialize HLL mode buffer overrun", "[hll_sketch]") {
     REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), 16420, 0), std::out_of_range); // before aux table
     REQUIRE_THROWS_AS(hll_sketch_test_alloc::deserialize(bytes.data(), bytes.size() - 1, 0), std::out_of_range);
 
-    // ckeck for leaks on stream exceptions
+    // check for leaks on stream exceptions
     {
       std::stringstream ss;
       ss.exceptions(std::ios::failbit | std::ios::badbit);

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

@@ -58,7 +58,7 @@ static void basicUnion(uint64_t n1, uint64_t n2,
 
   hll_sketch result = u.get_result(resultType);
 
-  // ensure we check a direct union estimate, without first caling get_result()
+  // ensure we check a direct union estimate, without first calling get_result()
   u.reset();
   u.update(std::move(h1));
   u.update(h2);
@@ -314,4 +314,74 @@ TEST_CASE("hll union: check hll to hll", "[hll_union]") {
   union_two_sketches_with_overlap(1000000, 11, HLL_4);
 }
 
+static hll_sketch make_hll_sketch(uint8_t lg_config_k, uint64_t start, uint64_t end) {
+  hll_sketch sketch(lg_config_k);
+  for (uint64_t i = start; i < end; ++i) sketch.update(i);
+  return sketch;
+}
+
+static hll_sketch::vector_bytes serialize_flat_union(
+    const hll_sketch& first, const hll_sketch& second, const hll_sketch& third) {
+  hll_union u(8);
+  u.update(first);
+  u.update(second);
+  u.update(third);
+  return u.get_result(HLL_8).serialize_updatable();
+}
+
+static hll_sketch::vector_bytes serialize_nested_union(
+    const hll_sketch& first, const hll_sketch& second, const hll_sketch& third) {
+  hll_union prefix(8);
+  prefix.update(first);
+  prefix.update(second);
+
+  hll_union u(8);
+  u.update(prefix.get_result(HLL_8));
+  u.update(third);
+  return u.get_result(HLL_8).serialize_updatable();
+}
+
+TEST_CASE("hll union: downsampling merge is not empty", "[hll_union]") {
+  const hll_sketch sketch = make_hll_sketch(15, 0, 100000);
+  hll_union u(8);
+  u.update(sketch);
+  REQUIRE_FALSE(u.is_empty());
+}
+
+TEST_CASE("hll union: mixed lgConfigK estimate is merge-order independent", "[hll_union]") {
+  const uint64_t n = 100000;
+  const hll_sketch a = make_hll_sketch(15, 0, n);
+  const hll_sketch b = make_hll_sketch(8, n, 2 * n);
+  const double truth = 2.0 * n;
+
+  hll_union larger_first(8);
+  larger_first.update(a);
+  larger_first.update(b);
+  REQUIRE(larger_first.get_estimate() == Approx(truth).epsilon(0.1));
+
+  hll_union smaller_first(8);
+  smaller_first.update(b);
+  smaller_first.update(a);
+  REQUIRE(smaller_first.get_estimate() == Approx(truth).epsilon(0.1));
+}
+
+TEST_CASE("hll union: scalar update after downsampling merge", "[hll_union]") {
+  const uint64_t n = 100000;
+  const hll_sketch sketch = make_hll_sketch(15, 0, n);
+  hll_union u(8);
+  u.update(sketch);
+  for (uint64_t i = n; i < 2 * n; ++i) u.update(i);
+  REQUIRE(u.get_estimate() == Approx(2.0 * n).epsilon(0.1));
+}
+
+TEST_CASE("hll union: serialization is grouping independent", "[hll_union]") {
+  const uint64_t n = 100000;
+  const hll_sketch a = make_hll_sketch(15, 0, n);
+  const hll_sketch b = make_hll_sketch(8, n, 2 * n);
+  const hll_sketch c = make_hll_sketch(11, n / 2, n + n / 2);
+  REQUIRE(serialize_nested_union(b, c, a) == serialize_flat_union(b, c, a));
+  REQUIRE(serialize_nested_union(a, c, b) == serialize_flat_union(a, c, b));
+  REQUIRE(serialize_nested_union(a, b, c) == serialize_flat_union(a, b, c));
+}
+
 } /* namespace datasketches */

data/vendor/datasketches-cpp/kll/include/kll_helper_impl.hpp

@@ -36,17 +36,17 @@ bool kll_helper::is_odd(uint32_t value) {
 }
 
 uint8_t kll_helper::floor_of_log2_of_fraction(uint64_t numer, uint64_t denom) {
-  if (denom > numer) return 0;
+  if (denom > numer) { return 0; }
   uint8_t count = 0;
   while (true) {
     denom <<= 1;
-    if (denom > numer) return count;
+    if (denom > numer) { return count; }
     count++;
   }
 }
 
 uint8_t kll_helper::ub_on_num_levels(uint64_t n) {
-  if (n == 0) return 1;
+  if (n == 0) { return 1; }
   return 1 + floor_of_log2_of_fraction(n, 1);
 }
 
@@ -65,8 +65,8 @@ uint16_t kll_helper::level_capacity(uint16_t k, uint8_t numLevels, uint8_t heigh
 }
 
 uint16_t kll_helper::int_cap_aux(uint16_t k, uint8_t depth) {
-  if (depth > 60) throw std::invalid_argument("depth > 60");
-  if (depth <= 30) return int_cap_aux_aux(k, depth);
+  if (depth > 60) { throw std::invalid_argument("depth > 60"); }
+  if (depth <= 30) { return int_cap_aux_aux(k, depth); }
   const uint8_t half = depth / 2;
   const uint8_t rest = depth - half;
   const uint16_t tmp = int_cap_aux_aux(k, half);
@@ -74,11 +74,11 @@ uint16_t kll_helper::int_cap_aux(uint16_t k, uint8_t depth) {
 }
 
 uint16_t kll_helper::int_cap_aux_aux(uint16_t k, uint8_t depth) {
-  if (depth > 30) throw std::invalid_argument("depth > 30");
+  if (depth > 30) { throw std::invalid_argument("depth > 30"); }
   const uint64_t twok = k << 1; // for rounding, we pre-multiply by 2
   const uint64_t tmp = (uint64_t) (((uint64_t) twok << depth) / powers_of_three[depth]);
   const uint64_t result = (tmp + 1) >> 1; // then here we add 1 and divide by 2
-  if (result > k) throw std::logic_error("result > k");
+  if (result > k) { throw std::logic_error("result > k"); }
   return static_cast<uint16_t>(result);
 }
 
@@ -94,7 +94,7 @@ uint64_t kll_helper::sum_the_sample_weights(uint8_t num_levels, const uint32_t*
 
 template <typename T>
 void kll_helper::randomly_halve_down(T* buf, uint32_t start, uint32_t length) {
-  if (!is_even(length)) throw std::invalid_argument("length must be even");
+  if (!is_even(length)) { throw std::invalid_argument("length must be even"); }
   const uint32_t half_length = length / 2;
 #ifdef KLL_VALIDATION
   const uint32_t offset = deterministic_offset();
@@ -110,7 +110,7 @@ void kll_helper::randomly_halve_down(T* buf, uint32_t start, uint32_t length) {
 
 template <typename T>
 void kll_helper::randomly_halve_up(T* buf, uint32_t start, uint32_t length) {
-  if (!is_even(length)) throw std::invalid_argument("length must be even");
+  if (!is_even(length)) { throw std::invalid_argument("length must be even"); }
   const uint32_t half_length = length / 2;
 #ifdef KLL_VALIDATION
   const uint32_t offset = deterministic_offset();
@@ -206,7 +206,7 @@ template <typename T, typename C>
 kll_helper::compress_result kll_helper::general_compress(uint16_t k, uint8_t m, uint8_t num_levels_in, T* items,
         uint32_t* in_levels, uint32_t* out_levels, bool is_level_zero_sorted)
 {
-  if (num_levels_in == 0) throw std::invalid_argument("num_levels_in == 0"); // things are too weird if zero levels are allowed
+  if (num_levels_in == 0) { throw std::invalid_argument("num_levels_in == 0"); } // things are too weird if zero levels are allowed
   const uint32_t starting_item_count = in_levels[num_levels_in] - in_levels[0];
   uint8_t current_num_levels = num_levels_in;
   uint32_t current_item_count = starting_item_count; // decreases with each compaction