Struct Normalizer 

pub struct Normalizer<F> { /* private fields */ }

A stateless row-wise normalizer.

Each sample (row) is independently scaled so that its chosen norm equals 1. Samples with a zero norm are left unchanged.

This transformer is stateless — no Fit step is needed. Call Transform::transform directly.

Examples

use ferrolearn_preprocess::normalizer::{Normalizer, NormType};
use ferrolearn_core::traits::Transform;
use ndarray::array;

let normalizer = Normalizer::<f64>::new(NormType::L2);
let x = array![[3.0, 4.0], [1.0, 0.0]];
let out = normalizer.transform(&x).unwrap();
// Row 0: [3/5, 4/5], Row 1: [1.0, 0.0]

Implementations

impl<F: Float + Send + Sync + 'static> Normalizer<F>

pub fn new(norm: NormType) -> Self

Create a new Normalizer with the specified norm type.

pub fn l2() -> Self

Create a new Normalizer using the default L2 norm.

pub fn l1() -> Self

Create a new Normalizer using the L1 norm.

pub fn max() -> Self

Create a new Normalizer using the Max norm.

pub fn norm(&self) -> NormType

Return the configured norm type.

pub fn with_copy(self, copy: bool) -> Self

Set the copy parameter (sklearn Normalizer(copy=...), _data.py:2058, _parameter_constraints {copy:["boolean"]} :2055).

This is an ACCEPT-AND-DOCUMENT no-op: ferrolearn’s Transform always returns a freshly allocated array, so copy has no observable effect on the output. It is retained for API parity with scikit-learn.

pub fn copy(&self) -> bool

Return the configured copy flag (sklearn Normalizer.copy).

Trait Implementations

impl<F: Clone> Clone for Normalizer<F>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug> Debug for Normalizer<F>

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

Formats the value using the given formatter.

impl<F: Float + Send + Sync + 'static> Default for Normalizer<F>

fn default() -> Self

Returns the “default value” for a type.

impl<F: Float + Send + Sync + 'static> Fit<ArrayBase<OwnedRepr<F>, Dim<[usize; 2]>>, ()> for Normalizer<F>

fn fit(&self, x: &Array2<F>, _y: &()) -> Result<FittedNormalizer<F>, FerroError>

Validate the input and record n_features_in_, returning a FittedNormalizer.

Normalizer is stateless: like scikit-learn’s Normalizer.fit (sklearn/preprocessing/_data.py:2062-2083, “Only validates estimator’s parameters”), this learns NO statistics. It runs the SAME check_array validation as Transform::transform / normalize (REQ-2, via the shared validate_normalize_input helper) and records n_features_in_ = x.ncols(). sklearn’s _validate_data uses the default force_all_finite=True, so NaN/±inf are REJECTED in fit (Normalizer().fit([[nan]]) / [[inf]] raise ValueError).

Errors

Returns FerroError::InsufficientSamples for zero rows and FerroError::InvalidParameter for zero features or any non-finite value (NaN, +inf, -inf) — matching check_array (sklearn/utils/validation.py:1084, :1093, :1063) as routed through Normalizer.fit -> _validate_data (_data.py:2082).

type Fitted = FittedNormalizer<F>

The fitted model type returned by fit.

type Error = FerroError

The error type returned by fit.

impl<F: Float + Send + Sync + 'static> FittedPipelineTransformer<F> for Normalizer<F>

fn transform_pipeline(&self, x: &Array2<F>) -> Result<Array2<F>, FerroError>

Transform data using the pipeline interface.

Errors

Propagates errors from Transform::transform.

impl<F: Float + Send + Sync + 'static> PipelineTransformer<F> for Normalizer<F>

fn fit_pipeline( &self, _x: &Array2<F>, _y: &Array1<F>, ) -> Result<Box<dyn FittedPipelineTransformer<F>>, FerroError>

Fit the normalizer using the pipeline interface.

Because Normalizer is stateless, this simply boxes self as a FittedPipelineTransformer.

Errors

This implementation never returns an error.

impl<F: Float + Send + Sync + 'static> Transform<ArrayBase<OwnedRepr<F>, Dim<[usize; 2]>>> for Normalizer<F>

fn transform(&self, x: &Array2<F>) -> Result<Array2<F>, FerroError>

Normalize each row of x to unit norm.

Rows with a zero norm value are left unchanged.

Errors

Returns FerroError::InsufficientSamples if x has zero rows. This mirrors scikit-learn’s Normalizer.transform -> normalize -> check_array (sklearn/preprocessing/_data.py:1933), whose min-samples check (utils/validation.py:1084, ensure_min_samples=1) raises ValueError: Found array with 0 sample(s) ... while a minimum of 1 is required by Normalizer.

Returns FerroError::InvalidParameter if x has zero features (columns). This mirrors the same check_array min-features check (utils/validation.py:1093, ensure_min_features=1) which raises ValueError: Found array with 0 feature(s) ... while a minimum of 1 is required by Normalizer.

Returns FerroError::InvalidParameter if x contains any non-finite value (NaN, +inf, or -inf). This mirrors check_array(force_all_finite= True) (utils/validation.py:1063), which raises ValueError: Input X contains NaN. / Input X contains infinity ... before normalizing.

type Output = ArrayBase<OwnedRepr<F>, Dim<[usize; 2]>>

The transformed output type.

type Error = FerroError

The error type returned by transform.