Struct CompactArrayOfDoublesSketch 

pub struct CompactArrayOfDoublesSketch { /* private fields */ }

An immutable, serializable snapshot of an ArrayOfDoubles Tuple sketch. Produced by super::ArrayOfDoublesSketch::compact, by any set operation’s result, or by Self::deserialize.

Implementations

impl CompactArrayOfDoublesSketch

pub fn deserialize(bytes: &[u8]) -> Result<Self, SketchError>

Deserializes bytes produced by Self::serialize. Returns SketchError::Deserialization if the bytes are truncated, corrupt, or not an ArrayOfDoubles sketch.

Examples found in repository

examples/bench_tuple_update.rs (line 365)

fn bench_serde(items: u64, reps: usize) {
    let mut update_sketch = build();
    for key in 0..items {
        update_sketch
            .update_u64(key, &VALUES)
            .expect("update rejected a correctly-sized value slice");
    }
    let sketch = update_sketch.compact(true);
    let reference = sketch.serialize();

    let mut passes = Vec::with_capacity(reps);
    for _ in 0..reps {
        let start = Instant::now();
        let mut total = 0usize;
        for _ in 0..SER_CALLS {
            total += black_box(sketch.serialize()).len();
        }
        let elapsed = start.elapsed();
        black_box(total);
        passes.push(Pass {
            elapsed,
            estimate: sketch.get_estimate(),
        });
    }
    report_bytes("ser", items, SER_CALLS, &passes, reference.len());

    let deserialize = || {
        CompactArrayOfDoublesSketch::deserialize(&reference).expect("the bytes came from serialize")
    };
    let mut passes = Vec::with_capacity(reps);
    for _ in 0..reps {
        let start = Instant::now();
        let mut total = 0.0;
        for _ in 0..DESER_CALLS {
            total += deserialize().get_estimate();
        }
        let elapsed = start.elapsed();
        black_box(total);
        passes.push(Pass {
            elapsed,
            estimate: deserialize().get_estimate(),
        });
    }
    report_bytes("deser", items, DESER_CALLS, &passes, reference.len());
}

examples/tuple.rs (line 95)

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 serialize(&self) -> Vec<u8>

Serializes this sketch. Unlike Theta, this family has exactly one serialization format upstream — there is no compressed variant — and no ordered parameter: orderedness is fixed when the snapshot was created (e.g. via ArrayOfDoublesSketch::compact).

Examples found in repository

examples/bench_tuple_update.rs (line 346)

fn bench_serde(items: u64, reps: usize) {
    let mut update_sketch = build();
    for key in 0..items {
        update_sketch
            .update_u64(key, &VALUES)
            .expect("update rejected a correctly-sized value slice");
    }
    let sketch = update_sketch.compact(true);
    let reference = sketch.serialize();

    let mut passes = Vec::with_capacity(reps);
    for _ in 0..reps {
        let start = Instant::now();
        let mut total = 0usize;
        for _ in 0..SER_CALLS {
            total += black_box(sketch.serialize()).len();
        }
        let elapsed = start.elapsed();
        black_box(total);
        passes.push(Pass {
            elapsed,
            estimate: sketch.get_estimate(),
        });
    }
    report_bytes("ser", items, SER_CALLS, &passes, reference.len());

    let deserialize = || {
        CompactArrayOfDoublesSketch::deserialize(&reference).expect("the bytes came from serialize")
    };
    let mut passes = Vec::with_capacity(reps);
    for _ in 0..reps {
        let start = Instant::now();
        let mut total = 0.0;
        for _ in 0..DESER_CALLS {
            total += deserialize().get_estimate();
        }
        let elapsed = start.elapsed();
        black_box(total);
        passes.push(Pass {
            elapsed,
            estimate: deserialize().get_estimate(),
        });
    }
    report_bytes("deser", items, DESER_CALLS, &passes, reference.len());
}

examples/tuple.rs (line 93)

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_estimate(&self) -> f64

Returns the current estimate of the number of distinct keys in this sketch.

Examples found in repository

examples/bench_tuple_update.rs (line 359)

fn bench_serde(items: u64, reps: usize) {
    let mut update_sketch = build();
    for key in 0..items {
        update_sketch
            .update_u64(key, &VALUES)
            .expect("update rejected a correctly-sized value slice");
    }
    let sketch = update_sketch.compact(true);
    let reference = sketch.serialize();

    let mut passes = Vec::with_capacity(reps);
    for _ in 0..reps {
        let start = Instant::now();
        let mut total = 0usize;
        for _ in 0..SER_CALLS {
            total += black_box(sketch.serialize()).len();
        }
        let elapsed = start.elapsed();
        black_box(total);
        passes.push(Pass {
            elapsed,
            estimate: sketch.get_estimate(),
        });
    }
    report_bytes("ser", items, SER_CALLS, &passes, reference.len());

    let deserialize = || {
        CompactArrayOfDoublesSketch::deserialize(&reference).expect("the bytes came from serialize")
    };
    let mut passes = Vec::with_capacity(reps);
    for _ in 0..reps {
        let start = Instant::now();
        let mut total = 0.0;
        for _ in 0..DESER_CALLS {
            total += deserialize().get_estimate();
        }
        let elapsed = start.elapsed();
        black_box(total);
        passes.push(Pass {
            elapsed,
            estimate: deserialize().get_estimate(),
        });
    }
    report_bytes("deser", items, DESER_CALLS, &passes, reference.len());
}

