Struct ArrayOfDoublesIntersection 

pub struct ArrayOfDoublesIntersection { /* private fields */ }

Computes the intersection of ArrayOfDoubles sketches fed via Self::update. Values are summed per index for keys present in every input.

Unlike super::ArrayOfDoublesUnion there is no builder — upstream’s array_of_doubles_intersection has a plain constructor, and the intersecting universe is defined entirely by the sketches passed to update. Only num_values (which the combine policy needs at construction time) must be supplied up front.

Upstream ships no default combine policy for this type; v1 uses sum-on-collision, mirroring the union’s policy. Additional policies (min/max, etc.) can be added later without changing this type’s shape.

Implementations

impl ArrayOfDoublesIntersection

pub fn new(num_values: u8) -> Result<Self, SketchError>

Creates a new intersection accumulator for sketches carrying num_values values per entry, with no result yet — call Self::update at least once before Self::get_result.

Returns SketchError::InvalidConfig if num_values is 0.

Examples found in repository

examples/tuple.rs (line 65)

fn main() {
    // Two sketches of user IDs, each carrying [sessions, revenue] per user.
    let mut day1 = ArrayOfDoublesSketchBuilder::new()
        .lg_k(12)
        .num_values(2)
        .build()
        .unwrap();
    for id in 0..10_000u64 {
        day1.update_u64(id, &[1.0, 2.50]).unwrap();
    }

    let mut day2 = ArrayOfDoublesSketchBuilder::new()
        .lg_k(12)
        .num_values(2)
        .build()
        .unwrap();
    for id in 5_000..15_000u64 {
        day2.update_u64(id, &[1.0, 4.00]).unwrap();
    }

    println!("Day 1 unique users (estimate): {:.0}", day1.get_estimate());
    println!("Day 2 unique users (estimate): {:.0}", day2.get_estimate());
    println!("Values per entry: {}", day1.get_num_values());

    // Union: unique users across both days, with per-user values summed for
    // anyone who appeared on both.
    let mut union = ArrayOfDoublesUnionBuilder::new()
        .lg_k(12)
        .num_values(2)
        .build()
        .unwrap();
    union.update(&day1).unwrap();
    union.update(&day2).unwrap();
    let combined = union.get_result(true);
    println!(
        "Total unique users (union estimate): {:.0}",
        combined.get_estimate()
    );

    // Per-entry access is what distinguishes Tuple sketches from HLL/Theta/CPC:
    // scale the retained sample's revenue back up by 1/theta to estimate the
    // full population total.
    let retained_revenue: f64 = combined.entries().map(|(_, values)| values[1]).sum();
    println!(
        "Estimated total revenue: {:.2} (from {} retained entries, theta = {:.4})",
        retained_revenue / combined.get_theta(),
        combined.get_num_retained(),
        combined.get_theta()
    );

    // Intersection: users who came back on day 2.
    let mut intersection = ArrayOfDoublesIntersection::new(2).unwrap();
    intersection.update(&day1).unwrap();
    intersection.update(&day2).unwrap();
    match intersection.get_result(true) {
        Ok(returning) => println!(
            "Returning users (intersection estimate): {:.0}",
            returning.get_estimate()
        ),
        Err(e) => println!("No intersection result: {e}"),
    }

    // A-not-b: users who only came on day 1.
    let a_not_b = ArrayOfDoublesAnotB::new();
    let day1_only = a_not_b.compute(&day1, &day2, true).unwrap();
    println!(
        "Day-1-only users (a-not-b estimate): {:.0}",
        day1_only.get_estimate()
    );

    // Jaccard similarity of the two days' audiences.
    let similarity = array_of_doubles_jaccard_similarity(&day1, &day2).unwrap();
    println!(
        "Jaccard similarity: {:.3} (range [{:.3}, {:.3}])",
        similarity.estimate, similarity.lower_bound, similarity.upper_bound
    );

    // Serialize a compact sketch for storage/transmission, then restore it.
    let compact = day1.compact(true);
    let bytes = compact.serialize();
    println!("Serialized day-1 sketch: {} bytes", bytes.len());
    let restored = CompactArrayOfDoublesSketch::deserialize(&bytes).unwrap();
    println!(
        "Restored estimate: {:.0} ({} values per entry)",
        restored.get_estimate(),
        restored.get_num_values()
    );
}

