Struct L2Norm 

pub struct L2Norm<Acc>(/* private fields */);

Identifies the Euclidean (L2) norm, ‖v‖₂ = √(Σᵢ |vᵢ|²).

The type parameter Acc selects the summation strategy for the scaled sum-of-squares loop. Typical choices:

• NaiveSum<R> — plain +=, fastest option.
• NeumaierSum<R> — compensated summation for higher accuracy when components span many orders of magnitude.

L2Norm<Acc> implements VectorNorm and ParallelVectorNorm for any FpScalar whose RealType matches Acc::Input.

In addition to the standard norm, L2Norm exposes the squared Euclidean norm ‖v‖₂² = Σᵢ |vᵢ|² as a separate operation (avoiding the square root) via L2Norm::compute_vector_norm_sq and its iterator/parallel variants. Note that ‖v‖₂² is not a norm — it violates the triangle inequality — and is therefore not part of the VectorNorm trait.

Implementations

impl<Acc: SumAccumulator<Input: RealScalar>> L2Norm<Acc>

pub fn compute_vector_norm_sq<T>(v: &[T]) -> NonNegativeRealScalar<Acc::Output>

where T: FpScalar<RealType = Acc::Output>,

Computes the squared Euclidean (L2) norm ‖v‖₂² of a slice.

Equivalent to compute_vector_norm_sq_iter called with v.iter().cloned().

This avoids the square root present in VectorNorm::compute_vector_norm and is useful when only relative comparisons of norms are needed.

pub fn compute_vector_norm_sq_iter<I>( v: I, ) -> NonNegativeRealScalar<Acc::Output>

where I: IntoIterator<Item: FpScalar<RealType = Acc::Output>>,

Computes the squared Euclidean (L2) norm ‖v‖₂² from an owned iterator.

Uses the same scaled sum-of-squares algorithm as VectorNorm but returns scale² × sumsq directly without taking the square root.

impl<Acc> L2Norm<Acc>

where Acc: SumAccumulator<Input: RealScalar> + Send,

pub fn compute_vector_norm_sq_par<T>( v: &[T], ) -> NonNegativeRealScalar<Acc::Output>

where T: FpScalar<RealType = Acc::Output>,

Computes the squared Euclidean (L2) norm ‖v‖₂² of a slice in parallel.

Equivalent to compute_vector_norm_sq_par_iter called with v.par_iter().cloned().

pub fn compute_vector_norm_sq_par_iter<I>( v: I, ) -> NonNegativeRealScalar<Acc::Output>

where I: IntoParallelIterator<Item: FpScalar<RealType = Acc::Output>>,

Computes the squared Euclidean (L2) norm ‖v‖₂² from a parallel iterator.

Chunks are processed in parallel and merged via Accumulator::combine, preserving the numerical properties of the chosen Acc strategy across chunks.

Trait Implementations

impl<T, SumAcc> ParallelVectorNorm<T> for L2Norm<SumAcc>

where T: FpScalar, SumAcc: SumAccumulator<Input = T::RealType> + Send,

fn compute_vector_norm_par_iter<I: IntoParallelIterator<Item = T>>( iter: I, ) -> NonNegativeRealScalar<T::RealType>

Computes the norm from an owned parallel iterator.

fn compute_vector_norm_par(v: &[T]) -> NonNegativeRealScalar<T::RealType>

Computes the norm of a slice in parallel.

impl<ScalarType, SumAcc> VectorNorm<ScalarType> for L2Norm<SumAcc>

where ScalarType: FpScalar, SumAcc: SumAccumulator<Input = ScalarType::RealType>,

fn compute_vector_norm_iter<I>( v: I, ) -> NonNegativeRealScalar<ScalarType::RealType>

where I: IntoIterator<Item = ScalarType>,

Computes the norm from an owned-item iterator.

fn compute_vector_norm( v: &[ScalarType], ) -> NonNegativeRealScalar<ScalarType::RealType>

Computes the norm of a slice of scalars.