Struct Summary 

pub struct Summary { /* private fields */ }

The statistics of a run of samples, as accumulators that merge.

Every field is additive or extremal, so the summary of two runs is a function of their two summaries and never of their samples: a window folded from ten sub-windows is the same value as the window folded from every sample at once. That is what makes this usable beneath a tiered store, where the coarse level is folded from the fine one and the samples themselves are long gone.

The accumulators are deliberately the ones harmos’s Bucket carries — count, sum, sum_sq, and the two extremes — so the two merge by one algebra and a summary’s numbers are a bucket’s, minus the axis coordinates a kernel has no notion of. Nothing here depends on harmos; the compatibility is in the arithmetic.

Variance is the exception, and the reason this is a reshape rather than a port: sum_sq / n − mean² loses every significant digit when the mean is large compared with the spread, and returns garbage — often negative. A Welford sum of squared deviations is carried alongside instead, merged by Chan’s formula, and the variance is read off that.

use harmos_signal::Summary;

let whole = Summary::of(&[1.0, 2.0, 3.0, 4.0]);
let split = Summary::of(&[1.0, 2.0]).merge(&Summary::of(&[3.0, 4.0]));

assert_eq!(whole, split);
assert_eq!(whole.mean(), Some(2.5));

Implementations

impl Summary

pub fn new() -> Self

A summary of nothing, which is the identity of merge.

pub fn of(values: &[f64]) -> Self

The summary of one run of samples.

pub fn push(&mut self, value: f64)

Folds one more sample in.

The running mean is what the squared deviation is measured against, both before and after this sample — Welford’s update, which is stable where subtracting two large sums is not.

pub fn merge(&self, other: &Self) -> Self

The summary of both runs together.

Associative, and that is the contract: which order a tree of summaries is folded in cannot change the answer. Chan’s parallel formula carries the squared deviations across, which needs both means and both counts and nothing else.

pub fn count(&self) -> u64

How many samples this summary folded.

pub fn is_empty(&self) -> bool

Whether this summary folded no samples at all.

pub fn sum(&self) -> f64

Every sample added together.

pub fn sum_sq(&self) -> f64

Every sample squared and added together.

pub fn min(&self) -> Option<f64>

The lowest sample.

pub fn max(&self) -> Option<f64>

The highest sample.

pub fn span(&self) -> Option<f64>

The distance between the highest sample and the lowest.

pub fn mean(&self) -> Option<f64>

The arithmetic mean.

pub fn variance(&self) -> Option<f64>

The population variance, read off the accumulated squared deviations.

Population and not sample: a summary describes the samples it folded, which are the whole of what it knows.

pub fn deviation(&self) -> Option<f64>

The population standard deviation.

pub fn rms(&self) -> Option<f64>

The root mean square: sqrt(sum_sq / count).

Trait Implementations

impl Clone for Summary

fn clone(&self) -> Summary

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Summary

impl Debug for Summary

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

Formats the value using the given formatter.

impl Default for Summary

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for Summary

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Summary