Struct Tolerance 

pub struct Tolerance { /* private fields */ }

Finite, non-negative tolerance used by numerical predicates and factorizations.

Construct with Tolerance::new when accepting raw caller input. Once constructed, the stored value is guaranteed to be finite and >= 0, so downstream algorithms do not need to revalidate the tolerance.

This is the crate-wide tolerance contract: raw negative, NaN, and infinite values are rejected with LaError::InvalidTolerance at construction time.

Implementations

impl Tolerance

pub const fn new(value: f64) -> Result<Self, LaError>

Construct a finite, non-negative tolerance.

Examples

use la_stack::prelude::*;

let tol = Tolerance::new(1e-12)?;
assert_eq!(tol.get(), 1e-12);

Errors

Returns LaError::InvalidTolerance when value is NaN, infinite, or negative.

pub const fn get(self) -> f64

Return the raw finite, non-negative tolerance value.

Examples

use la_stack::prelude::*;

let tol = Tolerance::new(0.0)?;
assert_eq!(tol.get(), 0.0);

Trait Implementations

impl Clone for Tolerance

fn clone(&self) -> Tolerance

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Tolerance

impl Debug for Tolerance

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

Formats the value using the given formatter.

impl PartialEq for Tolerance

fn eq(&self, other: &Tolerance) -> 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 StructuralPartialEq for Tolerance