[][src]Trait average::Merge

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

Merge another sample into this one.

Required methods

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

Loading content...

Implementors

impl Merge for Histogram
[src]

impl Merge for Kurtosis
[src]

impl Merge for Max
[src]

fn merge(&mut self, other: &Max)
[src]

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
[src]

fn merge(&mut self, other: &Mean)
[src]

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
[src]

fn merge(&mut self, other: &Min)
[src]

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
[src]

impl Merge for Skewness
[src]

impl Merge for Variance
[src]

fn merge(&mut self, other: &Variance)
[src]

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
[src]

fn merge(&mut self, other: &WeightedMean)
[src]

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
[src]

fn merge(&mut self, other: &WeightedMeanWithError)
[src]

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...