Struct Uncertain 

pub struct Uncertain<S: Scalar> {
    pub mean: S,
    pub variance: S,
}

An uncertain value with mean and variance.

Example

use numra_core::uncertainty::Uncertain;

// A measurement of 10.0 ± 0.5 (std dev)
let x: Uncertain<f64> = Uncertain::new(10.0, 0.25); // variance = 0.5²

// Scale by 2: mean scales, variance scales by 4
let y = x.scale(2.0);
assert!((y.mean - 20.0).abs() < 1e-10);
assert!((y.variance - 1.0).abs() < 1e-10);

Fields

mean: S

Mean value

variance: S

Variance (σ²)

Implementations

impl<S: Scalar> Uncertain<S>

pub fn new(mean: S, variance: S) -> Self

Create a new uncertain value.

pub fn from_std(mean: S, std: S) -> Self

Create from mean and standard deviation.

pub fn certain(value: S) -> Self

Create a certain value (zero variance).

pub fn std(&self) -> S

Standard deviation.

pub fn cv(&self) -> S

Coefficient of variation (std/mean).

pub fn scale(&self, a: S) -> Self

Scale by a constant: y = a*x. Variance scales by a².

pub fn add_const(&self, c: S) -> Self

Add a constant: y = x + c. Variance unchanged.

pub fn add(&self, other: &Self) -> Self

Add another uncertain value (assuming independence). y = x1 + x2, Var(y) = Var(x1) + Var(x2).

pub fn sub(&self, other: &Self) -> Self

Subtract another uncertain value (assuming independence).

pub fn mul(&self, other: &Self) -> Self

Multiply by another uncertain value (first-order approximation). For y = x1 * x2: E[y] ≈ E[x1] * E[x2] Var(y) ≈ E[x2]² * Var(x1) + E[x1]² * Var(x2)

pub fn div(&self, other: &Self) -> Self

Divide by another uncertain value (first-order approximation). For y = x1 / x2: E[y] ≈ E[x1] / E[x2] Var(y) ≈ (1/E[x2]²) * Var(x1) + (E[x1]/E[x2]²)² * Var(x2)

pub fn apply<F, D>(&self, f: F, df: D) -> Self

where F: Fn(S) -> S, D: Fn(S) -> S,

Apply a function with known derivative. For y = f(x): Var(y) ≈ (f’(x))² * Var(x).

pub fn square(&self) -> Self

Square: y = x².

pub fn sqrt_unc(&self) -> Self

Square root: y = √x.

pub fn exp(&self) -> Self

Exponential: y = e^x.

pub fn ln(&self) -> Self

Natural log: y = ln(x).

pub fn sin(&self) -> Self

Sine: y = sin(x).

pub fn cos(&self) -> Self

Cosine: y = cos(x).

Trait Implementations

impl<S: Clone + Scalar> Clone for Uncertain<S>

fn clone(&self) -> Uncertain<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug + Scalar> Debug for Uncertain<S>

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

Formats the value using the given formatter.

impl<S: Scalar> Default for Uncertain<S>

fn default() -> Self

Returns the “default value” for a type.

impl<S: PartialEq + Scalar> PartialEq for Uncertain<S>

fn eq(&self, other: &Uncertain<S>) -> 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<S: Copy + Scalar> Copy for Uncertain<S>

impl<S: Scalar> StructuralPartialEq for Uncertain<S>