datasketches 0.5.1 → 0.5.3

data/vendor/datasketches-cpp/tdigest/include/tdigest_impl.hpp

@@ -23,12 +23,35 @@
 #include <algorithm>
 #include <cmath>
 #include <sstream>
+#include <type_traits>
 
 #include "common_defs.hpp"
 #include "memory_operations.hpp"
 
 namespace datasketches {
 
+template<typename T>
+inline void check_not_nan(T value, const char* name) {
+  if (std::isnan(value)) {
+    throw std::invalid_argument(std::string(name) + " must not be NaN");
+  }
+}
+
+template<typename T>
+inline void check_not_infinite(T value, const char* name) {
+  if (std::isinf(value)) {
+    throw std::invalid_argument(std::string(name) + " must not be infinite");
+  }
+}
+
+template<typename T>
+inline void check_non_zero(T value, const char* name) {
+  static_assert(std::is_arithmetic<T>::value, "T must be an arithmetic type");
+  if (value == 0) {
+    throw std::invalid_argument(std::string(name) + " must not be zero");
+  }
+}
+
 template<typename T, typename A>
 tdigest<T, A>::tdigest(uint16_t k, const A& allocator):
 tdigest(false, k, std::numeric_limits<T>::infinity(), -std::numeric_limits<T>::infinity(), vector_centroid(allocator), 0, vector_t(allocator))
@@ -37,6 +60,7 @@ tdigest(false, k, std::numeric_limits<T>::infinity(), -std::numeric_limits<T>::i
 template<typename T, typename A>
 void tdigest<T, A>::update(T value) {
   if (std::isnan(value)) return;
+  if (std::isinf(value)) return;
   if (buffer_.size() == centroids_capacity_ * BUFFER_MULTIPLIER) compress();
   buffer_.push_back(value);
   min_ = std::min(min_, value);
@@ -46,6 +70,9 @@ void tdigest<T, A>::update(T value) {
 template<typename T, typename A>
 void tdigest<T, A>::merge(const tdigest& other) {
   if (other.is_empty()) return;
+  // Extreme centroid means are not the true min/max when those centroids have weight > 1.
+  min_ = std::min(min_, other.min_);
+  max_ = std::max(max_, other.max_);
   vector_centroid tmp(buffer_.get_allocator());
   tmp.reserve(buffer_.size() + centroids_.size() + other.buffer_.size() + other.centroids_.size());
   for (const T value: buffer_) tmp.push_back(centroid(value, 1));
@@ -106,7 +133,7 @@ double tdigest<T, A>::get_rank(T value) const {
   if (value < first_mean) {
     if (first_mean - min_ > 0) {
       if (value == min_) return 0.5 / centroids_weight_;
-      return (1.0 + (value - min_) / (first_mean - min_) * (centroids_.front().get_weight() / 2.0 - 1.0)); // ?
+      return (1.0 + (value - min_) / (first_mean - min_) * (centroids_.front().get_weight() / 2.0 - 1.0)) / centroids_weight_;
     }
     return 0; // should never happen
   }
@@ -116,7 +143,7 @@ double tdigest<T, A>::get_rank(T value) const {
   if (value > last_mean) {
     if (max_ - last_mean > 0) {
       if (value == max_) return 1.0 - 0.5 / centroids_weight_;
-        return 1.0 - ((1.0 + (max_ - value) / (max_ - last_mean) * (centroids_.back().get_weight() / 2.0 - 1.0)) / centroids_weight_); // ?
+      return 1.0 - ((1.0 + (max_ - value) / (max_ - last_mean) * (centroids_.back().get_weight() / 2.0 - 1.0)) / centroids_weight_);
     }
     return 1; // should never happen
   }
@@ -166,7 +193,10 @@ T tdigest<T, A>::get_quantile(double rank) const {
   }
   const double last_weight = centroids_.back().get_weight();
   if (last_weight > 1 && centroids_weight_ - weight <= last_weight / 2.0) {
-    return max_ + (centroids_weight_ - weight - 1.0) / (last_weight / 2.0 - 1.0) * (max_ - centroids_.back().get_mean());
+    // A last centroid of weight 2 makes the denominator zero. The only rank that
+    // reaches this branch is the one that returns the stored maximum.
+    if (last_weight == 2) return max_;
+    return max_ - (centroids_weight_ - weight - 1.0) / (last_weight / 2.0 - 1.0) * (max_ - centroids_.back().get_mean());
   }
 
   // interpolate between extremes
@@ -187,13 +217,15 @@ T tdigest<T, A>::get_quantile(double rank) const {
       }
       const double w1 = weight - weight_so_far - left_weight;
       const double w2 = weight_so_far + dw - weight - right_weight;
-      return weighted_average(centroids_[i].get_mean(), w1, centroids_[i + 1].get_mean(), w2);
+      // Weight each centroid by the distance to the other one, so the estimate
+      // moves toward the nearer centroid.
+      return weighted_average(centroids_[i].get_mean(), w2, centroids_[i + 1].get_mean(), w1);
     }
     weight_so_far += dw;
   }
   const double w1 = weight - centroids_weight_ - centroids_.back().get_weight() / 2.0;
   const double w2 = centroids_.back().get_weight() / 2.0 - w1;
-  return weighted_average(centroids_.back().get_weight(), w1, max_, w2);
+  return weighted_average(centroids_.back().get_mean(), w1, max_, w2);
 }
 
 template<typename T, typename A>
@@ -400,6 +432,8 @@ tdigest<T, A> tdigest<T, A>::deserialize(std::istream& is, const A& allocator) {
   const bool reverse_merge = flags_byte & (1 << flags::REVERSE_MERGE);
   if (is_single_value) {
     const T value = read<T>(is);
+    check_not_nan(value, "single_value");
+    check_not_infinite(value, "single_value");
     return tdigest(reverse_merge, k, value, value, vector_centroid(1, centroid(value, 1), allocator), 1, vector_t(allocator));
   }
 
@@ -408,12 +442,26 @@ tdigest<T, A> tdigest<T, A>::deserialize(std::istream& is, const A& allocator) {
 
   const T min = read<T>(is);
   const T max = read<T>(is);
+  check_not_nan(min, "min");
+  check_not_infinite(min, "min");
+  check_not_nan(max, "max");
+  check_not_infinite(max, "max");
   vector_centroid centroids(num_centroids, centroid(0, 0), allocator);
   if (num_centroids > 0) read(is, centroids.data(), num_centroids * sizeof(centroid));
   vector_t buffer(num_buffered, 0, allocator);
   if (num_buffered > 0) read(is, buffer.data(), num_buffered * sizeof(T));
   uint64_t weight = 0;
-  for (const auto& c: centroids) weight += c.get_weight();
+  for (const auto& c: centroids) {
+    check_not_nan(c.get_mean(), "centroid mean");
+    check_not_infinite(c.get_mean(), "centroid mean");
+    check_non_zero(c.get_weight(), "centroid weight");
+
+    weight += c.get_weight();
+  }
+  for (const auto& value: buffer) {
+    check_not_nan(value, "buffered_value");
+    check_not_infinite(value, "buffered_value");
+  }
   return tdigest(reverse_merge, k, min, max, std::move(centroids), weight, std::move(buffer));
 }
 
@@ -451,6 +499,8 @@ tdigest<T, A> tdigest<T, A>::deserialize(const void* bytes, size_t size, const A
     ensure_minimum_memory(end_ptr - ptr, sizeof(T));
     T value;
     ptr += copy_from_mem(ptr, value);
+    check_not_nan(value, "single_value");
+    check_not_infinite(value, "single_value");
     return tdigest(reverse_merge, k, value, value, vector_centroid(1, centroid(value, 1), allocator), 1, vector_t(allocator));
   }
 
@@ -465,12 +515,26 @@ tdigest<T, A> tdigest<T, A>::deserialize(const void* bytes, size_t size, const A
   ptr += copy_from_mem(ptr, min);
   T max;
   ptr += copy_from_mem(ptr, max);
+  check_not_nan(min, "min");
+  check_not_infinite(min, "min");
+  check_not_nan(max, "max");
+  check_not_infinite(max, "max");
   vector_centroid centroids(num_centroids, centroid(0, 0), allocator);
   if (num_centroids > 0) ptr += copy_from_mem(ptr, centroids.data(), num_centroids * sizeof(centroid));
   vector_t buffer(num_buffered, 0, allocator);
   if (num_buffered > 0) copy_from_mem(ptr, buffer.data(), num_buffered * sizeof(T));
   uint64_t weight = 0;
-  for (const auto& c: centroids) weight += c.get_weight();
+  for (const auto& c: centroids) {
+    check_not_nan(c.get_mean(), "centroid mean");
+    check_not_infinite(c.get_mean(), "centroid mean");
+    check_non_zero(c.get_weight(), "centroid weight");
+
+    weight += c.get_weight();
+  }
+  for (const auto& value: buffer) {
+    check_not_nan(value, "buffered_value");
+    check_not_infinite(value, "buffered_value");
+  }
   return tdigest(reverse_merge, k, min, max, std::move(centroids), weight, std::move(buffer));
 }
 
@@ -487,13 +551,24 @@ tdigest<T, A> tdigest<T, A>::deserialize_compat(std::istream& is, const A& alloc
   if (type == COMPAT_DOUBLE) { // compatibility with asBytes()
     const auto min = read_big_endian<double>(is);
     const auto max = read_big_endian<double>(is);
+    check_not_nan(min, "min");
+    check_not_infinite(min, "min");
+    check_not_nan(max, "max");
+    check_not_infinite(max, "max");
     const auto k = static_cast<uint16_t>(read_big_endian<double>(is));
     const auto num_centroids = read_big_endian<uint32_t>(is);
     vector_centroid centroids(num_centroids, centroid(0, 0), allocator);
     uint64_t total_weight = 0;
     for (auto& c: centroids) {
-      const W weight = static_cast<W>(read_big_endian<double>(is));
+      const auto weight_double = read_big_endian<double>(is);
+      check_not_nan(weight_double, "centroid weight");
+      check_not_infinite(weight_double, "centroid weight");
+      check_non_zero(weight_double, "centroid weight");
+
       const auto mean = read_big_endian<double>(is);
+      check_not_nan(mean, "centroid mean");
+      check_not_infinite(mean, "centroid mean");
+      const W weight = static_cast<W>(weight_double);
       c = centroid(mean, weight);
       total_weight += weight;
     }
@@ -502,6 +577,10 @@ tdigest<T, A> tdigest<T, A>::deserialize_compat(std::istream& is, const A& alloc
   // COMPAT_FLOAT: compatibility with asSmallBytes()
   const auto min = read_big_endian<double>(is); // reference implementation uses doubles for min and max
   const auto max = read_big_endian<double>(is);
+  check_not_nan(min, "min");
+  check_not_infinite(min, "min");
+  check_not_nan(max, "max");
+  check_not_infinite(max, "max");
   const auto k = static_cast<uint16_t>(read_big_endian<float>(is));
   // reference implementation stores capacities of the array of centroids and the buffer as shorts
   // they can be derived from k in the constructor
@@ -510,8 +589,13 @@ tdigest<T, A> tdigest<T, A>::deserialize_compat(std::istream& is, const A& alloc
   vector_centroid centroids(num_centroids, centroid(0, 0), allocator);
   uint64_t total_weight = 0;
   for (auto& c: centroids) {
-    const W weight = static_cast<W>(read_big_endian<float>(is));
+    const auto weight_float = read_big_endian<float>(is);
+    check_not_nan(weight_float, "centroid weight");
+    check_not_infinite(weight_float, "centroid weight");
     const auto mean = read_big_endian<float>(is);
+    check_not_nan(mean, "centroid mean");
+    check_not_infinite(mean, "centroid mean");
+    const W weight = static_cast<W>(weight_float);
     c = centroid(mean, weight);
     total_weight += weight;
   }
@@ -538,6 +622,10 @@ tdigest<T, A> tdigest<T, A>::deserialize_compat(const void* bytes, size_t size,
     double max;
     ptr += copy_from_mem(ptr, max);
     max = byteswap(max);
+    check_not_nan(min, "min");
+    check_not_infinite(min, "min");
+    check_not_nan(max, "max");
+    check_not_infinite(max, "max");
     double k_double;
     ptr += copy_from_mem(ptr, k_double);
     const uint16_t k = static_cast<uint16_t>(byteswap(k_double));
@@ -554,6 +642,10 @@ tdigest<T, A> tdigest<T, A>::deserialize_compat(const void* bytes, size_t size,
       double mean;
       ptr += copy_from_mem(ptr, mean);
       mean = byteswap(mean);
+      check_not_nan(weight, "centroid weight");
+      check_not_infinite(weight, "centroid weight");
+      check_not_nan(mean, "centroid mean");
+      check_not_infinite(mean, "centroid mean");
       c = centroid(mean, static_cast<W>(weight));
       total_weight += static_cast<uint64_t>(weight);
     }
@@ -567,6 +659,10 @@ tdigest<T, A> tdigest<T, A>::deserialize_compat(const void* bytes, size_t size,
   double max;
   ptr += copy_from_mem(ptr, max);
   max = byteswap(max);
+  check_not_nan(min, "min");
+  check_not_infinite(min, "min");
+  check_not_nan(max, "max");
+  check_not_infinite(max, "max");
   float k_float;
   ptr += copy_from_mem(ptr, k_float);
   const uint16_t k = static_cast<uint16_t>(byteswap(k_float));
@@ -586,6 +682,10 @@ tdigest<T, A> tdigest<T, A>::deserialize_compat(const void* bytes, size_t size,
     float mean;
     ptr += copy_from_mem(ptr, mean);
     mean = byteswap(mean);
+    check_not_nan(weight, "centroid weight");
+    check_not_infinite(weight, "centroid weight");
+    check_not_nan(mean, "centroid mean");
+    check_not_infinite(mean, "centroid mean");
     c = centroid(mean, static_cast<W>(weight));
     total_weight += static_cast<uint64_t>(weight);
   }
@@ -627,6 +727,65 @@ void tdigest<T, A>::check_split_points(const T* values, uint32_t size) {
   }
 }
 
+template <typename T, typename A>
+typename tdigest<T, A>::const_iterator tdigest<T, A>::begin() const {
+  return tdigest<T, A>::const_iterator(*this, false);
+}
+
+template <typename T, typename A>
+  typename tdigest<T, A>::const_iterator tdigest<T, A>::end() const {
+  return tdigest::const_iterator(*this, true);
+}
+
+template<typename T, typename A>
+tdigest<T, A>::const_iterator::const_iterator(const tdigest& tdigest_, const bool is_end):
+  centroids_(tdigest_.get_allocator())
+{
+  // Create a copy of the tdigest to generate the centroids after processing the buffered values
+  tdigest tmp(tdigest_);
+  tmp.compress();
+  centroids_.insert(centroids_.end(), tmp.centroids_.begin(), tmp.centroids_.end());
+
+  if (is_end) {
+    index_ = centroids_.size();
+  } else {
+    index_ = 0;
+  }
+}
+
+template<typename T, typename A>
+typename tdigest<T, A>::const_iterator& tdigest<T, A>::const_iterator::operator++() {
+  ++index_;
+  return *this;
+}
+
+template<typename T, typename A>
+typename tdigest<T, A>::const_iterator& tdigest<T, A>::const_iterator::operator++(int) {
+  const_iterator tmp(*this);
+  operator++();
+  return tmp;
+}
+
+template<typename T, typename A>
+bool tdigest<T, A>::const_iterator::operator==(const const_iterator& other) const {
+  return index_ == other.index_;
+}
+
+template<typename T, typename A>
+bool tdigest<T, A>::const_iterator::operator!=(const const_iterator& other) const {
+  return !operator==(other);
+}
+
+template<typename T, typename A>
+auto tdigest<T, A>::const_iterator::operator*() const -> reference {
+  return value_type(centroids_[index_].get_mean(), centroids_[index_].get_weight());
+}
+
+template<typename T, typename A>
+auto tdigest<T, A>::const_iterator::operator->() const -> pointer {
+  return **this;
+}
+
 } /* namespace datasketches */
 
 #endif // _TDIGEST_IMPL_HPP_

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

@@ -39,6 +39,7 @@ target_sources(tdigest_test
   PRIVATE
     tdigest_test.cpp
     tdigest_custom_allocator_test.cpp
+    tdigest_iterator_test.cpp
 )
 
 if (SERDE_COMPAT)

data/vendor/datasketches-cpp/tdigest/test/tdigest_iterator_test.cpp

@@ -0,0 +1,274 @@
+/*
+ * 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 <memory>
+#include <map>
+#include <vector>
+#include <set>
+
+#include "tdigest.hpp"
+
+namespace datasketches {
+
+TEST_CASE("tdigest iterator: basic iteration", "[tdigest]") {
+  tdigest_double td(100);
+  
+  // Insert 10 distinct values
+  for (int i = 0; i < 10; i++) {
+    td.update(static_cast<double>(i));
+  }
+  
+  // Collect all centroids via iteration
+  std::map<double, uint64_t> centroids;
+  for (const auto&& centroid : td) {
+    centroids[centroid.first] = centroid.second;
+  }
+  
+  // Should have collected all 10 distinct values
+  REQUIRE(centroids.size() == 10);
+  
+  // Verify each value was captured correctly
+  for (int i = 0; i < 10; i++) {
+    REQUIRE(centroids.count(static_cast<double>(i)) == 1);
+    REQUIRE(centroids[static_cast<double>(i)] == 1);
+  }
+}
+
+TEST_CASE("tdigest iterator: explicit begin/end with unique_ptr", "[tdigest]") {
+  // This test reproduces the bug scenario found in ClickHouse
+  std::unique_ptr<tdigest_double> td(new tdigest_double(100));
+  
+  // Insert distinct values
+  for (int i = 0; i < 10; i++) {
+    td->update(static_cast<double>(i));
+  }
+  
+  // Use explicit begin/end iterators
+  auto it = td->begin();
+  auto end_it = td->end();
+  
+  std::vector<double> means;
+  std::vector<uint64_t> weights;
+  
+  while (it != end_it) {
+    // Before the fix, accessing it->first would return garbage or same value repeatedly
+    double mean = it->first;
+    uint64_t weight = it->second;
+    means.push_back(mean);
+    weights.push_back(weight);
+    ++it;
+  }
+  
+  // Should have collected 10 centroids
+  REQUIRE(means.size() == 10);
+  REQUIRE(weights.size() == 10);
+  
+  // All means should be distinct (not all zeros or garbage)
+  std::set<double> unique_means(means.begin(), means.end());
+  REQUIRE(unique_means.size() == 10);
+  
+  // Verify all expected values are present
+  for (int i = 0; i < 10; i++) {
+    REQUIRE(unique_means.count(static_cast<double>(i)) == 1);
+  }
+}
+
+TEST_CASE("tdigest iterator: structured bindings", "[tdigest]") {
+  tdigest_double td(100);
+  
+  for (int i = 0; i < 5; i++) {
+    td.update(static_cast<double>(i * 10));
+  }
+  
+  std::vector<std::pair<double, uint64_t>> collected;
+  
+  // Test structured bindings
+  for (auto it = td.begin(); it != td.end(); ++it) {
+    const auto& centroid = *it;
+    collected.emplace_back(centroid.first, centroid.second);
+  }
+  
+  REQUIRE(collected.size() == 5);
+  
+  // Verify distinct values were collected
+  std::set<double> means;
+  for (const auto& pair : collected) {
+    means.insert(pair.first);
+    REQUIRE(pair.second == 1);  // Each value inserted once
+  }
+  
+  REQUIRE(means.size() == 5);
+  for (int i = 0; i < 5; i++) {
+    REQUIRE(means.count(static_cast<double>(i * 10)) == 1);
+  }
+}
+
+TEST_CASE("tdigest iterator: operator-> access", "[tdigest]") {
+  tdigest_double td(100);
+  
+  // Insert values
+  for (int i = 1; i <= 10; i++) {
+    td.update(static_cast<double>(i * i));  // 1, 4, 9, 16, 25, 36, 49, 64, 81, 100
+  }
+  
+  // Access via operator->
+  std::map<double, uint64_t> centroids;
+  auto end_it = td.end();
+  for (auto it = td.begin(); it != end_it; ++it) {
+    // operator-> should return valid values
+    centroids[it->first] = it->second;
+  }
+  
+  REQUIRE(centroids.size() == 10);
+  
+  // Verify the squared values
+  for (int i = 1; i <= 10; i++) {
+    double expected = static_cast<double>(i * i);
+    REQUIRE(centroids.count(expected) == 1);
+  }
+}
+
+TEST_CASE("tdigest iterator: range-based for with const auto&&", "[tdigest]") {
+  tdigest_double td(100);
+  
+  // Insert values
+  for (double d = 0.0; d < 10.0; d += 1.0) {
+    td.update(d);
+  }
+  
+  size_t count = 0;
+  std::set<double> seen_means;
+  
+  // This pattern was working in simple tests but failing in optimized builds
+  for (const auto&& centroid : td) {
+    seen_means.insert(centroid.first);
+    count++;
+  }
+  
+  REQUIRE(count == 10);
+  REQUIRE(seen_means.size() == 10);
+  
+  // Verify all values from 0 to 9 are present
+  for (int i = 0; i < 10; i++) {
+    REQUIRE(seen_means.count(static_cast<double>(i)) == 1);
+  }
+}
+
+TEST_CASE("tdigest iterator: copy vs reference semantics", "[tdigest]") {
+  tdigest_double td(100);
+  
+  td.update(1.0);
+  td.update(2.0);
+  td.update(3.0);
+  
+  auto it = td.begin();
+  
+  // Store the pair
+  auto pair1 = *it;
+  double mean1 = pair1.first;
+  
+  ++it;
+  
+  // Store another pair
+  auto pair2 = *it;
+  double mean2 = pair2.first;
+  
+  ++it;
+  
+  auto pair3 = *it;
+  double mean3 = pair3.first;
+  
+  // All three means should be distinct
+  REQUIRE(mean1 != mean2);
+  REQUIRE(mean2 != mean3);
+  REQUIRE(mean1 != mean3);
+  
+  // And they should match our input values
+  std::set<double> means = {mean1, mean2, mean3};
+  REQUIRE(means.count(1.0) == 1);
+  REQUIRE(means.count(2.0) == 1);
+  REQUIRE(means.count(3.0) == 1);
+}
+
+TEST_CASE("tdigest iterator: empty sketch", "[tdigest]") {
+  tdigest_double td(100);
+  
+  // Empty sketch should have begin() == end()
+  REQUIRE(td.begin() == td.end());
+  
+  // Range-based for should not execute
+  size_t count = 0;
+  for (const auto&& centroid : td) {
+    (void)centroid;  // Silence unused warning
+    count++;
+  }
+  REQUIRE(count == 0);
+}
+
+TEST_CASE("tdigest iterator: single value", "[tdigest]") {
+  tdigest_double td(100);
+  td.update(42.0);
+  
+  size_t count = 0;
+  double captured_mean = 0.0;
+  uint64_t captured_weight = 0;
+  
+  for (const auto&& centroid : td) {
+    captured_mean = centroid.first;
+    captured_weight = centroid.second;
+    count++;
+  }
+  
+  REQUIRE(count == 1);
+  REQUIRE(captured_mean == 42.0);
+  REQUIRE(captured_weight == 1);
+}
+
+TEST_CASE("tdigest iterator: large dataset", "[tdigest]") {
+  tdigest_double td(100);
+  
+  // Insert 1000 distinct values
+  for (int i = 0; i < 1000; i++) {
+    td.update(static_cast<double>(i));
+  }
+  
+  // Iterator should provide compressed centroids (not all 1000)
+  size_t centroid_count = 0;
+  std::set<double> unique_means;
+  uint64_t total_weight = 0;
+  
+  for (const auto&& centroid : td) {
+    unique_means.insert(centroid.first);
+    total_weight += centroid.second;
+    centroid_count++;
+  }
+  
+  // Should have fewer centroids than input values due to compression
+  REQUIRE(centroid_count < 1000);
+  REQUIRE(centroid_count > 0);
+  
+  // Total weight should equal number of input values
+  REQUIRE(total_weight == 1000);
+  
+  // All means should be unique (no duplicates)
+  REQUIRE(unique_means.size() == centroid_count);
+}
+
+} // namespace datasketches