Struct TupleAnotB 

pub struct TupleAnotB<S: TupleSummary> { /* private fields */ }

Computes the set difference a - b over generic Tuple sketches.

Retained entries keep a’s summaries unchanged: unlike TupleUnion and TupleIntersection, a-not-b has no combine policy at all, so neither TupleSummary::union_combine nor TupleSummary::intersection_combine is ever invoked. Each surviving summary is cloned out of a, which leaves a itself untouched and usable afterwards.

Stateless between calls, and asymmetric: compute(a, b) and compute(b, a) are different operations.

No builder: upstream’s type has a plain constructor, matching ArrayOfDoublesAnotB.

Implementations

impl<S: TupleSummary> TupleAnotB<S>

pub fn new() -> Self

Creates a reusable a-not-b calculator.

Examples found in repository

examples/tuple_generic.rs (line 139)

fn main() {
    let mut january: TupleSketch<Activity> = TupleSketchBuilder::new().lg_k(12).build().unwrap();
    for user in 0..10_000u64 {
        january.update_u64(
            user,
            &Event {
                revenue_cents: 250 + (user % 100),
                country: if user % 2 == 0 { "GB" } else { "US" },
            },
        );
    }

    let mut february: TupleSketch<Activity> = TupleSketchBuilder::new().lg_k(12).build().unwrap();
    for user in 5_000..15_000u64 {
        february.update_u64(
            user,
            &Event {
                revenue_cents: 400,
                country: "US",
            },
        );
    }

    println!("January unique users:  {:.0}", january.get_estimate());
    println!("February unique users: {:.0}", february.get_estimate());

    // Union: everyone who appeared in either month, with their activity merged.
    let mut union = TupleUnionBuilder::<Activity>::new()
        .lg_k(12)
        .build()
        .unwrap();
    union.update(&january);
    union.update(&february);
    let combined = union.get_result(true);
    println!("Users across both months: {:.0}", combined.get_estimate());

    // Per-entry summaries are the point of a Tuple sketch. Scale the retained
    // sample back up by 1/theta to estimate population totals.
    let retained_revenue: u64 = combined.entries().map(|(_, a)| a.revenue_cents).sum();
    let biggest_order = combined
        .entries()
        .map(|(_, a)| a.largest_order_cents)
        .max()
        .unwrap_or(0);
    println!(
        "Estimated total revenue: {:.2} (from {} retained entries, theta = {:.4})",
        (retained_revenue as f64 / combined.get_theta()) / 100.0,
        combined.get_num_retained(),
        combined.get_theta()
    );
    println!(
        "Largest single order seen: {:.2}",
        biggest_order as f64 / 100.0
    );

    // Intersection: users active in both months.
    let mut intersection = TupleIntersection::<Activity>::new();
    intersection.update(&january);
    intersection.update(&february);
    match intersection.get_result(true) {
        Ok(returning) => {
            println!("Returning users: {:.0}", returning.get_estimate());
            // `intersection_combine`'s `min` semantics at work: a returning
            // user's sessions/countries reflect only what showed up in BOTH
            // months, not the union of the two.
            if let Some((_, activity)) = returning.entries().next() {
                println!(
                    "  e.g. one returning user: {} session(s), countries seen in both months: {:?}",
                    activity.sessions, activity.countries
                );
            }
        }
        Err(e) => println!("No intersection result: {e}"),
    }

    // A-not-b: users who churned after January.
    let churned = TupleAnotB::<Activity>::new().compute(&january, &february, true);
    println!("Churned after January: {:.0}", churned.get_estimate());

    // Jaccard similarity of the two months' audiences.
    let similarity = tuple_jaccard_similarity(&january, &february);
    println!(
        "Audience overlap (Jaccard): {:.3} (range [{:.3}, {:.3}])",
        similarity.estimate, similarity.lower_bound, similarity.upper_bound
    );
}

pub fn compute( &self, a: &impl TupleInput<S>, b: &impl TupleInput<S>, ordered: bool, ) -> CompactTupleSketch<S>

Computes a - b: keys in a that are not in b, carrying a’s summaries. If ordered is true, the result’s entries are sorted by hash value.

Infallible: upstream throws only on a seed-hash mismatch, and this family never exposes a seed — every sketch here is built with the default one.

Examples found in repository

examples/tuple_generic.rs (line 139)

fn main() {
    let mut january: TupleSketch<Activity> = TupleSketchBuilder::new().lg_k(12).build().unwrap();
    for user in 0..10_000u64 {
        january.update_u64(
            user,
            &Event {
                revenue_cents: 250 + (user % 100),
                country: if user % 2 == 0 { "GB" } else { "US" },
            },
        );
    }

    let mut february: TupleSketch<Activity> = TupleSketchBuilder::new().lg_k(12).build().unwrap();
    for user in 5_000..15_000u64 {
        february.update_u64(
            user,
            &Event {
                revenue_cents: 400,
                country: "US",
            },
        );
    }

    println!("January unique users:  {:.0}", january.get_estimate());
    println!("February unique users: {:.0}", february.get_estimate());

    // Union: everyone who appeared in either month, with their activity merged.
    let mut union = TupleUnionBuilder::<Activity>::new()
        .lg_k(12)
        .build()
        .unwrap();
    union.update(&january);
    union.update(&february);
    let combined = union.get_result(true);
    println!("Users across both months: {:.0}", combined.get_estimate());

    // Per-entry summaries are the point of a Tuple sketch. Scale the retained
    // sample back up by 1/theta to estimate population totals.
    let retained_revenue: u64 = combined.entries().map(|(_, a)| a.revenue_cents).sum();
    let biggest_order = combined
        .entries()
        .map(|(_, a)| a.largest_order_cents)
        .max()
        .unwrap_or(0);
    println!(
        "Estimated total revenue: {:.2} (from {} retained entries, theta = {:.4})",
        (retained_revenue as f64 / combined.get_theta()) / 100.0,
        combined.get_num_retained(),
        combined.get_theta()
    );
    println!(
        "Largest single order seen: {:.2}",
        biggest_order as f64 / 100.0
    );

    // Intersection: users active in both months.
    let mut intersection = TupleIntersection::<Activity>::new();
    intersection.update(&january);
    intersection.update(&february);
    match intersection.get_result(true) {
        Ok(returning) => {
            println!("Returning users: {:.0}", returning.get_estimate());
            // `intersection_combine`'s `min` semantics at work: a returning
            // user's sessions/countries reflect only what showed up in BOTH
            // months, not the union of the two.
            if let Some((_, activity)) = returning.entries().next() {
                println!(
                    "  e.g. one returning user: {} session(s), countries seen in both months: {:?}",
                    activity.sessions, activity.countries
                );
            }
        }
        Err(e) => println!("No intersection result: {e}"),
    }

    // A-not-b: users who churned after January.
    let churned = TupleAnotB::<Activity>::new().compute(&january, &february, true);
    println!("Churned after January: {:.0}", churned.get_estimate());

    // Jaccard similarity of the two months' audiences.
    let similarity = tuple_jaccard_similarity(&january, &february);
    println!(
        "Audience overlap (Jaccard): {:.3} (range [{:.3}, {:.3}])",
        similarity.estimate, similarity.lower_bound, similarity.upper_bound
    );
}

Trait Implementations

impl<S: TupleSummary> Default for TupleAnotB<S>

fn default() -> Self

Returns the “default value” for a type.

impl<S: TupleSummary> Send for TupleAnotB<S>