Struct QuantileSketch 

pub struct QuantileSketch { /* private fields */ }

A deterministic Greenwald-Khanna streaming quantile summary. The sketch stores observations exactly through QuantilePolicy::exact_threshold. Larger streams use rank intervals and deterministic compression. Compatible sketches can be merged without replaying their source streams. The hard entry limit makes memory admission explicit: an operation that cannot retain the requested rank error is rejected transactionally.

Implementations

impl QuantileSketch

pub fn new(policy: QuantilePolicy) -> Result<Self, QuantileError>

Creates an empty sketch governed by policy.

Examples found in repository

examples/bounded_sequence_inference.rs (line 8)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let policy = QuantilePolicy::new(0.02, 8, 256)?;
    let mut left = QuantileSketch::new(policy.clone())?;
    let mut right = QuantileSketch::new(policy)?;
    for value in 0..100 {
        if value % 2 == 0 {
            left.insert(value as f64)?;
        } else {
            right.insert(value as f64)?;
        }
    }
    left.merge(&right)?;
    let median = left.estimate(0.5)?;
    println!(
        "quantile value={} rank=[{:.3},{:.3}] retained={} exact={}",
        median.value, median.rank_lower, median.rank_upper, median.retained_entries, median.exact
    );

    let model = HiddenMarkovModel::discrete(
        vec!["quiet", "active"],
        vec![0.6, 0.4],
        vec![vec![0.8, 0.2], vec![0.3, 0.7]],
        vec![vec![0.9, 0.1], vec![0.2, 0.8]],
    )?;
    let observations = [0, 0, 1, 1];
    let inference = forward_backward(&model, &observations)?;
    let path = viterbi(&model, &observations)?;
    println!(
        "inference log-likelihood={:.6} path={:?} repairs={}",
        inference.evidence.log_likelihood, path.states, inference.evidence.numerical_repairs
    );

    let data = [
        Sequence::Discrete(vec![0, 0, 1, 1, 1, 0]),
        Sequence::Discrete(vec![0, 1, 1, 0, 0, 0]),
    ];
    let report = fit_hmm(
        &data,
        HmmSpec::Discrete {
            states: 2,
            symbols: 2,
            additive_smoothing: 1.0e-6,
        },
        HmmFitControl::new(23, 6, 1.0e-7, 10_000, 1.0e-12)?,
    )?;
    println!(
        "fit likelihood={:.6} iterations={} converged={} repairs={} work={} termination={:?} seed={}",
        report.evidence.log_likelihood,
        report.evidence.iterations,
        report.evidence.converged,
        report.evidence.numerical_repairs,
        report.evidence.work,
        report.evidence.termination,
        report.evidence.seed
    );
    Ok(())
}

pub fn policy(&self) -> &QuantilePolicy

Returns the immutable error and memory policy.

pub fn len(&self) -> u64

Returns the number of observations represented by the sketch.

pub fn is_empty(&self) -> bool

Returns whether the sketch is empty.

pub fn retained_entries(&self) -> usize

Returns the number of retained exact values or summary entries.

pub fn retained_entry_bytes(&self) -> usize

Returns an upper bound on bytes occupied by retained numeric entries. This excludes allocator metadata and the fixed-size sketch value.

pub fn insert(&mut self, value: f64) -> Result<(), QuantileError>

Inserts one finite observation. The operation is transactional when the configured entry limit is too small for the requested error.

Examples found in repository

examples/bounded_sequence_inference.rs (line 12)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let policy = QuantilePolicy::new(0.02, 8, 256)?;
    let mut left = QuantileSketch::new(policy.clone())?;
    let mut right = QuantileSketch::new(policy)?;
    for value in 0..100 {
        if value % 2 == 0 {
            left.insert(value as f64)?;
        } else {
            right.insert(value as f64)?;
        }
    }
    left.merge(&right)?;
    let median = left.estimate(0.5)?;
    println!(
        "quantile value={} rank=[{:.3},{:.3}] retained={} exact={}",
        median.value, median.rank_lower, median.rank_upper, median.retained_entries, median.exact
    );

    let model = HiddenMarkovModel::discrete(
        vec!["quiet", "active"],
        vec![0.6, 0.4],
        vec![vec![0.8, 0.2], vec![0.3, 0.7]],
        vec![vec![0.9, 0.1], vec![0.2, 0.8]],
    )?;
    let observations = [0, 0, 1, 1];
    let inference = forward_backward(&model, &observations)?;
    let path = viterbi(&model, &observations)?;
    println!(
        "inference log-likelihood={:.6} path={:?} repairs={}",
        inference.evidence.log_likelihood, path.states, inference.evidence.numerical_repairs
    );

    let data = [
        Sequence::Discrete(vec![0, 0, 1, 1, 1, 0]),
        Sequence::Discrete(vec![0, 1, 1, 0, 0, 0]),
    ];
    let report = fit_hmm(
        &data,
        HmmSpec::Discrete {
            states: 2,
            symbols: 2,
            additive_smoothing: 1.0e-6,
        },
        HmmFitControl::new(23, 6, 1.0e-7, 10_000, 1.0e-12)?,
    )?;
    println!(
        "fit likelihood={:.6} iterations={} converged={} repairs={} work={} termination={:?} seed={}",
        report.evidence.log_likelihood,
        report.evidence.iterations,
        report.evidence.converged,
        report.evidence.numerical_repairs,
        report.evidence.work,
        report.evidence.termination,
        report.evidence.seed
    );
    Ok(())
}

