Struct StableMetrics 

pub struct StableMetrics<T> {
    pub epsilon: T,
    pub max_value: T,
    pub clip_values: bool,
    pub use_logsumexp: bool,
}

Numerically stable computation of common operations

Fields

epsilon: T

Minimum value to avoid division by zero or log of zero

max_value: T

Maximum value to clip extreme values

clip_values: bool

Whether to clip values

use_logsumexp: bool

Whether to use log-sum-exp trick for numerical stability

Implementations

impl<T: Float + NumCast> StableMetrics<T>

pub fn new() -> Self

Create a new StableMetrics with default settings

pub fn with_epsilon(self, epsilon: T) -> Self

Set the epsilon value

pub fn with_max_value(self, maxvalue: T) -> Self

Set the maximum value

pub fn with_clip_values(self, clipvalues: bool) -> Self

Set whether to clip values

pub fn with_logsumexp(self, uselogsumexp: bool) -> Self

Set whether to use log-sum-exp trick

pub fn stable_mean(&self, values: &[T]) -> Result<T>

Numerically stable calculation of the mean

Implements Welford’s online algorithm for computing the mean, which is more stable for large datasets.

Arguments

• values - Input array of values

Returns

• The mean of the values

pub fn stable_variance(&self, values: &[T], ddof: usize) -> Result<T>

Numerically stable calculation of variance

Implements Welford’s online algorithm for computing variance, which is more stable for large datasets.

Arguments

• values - Input array of values
• ddof - Delta degrees of freedom (0 for population variance, 1 for sample variance)

Returns

• The variance of the values

pub fn stable_std(&self, values: &[T], ddof: usize) -> Result<T>

Numerically stable calculation of standard deviation

Uses the stable variance calculation and takes the square root.

Arguments

• values - Input array of values
• ddof - Delta degrees of freedom (0 for population std, 1 for sample std)

Returns

• The standard deviation of the values

pub fn safe_log(&self, x: T) -> T

Safely compute logarithm

Avoids taking the logarithm of zero by adding a small epsilon value.

Arguments

• x - Input value

Returns

• The logarithm of the input, with epsilon added to avoid log(0)

pub fn safe_div(&self, numer: T, denom: T) -> T

Safely compute reciprocal

Avoids division by zero by adding a small epsilon value to the denominator.

Arguments

• numer - Numerator
• denom - Denominator

Returns

• The result of numer / (denom + epsilon)

pub fn clip(&self, x: T) -> T

Clip values to a reasonable range

Limits extreme values to prevent numerical instability.

Arguments

• x - Input value

Returns

• The input value, clipped to the range [epsilon, max_value]

pub fn logsumexp(&self, x: &[T]) -> T

Compute log-sum-exp in a numerically stable way

Uses the log-sum-exp trick to prevent overflow in exponentials.

Arguments

• x - Array of values

Returns

• The log-sum-exp of the values

pub fn softmax(&self, x: &[T]) -> Vec<T>

Compute softmax in a numerically stable way

Uses the log-sum-exp trick to prevent overflow in exponentials.

Arguments

• x - Array of values

Returns

• Array with softmax values

pub fn cross_entropy(&self, y_true: &[T], ypred: &[T]) -> Result<T>

Compute cross-entropy in a numerically stable way

Arguments

• y_true - True probabilities
• ypred - Predicted probabilities

Returns

• The cross-entropy loss

pub fn kl_divergence(&self, p: &[T], q: &[T]) -> Result<T>

Compute Kullback-Leibler divergence in a numerically stable way

Arguments

• p - True probability distribution
• q - Predicted probability distribution

Returns

• The KL divergence

pub fn js_divergence(&self, p: &[T], q: &[T]) -> Result<T>

Compute Jensen-Shannon divergence in a numerically stable way

Arguments

• p - First probability distribution
• q - Second probability distribution

Returns

• The JS divergence

pub fn wasserstein_distance(&self, u_values: &[T], vvalues: &[T]) -> Result<T>

Compute Wasserstein distance between 1D probability distributions

Arguments

• u_values - First distribution sample values
• u_values - Second distribution sample values

Returns

• The Wasserstein distance

pub fn maximum_mean_discrepancy( &self, x: &[T], y: &[T], gamma: Option<T>, ) -> Result<T>

Compute maximum mean discrepancy (MMD) between samples

Arguments

• x - First sample
• y - Second sample
• gamma - RBF kernel parameter

Returns

• The MMD value

pub fn matrix_exp_trace(&self, eigenvalues: &[T]) -> Result<T>

Safely compute matrix exponential trace

Computes tr(exp(A)) in a numerically stable way. This is useful for computing the nuclear norm of a matrix.

Arguments

• eigenvalues - Eigenvalues of matrix A

Returns

• The trace of the matrix exponential

pub fn matrix_logdet(&self, eigenvalues: &[T]) -> Result<T>

Compute stable matrix logarithm determinant

Computes log(det(A)) in a numerically stable way by summing the logarithms of eigenvalues.

Arguments

• eigenvalues - Eigenvalues of matrix A

Returns

• The logarithm of the determinant

pub fn log1p(&self, x: T) -> T

Compute numerically stable log1p (log(1+x))

More accurate than log(1+x) for small values of x.

Arguments

• x - Input value

Returns

• log(1+x) computed in a numerically stable way

pub fn expm1(&self, x: T) -> T

Compute numerically stable expm1 (exp(x)-1)

More accurate than exp(x)-1 for small values of x.

Arguments

• x - Input value

Returns

• exp(x)-1 computed in a numerically stable way

Trait Implementations

impl<T: Clone> Clone for StableMetrics<T>

fn clone(&self) -> StableMetrics<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for StableMetrics<T>

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

Formats the value using the given formatter.

impl<T: Float + NumCast> Default for StableMetrics<T>

fn default() -> Self

Returns the “default value” for a type.