/// Two operands with 50% overlap, built once outside every timed region: the
/// operand-construction cost belongs to the setup, not to the union/
/// intersection/jaccard call being measured.
fn build_operands(items: u64) -> (CompactArrayOfDoublesSketch, CompactArrayOfDoublesSketch) {
    let mut a = build();
    for key in 0..items {
        a.update_u64(key, &VALUES)
            .expect("update rejected a correctly-sized value slice");
    }
    let mut b = build();
    for key in (items / 2)..(items + items / 2) {
        b.update_u64(key, &VALUES)
            .expect("update rejected a correctly-sized value slice");
    }
    (a.compact(true), b.compact(true))
}

/// A fresh union is built inside the timed loop, so the figure is
/// construct + two updates + get_result, not the merge alone -- reusing one
/// accumulator across `OP_CALLS` iterations would have each iteration merge
/// into an ever-growing result, measuring a different workload every time.
fn bench_union(items: u64, reps: usize) {
    let (a, b) = build_operands(items);
    let mut passes = Vec::with_capacity(reps);
    for _ in 0..reps {
        let start = Instant::now();
        let mut total = 0.0;
        let mut estimate = 0.0;
        for _ in 0..OP_CALLS {
            let mut union = ArrayOfDoublesUnionBuilder::new()
                .lg_k(LG_K)
                .num_values(NUM_VALUES)
                .build()
                .expect("fixed valid parameters were rejected");
            union
                .update(&a)
                .expect("operands match the union's num_values");
            union
                .update(&b)
                .expect("operands match the union's num_values");
            estimate = union.get_result(true).get_estimate();
            total += estimate;
        }
        let elapsed = start.elapsed();
        black_box(total);
        passes.push(Pass { elapsed, estimate });
    }
    report_line("union", items, OP_CALLS, &passes, String::new());
}

/// As [`bench_union`]: a fresh intersection per iteration, so the figure is
/// construct + two updates + get_result.
fn bench_intersect(items: u64, reps: usize) {
    let (a, b) = build_operands(items);
    let mut passes = Vec::with_capacity(reps);
    for _ in 0..reps {
        let start = Instant::now();
        let mut total = 0.0;
        let mut estimate = 0.0;
        for _ in 0..OP_CALLS {
            let mut intersection = ArrayOfDoublesIntersection::new(NUM_VALUES)
                .expect("fixed valid num_values was rejected");
            intersection
                .update(&a)
                .expect("operands match the intersection's num_values");
            intersection
                .update(&b)
                .expect("operands match the intersection's num_values");
            estimate = intersection
                .get_result(true)
                .expect("both operands were non-empty")
                .get_estimate();
            total += estimate;
        }
        let elapsed = start.elapsed();
        black_box(total);
        passes.push(Pass { elapsed, estimate });
    }
    report_line("intersect", items, OP_CALLS, &passes, String::new());
}

examples/tuple.rs (line 50)

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_lower_bound(&self, num_std_dev: u8) -> Result<f64, SketchError>

Returns the lower bound of the confidence interval around Self::get_estimate. See ArrayOfDoublesSketch::get_lower_bound for the meaning of num_std_dev.

pub fn get_upper_bound(&self, num_std_dev: u8) -> Result<f64, SketchError>

Returns the upper bound of the confidence interval around Self::get_estimate. See ArrayOfDoublesSketch::get_lower_bound for the meaning of num_std_dev.

pub fn is_empty(&self) -> bool

Returns true if this sketch represents an empty set.

pub fn is_estimation_mode(&self) -> bool

Returns true if this sketch’s theta threshold is below 1.0 (i.e. Self::get_estimate is a statistical estimate rather than an exact count).

pub fn is_ordered(&self) -> bool

Returns true if this sketch’s retained entries are sorted by hash value.

pub fn get_theta(&self) -> f64

Returns the current theta threshold (1.0 if not in estimation mode).

Examples found in repository

examples/tuple.rs (line 59)

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_num_retained(&self) -> u32

Returns the number of entries retained by this sketch.

Examples found in repository

examples/tuple.rs (line 60)

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_num_values(&self) -> u8

Returns the fixed number of f64 values each retained entry carries.

Examples found in repository

examples/tuple.rs (line 99)

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 entries(&self) -> impl Iterator<Item = (u64, Vec<f64>)>

Iterates the retained entries as (hash, values) pairs, where values.len() == self.get_num_values(). Ordered by hash if Self::is_ordered is true.

The entries are copied out of C++ in two FFI calls up front (cxx cannot hand back a live C++ iterator), so each item owns its Vec rather than borrowing from the sketch.

Examples found in repository

examples/tuple.rs (line 56)

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()
    );
}

Trait Implementations

impl ArrayOfDoublesInput for CompactArrayOfDoublesSketch

fn get_num_values(&self) -> u8

The fixed number of f64 values each of this sketch’s retained entries carries. Set operations require all operands to agree.

impl Send for CompactArrayOfDoublesSketch