pub fn merge(&mut self, other: &Self) -> Result<(), QuantileError>

Merges another compatible sketch transactionally.

Examples found in repository

examples/bounded_sequence_inference.rs (line 17)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let policy = QuantilePolicy::new(0.02, 8, 256)?;
    let mut left = QuantileSketch::new(policy.clone())?;
    let mut right = QuantileSketch::new(policy)?;
    for value in 0..100 {
        if value % 2 == 0 {
            left.insert(value as f64)?;
        } else {
            right.insert(value as f64)?;
        }
    }
    left.merge(&right)?;
    let median = left.estimate(0.5)?;
    println!(
        "quantile value={} rank=[{:.3},{:.3}] retained={} exact={}",
        median.value, median.rank_lower, median.rank_upper, median.retained_entries, median.exact
    );

    let model = HiddenMarkovModel::discrete(
        vec!["quiet", "active"],
        vec![0.6, 0.4],
        vec![vec![0.8, 0.2], vec![0.3, 0.7]],
        vec![vec![0.9, 0.1], vec![0.2, 0.8]],
    )?;
    let observations = [0, 0, 1, 1];
    let inference = forward_backward(&model, &observations)?;
    let path = viterbi(&model, &observations)?;
    println!(
        "inference log-likelihood={:.6} path={:?} repairs={}",
        inference.evidence.log_likelihood, path.states, inference.evidence.numerical_repairs
    );

    let data = [
        Sequence::Discrete(vec![0, 0, 1, 1, 1, 0]),
        Sequence::Discrete(vec![0, 1, 1, 0, 0, 0]),
    ];
    let report = fit_hmm(
        &data,
        HmmSpec::Discrete {
            states: 2,
            symbols: 2,
            additive_smoothing: 1.0e-6,
        },
        HmmFitControl::new(23, 6, 1.0e-7, 10_000, 1.0e-12)?,
    )?;
    println!(
        "fit likelihood={:.6} iterations={} converged={} repairs={} work={} termination={:?} seed={}",
        report.evidence.log_likelihood,
        report.evidence.iterations,
        report.evidence.converged,
        report.evidence.numerical_repairs,
        report.evidence.work,
        report.evidence.termination,
        report.evidence.seed
    );
    Ok(())
}

pub fn estimate(&self, quantile: f64) -> Result<QuantileEstimate, QuantileError>

Estimates a quantile and returns its retained rank interval.

Examples found in repository

examples/bounded_sequence_inference.rs (line 18)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let policy = QuantilePolicy::new(0.02, 8, 256)?;
    let mut left = QuantileSketch::new(policy.clone())?;
    let mut right = QuantileSketch::new(policy)?;
    for value in 0..100 {
        if value % 2 == 0 {
            left.insert(value as f64)?;
        } else {
            right.insert(value as f64)?;
        }
    }
    left.merge(&right)?;
    let median = left.estimate(0.5)?;
    println!(
        "quantile value={} rank=[{:.3},{:.3}] retained={} exact={}",
        median.value, median.rank_lower, median.rank_upper, median.retained_entries, median.exact
    );

    let model = HiddenMarkovModel::discrete(
        vec!["quiet", "active"],
        vec![0.6, 0.4],
        vec![vec![0.8, 0.2], vec![0.3, 0.7]],
        vec![vec![0.9, 0.1], vec![0.2, 0.8]],
    )?;
    let observations = [0, 0, 1, 1];
    let inference = forward_backward(&model, &observations)?;
    let path = viterbi(&model, &observations)?;
    println!(
        "inference log-likelihood={:.6} path={:?} repairs={}",
        inference.evidence.log_likelihood, path.states, inference.evidence.numerical_repairs
    );

    let data = [
        Sequence::Discrete(vec![0, 0, 1, 1, 1, 0]),
        Sequence::Discrete(vec![0, 1, 1, 0, 0, 0]),
    ];
    let report = fit_hmm(
        &data,
        HmmSpec::Discrete {
            states: 2,
            symbols: 2,
            additive_smoothing: 1.0e-6,
        },
        HmmFitControl::new(23, 6, 1.0e-7, 10_000, 1.0e-12)?,
    )?;
    println!(
        "fit likelihood={:.6} iterations={} converged={} repairs={} work={} termination={:?} seed={}",
        report.evidence.log_likelihood,
        report.evidence.iterations,
        report.evidence.converged,
        report.evidence.numerical_repairs,
        report.evidence.work,
        report.evidence.termination,
        report.evidence.seed
    );
    Ok(())
}

Trait Implementations

impl Clone for QuantileSketch

fn clone(&self) -> QuantileSketch

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QuantileSketch

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

Formats the value using the given formatter.

impl PartialEq for QuantileSketch

fn eq(&self, other: &QuantileSketch) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for QuantileSketch