You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datasketches.apache.org by ti...@apache.org on 2026/07/23 12:39:49 UTC
(datasketches-rust) branch main updated: refactor: simplify builders interface and rework tuple summary policy (#158)
This is an automated email from the ASF dual-hosted git repository.
tisonkun pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/datasketches-rust.git
The following commit(s) were added to refs/heads/main by this push:
new 7f35b05 refactor: simplify builders interface and rework tuple summary policy (#158)
7f35b05 is described below
commit 7f35b0510029740a38338ccaf587a07ab4426ee3
Author: tison <wa...@gmail.com>
AuthorDate: Thu Jul 23 20:39:44 2026 +0800
refactor: simplify builders interface and rework tuple summary policy (#158)
Signed-off-by: tison <wa...@gmail.com>
---
CHANGELOG.md | 4 +
datasketches/src/countmin/mod.rs | 3 +-
datasketches/src/hll/union.rs | 6 +-
datasketches/src/theta/hash_table.rs | 12 +-
datasketches/src/theta/mod.rs | 4 +-
datasketches/src/theta/sketch.rs | 78 +++---
datasketches/src/theta/union.rs | 30 +--
datasketches/src/tuple/mod.rs | 13 +-
datasketches/src/tuple/policy.rs | 68 +++---
datasketches/src/tuple/sketch.rs | 329 +++++++++++++++-----------
datasketches/tests/cpc_union_test.rs | 4 +-
datasketches/tests/frequencies_update_test.rs | 2 +-
datasketches/tests/theta_intersection_test.rs | 31 +--
datasketches/tests/theta_sketch_test.rs | 34 +--
datasketches/tests/theta_union_test.rs | 93 ++++----
datasketches/tests/tuple_sketch_test.rs | 53 ++---
16 files changed, 406 insertions(+), 358 deletions(-)
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e7ada56..da6cb3f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,10 @@ All significant changes to this project will be documented in this file.
## Unreleased
+### Breaking changes
+
+* Remove `ThetaSketch::builder`, `ThetaUnion::builder`, and `TupleSketch::builder`. Construct `ThetaSketchBuilder`, `ThetaUnionBuilder`, and `TupleSketchBuilder` with `Default::default` instead.
+
### New features
* `FrequentItemsSketch` now supports borrowed-key updates via `update_ref` and `update_with_count_ref`, allowing sketches such as `FrequentItemsSketch<String>` to update from `&str` without allocating on existing-key hits. Frequency queries also accept borrowed key forms matching `Borrow<Q>`.
diff --git a/datasketches/src/countmin/mod.rs b/datasketches/src/countmin/mod.rs
index cea20ae..4331c20 100644
--- a/datasketches/src/countmin/mod.rs
+++ b/datasketches/src/countmin/mod.rs
@@ -36,7 +36,8 @@
//! # use datasketches::countmin::CountMinSketch;
//! let buckets = CountMinSketch::<i64>::suggest_num_buckets(0.01);
//! let hashes = CountMinSketch::<i64>::suggest_num_hashes(0.99);
-//! let _sketch = CountMinSketch::<i64>::new(hashes, buckets);
+//! let sketch = CountMinSketch::<i64>::new(hashes, buckets);
+//! assert_eq!(sketch.estimate("apple"), 0);
//! ```
mod serialization;
diff --git a/datasketches/src/hll/union.rs b/datasketches/src/hll/union.rs
index 9d0fd06..df995f6 100644
--- a/datasketches/src/hll/union.rs
+++ b/datasketches/src/hll/union.rs
@@ -74,7 +74,8 @@ impl HllUnion {
/// # use datasketches::hll::HllUnion;
/// let mut union = HllUnion::new(10);
/// union.update_value("apple");
- /// let _result = union.to_sketch(HllType::Hll8);
+ /// let result = union.to_sketch(HllType::Hll8);
+ /// assert_eq!(result.estimate(), 1.0);
/// ```
pub fn new(lg_max_k: u8) -> Self {
assert!(
@@ -101,7 +102,8 @@ impl HllUnion {
/// # use datasketches::hll::HllUnion;
/// let mut union = HllUnion::new(10);
/// union.update_value("apple");
- /// let _result = union.to_sketch(HllType::Hll8);
+ /// let result = union.to_sketch(HllType::Hll8);
+ /// assert_eq!(result.estimate(), 1.0);
/// ```
pub fn update_value<T: Hash>(&mut self, value: T) {
self.gadget.update(value);
diff --git a/datasketches/src/theta/hash_table.rs b/datasketches/src/theta/hash_table.rs
index fa9036b..5dd83ee 100644
--- a/datasketches/src/theta/hash_table.rs
+++ b/datasketches/src/theta/hash_table.rs
@@ -217,7 +217,7 @@ mod tests {
// Insert many values to trigger rebuild
for i in 0..100 {
- let _ = table.try_insert(format!("value_{}", i));
+ table.try_insert(format!("value_{i}"));
}
// After rebuild, theta should be reduced (rebuild is called automatically during insert)
@@ -229,7 +229,7 @@ mod tests {
// Continue to insert values to trigger rebuild again
for i in 100..200 {
- let _ = table.try_insert(format!("value_{}", i));
+ table.try_insert(format!("value_{i}"));
}
assert_eq!(table.lg_cur_size(), 6);
@@ -243,7 +243,7 @@ mod tests {
// Insert more than k values
for i in 0..100 {
- let _ = table.try_insert(format!("value_{}", i));
+ table.try_insert(format!("value_{i}"));
}
let before_trim = table.num_retained();
@@ -261,7 +261,7 @@ mod tests {
// Insert fewer than k values
for i in 0..10 {
- let _ = table.try_insert(format!("value_{}", i));
+ table.try_insert(format!("value_{i}"));
}
let before_trim = table.num_retained();
@@ -283,7 +283,7 @@ mod tests {
// Insert some values
for i in 0..10 {
- let _ = table.try_insert(format!("value_{}", i));
+ table.try_insert(format!("value_{i}"));
}
assert!(!table.is_empty());
@@ -312,7 +312,7 @@ mod tests {
// Insert some values
for i in 0..10 {
- let _ = table.try_insert(format!("value_{}", i));
+ table.try_insert(format!("value_{i}"));
}
table.reset();
diff --git a/datasketches/src/theta/mod.rs b/datasketches/src/theta/mod.rs
index 10bfa3e..0178f34 100644
--- a/datasketches/src/theta/mod.rs
+++ b/datasketches/src/theta/mod.rs
@@ -33,8 +33,8 @@
//! # Usage
//!
//! ```
-//! # use datasketches::theta::ThetaSketch;
-//! let mut sketch = ThetaSketch::builder().build();
+//! # use datasketches::theta::ThetaSketchBuilder;
+//! let mut sketch = ThetaSketchBuilder::default().build();
//! sketch.update("apple");
//! assert!(sketch.estimate() >= 1.0);
//! ```
diff --git a/datasketches/src/theta/sketch.rs b/datasketches/src/theta/sketch.rs
index 1d26c8d..0ccbf61 100644
--- a/datasketches/src/theta/sketch.rs
+++ b/datasketches/src/theta/sketch.rs
@@ -95,19 +95,6 @@ pub struct ThetaSketch {
}
impl ThetaSketch {
- /// Create a new builder for ThetaSketch
- ///
- /// # Examples
- ///
- /// ```
- /// # use datasketches::theta::ThetaSketch;
- /// let sketch = ThetaSketch::builder().lg_k(12).build();
- /// assert_eq!(sketch.lg_k(), 12);
- /// ```
- pub fn builder() -> ThetaSketchBuilder {
- ThetaSketchBuilder::default()
- }
-
/// Update the sketch with a hashable value.
///
/// You may use [`hash_value`](crate::hash_value) wrappers when matching other datasketches
@@ -117,13 +104,13 @@ impl ThetaSketch {
///
/// ```
/// use datasketches::hash_value;
- /// use datasketches::theta::ThetaSketch;
+ /// use datasketches::theta::ThetaSketchBuilder;
///
- /// let mut sketch = ThetaSketch::builder().build();
+ /// let mut sketch = ThetaSketchBuilder::default().build();
/// sketch.update("apple");
/// assert!(sketch.estimate() >= 1.0);
///
- /// let mut sketch = ThetaSketch::builder().build();
+ /// let mut sketch = ThetaSketchBuilder::default().build();
/// sketch.update(hash_value::raw_bytes::from_str("apple"));
/// assert!(sketch.estimate() >= 1.0);
/// ```
@@ -136,8 +123,8 @@ impl ThetaSketch {
/// # Examples
///
/// ```
- /// # use datasketches::theta::ThetaSketch;
- /// # let mut sketch = ThetaSketch::builder().build();
+ /// # use datasketches::theta::ThetaSketchBuilder;
+ /// # let mut sketch = ThetaSketchBuilder::default().build();
/// # sketch.update("apple");
/// assert!(sketch.estimate() >= 1.0);
/// ```
@@ -200,8 +187,8 @@ impl ThetaSketch {
/// # Examples
///
/// ```
- /// # use datasketches::theta::ThetaSketch;
- /// # let mut sketch = ThetaSketch::builder().build();
+ /// # use datasketches::theta::ThetaSketchBuilder;
+ /// # let mut sketch = ThetaSketchBuilder::default().build();
/// # sketch.update("apple");
/// let mut iter = sketch.iter();
/// assert!(iter.next().is_some());
@@ -217,8 +204,8 @@ impl ThetaSketch {
/// # Examples
///
/// ```
- /// # use datasketches::theta::ThetaSketch;
- /// let mut sketch = ThetaSketch::builder().build();
+ /// # use datasketches::theta::ThetaSketchBuilder;
+ /// let mut sketch = ThetaSketchBuilder::default().build();
/// sketch.update("apple");
/// let compact = sketch.compact(true);
/// assert_eq!(compact.num_retained(), 1);
@@ -248,9 +235,9 @@ impl ThetaSketch {
///
/// ```
/// use datasketches::common::NumStdDev;
- /// use datasketches::theta::ThetaSketch;
+ /// use datasketches::theta::ThetaSketchBuilder;
///
- /// let mut sketch = ThetaSketch::builder().lg_k(12).build();
+ /// let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
/// for i in 0..10000 {
/// sketch.update(i);
/// }
@@ -282,9 +269,9 @@ impl ThetaSketch {
///
/// ```
/// use datasketches::common::NumStdDev;
- /// use datasketches::theta::ThetaSketch;
+ /// use datasketches::theta::ThetaSketchBuilder;
///
- /// let mut sketch = ThetaSketch::builder().lg_k(12).build();
+ /// let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
/// for i in 0..10000 {
/// sketch.update(i);
/// }
@@ -931,8 +918,8 @@ impl ThetaSketchBuilder {
/// # Examples
///
/// ```
- /// # use datasketches::theta::ThetaSketch;
- /// let sketch = ThetaSketch::builder().lg_k(12).build();
+ /// # use datasketches::theta::ThetaSketchBuilder;
+ /// let sketch = ThetaSketchBuilder::default().lg_k(12).build();
/// assert_eq!(sketch.lg_k(), 12);
/// ```
pub fn lg_k(mut self, lg_k: u8) -> Self {
@@ -965,8 +952,10 @@ impl ThetaSketchBuilder {
/// # Examples
///
/// ```
- /// # use datasketches::theta::ThetaSketch;
- /// let _sketch = ThetaSketch::builder().sampling_probability(0.5).build();
+ /// # use datasketches::theta::ThetaSketchBuilder;
+ /// ThetaSketchBuilder::default()
+ /// .sampling_probability(0.5)
+ /// .build();
/// ```
pub fn sampling_probability(mut self, probability: f32) -> Self {
assert!(
@@ -982,8 +971,8 @@ impl ThetaSketchBuilder {
/// # Examples
///
/// ```
- /// # use datasketches::theta::ThetaSketch;
- /// let _sketch = ThetaSketch::builder().seed(7).build();
+ /// # use datasketches::theta::ThetaSketchBuilder;
+ /// ThetaSketchBuilder::default().seed(7).build();
/// ```
pub fn seed(mut self, seed: u64) -> Self {
self.seed = seed;
@@ -995,9 +984,8 @@ impl ThetaSketchBuilder {
/// # Examples
///
/// ```
- /// # use datasketches::theta::ThetaSketch;
- /// let sketch = ThetaSketch::builder().lg_k(10).build();
- /// assert_eq!(sketch.lg_k(), 10);
+ /// # use datasketches::theta::ThetaSketchBuilder;
+ /// ThetaSketchBuilder::default().lg_k(10).build();
/// ```
pub fn build(self) -> ThetaSketch {
let table = ThetaHashTable::new(
@@ -1065,7 +1053,7 @@ mod tests {
#[test]
fn theta_and_compact_theta_equivalent() {
- let mut exact_theta = ThetaSketch::builder().lg_k(12).build();
+ let mut exact_theta = ThetaSketchBuilder::default().lg_k(12).build();
for i in 0..2000 {
exact_theta.update(i);
}
@@ -1074,7 +1062,7 @@ mod tests {
assert_theta_and_compact_equivalent_ordered(&exact_theta, ordered);
}
- let mut estimation_theta = ThetaSketch::builder().lg_k(5).build();
+ let mut estimation_theta = ThetaSketchBuilder::default().lg_k(5).build();
for i in 0..5000 {
estimation_theta.update(i);
}
@@ -1086,7 +1074,7 @@ mod tests {
#[test]
fn compact_theta_serialize_deserialize_round_trip_equivalent_to_compact_and_theta() {
- let mut theta = ThetaSketch::builder().lg_k(5).build();
+ let mut theta = ThetaSketchBuilder::default().lg_k(5).build();
for i in 0..5000 {
theta.update(i);
}
@@ -1102,7 +1090,7 @@ mod tests {
#[test]
fn compact_theta_serialize_compressed_round_trip_tail_entries() {
- let mut theta = ThetaSketch::builder().lg_k(12).build();
+ let mut theta = ThetaSketchBuilder::default().lg_k(12).build();
for i in 0..13 {
theta.update(i);
}
@@ -1117,7 +1105,7 @@ mod tests {
#[test]
fn compact_theta_serialize_compressed_round_trip_more_than_255_entries() {
- let mut theta = ThetaSketch::builder().lg_k(12).build();
+ let mut theta = ThetaSketchBuilder::default().lg_k(12).build();
for i in 0..300 {
theta.update(i);
}
@@ -1132,7 +1120,7 @@ mod tests {
#[test]
fn compact_theta_serialize_compressed_round_trip_estimation_mode() {
- let mut theta = ThetaSketch::builder().lg_k(5).build();
+ let mut theta = ThetaSketchBuilder::default().lg_k(5).build();
for i in 0..5000 {
theta.update(i);
}
@@ -1146,7 +1134,7 @@ mod tests {
#[test]
fn deserialize_rejects_seed_hash_mismatch() {
- let mut theta = ThetaSketch::builder().seed(7).build();
+ let mut theta = ThetaSketchBuilder::default().seed(7).build();
theta.update("apple");
let bytes = theta.compact(true).serialize();
@@ -1157,7 +1145,7 @@ mod tests {
#[test]
fn deserialize_rejects_invalid_family_id() {
- let mut theta = ThetaSketch::builder().build();
+ let mut theta = ThetaSketchBuilder::default().build();
theta.update("apple");
let mut bytes = theta.compact(true).serialize();
bytes[2] = 0;
@@ -1169,7 +1157,7 @@ mod tests {
#[test]
fn deserialize_rejects_unsupported_serial_version() {
- let mut theta = ThetaSketch::builder().build();
+ let mut theta = ThetaSketchBuilder::default().build();
theta.update("apple");
let mut bytes = theta.compact(true).serialize();
bytes[1] = 99;
@@ -1181,7 +1169,7 @@ mod tests {
#[test]
fn deserialize_rejects_truncated_payload() {
- let mut theta = ThetaSketch::builder().lg_k(5).build();
+ let mut theta = ThetaSketchBuilder::default().lg_k(5).build();
for i in 0..5000 {
theta.update(i);
}
diff --git a/datasketches/src/theta/union.rs b/datasketches/src/theta/union.rs
index 06ec617..9bded2e 100644
--- a/datasketches/src/theta/union.rs
+++ b/datasketches/src/theta/union.rs
@@ -41,18 +41,6 @@ impl RawThetaUnionPolicy<ThetaEntry> for NoopUnionPolicy {
}
impl ThetaUnion {
- /// Create a new builder for ThetaUnion
- ///
- /// # Examples
- ///
- /// ```
- /// # use datasketches::theta::ThetaUnion;
- /// let _union = ThetaUnion::builder().lg_k(12).build();
- /// ```
- pub fn builder() -> ThetaUnionBuilder {
- ThetaUnionBuilder::default()
- }
-
/// Update this union with a given sketch.
pub fn update<S: ThetaSketchView>(&mut self, sketch: &S) -> Result<(), Error> {
self.raw.update(sketch)
@@ -110,8 +98,8 @@ impl ThetaUnionBuilder {
/// # Examples
///
/// ```
- /// # use datasketches::theta::ThetaUnion;
- /// let _union = ThetaUnion::builder().lg_k(12).build();
+ /// # use datasketches::theta::ThetaUnionBuilder;
+ /// ThetaUnionBuilder::default().lg_k(12).build();
/// ```
pub fn lg_k(mut self, lg_k: u8) -> Self {
assert!(
@@ -137,8 +125,10 @@ impl ThetaUnionBuilder {
/// # Examples
///
/// ```
- /// # use datasketches::theta::ThetaUnion;
- /// let _union = ThetaUnion::builder().sampling_probability(0.5).build();
+ /// # use datasketches::theta::ThetaUnionBuilder;
+ /// ThetaUnionBuilder::default()
+ /// .sampling_probability(0.5)
+ /// .build();
/// ```
pub fn sampling_probability(mut self, p: f32) -> Self {
assert!(
@@ -154,8 +144,8 @@ impl ThetaUnionBuilder {
/// # Examples
///
/// ```
- /// # use datasketches::theta::ThetaUnion;
- /// let _union = ThetaUnion::builder().seed(7).build();
+ /// # use datasketches::theta::ThetaUnionBuilder;
+ /// ThetaUnionBuilder::default().seed(7).build();
/// ```
pub fn seed(mut self, seed: u64) -> Self {
self.seed = seed;
@@ -167,8 +157,8 @@ impl ThetaUnionBuilder {
/// # Examples
///
/// ```
- /// # use datasketches::theta::ThetaUnion;
- /// let _union = ThetaUnion::builder().lg_k(10).build();
+ /// # use datasketches::theta::ThetaUnionBuilder;
+ /// ThetaUnionBuilder::default().lg_k(10).build();
/// ```
pub fn build(self) -> ThetaUnion {
ThetaUnion {
diff --git a/datasketches/src/tuple/mod.rs b/datasketches/src/tuple/mod.rs
index f76af9e..543e958 100644
--- a/datasketches/src/tuple/mod.rs
+++ b/datasketches/src/tuple/mod.rs
@@ -22,15 +22,17 @@
//! mechanics (theta screening, resize, rebuild to nominal size k) mirror the Theta sketch, with the
//! added requirement that colliding keys merge their summaries.
//!
-//! The behavior of a summary (how to create and update it) is supplied externally through
-//! policy objects ([`SummaryUpdatePolicy`]) rather than being baked into the summary type.
+//! Custom summary behavior is supplied externally through policy objects: [`SummaryPolicy`]
+//! creates summaries, while [`SummaryUpdatePolicy`] folds update values into them. Summaries that
+//! implement `Default` and `AddAssign` can use [`DefaultUpdatePolicy`].
//!
//! # Usage
//!
//! ```
-//! # use datasketches::tuple::TupleSketch;
-//! let mut sketch = TupleSketch::<u64>::builder().build();
-//! sketch.update("apple", 1);
+//! # use datasketches::tuple::{DefaultUpdatePolicy, TupleSketchBuilder};
+//! let policy = DefaultUpdatePolicy::<u64>::default();
+//! let mut sketch = TupleSketchBuilder::new(policy).build();
+//! sketch.update("apple", 1_u64);
//! assert!(sketch.estimate() >= 1.0);
//! ```
@@ -41,6 +43,7 @@ mod sketch;
pub use self::hash_table::TupleEntry;
pub use self::policy::DefaultUpdatePolicy;
+pub use self::policy::SummaryPolicy;
pub use self::policy::SummaryUpdatePolicy;
pub use self::serialization::TupleSummaryValue;
pub use self::sketch::CompactTupleSketch;
diff --git a/datasketches/src/tuple/policy.rs b/datasketches/src/tuple/policy.rs
index 468ffd4..c83eebf 100644
--- a/datasketches/src/tuple/policy.rs
+++ b/datasketches/src/tuple/policy.rs
@@ -15,7 +15,7 @@
// specific language governing permissions and limitations
// under the License.
-//! Policies describing how summaries are created, updated, and combined.
+//! Policies describing how summaries are created and updated.
//!
//! A Tuple sketch keeps a user-defined summary `S` next to every retained key. The behavior of a
//! summary is supplied externally through policy objects rather than baked into the summary type
@@ -23,54 +23,56 @@
//! different behaviors and can carry per-instance configuration (such as the number of values in an
//! array-of-doubles summary).
+use std::marker::PhantomData;
use std::ops::AddAssign;
-/// Defines how a summary is created and how update values are folded into it.
-///
-/// This is used by the update tuple sketch. `S` is the stored summary type and `U` is the type of
-/// the update value, which may be a borrowed type such as `&[f64]`.
-pub trait SummaryUpdatePolicy<S, U> {
+/// Defines how summaries are created.
+pub trait SummaryPolicy {
+ /// Summary type retained alongside each key.
+ type Summary;
+
/// Creates a new summary for a key seen for the first time.
///
/// The summary should be in its identity state; the first update value is folded in separately
- /// via [`update`](Self::update).
- fn create(&self) -> S;
+ /// via [`SummaryUpdatePolicy::update`].
+ fn create(&self) -> Self::Summary;
+}
+/// Defines how update values are folded into summaries.
+///
+/// A policy may implement this trait for multiple update types. For example, an array policy can
+/// accept slices, vectors, or other containers while retaining a single summary type defined by
+/// [`SummaryPolicy`].
+pub trait SummaryUpdatePolicy<U>: SummaryPolicy {
/// Folds an update value into an existing summary.
- fn update(&self, summary: &mut S, value: U);
+ fn update(&self, summary: &mut Self::Summary, value: U);
}
-/// Default update policy for summaries that are default-constructible and additive.
+/// Built-in update policy for additive summaries.
///
-/// This is the convenience policy used when no custom policy is supplied, equivalent to C++
-/// `default_tuple_update_policy` (which folds updates with `summary += update`). It is available
-/// for any summary type `S` and update type `U` where `S: Default + AddAssign<U>`.
-#[derive(Debug, Default, Clone, Copy)]
-pub struct DefaultUpdatePolicy(());
+/// The factory determines the summary type and creates its identity state. The policy accepts every
+/// update type `U` for which the summary implements [`AddAssign<U>`].
+#[derive(Default, Debug, Clone, Copy)]
+pub struct DefaultUpdatePolicy<S> {
+ marker: PhantomData<fn() -> S>,
+}
-impl<S, U> SummaryUpdatePolicy<S, U> for DefaultUpdatePolicy
+impl<S> SummaryPolicy for DefaultUpdatePolicy<S>
where
- S: Default + AddAssign<U>,
+ S: Default,
{
- fn create(&self) -> S {
- S::default()
- }
+ type Summary = S;
- fn update(&self, summary: &mut S, value: U) {
- *summary += value;
+ fn create(&self) -> Self::Summary {
+ S::default()
}
}
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn default_update_policy_update_accumulates() {
- let policy = DefaultUpdatePolicy::default();
- let mut summary = 0u64;
- policy.update(&mut summary, 3);
- policy.update(&mut summary, 4);
- assert_eq!(summary, 7);
+impl<S, U> SummaryUpdatePolicy<U> for DefaultUpdatePolicy<S>
+where
+ S: Default + AddAssign<U>,
+{
+ fn update(&self, summary: &mut Self::Summary, value: U) {
+ *summary += value;
}
}
diff --git a/datasketches/src/tuple/sketch.rs b/datasketches/src/tuple/sketch.rs
index 78cc6ae..501ebcc 100644
--- a/datasketches/src/tuple/sketch.rs
+++ b/datasketches/src/tuple/sketch.rs
@@ -19,10 +19,10 @@
//!
//! This module provides [`TupleSketch`] (mutable) and [`CompactTupleSketch`] (immutable),
//! the Tuple sketch analogues of the Theta sketch. Each retained key carries a user-defined summary
-//! whose behavior is supplied by a [`SummaryUpdatePolicy`].
+//! created by a [`SummaryPolicy`] and updated through one or more [`SummaryUpdatePolicy`]
+//! implementations.
use std::hash::Hash;
-use std::marker::PhantomData;
use crate::codec::SketchBytes;
use crate::codec::SketchSlice;
@@ -46,9 +46,12 @@ use crate::thetacommon::constants::MAX_THETA;
use crate::thetacommon::constants::MIN_LG_K;
use crate::tuple::hash_table::TupleEntry;
use crate::tuple::hash_table::TupleHashTable;
-use crate::tuple::policy::DefaultUpdatePolicy;
+use crate::tuple::policy::SummaryPolicy;
use crate::tuple::policy::SummaryUpdatePolicy;
-use crate::tuple::serialization;
+use crate::tuple::serialization::SERIAL_VERSION;
+use crate::tuple::serialization::SERIAL_VERSION_LEGACY;
+use crate::tuple::serialization::SKETCH_TYPE;
+use crate::tuple::serialization::SKETCH_TYPE_LEGACY;
use crate::tuple::serialization::TupleSummaryValue;
/// Read-only view for Tuple sketches.
@@ -65,43 +68,35 @@ impl<S, T> TupleSketchView<S> for T where T: RawThetaSketchView<TupleEntry<S>> {
/// Mutable Tuple sketch for building from input data.
///
-/// `S` is the summary type retained alongside each key, and `P` is the [`SummaryUpdatePolicy`] that
-/// defines how summaries are created and updated. For additive summaries the default
-/// [`DefaultUpdatePolicy`] is used.
+/// `P` defines how summaries are created. The summary retained alongside each key is
+/// [`P::Summary`](SummaryPolicy::Summary), while each accepted update type is selected by a
+/// [`SummaryUpdatePolicy<U>`] implementation.
///
/// # Examples
///
/// ```
-/// # use datasketches::tuple::TupleSketch;
-/// let mut sketch = TupleSketch::<u64>::builder().build();
+/// # use datasketches::tuple::{DefaultUpdatePolicy, TupleSketchBuilder};
+/// let policy = DefaultUpdatePolicy::<u64>::default();
+/// let mut sketch = TupleSketchBuilder::new(policy).build();
/// sketch.update("apple", 1);
/// sketch.update("apple", 1);
/// assert!(sketch.estimate() >= 1.0);
/// assert_eq!(sketch.num_retained(), 1);
/// ```
#[derive(Debug)]
-pub struct TupleSketch<S, P = DefaultUpdatePolicy> {
- table: TupleHashTable<S>,
+pub struct TupleSketch<P>
+where
+ P: SummaryPolicy,
+{
+ table: TupleHashTable<P::Summary>,
policy: P,
}
-impl<S> TupleSketch<S, DefaultUpdatePolicy> {
- /// Creates a new builder using the default update policy.
- ///
- /// # Examples
- ///
- /// ```
- /// # use datasketches::tuple::TupleSketch;
- /// let sketch = TupleSketch::<u64>::builder().lg_k(12).build();
- /// assert_eq!(sketch.lg_k(), 12);
- /// ```
- pub fn builder() -> TupleSketchBuilder<S, DefaultUpdatePolicy> {
- TupleSketchBuilder::default()
- }
-}
-
-impl<S, P> TupleSketch<S, P> {
- /// Updates the sketch with a key and an update value.
+impl<P> TupleSketch<P>
+where
+ P: SummaryPolicy,
+{
+ /// Updates the sketch with a key and a value accepted by the policy.
///
/// If the key is new, the policy creates a summary and folds in `value`; if the key already
/// exists, `value` is folded into the retained summary. Updates screened out by theta do not
@@ -110,13 +105,14 @@ impl<S, P> TupleSketch<S, P> {
/// # Examples
///
/// ```
- /// # use datasketches::tuple::TupleSketch;
- /// let mut sketch = TupleSketch::<u64>::builder().build();
+ /// # use datasketches::tuple::{DefaultUpdatePolicy, TupleSketchBuilder};
+ /// let policy = DefaultUpdatePolicy::<u64>::default();
+ /// let mut sketch = TupleSketchBuilder::new(policy).build();
/// sketch.update(42, 5);
/// ```
pub fn update<U>(&mut self, key: impl Hash, value: U)
where
- P: SummaryUpdatePolicy<S, U>,
+ P: SummaryUpdatePolicy<U>,
{
let policy = &self.policy;
self.table.try_insert(key, |existing| match existing {
@@ -188,7 +184,7 @@ impl<S, P> TupleSketch<S, P> {
}
/// Returns an iterator over retained entries as `(hash, &summary)` pairs.
- pub fn iter(&self) -> impl Iterator<Item = (u64, &S)> + '_ {
+ pub fn iter(&self) -> impl Iterator<Item = (u64, &P::Summary)> + '_ {
self.table.iter()
}
@@ -221,7 +217,11 @@ impl<S, P> TupleSketch<S, P> {
}
}
-impl<S: Clone, P> TupleSketch<S, P> {
+impl<P> TupleSketch<P>
+where
+ P: SummaryPolicy,
+ P::Summary: Clone,
+{
/// Returns this sketch in compact (immutable) form.
///
/// If `ordered` is true, retained entries are sorted by hash in ascending order.
@@ -229,13 +229,14 @@ impl<S: Clone, P> TupleSketch<S, P> {
/// # Examples
///
/// ```
- /// # use datasketches::tuple::TupleSketch;
- /// let mut sketch = TupleSketch::<u64>::builder().build();
+ /// # use datasketches::tuple::{DefaultUpdatePolicy, TupleSketchBuilder};
+ /// let policy = DefaultUpdatePolicy::<u64>::default();
+ /// let mut sketch = TupleSketchBuilder::new(policy).build();
/// sketch.update("apple", 1);
/// let compact = sketch.compact(true);
/// assert_eq!(compact.num_retained(), 1);
/// ```
- pub fn compact(&self, ordered: bool) -> CompactTupleSketch<S> {
+ pub fn compact(&self, ordered: bool) -> CompactTupleSketch<P::Summary> {
let parts = self.table.to_compact_parts(ordered);
CompactTupleSketch::from_parts(
parts.entries,
@@ -247,7 +248,11 @@ impl<S: Clone, P> TupleSketch<S, P> {
}
}
-impl<S: Clone, P> RawThetaSketchView<TupleEntry<S>> for TupleSketch<S, P> {
+impl<P> RawThetaSketchView<TupleEntry<P::Summary>> for TupleSketch<P>
+where
+ P: SummaryPolicy,
+ P::Summary: Clone,
+{
fn seed_hash(&self) -> u16 {
self.table.seed_hash()
}
@@ -264,7 +269,7 @@ impl<S: Clone, P> RawThetaSketchView<TupleEntry<S>> for TupleSketch<S, P> {
false
}
- fn iter(&self) -> impl Iterator<Item = TupleEntry<S>> + '_ {
+ fn iter(&self) -> impl Iterator<Item = TupleEntry<P::Summary>> + '_ {
self.table
.iter()
.map(|(hash, summary)| TupleEntry::new(hash, summary.clone()))
@@ -408,8 +413,9 @@ impl<S> CompactTupleSketch<S> {
/// # Examples
///
/// ```
- /// # use datasketches::tuple::TupleSketch;
- /// let mut sketch = TupleSketch::<u64>::builder().build();
+ /// # use datasketches::tuple::{DefaultUpdatePolicy, TupleSketchBuilder};
+ /// let policy = DefaultUpdatePolicy::<u64>::default();
+ /// let mut sketch = TupleSketchBuilder::new(policy).build();
/// sketch.update("apple", 1);
/// let bytes = sketch.compact(true).serialize();
/// assert!(!bytes.is_empty());
@@ -427,9 +433,9 @@ impl<S> CompactTupleSketch<S> {
let mut bytes = SketchBytes::with_capacity(8 * pre_longs as usize + entries_size);
bytes.write_u8(pre_longs);
- bytes.write_u8(serialization::SERIAL_VERSION);
+ bytes.write_u8(SERIAL_VERSION);
bytes.write_u8(Family::TUPLE.id);
- bytes.write_u8(serialization::SKETCH_TYPE);
+ bytes.write_u8(SKETCH_TYPE);
bytes.write_u8(0); // unused
let mut flags = FLAGS_IS_READ_ONLY | FLAGS_IS_COMPACT;
@@ -495,22 +501,16 @@ impl<S> CompactTupleSketch<S> {
Family::TUPLE.min_pre_longs..=Family::TUPLE.max_pre_longs,
pre_longs,
)?;
- if ser_ver != serialization::SERIAL_VERSION
- && ser_ver != serialization::SERIAL_VERSION_LEGACY
- {
+ if ser_ver != SERIAL_VERSION && ser_ver != SERIAL_VERSION_LEGACY {
return Err(Error::deserial(format!(
"unsupported serial version: expected {} or {}, got {ser_ver}",
- serialization::SERIAL_VERSION,
- serialization::SERIAL_VERSION_LEGACY,
+ SERIAL_VERSION, SERIAL_VERSION_LEGACY,
)));
}
- if sketch_type != serialization::SKETCH_TYPE
- && sketch_type != serialization::SKETCH_TYPE_LEGACY
- {
+ if sketch_type != SKETCH_TYPE && sketch_type != SKETCH_TYPE_LEGACY {
return Err(Error::deserial(format!(
"unsupported sketch type: expected {} or {}, got {sketch_type}",
- serialization::SKETCH_TYPE,
- serialization::SKETCH_TYPE_LEGACY,
+ SKETCH_TYPE, SKETCH_TYPE_LEGACY,
)));
}
@@ -594,33 +594,64 @@ impl<S: Clone> RawThetaSketchView<TupleEntry<S>> for CompactTupleSketch<S> {
/// Builder for [`TupleSketch`].
///
-/// The summary type `S` is fixed when the builder is created (for example via
-/// `TupleSketch::<u64>::builder()`), and the policy type `P` defaults to
-/// [`DefaultUpdatePolicy`]. Use [`policy`](Self::policy) to supply a custom policy.
+/// Every builder carries a concrete [`SummaryPolicy`]. Use
+/// [`DefaultUpdatePolicy`](crate::tuple::DefaultUpdatePolicy) for default-constructed additive
+/// summaries, or supply a custom policy.
#[derive(Debug)]
-pub struct TupleSketchBuilder<S, P = DefaultUpdatePolicy> {
+pub struct TupleSketchBuilder<P>
+where
+ P: SummaryPolicy,
+{
lg_k: u8,
resize_factor: ResizeFactor,
sampling_probability: f32,
seed: u64,
policy: P,
- _marker: PhantomData<fn() -> S>,
}
-impl<S> Default for TupleSketchBuilder<S, DefaultUpdatePolicy> {
- fn default() -> Self {
+impl<P> TupleSketchBuilder<P>
+where
+ P: SummaryPolicy,
+{
+ /// Creates a builder with the given summary policy.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use datasketches::tuple::SummaryPolicy;
+ /// use datasketches::tuple::SummaryUpdatePolicy;
+ /// use datasketches::tuple::TupleSketchBuilder;
+ ///
+ /// struct MaxPolicy;
+ ///
+ /// impl SummaryPolicy for MaxPolicy {
+ /// type Summary = u64;
+ ///
+ /// fn create(&self) -> Self::Summary {
+ /// 0
+ /// }
+ /// }
+ ///
+ /// impl SummaryUpdatePolicy<u64> for MaxPolicy {
+ /// fn update(&self, summary: &mut Self::Summary, value: u64) {
+ /// *summary = (*summary).max(value);
+ /// }
+ /// }
+ ///
+ /// let mut sketch = TupleSketchBuilder::new(MaxPolicy).build();
+ /// sketch.update("k", 3);
+ /// sketch.update("k", 7);
+ /// ```
+ pub fn new(policy: P) -> Self {
Self {
lg_k: DEFAULT_LG_K,
resize_factor: ResizeFactor::X8,
sampling_probability: 1.0,
seed: DEFAULT_UPDATE_SEED,
- policy: DefaultUpdatePolicy::default(),
- _marker: PhantomData,
+ policy,
}
}
-}
-impl<S, P> TupleSketchBuilder<S, P> {
/// Sets lg_k (log2 of the nominal size k).
///
/// # Panics
@@ -661,51 +692,15 @@ impl<S, P> TupleSketchBuilder<S, P> {
self
}
- /// Sets a custom update policy, changing the builder's policy type.
- ///
- /// # Examples
- ///
- /// ```
- /// use datasketches::tuple::SummaryUpdatePolicy;
- /// use datasketches::tuple::TupleSketch;
- ///
- /// struct MaxPolicy;
- ///
- /// impl SummaryUpdatePolicy<u64, u64> for MaxPolicy {
- /// fn create(&self) -> u64 {
- /// 0
- /// }
- ///
- /// fn update(&self, summary: &mut u64, value: u64) {
- /// *summary = (*summary).max(value);
- /// }
- /// }
- ///
- /// let mut sketch = TupleSketch::<u64>::builder().policy(MaxPolicy).build();
- /// sketch.update("k", 3);
- /// sketch.update("k", 7);
- /// ```
- pub fn policy<P2>(self, policy: P2) -> TupleSketchBuilder<S, P2> {
- TupleSketchBuilder {
- lg_k: self.lg_k,
- resize_factor: self.resize_factor,
- sampling_probability: self.sampling_probability,
- seed: self.seed,
- policy,
- _marker: PhantomData,
- }
- }
-
- /// Builds the [`TupleSketch`].
- pub fn build(self) -> TupleSketch<S, P> {
- let table = TupleHashTable::new(
- self.lg_k,
- self.resize_factor,
- self.sampling_probability,
- self.seed,
- );
+ /// Builds a [`TupleSketch`] using the supplied policy.
+ pub fn build(self) -> TupleSketch<P> {
TupleSketch {
- table,
+ table: TupleHashTable::new(
+ self.lg_k,
+ self.resize_factor,
+ self.sampling_probability,
+ self.seed,
+ ),
policy: self.policy,
}
}
@@ -715,9 +710,14 @@ impl<S, P> TupleSketchBuilder<S, P> {
mod tests {
use super::*;
use crate::error::ErrorKind;
+ use crate::tuple::policy::DefaultUpdatePolicy;
+ use crate::tuple::policy::SummaryPolicy;
use crate::tuple::policy::SummaryUpdatePolicy;
- fn sorted_updatable_entries(sketch: &TupleSketch<u64>) -> Vec<(u64, u64)> {
+ fn sorted_updatable_entries<P>(sketch: &TupleSketch<P>) -> Vec<(u64, u64)>
+ where
+ P: SummaryPolicy<Summary = u64>,
+ {
let mut entries: Vec<(u64, u64)> = sketch.iter().map(|(h, &s)| (h, s)).collect();
entries.sort_unstable();
entries
@@ -729,10 +729,12 @@ mod tests {
entries
}
- fn assert_updatable_and_compact_equivalent(
- updatable: &TupleSketch<u64>,
+ fn assert_updatable_and_compact_equivalent<P>(
+ updatable: &TupleSketch<P>,
compact: &CompactTupleSketch<u64>,
- ) {
+ ) where
+ P: SummaryPolicy<Summary = u64>,
+ {
assert_eq!(updatable.is_empty(), compact.is_empty());
assert_eq!(updatable.is_estimation_mode(), compact.is_estimation_mode());
assert_eq!(updatable.num_retained(), compact.num_retained());
@@ -747,7 +749,8 @@ mod tests {
#[test]
fn exact_mode_updatable_and_compact_equivalent() {
- let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+ let policy = DefaultUpdatePolicy::<u64>::default();
+ let mut sketch = TupleSketchBuilder::new(policy).lg_k(12).build();
for i in 0..2000 {
sketch.update(i, 1u64);
}
@@ -764,7 +767,8 @@ mod tests {
#[test]
fn estimation_mode_updatable_and_compact_equivalent() {
- let mut sketch = TupleSketch::<u64>::builder().lg_k(5).build();
+ let policy = DefaultUpdatePolicy::<u64>::default();
+ let mut sketch = TupleSketchBuilder::new(policy).lg_k(5).build();
for i in 0..5000 {
sketch.update(i, 1u64);
}
@@ -778,7 +782,8 @@ mod tests {
#[test]
fn summaries_accumulate_with_default_policy() {
- let mut sketch = TupleSketch::<u64>::builder().build();
+ let policy = DefaultUpdatePolicy::<u64>::default();
+ let mut sketch = TupleSketchBuilder::new(policy).build();
for _ in 0..5 {
sketch.update("same_key", 2u64);
}
@@ -792,9 +797,20 @@ mod tests {
assert_eq!(sorted_compact_entries(&compact)[0].1, 10);
}
+ #[test]
+ fn default_policy_accepts_any_add_assign_rhs() {
+ let policy = DefaultUpdatePolicy::<String>::default();
+ let mut sketch = TupleSketchBuilder::new(policy).build();
+ sketch.update("k", "hello");
+ sketch.update("k", " world");
+
+ assert_eq!(sketch.iter().next().unwrap().1, "hello world");
+ }
+
#[test]
fn empty_sketch_is_ordered_and_zero_estimate() {
- let sketch = TupleSketch::<u64>::builder().build();
+ let policy = DefaultUpdatePolicy::<u64>::default();
+ let sketch = TupleSketchBuilder::new(policy).build();
assert!(sketch.is_empty());
assert_eq!(sketch.estimate(), 0.0);
@@ -807,7 +823,8 @@ mod tests {
#[test]
fn bounds_bracket_estimate_in_estimation_mode() {
- let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+ let policy = DefaultUpdatePolicy::<u64>::default();
+ let mut sketch = TupleSketchBuilder::new(policy).lg_k(12).build();
for i in 0..10000 {
sketch.update(i, 1u64);
}
@@ -821,32 +838,64 @@ mod tests {
#[derive(Default)]
struct MaxPolicy;
- impl SummaryUpdatePolicy<u64, u64> for MaxPolicy {
- fn create(&self) -> u64 {
+ impl SummaryPolicy for MaxPolicy {
+ type Summary = u64;
+
+ fn create(&self) -> Self::Summary {
0
}
+ }
- fn update(&self, summary: &mut u64, value: u64) {
+ impl SummaryUpdatePolicy<u64> for MaxPolicy {
+ fn update(&self, summary: &mut Self::Summary, value: u64) {
*summary = (*summary).max(value);
}
}
#[test]
fn custom_policy_drives_summary_behavior() {
- let mut sketch = TupleSketch::<u64>::builder().policy(MaxPolicy).build();
+ let mut sketch = TupleSketchBuilder::new(MaxPolicy).build();
sketch.update("k", 3u64);
sketch.update("k", 7u64);
sketch.update("k", 2u64);
assert_eq!(sketch.num_retained(), 1);
- let entries = sorted_updatable_entries_generic(&sketch);
+ let entries = sorted_updatable_entries(&sketch);
assert_eq!(entries[0].1, 7);
}
- fn sorted_updatable_entries_generic<P>(sketch: &TupleSketch<u64, P>) -> Vec<(u64, u64)> {
- let mut entries: Vec<(u64, u64)> = sketch.iter().map(|(h, &s)| (h, s)).collect();
- entries.sort_unstable();
- entries
+ struct ArraySumPolicy {
+ num_values: usize,
+ }
+
+ impl SummaryPolicy for ArraySumPolicy {
+ type Summary = Vec<f64>;
+
+ fn create(&self) -> Self::Summary {
+ vec![0.0; self.num_values]
+ }
+ }
+
+ impl<U> SummaryUpdatePolicy<U> for ArraySumPolicy
+ where
+ U: AsRef<[f64]>,
+ {
+ fn update(&self, summary: &mut Self::Summary, value: U) {
+ let value = value.as_ref();
+ assert_eq!(value.len(), self.num_values);
+ for (summary, value) in summary.iter_mut().zip(value) {
+ *summary += value;
+ }
+ }
+ }
+
+ #[test]
+ fn custom_policy_accepts_multiple_update_representations() {
+ let mut sketch = TupleSketchBuilder::new(ArraySumPolicy { num_values: 2 }).build();
+ sketch.update("k", &[1.0, 2.0]);
+ sketch.update("k", vec![3.0, 4.0]);
+
+ assert_eq!(sketch.iter().next().unwrap().1, &vec![4.0, 6.0]);
}
fn view_num_retained<V: TupleSketchView<u64>>(view: &V) -> usize {
@@ -863,7 +912,8 @@ mod tests {
#[test]
fn view_trait_accepts_both_sketch_types() {
- let mut sketch = TupleSketch::<u64>::builder().build();
+ let policy = DefaultUpdatePolicy::<u64>::default();
+ let mut sketch = TupleSketchBuilder::new(policy).build();
for i in 0..100 {
sketch.update(i, 2u64);
}
@@ -896,7 +946,8 @@ mod tests {
#[test]
fn serialize_round_trip_exact_mode() {
- let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+ let policy = DefaultUpdatePolicy::<u64>::default();
+ let mut sketch = TupleSketchBuilder::new(policy).lg_k(12).build();
for i in 0..2000 {
sketch.update(i, 1u64);
}
@@ -907,7 +958,8 @@ mod tests {
#[test]
fn serialize_round_trip_estimation_mode() {
- let mut sketch = TupleSketch::<u64>::builder().lg_k(5).build();
+ let policy = DefaultUpdatePolicy::<u64>::default();
+ let mut sketch = TupleSketchBuilder::new(policy).lg_k(5).build();
for i in 0..5000 {
sketch.update(i, 3u64);
}
@@ -919,7 +971,8 @@ mod tests {
#[test]
fn serialize_round_trip_empty() {
- let sketch = TupleSketch::<u64>::builder().build();
+ let policy = DefaultUpdatePolicy::<u64>::default();
+ let sketch = TupleSketchBuilder::new(policy).build();
let compact = sketch.compact(true);
assert!(compact.is_empty());
assert_compact_round_trip(&compact);
@@ -927,7 +980,8 @@ mod tests {
#[test]
fn serialize_round_trip_single_entry() {
- let mut sketch = TupleSketch::<u64>::builder().build();
+ let policy = DefaultUpdatePolicy::<u64>::default();
+ let mut sketch = TupleSketchBuilder::new(policy).build();
sketch.update("only", 42u64);
let compact = sketch.compact(true);
assert_eq!(compact.num_retained(), 1);
@@ -943,7 +997,8 @@ mod tests {
#[test]
fn serialize_header_fields_match_tuple_format() {
- let mut sketch = TupleSketch::<u64>::builder().build();
+ let policy = DefaultUpdatePolicy::<u64>::default();
+ let mut sketch = TupleSketchBuilder::new(policy).build();
for i in 0..100 {
sketch.update(i, 1u64);
}
@@ -956,7 +1011,8 @@ mod tests {
#[test]
fn serialize_preserves_summaries() {
- let mut sketch = TupleSketch::<u64>::builder().build();
+ let policy = DefaultUpdatePolicy::<u64>::default();
+ let mut sketch = TupleSketchBuilder::new(policy).build();
for i in 0..50 {
sketch.update(i, 1u64);
sketch.update(i, 1u64); // each summary accumulates to 2
@@ -969,7 +1025,8 @@ mod tests {
#[test]
fn deserialize_rejects_wrong_family() {
- let mut sketch = TupleSketch::<u64>::builder().build();
+ let policy = DefaultUpdatePolicy::<u64>::default();
+ let mut sketch = TupleSketchBuilder::new(policy).build();
for i in 0..10 {
sketch.update(i, 1u64);
}
@@ -981,7 +1038,8 @@ mod tests {
#[test]
fn deserialize_rejects_seed_mismatch() {
- let mut sketch = TupleSketch::<u64>::builder().build();
+ let policy = DefaultUpdatePolicy::<u64>::default();
+ let mut sketch = TupleSketchBuilder::new(policy).build();
for i in 0..10 {
sketch.update(i, 1u64);
}
@@ -992,7 +1050,8 @@ mod tests {
#[test]
fn deserialize_rejects_truncated_summary() {
- let mut sketch = TupleSketch::<u64>::builder().build();
+ let policy = DefaultUpdatePolicy::<u64>::default();
+ let mut sketch = TupleSketchBuilder::new(policy).build();
for i in 0..100 {
sketch.update(i, 1u64);
}
diff --git a/datasketches/tests/cpc_union_test.rs b/datasketches/tests/cpc_union_test.rs
index 5bc3b18..ec2377c 100644
--- a/datasketches/tests/cpc_union_test.rs
+++ b/datasketches/tests/cpc_union_test.rs
@@ -173,11 +173,11 @@ fn test_reduce_k_window() {
#[test]
#[should_panic]
fn test_lg_k_too_small() {
- let _ = CpcSketch::new(3);
+ CpcSketch::new(3);
}
#[test]
#[should_panic]
fn test_lg_k_too_large() {
- let _ = CpcSketch::new(27);
+ CpcSketch::new(27);
}
diff --git a/datasketches/tests/frequencies_update_test.rs b/datasketches/tests/frequencies_update_test.rs
index 792fa9d..746c410 100644
--- a/datasketches/tests/frequencies_update_test.rs
+++ b/datasketches/tests/frequencies_update_test.rs
@@ -535,5 +535,5 @@ fn test_longs_invalid_map_size_panics() {
#[test]
#[should_panic(expected = "max_map_size must be power of 2")]
fn test_items_invalid_map_size_panics() {
- let _ = FrequentItemsSketch::<String>::new(6);
+ FrequentItemsSketch::<String>::new(6);
}
diff --git a/datasketches/tests/theta_intersection_test.rs b/datasketches/tests/theta_intersection_test.rs
index bb662b6..aaa5d44 100644
--- a/datasketches/tests/theta_intersection_test.rs
+++ b/datasketches/tests/theta_intersection_test.rs
@@ -20,9 +20,10 @@
use datasketches::theta::CompactThetaSketch;
use datasketches::theta::ThetaIntersection;
use datasketches::theta::ThetaSketch;
+use datasketches::theta::ThetaSketchBuilder;
fn sketch_with_range(start: u64, count: u64) -> ThetaSketch {
- let mut sketch = ThetaSketch::builder().build();
+ let mut sketch = ThetaSketchBuilder::default().build();
for i in 0..count {
sketch.update(start + i);
}
@@ -31,7 +32,7 @@ fn sketch_with_range(start: u64, count: u64) -> ThetaSketch {
#[test]
fn test_has_result_state_machine() {
- let mut a = ThetaSketch::builder().build();
+ let mut a = ThetaSketchBuilder::default().build();
a.update("x");
let mut i = ThetaIntersection::new_with_default_seed();
@@ -45,18 +46,18 @@ fn test_has_result_state_machine() {
fn test_result_before_update_panics() {
let i = ThetaIntersection::new(123);
let result = std::panic::catch_unwind(|| {
- let _ = i.to_sketch(true);
+ i.to_sketch(true);
});
assert!(result.is_err());
}
#[test]
fn test_update_accepts_compact_sketch() {
- let mut a = ThetaSketch::builder().build();
+ let mut a = ThetaSketchBuilder::default().build();
a.update("x");
a.update("y");
- let mut b = ThetaSketch::builder().build();
+ let mut b = ThetaSketchBuilder::default().build();
b.update("y");
b.update("z");
@@ -68,7 +69,7 @@ fn test_update_accepts_compact_sketch() {
assert!(r.estimate() == 1.0);
assert!(r.is_ordered());
- let mut c = ThetaSketch::builder().build();
+ let mut c = ThetaSketchBuilder::default().build();
c.update("a");
c.update("b");
c.update("c");
@@ -82,7 +83,7 @@ fn test_update_accepts_compact_sketch() {
#[test]
fn test_seed_mismatch_behaviour_for_empty_sketch() {
- let empty_other_seed = ThetaSketch::builder().seed(2).build();
+ let empty_other_seed = ThetaSketchBuilder::default().seed(2).build();
let mut i = ThetaIntersection::new(1);
i.update(&empty_other_seed).unwrap();
@@ -93,7 +94,7 @@ fn test_seed_mismatch_behaviour_for_empty_sketch() {
#[test]
fn test_seed_mismatch_behaviour() {
- let mut one_other_seed = ThetaSketch::builder().seed(2).build();
+ let mut one_other_seed = ThetaSketchBuilder::default().seed(2).build();
one_other_seed.update("value");
let mut i = ThetaIntersection::new(1);
@@ -102,9 +103,9 @@ fn test_seed_mismatch_behaviour() {
#[test]
fn test_terminal_empty_state_ignores_future_updates() {
- let empty = ThetaSketch::builder().build();
+ let empty = ThetaSketchBuilder::default().build();
- let mut non_empty = ThetaSketch::builder().build();
+ let mut non_empty = ThetaSketchBuilder::default().build();
non_empty.update("x");
let mut i = ThetaIntersection::new_with_default_seed();
@@ -117,7 +118,7 @@ fn test_terminal_empty_state_ignores_future_updates() {
#[test]
fn test_to_sketch_unordered_is_not_ordered() {
- let mut a = ThetaSketch::builder().build();
+ let mut a = ThetaSketchBuilder::default().build();
for i in 0..64 {
a.update(i);
}
@@ -130,7 +131,7 @@ fn test_to_sketch_unordered_is_not_ordered() {
#[test]
fn test_empty_update_twice() {
- let empty = ThetaSketch::builder().build();
+ let empty = ThetaSketchBuilder::default().build();
let mut i = ThetaIntersection::new_with_default_seed();
i.update(&empty).unwrap();
@@ -150,7 +151,9 @@ fn test_empty_update_twice() {
#[test]
fn test_non_empty_no_retained_keys() {
- let mut s = ThetaSketch::builder().sampling_probability(0.001).build();
+ let mut s = ThetaSketchBuilder::default()
+ .sampling_probability(0.001)
+ .build();
s.update(1u64);
let mut i = ThetaIntersection::new_with_default_seed();
@@ -310,7 +313,7 @@ fn test_estimation_disjoint_ordered() {
#[test]
fn test_seed_mismatch_non_empty_returns_error() {
- let mut s = ThetaSketch::builder().build();
+ let mut s = ThetaSketchBuilder::default().build();
s.update(1u64);
let mut i = ThetaIntersection::new(123);
diff --git a/datasketches/tests/theta_sketch_test.rs b/datasketches/tests/theta_sketch_test.rs
index 55664ef..b7d58ba 100644
--- a/datasketches/tests/theta_sketch_test.rs
+++ b/datasketches/tests/theta_sketch_test.rs
@@ -19,11 +19,11 @@
use datasketches::common::NumStdDev;
use datasketches::hash_value;
-use datasketches::theta::ThetaSketch;
+use datasketches::theta::ThetaSketchBuilder;
#[test]
fn test_basic_update() {
- let mut sketch = ThetaSketch::builder().lg_k(12).build();
+ let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
assert!(sketch.is_empty());
assert_eq!(sketch.estimate(), 0.0);
@@ -37,7 +37,7 @@ fn test_basic_update() {
#[test]
fn test_update_various_types() {
- let mut sketch = ThetaSketch::builder().lg_k(12).build();
+ let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
sketch.update("string");
sketch.update(42i64);
@@ -52,7 +52,7 @@ fn test_update_various_types() {
assert!(!sketch.is_empty());
assert_eq!(sketch.estimate(), 5.0);
- let mut sketch = ThetaSketch::builder().lg_k(12).build();
+ let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
sketch.update("string");
sketch.update(42i64);
@@ -70,7 +70,7 @@ fn test_update_various_types() {
#[test]
fn test_duplicate_updates() {
- let mut sketch = ThetaSketch::builder().lg_k(12).build();
+ let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
for _ in 0..100 {
sketch.update("same_value");
@@ -81,7 +81,7 @@ fn test_duplicate_updates() {
#[test]
fn test_theta_reduction() {
- let mut sketch = ThetaSketch::builder().lg_k(5).build(); // Small k to trigger theta reduction
+ let mut sketch = ThetaSketchBuilder::default().lg_k(5).build(); // Small k to trigger theta reduction
assert!(!sketch.is_estimation_mode()); // Should be in estimation mode
// Insert many values to trigger theta reduction
@@ -95,7 +95,7 @@ fn test_theta_reduction() {
#[test]
fn test_trim() {
- let mut sketch = ThetaSketch::builder().lg_k(5).build();
+ let mut sketch = ThetaSketchBuilder::default().lg_k(5).build();
// Insert many values
for i in 0..1000 {
@@ -113,7 +113,7 @@ fn test_trim() {
#[test]
fn test_reset() {
- let mut sketch = ThetaSketch::builder().lg_k(5).build();
+ let mut sketch = ThetaSketchBuilder::default().lg_k(5).build();
// Insert many values
for i in 0..1000 {
@@ -136,7 +136,7 @@ fn test_reset() {
#[test]
fn test_iterator() {
- let mut sketch = ThetaSketch::builder().lg_k(12).build();
+ let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
sketch.update("value1");
sketch.update("value2");
@@ -148,7 +148,7 @@ fn test_iterator() {
#[test]
fn test_bounds_empty_sketch() {
- let sketch = ThetaSketch::builder().lg_k(12).build();
+ let sketch = ThetaSketchBuilder::default().lg_k(12).build();
assert!(sketch.is_empty());
assert!(!sketch.is_estimation_mode());
assert_eq!(sketch.theta(), 1.0);
@@ -163,7 +163,7 @@ fn test_bounds_empty_sketch() {
#[test]
fn test_bounds_exact_mode() {
- let mut sketch = ThetaSketch::builder().lg_k(12).build();
+ let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
for i in 0..2000 {
sketch.update(i);
}
@@ -177,7 +177,7 @@ fn test_bounds_exact_mode() {
#[test]
fn test_bounds_estimation_mode() {
- let mut sketch = ThetaSketch::builder().lg_k(12).build();
+ let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
let n = 10000;
for i in 0..n {
sketch.update(i);
@@ -219,7 +219,7 @@ fn test_bounds_estimation_mode() {
#[test]
fn test_bounds_with_sampling() {
- let mut sketch = ThetaSketch::builder()
+ let mut sketch = ThetaSketchBuilder::default()
.lg_k(12)
.sampling_probability(0.5)
.build();
@@ -242,7 +242,7 @@ fn test_bounds_with_sampling() {
#[test]
fn test_bounds_all_num_std_devs() {
- let mut sketch = ThetaSketch::builder().lg_k(12).build();
+ let mut sketch = ThetaSketchBuilder::default().lg_k(12).build();
for i in 0..10000 {
sketch.update(i);
}
@@ -266,7 +266,7 @@ fn test_bounds_all_num_std_devs() {
#[test]
fn test_bounds_empty_estimation_mode() {
// Create a sketch with sampling probability < 1.0 to force estimation mode
- let sketch = ThetaSketch::builder()
+ let sketch = ThetaSketchBuilder::default()
.lg_k(12)
.sampling_probability(0.1)
.build();
@@ -284,7 +284,7 @@ fn test_bounds_empty_estimation_mode() {
fn test_compact_preserves_logical_non_empty_after_screened_update() {
let screened_value = (0u64..)
.find(|candidate| {
- let mut sketch = ThetaSketch::builder()
+ let mut sketch = ThetaSketchBuilder::default()
.lg_k(12)
.sampling_probability(0.5)
.build();
@@ -293,7 +293,7 @@ fn test_compact_preserves_logical_non_empty_after_screened_update() {
})
.expect("failed to find a value screened out by the sampling theta");
- let mut sketch = ThetaSketch::builder()
+ let mut sketch = ThetaSketchBuilder::default()
.lg_k(12)
.sampling_probability(0.5)
.build();
diff --git a/datasketches/tests/theta_union_test.rs b/datasketches/tests/theta_union_test.rs
index e6e9160..453af37 100644
--- a/datasketches/tests/theta_union_test.rs
+++ b/datasketches/tests/theta_union_test.rs
@@ -19,10 +19,11 @@
use datasketches::theta::CompactThetaSketch;
use datasketches::theta::ThetaSketch;
-use datasketches::theta::ThetaUnion;
+use datasketches::theta::ThetaSketchBuilder;
+use datasketches::theta::ThetaUnionBuilder;
fn sketch_with_range(lg_k: u8, start: i64, count: i64) -> ThetaSketch {
- let mut sketch = ThetaSketch::builder().lg_k(lg_k).build();
+ let mut sketch = ThetaSketchBuilder::default().lg_k(lg_k).build();
for value in start..start + count {
sketch.update(value);
}
@@ -43,8 +44,8 @@ fn assert_estimate_close(sketch: &CompactThetaSketch, expected: f64, tolerance:
#[test]
fn test_empty_union() {
- let sketch = ThetaSketch::builder().build();
- let mut union = ThetaUnion::builder().build();
+ let sketch = ThetaSketchBuilder::default().build();
+ let mut union = ThetaUnionBuilder::default().build();
let result = union.to_sketch(true);
assert_eq!(result.num_retained(), 0);
assert!(result.is_empty());
@@ -59,10 +60,12 @@ fn test_empty_union() {
#[test]
fn test_non_empty_no_retained_keys() {
- let mut sketch = ThetaSketch::builder().sampling_probability(0.001).build();
+ let mut sketch = ThetaSketchBuilder::default()
+ .sampling_probability(0.001)
+ .build();
sketch.update(1u64);
- let mut union = ThetaUnion::builder().build();
+ let mut union = ThetaUnionBuilder::default().build();
union.update(&sketch).unwrap();
let result = union.to_sketch(true);
assert_eq!(result.num_retained(), 0);
@@ -73,17 +76,17 @@ fn test_non_empty_no_retained_keys() {
#[test]
fn test_exact_mode_half_overlap() {
- let mut sketch1 = ThetaSketch::builder().build();
+ let mut sketch1 = ThetaSketchBuilder::default().build();
for value in 0i64..1000i64 {
sketch1.update(value);
}
- let mut sketch2 = ThetaSketch::builder().build();
+ let mut sketch2 = ThetaSketchBuilder::default().build();
for value in 500i64..1500i64 {
sketch2.update(value);
}
- let mut union = ThetaUnion::builder().build();
+ let mut union = ThetaUnionBuilder::default().build();
union.update(&sketch1).unwrap();
union.update(&sketch2).unwrap();
let result = union.to_sketch(true);
@@ -100,19 +103,19 @@ fn test_exact_mode_half_overlap() {
#[test]
fn test_exact_mode_half_overlap_compact() {
- let mut sketch1 = ThetaSketch::builder().build();
+ let mut sketch1 = ThetaSketchBuilder::default().build();
for value in 0i64..1000i64 {
sketch1.update(value);
}
let compact1 = CompactThetaSketch::deserialize(&sketch1.compact(true).serialize()).unwrap();
- let mut sketch2 = ThetaSketch::builder().build();
+ let mut sketch2 = ThetaSketchBuilder::default().build();
for value in 500i64..1500i64 {
sketch2.update(value);
}
let compact2 = CompactThetaSketch::deserialize(&sketch2.compact(true).serialize()).unwrap();
- let mut union = ThetaUnion::builder().build();
+ let mut union = ThetaUnionBuilder::default().build();
union.update(&compact1).unwrap();
union.update(&compact2).unwrap();
let result = union.to_sketch(true);
@@ -123,17 +126,17 @@ fn test_exact_mode_half_overlap_compact() {
#[test]
fn test_estimation_mode_half_overlap() {
- let mut sketch1 = ThetaSketch::builder().build();
+ let mut sketch1 = ThetaSketchBuilder::default().build();
for value in 0i64..10000i64 {
sketch1.update(value);
}
- let mut sketch2 = ThetaSketch::builder().build();
+ let mut sketch2 = ThetaSketchBuilder::default().build();
for value in 5000i64..15000i64 {
sketch2.update(value);
}
- let mut union = ThetaUnion::builder().build();
+ let mut union = ThetaUnionBuilder::default().build();
union.update(&sketch1).unwrap();
union.update(&sketch2).unwrap();
let result = union.to_sketch(true);
@@ -150,38 +153,38 @@ fn test_estimation_mode_half_overlap() {
#[test]
fn test_seed_mismatch() {
- let mut sketch = ThetaSketch::builder().build();
+ let mut sketch = ThetaSketchBuilder::default().build();
sketch.update(1u64);
- let mut union = ThetaUnion::builder().seed(123).build();
+ let mut union = ThetaUnionBuilder::default().seed(123).build();
assert!(union.update(&sketch).is_err());
}
#[test]
fn test_larger_k() {
- let mut sketch1 = ThetaSketch::builder().lg_k(14).build();
+ let mut sketch1 = ThetaSketchBuilder::default().lg_k(14).build();
for value in 0i64..16384i64 {
sketch1.update(value);
}
- let mut sketch2 = ThetaSketch::builder().lg_k(14).build();
+ let mut sketch2 = ThetaSketchBuilder::default().lg_k(14).build();
for value in 0i64..26384i64 {
sketch2.update(value);
}
- let mut sketch3 = ThetaSketch::builder().lg_k(14).build();
+ let mut sketch3 = ThetaSketchBuilder::default().lg_k(14).build();
for value in 0i64..86384i64 {
sketch3.update(value);
}
- let mut union1 = ThetaUnion::builder().lg_k(16).build();
+ let mut union1 = ThetaUnionBuilder::default().lg_k(16).build();
union1.update(&sketch2).unwrap();
union1.update(&sketch1).unwrap();
union1.update(&sketch3).unwrap();
let result1 = union1.to_sketch(true);
assert_eq!(result1.estimate(), sketch3.estimate());
- let mut union2 = ThetaUnion::builder().lg_k(16).build();
+ let mut union2 = ThetaUnionBuilder::default().lg_k(16).build();
union2.update(&sketch1).unwrap();
union2.update(&sketch3).unwrap();
union2.update(&sketch2).unwrap();
@@ -196,7 +199,7 @@ fn test_exact_union_no_overlap() {
let sketch1 = sketch_with_range(lg_k, 0, k / 2);
let sketch2 = sketch_with_range(lg_k, k / 2, k / 2);
- let mut union = ThetaUnion::builder().lg_k(lg_k).build();
+ let mut union = ThetaUnionBuilder::default().lg_k(lg_k).build();
union.update(&sketch1).unwrap();
union.update(&sketch2).unwrap();
@@ -213,7 +216,7 @@ fn test_estimation_union_no_overlap() {
let sketch1 = sketch_with_range(lg_k, 0, 2 * k);
let sketch2 = sketch_with_range(lg_k, 2 * k, 2 * k);
- let mut union = ThetaUnion::builder().lg_k(lg_k).build();
+ let mut union = ThetaUnionBuilder::default().lg_k(lg_k).build();
union.update(&sketch1).unwrap();
union.update(&sketch2).unwrap();
@@ -231,7 +234,7 @@ fn test_exact_union_with_overlap() {
let sketch1 = sketch_with_range(lg_k, 0, k / 2);
let sketch2 = sketch_with_range(lg_k, 0, k);
- let mut union = ThetaUnion::builder().lg_k(lg_k).build();
+ let mut union = ThetaUnionBuilder::default().lg_k(lg_k).build();
union.update(&sketch1).unwrap();
union.update(&sketch2).unwrap();
@@ -250,11 +253,11 @@ fn test_ordered_and_unordered_compact_inputs() {
let compact_ordered = sketch2.compact(true);
let compact_unordered = sketch2.compact(false);
- let mut ordered_union = ThetaUnion::builder().lg_k(lg_k).build();
+ let mut ordered_union = ThetaUnionBuilder::default().lg_k(lg_k).build();
ordered_union.update(&sketch1).unwrap();
ordered_union.update(&compact_ordered).unwrap();
- let mut unordered_union = ThetaUnion::builder().lg_k(lg_k).build();
+ let mut unordered_union = ThetaUnionBuilder::default().lg_k(lg_k).build();
unordered_union.update(&sketch1).unwrap();
unordered_union.update(&compact_unordered).unwrap();
@@ -274,7 +277,7 @@ fn test_result_ordering_forms_have_same_estimate() {
let sketch1 = sketch_with_range(12, 0, 8192);
let sketch2 = sketch_with_range(12, 8192, 1024);
- let mut union = ThetaUnion::builder().lg_k(12).build();
+ let mut union = ThetaUnionBuilder::default().lg_k(12).build();
union.update(&sketch1).unwrap();
union.update(&sketch2).unwrap();
@@ -295,7 +298,7 @@ fn test_multi_union() {
(126_797, 26_797),
(153_594, 26_797),
];
- let mut union = ThetaUnion::builder().lg_k(lg_k).build();
+ let mut union = ThetaUnionBuilder::default().lg_k(lg_k).build();
for (start, count) in ranges {
let sketch = sketch_with_range(lg_k, start, count);
@@ -312,7 +315,7 @@ fn test_result_does_not_reset_union() {
let compact1 = sketch_with_range(lg_k, 0, k).compact(true);
let compact2 = sketch_with_range(lg_k, k, k).compact(true);
- let mut union = ThetaUnion::builder().lg_k(lg_k).build();
+ let mut union = ThetaUnionBuilder::default().lg_k(lg_k).build();
union.update(&compact1).unwrap();
union.update(&compact2).unwrap();
let first = union.to_sketch(true);
@@ -329,7 +332,7 @@ fn test_union_full_overlap() {
let compact1 = sketch_with_range(lg_k, 0, k).compact(true);
let compact2 = sketch_with_range(lg_k, 0, k).compact(true);
- let mut union = ThetaUnion::builder().lg_k(lg_k).build();
+ let mut union = ThetaUnionBuilder::default().lg_k(lg_k).build();
union.update(&compact1).unwrap();
union.update(&compact2).unwrap();
let result = union.to_sketch(true);
@@ -352,11 +355,11 @@ fn test_ordered_input_early_stop_matches_unordered_input() {
let unordered1 = sketch1.compact(false);
let unordered2 = sketch2.compact(false);
- let mut ordered_union = ThetaUnion::builder().lg_k(lg_k + 1).build();
+ let mut ordered_union = ThetaUnionBuilder::default().lg_k(lg_k + 1).build();
ordered_union.update(&ordered1).unwrap();
ordered_union.update(&ordered2).unwrap();
- let mut unordered_union = ThetaUnion::builder().lg_k(lg_k + 1).build();
+ let mut unordered_union = ThetaUnionBuilder::default().lg_k(lg_k + 1).build();
unordered_union.update(&unordered1).unwrap();
unordered_union.update(&unordered2).unwrap();
@@ -374,7 +377,7 @@ fn test_union_cutback_to_k() {
let compact1 = sketch_with_range(lg_k, 0, 3 * k).compact(true);
let compact2 = sketch_with_range(lg_k, 6 * k, 3 * k).compact(true);
- let mut union = ThetaUnion::builder().lg_k(lg_k).build();
+ let mut union = ThetaUnionBuilder::default().lg_k(lg_k).build();
union.update(&compact1).unwrap();
union.update(&compact2).unwrap();
let result = union.to_sketch(true);
@@ -385,23 +388,23 @@ fn test_union_cutback_to_k() {
#[test]
fn test_union_empty_valid_rules() {
- let empty1 = ThetaSketch::builder().build().compact(true);
- let empty2 = ThetaSketch::builder().build().compact(true);
- let mut one = ThetaSketch::builder().build();
+ let empty1 = ThetaSketchBuilder::default().build().compact(true);
+ let empty2 = ThetaSketchBuilder::default().build().compact(true);
+ let mut one = ThetaSketchBuilder::default().build();
one.update(1i64);
let one = one.compact(true);
- let mut empty_union = ThetaUnion::builder().lg_k(5).build();
+ let mut empty_union = ThetaUnionBuilder::default().lg_k(5).build();
empty_union.update(&empty1).unwrap();
empty_union.update(&empty2).unwrap();
assert!(empty_union.to_sketch(true).is_empty());
- let mut left_non_empty_union = ThetaUnion::builder().lg_k(5).build();
+ let mut left_non_empty_union = ThetaUnionBuilder::default().lg_k(5).build();
left_non_empty_union.update(&one).unwrap();
left_non_empty_union.update(&empty2).unwrap();
assert!(!left_non_empty_union.to_sketch(true).is_empty());
- let mut right_non_empty_union = ThetaUnion::builder().lg_k(5).build();
+ let mut right_non_empty_union = ThetaUnionBuilder::default().lg_k(5).build();
right_non_empty_union.update(&empty1).unwrap();
right_non_empty_union.update(&one).unwrap();
assert!(!right_non_empty_union.to_sketch(true).is_empty());
@@ -412,7 +415,7 @@ fn test_trim_to_k() {
let hi_sketch = sketch_with_range(10, 0, 3749);
let lo_sketch = sketch_with_range(9, 10_000, 1783);
- let mut union = ThetaUnion::builder().lg_k(10).build();
+ let mut union = ThetaUnionBuilder::default().lg_k(10).build();
union.update(&hi_sketch).unwrap();
union.update(&lo_sketch).unwrap();
let result = union.to_sketch(true);
@@ -423,7 +426,7 @@ fn test_trim_to_k() {
#[test]
fn test_builder_lg_k() {
let sketch = sketch_with_range(10, 0, 1000);
- let mut union = ThetaUnion::builder().lg_k(10).build();
+ let mut union = ThetaUnionBuilder::default().lg_k(10).build();
union.update(&sketch).unwrap();
assert_eq!(union.to_sketch(true).estimate(), 1000.0);
@@ -438,7 +441,7 @@ enum CornerSketchState {
}
fn corner_sketch(state: CornerSketchState, p: f32, value: i64) -> ThetaSketch {
- let builder = ThetaSketch::builder().lg_k(5);
+ let builder = ThetaSketchBuilder::default().lg_k(5);
let mut sketch = match state {
CornerSketchState::Empty | CornerSketchState::Exact => builder.build(),
CornerSketchState::Estimation | CornerSketchState::Degenerate => {
@@ -653,7 +656,7 @@ fn test_corner_case_union_states() {
let sketch_a = corner_sketch(state_a, p_a, value_a);
let sketch_b = corner_sketch(state_b, p_b, value_b);
- let mut union = ThetaUnion::builder().build();
+ let mut union = ThetaUnionBuilder::default().build();
union.update(&sketch_a).unwrap();
union.update(&sketch_b).unwrap();
let result = union.to_sketch(true);
@@ -676,7 +679,7 @@ fn test_corner_case_union_states() {
let compact_a = sketch_a.compact(true);
let compact_b = sketch_b.compact(true);
- let mut union = ThetaUnion::builder().build();
+ let mut union = ThetaUnionBuilder::default().build();
union.update(&compact_a).unwrap();
union.update(&compact_b).unwrap();
let compact_result = union.to_sketch(true);
diff --git a/datasketches/tests/tuple_sketch_test.rs b/datasketches/tests/tuple_sketch_test.rs
index 276ed0d..e80b155 100644
--- a/datasketches/tests/tuple_sketch_test.rs
+++ b/datasketches/tests/tuple_sketch_test.rs
@@ -24,11 +24,16 @@
use datasketches::common::NumStdDev;
use datasketches::hash_value;
-use datasketches::tuple::TupleSketch;
+use datasketches::tuple::DefaultUpdatePolicy;
+use datasketches::tuple::TupleSketchBuilder;
+
+fn builder() -> TupleSketchBuilder<DefaultUpdatePolicy<u64>> {
+ TupleSketchBuilder::new(DefaultUpdatePolicy::<u64>::default())
+}
#[test]
fn test_basic_update() {
- let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+ let mut sketch = builder().lg_k(12).build();
assert!(sketch.is_empty());
assert_eq!(sketch.estimate(), 0.0);
@@ -42,7 +47,7 @@ fn test_basic_update() {
#[test]
fn test_summary_accumulates_per_key() {
- let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+ let mut sketch = builder().lg_k(12).build();
for _ in 0..5 {
sketch.update("same_key", 2u64);
}
@@ -54,7 +59,7 @@ fn test_summary_accumulates_per_key() {
#[test]
fn test_update_various_types() {
- let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+ let mut sketch = builder().lg_k(12).build();
sketch.update("string", 1u64);
sketch.update(42i64, 1u64);
@@ -69,7 +74,7 @@ fn test_update_various_types() {
assert!(!sketch.is_empty());
assert_eq!(sketch.estimate(), 5.0);
- let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+ let mut sketch = builder().lg_k(12).build();
sketch.update("string", 1u64);
sketch.update(42i64, 1u64);
@@ -87,7 +92,7 @@ fn test_update_various_types() {
#[test]
fn test_duplicate_updates() {
- let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+ let mut sketch = builder().lg_k(12).build();
for _ in 0..100 {
sketch.update("same_value", 1u64);
@@ -98,7 +103,7 @@ fn test_duplicate_updates() {
#[test]
fn test_theta_reduction() {
- let mut sketch = TupleSketch::<u64>::builder().lg_k(5).build(); // Small k to trigger theta reduction
+ let mut sketch = builder().lg_k(5).build(); // Small k to trigger theta reduction
assert!(!sketch.is_estimation_mode());
// Insert many values to trigger theta reduction
@@ -112,7 +117,7 @@ fn test_theta_reduction() {
#[test]
fn test_trim() {
- let mut sketch = TupleSketch::<u64>::builder().lg_k(5).build();
+ let mut sketch = builder().lg_k(5).build();
// Insert many values
for i in 0..1000 {
@@ -130,7 +135,7 @@ fn test_trim() {
#[test]
fn test_reset() {
- let mut sketch = TupleSketch::<u64>::builder().lg_k(5).build();
+ let mut sketch = builder().lg_k(5).build();
// Insert many values
for i in 0..1000 {
@@ -153,7 +158,7 @@ fn test_reset() {
#[test]
fn test_iterator() {
- let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+ let mut sketch = builder().lg_k(12).build();
sketch.update("value1", 1u64);
sketch.update("value2", 1u64);
@@ -165,7 +170,7 @@ fn test_iterator() {
#[test]
fn test_bounds_empty_sketch() {
- let sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+ let sketch = builder().lg_k(12).build();
assert!(sketch.is_empty());
assert!(!sketch.is_estimation_mode());
assert_eq!(sketch.theta(), 1.0);
@@ -180,7 +185,7 @@ fn test_bounds_empty_sketch() {
#[test]
fn test_bounds_exact_mode() {
- let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+ let mut sketch = builder().lg_k(12).build();
for i in 0..2000 {
sketch.update(i, 1u64);
}
@@ -194,7 +199,7 @@ fn test_bounds_exact_mode() {
#[test]
fn test_bounds_estimation_mode() {
- let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+ let mut sketch = builder().lg_k(12).build();
let n = 10000;
for i in 0..n {
sketch.update(i, 1u64);
@@ -236,10 +241,7 @@ fn test_bounds_estimation_mode() {
#[test]
fn test_bounds_with_sampling() {
- let mut sketch = TupleSketch::<u64>::builder()
- .lg_k(12)
- .sampling_probability(0.5)
- .build();
+ let mut sketch = builder().lg_k(12).sampling_probability(0.5).build();
for i in 0..1000 {
sketch.update(i, 1u64);
@@ -259,7 +261,7 @@ fn test_bounds_with_sampling() {
#[test]
fn test_bounds_all_num_std_devs() {
- let mut sketch = TupleSketch::<u64>::builder().lg_k(12).build();
+ let mut sketch = builder().lg_k(12).build();
for i in 0..10000 {
sketch.update(i, 1u64);
}
@@ -281,10 +283,7 @@ fn test_bounds_all_num_std_devs() {
#[test]
fn test_bounds_empty_estimation_mode() {
// Create a sketch with sampling probability < 1.0 to force estimation mode
- let sketch = TupleSketch::<u64>::builder()
- .lg_k(12)
- .sampling_probability(0.1)
- .build();
+ let sketch = builder().lg_k(12).sampling_probability(0.1).build();
// The sketch is empty but theta < 1.0, so it's in estimation mode.
// When empty, both bounds should return 0.0 (matching the Java/Theta behavior).
@@ -299,19 +298,13 @@ fn test_bounds_empty_estimation_mode() {
fn test_compact_preserves_logical_non_empty_after_screened_update() {
let screened_value = (0u64..)
.find(|candidate| {
- let mut sketch = TupleSketch::<u64>::builder()
- .lg_k(12)
- .sampling_probability(0.5)
- .build();
+ let mut sketch = builder().lg_k(12).sampling_probability(0.5).build();
sketch.update(*candidate, 1u64);
!sketch.is_empty() && sketch.num_retained() == 0
})
.expect("failed to find a value screened out by the sampling theta");
- let mut sketch = TupleSketch::<u64>::builder()
- .lg_k(12)
- .sampling_probability(0.5)
- .build();
+ let mut sketch = builder().lg_k(12).sampling_probability(0.5).build();
sketch.update(screened_value, 1u64);
assert!(!sketch.is_empty());
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datasketches.apache.org
For additional commands, e-mail: commits-help@datasketches.apache.org