Struct IncrementalNormalizer 

pub struct IncrementalNormalizer { /* private fields */ }

Welford online normalizer – incremental zero-mean, unit-variance standardization.

Internally tracks per-feature mean and M2 (sum of squared deviations from the current mean) so that variance is always available as M2 / count.

The struct supports two initialisation modes:

1. Lazy – call new and let the first update determine n_features from the slice length.
2. Explicit – call with_n_features to pre-allocate buffers and enforce a fixed dimensionality.

Implementations

impl IncrementalNormalizer

pub fn new() -> Self

Create a normalizer with lazy dimensionality detection.

The number of features is inferred from the first call to update.

use irithyll::preprocessing::IncrementalNormalizer;
let norm = IncrementalNormalizer::new();
assert_eq!(norm.count(), 0);

pub fn with_n_features(n: usize) -> Self

Create a normalizer with a known feature count, pre-allocating buffers.

Subsequent calls to update will panic if the slice length does not match n.

use irithyll::preprocessing::IncrementalNormalizer;
let norm = IncrementalNormalizer::with_n_features(5);
assert_eq!(norm.n_features(), Some(5));

pub fn with_variance_floor(n: usize, floor: f64) -> Self

Create a normalizer with a known feature count and custom variance floor.

The floor is added to variance before taking the square root during transformation, preventing NaN on constant features.

use irithyll::preprocessing::IncrementalNormalizer;
let norm = IncrementalNormalizer::with_variance_floor(3, 1e-8);
assert_eq!(norm.n_features(), Some(3));

pub fn update(&mut self, features: &[f64])

Incorporate a single sample into running statistics.

Uses Welford’s algorithm for numerically stable incremental updates:

count  += 1
delta   = x - mean
mean   += delta / count
delta2  = x - mean   (post-update)
M2     += delta * delta2

Panics

Panics if features.len() does not match the previously established dimensionality (either from with_n_features or from the first update call).

pub fn transform(&self, features: &[f64]) -> Vec<f64>

Standardize features using current running statistics.

Returns a new Vec<f64> where each element is (x_i - mean_i) / sqrt(var_i + floor).

Panics

Panics if no samples have been incorporated yet, or if the slice length does not match the established dimensionality.

pub fn transform_in_place(&self, features: &mut [f64])

Standardize features in place using current running statistics.

Equivalent to transform but writes results back into the provided mutable slice, avoiding allocation.

Panics

Same conditions as transform.

pub fn update_and_transform(&mut self, features: &[f64]) -> Vec<f64>

Update statistics with features then return the standardized result.

This is equivalent to calling update followed by transform, but slightly more efficient since the sample count is guaranteed to be at least 1 after the update.

use irithyll::preprocessing::IncrementalNormalizer;
let mut norm = IncrementalNormalizer::new();
let z = norm.update_and_transform(&[5.0, 10.0]);
// After a single sample, variance is 0 so output is ~0 (floor-limited).
assert!(z[0].abs() < 1e6);

pub fn mean(&self, idx: usize) -> f64

Running mean for feature at idx.

Panics

Panics if idx >= n_features or if no features have been set.

pub fn variance(&self, idx: usize) -> f64

Running population variance for feature at idx.

Returns M2[idx] / count. Returns 0.0 if count == 0.

pub fn std_dev(&self, idx: usize) -> f64

Running population standard deviation for feature at idx.

Equal to sqrt(variance(idx)).

pub fn n_features(&self) -> Option<usize>

Number of features, or None if lazy mode has not yet seen a sample.

pub fn count(&self) -> u64

Number of samples incorporated so far.

pub fn reset(&mut self)

Reset all statistics, returning the normalizer to its initial state.

Preserves n_features and variance_floor settings but clears all running accumulators.

Trait Implementations

impl Clone for IncrementalNormalizer

fn clone(&self) -> IncrementalNormalizer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IncrementalNormalizer

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

Formats the value using the given formatter.

impl Default for IncrementalNormalizer

fn default() -> Self

Returns the “default value” for a type.

impl StreamingPreprocessor for IncrementalNormalizer

fn update_and_transform(&mut self, features: &[f64]) -> Vec<f64>

Update internal statistics from this sample and return transformed features.

fn transform(&self, features: &[f64]) -> Vec<f64>

Transform features using current statistics without updating them.

fn output_dim(&self) -> Option<usize>

Number of output features, or None if unknown until the first sample.

fn reset(&mut self)

Reset to initial (untrained) state.