Struct TupleIntersection 

pub struct TupleIntersection<P>
where
    P: SummaryCombinePolicy,
{ /* private fields */ }

Available on crate feature tuple and (crate features theta or tuple) only.

Stateful intersection operator for Tuple sketches.

P is the SummaryCombinePolicy applied to keys present in more than one input. There is no default policy (see the module docs), so one must be supplied at construction.

A newly created operator has no result. has_result returns false and to_sketch returns None until the first successful update.

Examples

use datasketches::tuple::DefaultUpdatePolicy;
use datasketches::tuple::SummaryCombinePolicy;
use datasketches::tuple::SummaryPolicy;
use datasketches::tuple::TupleIntersection;
use datasketches::tuple::TupleSketchBuilder;

// Sum the summaries of keys that appear in both inputs.
#[derive(Default)]
struct SumPolicy;
impl SummaryPolicy for SumPolicy {
    type Summary = u64;

    fn create(&self) -> Self::Summary {
        0
    }
}
impl SummaryCombinePolicy for SumPolicy {
    fn combine(&self, summary: &mut Self::Summary, other: &Self::Summary) {
        *summary += *other;
    }
}

let update_policy = DefaultUpdatePolicy::<u64>::default();
let mut a = TupleSketchBuilder::new(update_policy).build().unwrap();
a.update("shared", 3);
a.update("only_a", 1);

let mut b = TupleSketchBuilder::new(update_policy).build().unwrap();
b.update("shared", 4);
b.update("only_b", 1);

let mut intersection = TupleIntersection::new(SumPolicy);
intersection.update(&a).unwrap();
intersection.update(&b).unwrap();

let result = intersection.to_sketch(true).unwrap();
assert_eq!(result.num_retained(), 1); // only "shared"
assert_eq!(result.iter().next().unwrap().summary(), &7); // 3 + 4

Implementations

impl<P> TupleIntersection<P>

where P: SummaryCombinePolicy,

pub fn new(policy: P) -> Self

Creates a new intersection operator with the default seed and the given combine policy.

pub fn with_seed(policy: P, seed: u64) -> Result<Self, Error>

Creates a new intersection operator for the given combine policy and seed.

Errors

Returns an error if the computed seed hash is zero.

pub fn update<'a>( &mut self, sketch: impl Into<TupleSketchView<'a, P::Summary>>, ) -> Result<(), Error>

where P::Summary: Clone + 'a,

Updates the intersection with a given sketch.

The intersection can be viewed as starting from the “universe” set, and every update reduces the current set to the keys it shares with sketch. Summaries of shared keys are combined via the policy.

Errors

Returns an error if sketch (when non-empty) has a different seed hash, or if the input appears corrupted (entry counts do not match what the sketch reports).

pub fn has_result(&self) -> bool

Returns true after the first successful update.

pub fn estimated_size(&self) -> usize

Returns the estimated size of the intersection in bytes.

pub fn to_sketch(&self, ordered: bool) -> Option<CompactTupleSketch<P::Summary>>

where P::Summary: Clone,

Returns the current intersection as a compact Tuple sketch.

Returns None until the first successful update. After that, returns Some even when the intersection is empty.

If ordered is true, retained entries are sorted in ascending hash order.

Trait Implementations

impl<P> Debug for TupleIntersection<P>

where P: SummaryCombinePolicy + Debug, P::Summary: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.