Trait average::Merge

pub trait Merge {
    fn merge(&mut self, other: &Self);
}

Merge with another estimator.

Required methods

fn merge(&mut self, other: &Self)

Merge the other estimator into this one.

Both estimators are assumed to be fed samples from the same population.

This method is useful for parallelizing the calculation of estimates:

use average::{Estimate, Mean, Merge};

let data = &[1., 2., 3., 4., 5., 6., 7., 8., 9., 10.];

let mut thread1 = std::thread::spawn(move || -> Mean {
    let mut avg = Mean::new();
    for &x in &data[..5] {
        avg.add(x);
    }
    avg
});
let mut thread2 = std::thread::spawn(move || -> Mean {
    let mut avg = Mean::new();
    for &x in &data[5..] {
        avg.add(x);
    }
    avg
});

let mut avg = thread1.join().unwrap();
avg.merge(&thread2.join().unwrap());
assert_eq!(avg.mean(), 5.5);

Loading content...

Implementors

impl Merge for Histogram

fn merge(&mut self, other: &Self)

impl Merge for Kurtosis

fn merge(&mut self, other: &Kurtosis)

impl Merge for Max

fn merge(&mut self, other: &Max)

Merge another sample into this one.

Example

use average::{Max, Merge};

let sequence: &[f64] = &[1., 2., 3., 4., 5., 6., 7., 8., 9.];
let (left, right) = sequence.split_at(3);
let max_total: Max = sequence.iter().collect();
let mut max_left: Max = left.iter().collect();
let max_right: Max = right.iter().collect();
max_left.merge(&max_right);
assert_eq!(max_total.max(), max_left.max());

impl Merge for Mean

fn merge(&mut self, other: &Mean)

Merge another sample into this one.

Example

use average::{Mean, Merge};

let sequence: &[f64] = &[1., 2., 3., 4., 5., 6., 7., 8., 9.];
let (left, right) = sequence.split_at(3);
let avg_total: Mean = sequence.iter().collect();
let mut avg_left: Mean = left.iter().collect();
let avg_right: Mean = right.iter().collect();
avg_left.merge(&avg_right);
assert_eq!(avg_total.mean(), avg_left.mean());

impl Merge for Min

fn merge(&mut self, other: &Min)

Merge another sample into this one.

Example

use average::{Min, Merge};

let sequence: &[f64] = &[1., 2., 3., 4., 5., 6., 7., 8., 9.];
let (left, right) = sequence.split_at(3);
let min_total: Min = sequence.iter().collect();
let mut min_left: Min = left.iter().collect();
let min_right: Min = right.iter().collect();
min_left.merge(&min_right);
assert_eq!(min_total.min(), min_left.min());

impl Merge for Moments4

fn merge(&mut self, other: &Moments4)

impl Merge for Skewness

fn merge(&mut self, other: &Skewness)

impl Merge for Variance

fn merge(&mut self, other: &Variance)

Merge another sample into this one.

Example

use average::{Variance, Merge};

let sequence: &[f64] = &[1., 2., 3., 4., 5., 6., 7., 8., 9.];
let (left, right) = sequence.split_at(3);
let avg_total: Variance = sequence.iter().collect();
let mut avg_left: Variance = left.iter().collect();
let avg_right: Variance = right.iter().collect();
avg_left.merge(&avg_right);
assert_eq!(avg_total.mean(), avg_left.mean());
assert_eq!(avg_total.sample_variance(), avg_left.sample_variance());

impl Merge for WeightedMean

fn merge(&mut self, other: &WeightedMean)

Merge another sample into this one.

Example

use average::{WeightedMean, Merge};

let weighted_sequence: &[(f64, f64)] = &[
    (1., 0.1), (2., 0.2), (3., 0.3), (4., 0.4), (5., 0.5),
    (6., 0.6), (7., 0.7), (8., 0.8), (9., 0.9)];
let (left, right) = weighted_sequence.split_at(3);
let avg_total: WeightedMean = weighted_sequence.iter().collect();
let mut avg_left: WeightedMean = left.iter().collect();
let avg_right: WeightedMean = right.iter().collect();
avg_left.merge(&avg_right);
assert!((avg_total.mean() - avg_left.mean()).abs() < 1e-15);

impl Merge for WeightedMeanWithError

fn merge(&mut self, other: &WeightedMeanWithError)

Merge another sample into this one.

Example

use average::{WeightedMeanWithError, Merge};

let weighted_sequence: &[(f64, f64)] = &[
    (1., 0.1), (2., 0.2), (3., 0.3), (4., 0.4), (5., 0.5),
    (6., 0.6), (7., 0.7), (8., 0.8), (9., 0.9)];
let (left, right) = weighted_sequence.split_at(3);
let avg_total: WeightedMeanWithError = weighted_sequence.iter().collect();
let mut avg_left: WeightedMeanWithError = left.iter().collect();
let avg_right: WeightedMeanWithError = right.iter().collect();
avg_left.merge(&avg_right);
assert!((avg_total.weighted_mean() - avg_left.weighted_mean()).abs() < 1e-15);
assert!((avg_total.error() - avg_left.error()).abs() < 1e-15);

Loading content...