pub fn update( &mut self, input: &impl ArrayOfDoublesInput, ) -> Result<(), SketchError>

Narrows this intersection’s running result to also require membership in the given sketch. The first call establishes the initial universe; each subsequent call intersects further.

Returns SketchError::InvalidConfig if the sketch’s num_values differs from this intersection’s — upstream does not validate this itself, and mismatched widths would read and write out of bounds.

Examples found in repository

examples/tuple.rs (line 66)

fn main() {
    // Two sketches of user IDs, each carrying [sessions, revenue] per user.
    let mut day1 = ArrayOfDoublesSketchBuilder::new()
        .lg_k(12)
        .num_values(2)
        .build()
        .unwrap();
    for id in 0..10_000u64 {
        day1.update_u64(id, &[1.0, 2.50]).unwrap();
    }

    let mut day2 = ArrayOfDoublesSketchBuilder::new()
        .lg_k(12)
        .num_values(2)
        .build()
        .unwrap();
    for id in 5_000..15_000u64 {
        day2.update_u64(id, &[1.0, 4.00]).unwrap();
    }

    println!("Day 1 unique users (estimate): {:.0}", day1.get_estimate());
    println!("Day 2 unique users (estimate): {:.0}", day2.get_estimate());
    println!("Values per entry: {}", day1.get_num_values());

    // Union: unique users across both days, with per-user values summed for
    // anyone who appeared on both.
    let mut union = ArrayOfDoublesUnionBuilder::new()
        .lg_k(12)
        .num_values(2)
        .build()
        .unwrap();
    union.update(&day1).unwrap();
    union.update(&day2).unwrap();
    let combined = union.get_result(true);
    println!(
        "Total unique users (union estimate): {:.0}",
        combined.get_estimate()
    );

    // Per-entry access is what distinguishes Tuple sketches from HLL/Theta/CPC:
    // scale the retained sample's revenue back up by 1/theta to estimate the
    // full population total.
    let retained_revenue: f64 = combined.entries().map(|(_, values)| values[1]).sum();
    println!(
        "Estimated total revenue: {:.2} (from {} retained entries, theta = {:.4})",
        retained_revenue / combined.get_theta(),
        combined.get_num_retained(),
        combined.get_theta()
    );

    // Intersection: users who came back on day 2.
    let mut intersection = ArrayOfDoublesIntersection::new(2).unwrap();
    intersection.update(&day1).unwrap();
    intersection.update(&day2).unwrap();
    match intersection.get_result(true) {
        Ok(returning) => println!(
            "Returning users (intersection estimate): {:.0}",
            returning.get_estimate()
        ),
        Err(e) => println!("No intersection result: {e}"),
    }

    // A-not-b: users who only came on day 1.
    let a_not_b = ArrayOfDoublesAnotB::new();
    let day1_only = a_not_b.compute(&day1, &day2, true).unwrap();
    println!(
        "Day-1-only users (a-not-b estimate): {:.0}",
        day1_only.get_estimate()
    );

    // Jaccard similarity of the two days' audiences.
    let similarity = array_of_doubles_jaccard_similarity(&day1, &day2).unwrap();
    println!(
        "Jaccard similarity: {:.3} (range [{:.3}, {:.3}])",
        similarity.estimate, similarity.lower_bound, similarity.upper_bound
    );

    // Serialize a compact sketch for storage/transmission, then restore it.
    let compact = day1.compact(true);
    let bytes = compact.serialize();
    println!("Serialized day-1 sketch: {} bytes", bytes.len());
    let restored = CompactArrayOfDoublesSketch::deserialize(&bytes).unwrap();
    println!(
        "Restored estimate: {:.0} ({} values per entry)",
        restored.get_estimate(),
        restored.get_num_values()
    );
}

