Struct Normalizer 

pub struct Normalizer<const D: usize> {
    pub strategy: NormStrategy,
    pub params: [NormParams; D],
}

Fixed-dim normalizer with per-feature parameters.

Examples

use anomstream_core::{NormStrategy, Normalizer};

let samples = [[0.0, 0.0], [100.0, 1000.0]];
let n = Normalizer::<2>::fit(NormStrategy::MinMax, &samples);
let out = n.transform(&[50.0, 500.0]);
assert!((out[0] - 0.5).abs() < 1e-12);
assert!((out[1] - 0.5).abs() < 1e-12);

Fields

strategy: NormStrategy

Active transform strategy.

params: [NormParams; D]

Per-dimension learned parameters.

Implementations

impl<const D: usize> Normalizer<D>

pub const fn identity(strategy: NormStrategy) -> Self

Build with identity parameters. Use when no fit data is yet available; transform is then a pass-through (or a clamp-to-[0,1] under MinMax).

pub fn fit(strategy: NormStrategy, samples: &[[f64; D]]) -> Self

Learn per-dim (mean, std_dev, min, max) from samples. Returns Self::identity when samples is empty.

Uses the same two-pass formulation as the original enterprise baseline so numeric results are stable across the migration.

pub fn transform(&self, input: &[f64; D]) -> [f64; D]

Apply the active strategy to input, returning a new [f64; D]. MinMax clamps to [0, 1]; ZScore divides by std_dev with zero-guard.

Trait Implementations

impl<const D: usize> Clone for Normalizer<D>

fn clone(&self) -> Normalizer<D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const D: usize> Debug for Normalizer<D>

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

Formats the value using the given formatter.

impl<'de, const D: usize> Deserialize<'de> for Normalizer<D>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const D: usize> PartialEq for Normalizer<D>

fn eq(&self, other: &Normalizer<D>) -> 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<const D: usize> Serialize for Normalizer<D>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<const D: usize> Copy for Normalizer<D>

impl<const D: usize> StructuralPartialEq for Normalizer<D>