pub fn get_result( &self, ordered: bool, ) -> Result<CompactArrayOfDoublesSketch, SketchError>

Returns the current intersection result as a CompactArrayOfDoublesSketch, or SketchError::EmptyIntersection if Self::update has never been called. If ordered is true, the result’s entries are sorted by hash value.

Examples found in repository

examples/tuple.rs (line 68)

fn main() {
    // Two sketches of user IDs, each carrying [sessions, revenue] per user.
    let mut day1 = ArrayOfDoublesSketchBuilder::new()
        .lg_k(12)
        .num_values(2)
        .build()
        .unwrap();
    for id in 0..10_000u64 {
        day1.update_u64(id, &[1.0, 2.50]).unwrap();
    }

    let mut day2 = ArrayOfDoublesSketchBuilder::new()
        .lg_k(12)
        .num_values(2)
        .build()
        .unwrap();
    for id in 5_000..15_000u64 {
        day2.update_u64(id, &[1.0, 4.00]).unwrap();
    }

    println!("Day 1 unique users (estimate): {:.0}", day1.get_estimate());
    println!("Day 2 unique users (estimate): {:.0}", day2.get_estimate());
    println!("Values per entry: {}", day1.get_num_values());

    // Union: unique users across both days, with per-user values summed for
    // anyone who appeared on both.
    let mut union = ArrayOfDoublesUnionBuilder::new()
        .lg_k(12)
        .num_values(2)
        .build()
        .unwrap();
    union.update(&day1).unwrap();
    union.update(&day2).unwrap();
    let combined = union.get_result(true);
    println!(
        "Total unique users (union estimate): {:.0}",
        combined.get_estimate()
    );

    // Per-entry access is what distinguishes Tuple sketches from HLL/Theta/CPC:
    // scale the retained sample's revenue back up by 1/theta to estimate the
    // full population total.
    let retained_revenue: f64 = combined.entries().map(|(_, values)| values[1]).sum();
    println!(
        "Estimated total revenue: {:.2} (from {} retained entries, theta = {:.4})",
        retained_revenue / combined.get_theta(),
        combined.get_num_retained(),
        combined.get_theta()
    );

    // Intersection: users who came back on day 2.
    let mut intersection = ArrayOfDoublesIntersection::new(2).unwrap();
    intersection.update(&day1).unwrap();
    intersection.update(&day2).unwrap();
    match intersection.get_result(true) {
        Ok(returning) => println!(
            "Returning users (intersection estimate): {:.0}",
            returning.get_estimate()
        ),
        Err(e) => println!("No intersection result: {e}"),
    }

    // A-not-b: users who only came on day 1.
    let a_not_b = ArrayOfDoublesAnotB::new();
    let day1_only = a_not_b.compute(&day1, &day2, true).unwrap();
    println!(
        "Day-1-only users (a-not-b estimate): {:.0}",
        day1_only.get_estimate()
    );

    // Jaccard similarity of the two days' audiences.
    let similarity = array_of_doubles_jaccard_similarity(&day1, &day2).unwrap();
    println!(
        "Jaccard similarity: {:.3} (range [{:.3}, {:.3}])",
        similarity.estimate, similarity.lower_bound, similarity.upper_bound
    );

    // Serialize a compact sketch for storage/transmission, then restore it.
    let compact = day1.compact(true);
    let bytes = compact.serialize();
    println!("Serialized day-1 sketch: {} bytes", bytes.len());
    let restored = CompactArrayOfDoublesSketch::deserialize(&bytes).unwrap();
    println!(
        "Restored estimate: {:.0} ({} values per entry)",
        restored.get_estimate(),
        restored.get_num_values()
    );
}

pub fn has_result(&self) -> bool

Returns true if Self::update has been called at least once.

pub fn get_num_values(&self) -> u8

Returns the fixed number of f64 values per entry this intersection was created with. Every input passed to Self::update must match it.

Trait Implementations

impl Send for ArrayOfDoublesIntersection