Struct UnguardedF64

pub struct UnguardedF64(/* private fields */);

Represents a checked floating-point number that ensures it is neither NaN nor infinite.

Example

use floatguard::{UnguardedF64, FloatError, GuardedF64};

let unchecked_f64 = UnguardedF64::new(1.0);
assert_eq!((unchecked_f64 + 1.0).check(), GuardedF64::new(2.0));

assert_eq!(unchecked_f64.check(), GuardedF64::new(1.0));

assert_eq!((unchecked_f64 - f64::INFINITY).check(), Err(FloatError::Infinity));

Implementations

impl UnguardedF64

pub const RADIX: u32 = 2u32

The radix or base of the internal representation of f64.

See: f64::RADIX

impl UnguardedF64

pub const MANTISSA_DIGITS: u32 = 53u32

Number of significant digits in base 2.

See: f64::MANTISSA_DIGITS.

impl UnguardedF64

pub const DIGITS: u32 = 15u32

Approximate number of significant digits in base 10.

See: f64::DIGITS.

impl UnguardedF64

pub const EPSILON: GuardedF64

The difference between 1.0 and the next larger representable number. Equal to 2^{1 − MANTISSA_DIGITS}.

See: f64::EPSILON

impl UnguardedF64

pub const MIN: GuardedF64

Smallest finite f64 value.

See: f64::MIN

impl UnguardedF64

pub const MIN_POSITIVE: GuardedF64

Smallest positive normal f64 value.

See: f64::MIN_POSITIVE

impl UnguardedF64

pub const MAX: GuardedF64

Largest finite f64 value.

See: f64::MAX

impl UnguardedF64

pub const MIN_EXP: i32 = -1_021i32

Minimum possible normal power of 2 exponent.

See: f64::MIN_EXP

impl UnguardedF64

pub const MAX_EXP: i32 = 1_024i32

Maximum possible normal power of 2 exponent.

See: f64::MAX_EXP

impl UnguardedF64

pub const MIN_10_EXP: i32 = -307i32

Minimum possible normal power of 10 exponent.

See: f64::MIN_10_EXP

impl UnguardedF64

pub const MAX_10_EXP: i32 = 308i32

Maximum possible normal power of 10 exponent.

See: f64::MAX_10_EXP

impl UnguardedF64

pub const PI: GuardedF64

Archimedes’ constant (π)

See: std::f64::consts::PI

impl UnguardedF64

pub const TAU: GuardedF64

The full circle constant (τ = 2π)

See: std::f64::consts::TAU

impl UnguardedF64

pub const FRAC_PI_2: GuardedF64

π/2

See: std::f64::consts::FRAC_PI_2

impl UnguardedF64

pub const FRAC_PI_3: GuardedF64

π/3

See: std::f64::consts::FRAC_PI_3

impl UnguardedF64

pub const FRAC_PI_4: GuardedF64

π/4

See: std::f64::consts::FRAC_PI_4

impl UnguardedF64

pub const FRAC_PI_6: GuardedF64

π/6

See: std::f64::consts::FRAC_PI_6

impl UnguardedF64

pub const FRAC_PI_8: GuardedF64

π/8

See: std::f64::consts::FRAC_PI_8

impl UnguardedF64

pub const FRAC_1_PI: GuardedF64

1/π

See: std::f64::consts::FRAC_1_PI

impl UnguardedF64

pub const FRAC_2_PI: GuardedF64

2/π

See: std::f64::consts::FRAC_2_PI

impl UnguardedF64

pub const FRAC_2_SQRT_PI: GuardedF64

1/√π

See: std::f64::consts::FRAC_2_SQRT_PI

impl UnguardedF64

pub const SQRT_2: GuardedF64

√2

See: std::f64::consts::SQRT_2

impl UnguardedF64

pub const FRAC_1_SQRT_2: GuardedF64

1/√2

See: std::f64::consts::FRAC_1_SQRT_2

impl UnguardedF64

pub const E: GuardedF64

Euler’s number (e)

See: std::f64::consts::E

impl UnguardedF64

pub const LOG2_E: GuardedF64

log₂(e)

See: std::f64::consts::LOG2_E

impl UnguardedF64

pub const LOG2_10: GuardedF64

log₂(10)

See: std::f64::consts::LOG2_10

impl UnguardedF64

pub const LOG10_2: GuardedF64

log₁₀(2)

See: std::f64::consts::LOG10_2

impl UnguardedF64

pub const LOG10_E: GuardedF64

log₁₀(e)

See: std::f64::consts::LOG10_E

impl UnguardedF64

pub const LN_2: GuardedF64

ln(2)

See: std::f64::consts::LN_2

impl UnguardedF64

pub const LN_10: GuardedF64

ln(10)

See: std::f64::consts::LN_10

impl UnguardedF64

pub const fn check(self) -> Result<GuardedF64, FloatError>

Checks if the UnguardedF64 value is valid (finite).

Returns

Returns a GuardedF64 if the value is valid (finite), otherwise returns an error.

Errors

Returns FloatError if the value is NaN or infinite.

Example

use floatguard::{UnguardedF64, FloatError, GuardedF64};

let unchecked_f64 = UnguardedF64::new(1.0);
assert_eq!(unchecked_f64.check(), GuardedF64::new(1.0));

let invalid_f64 = UnguardedF64::new(f64::NAN);
assert_eq!(invalid_f64.check(), Err(FloatError::NaN));

let inf_f64 = UnguardedF64::new(f64::INFINITY);
assert_eq!(inf_f64.check(), Err(FloatError::Infinity));

let neg_inf_f64 = UnguardedF64::new(f64::NEG_INFINITY);
assert_eq!(neg_inf_f64.check(), Err(FloatError::Infinity));

impl UnguardedF64

pub const fn abs(self) -> Self

Computes the absolute value of self. GuardedF64::abs returns a GuardedF64 type because any value that is not NaN or infinite is guaranteed to return a valid value.

See: f64::abs

Examples

use floatguard::{GuardedF64, UnguardedF64};

let checked = GuardedF64::new(3.5_f64).unwrap();
assert_eq!(checked.abs(), 3.5_f64);

let unchecked = UnguardedF64::new(-3.5_f64);
assert_eq!(unchecked.abs().check(), GuardedF64::new(3.5_f64));

impl UnguardedF64

pub const fn signum(self) -> Self

Returns a number that represents the sign of self. GuardedF64::signum returns a GuardedF64 type because any value that is not NaN or infinite is guaranteed to return a valid value.

See: f64::signum

Examples

use floatguard::{GuardedF64, UnguardedF64};

let pos = GuardedF64::new(3.5_f64).unwrap();
let neg = UnguardedF64::new(-3.5_f64);

assert_eq!(pos.signum(), GuardedF64::new(1.0).unwrap());
assert_eq!(neg.signum().check(), GuardedF64::new(-1.0));

impl UnguardedF64

pub fn sqrt(self) -> UnguardedF64

Returns the square root of self.

See: f64::sqrt

Examples

use floatguard::{GuardedF64, FloatError, UnguardedF64};

let positive = GuardedF64::new(4.0_f64).unwrap();
let negative = GuardedF64::new(-4.0_f64).unwrap();
let negative_zero = UnguardedF64::new(-0.0_f64);

assert_eq!(positive.sqrt().check(), GuardedF64::new(2.0));
assert_eq!(negative.sqrt().check(), Err(FloatError::NaN));
assert_eq!(negative_zero.sqrt().check(), GuardedF64::new(-0.0));

impl UnguardedF64

pub const fn recip(self) -> UnguardedF64

Takes the reciprocal (inverse) of self, 1/x where x is self. This returns an UncheckedF64 because CheckedF64::new(0.0).unwrap().recip() is invalid.

See: f64::recip

Examples

use floatguard::{GuardedF64, UnguardedF64};

let x = UnguardedF64::new(2.0_f64);
let abs_difference = (x.recip() - (1.0 / x)).abs().check().unwrap();

assert!(abs_difference < GuardedF64::EPSILON);

impl UnguardedF64

pub fn exp(self) -> UnguardedF64

Returns $e($self), (the exponential function).

See: f64::exp

Examples

use floatguard::UnguardedF64;

let one = UnguardedF64::new(1.0_f64);

// e^1
let e = one.exp();

// ln(e) - 1 == 0
let abs_difference = (e.ln() - 1.0).abs().check().unwrap();

assert!(abs_difference < 1e-10);

impl UnguardedF64

pub fn ln(self) -> UnguardedF64

Returns the natural logarithm of a number, ln(self).

See: f64::ln

Examples

use floatguard::UnguardedF64;

let e = UnguardedF64::new(2.718281828459045_f64);

// ln(e) == 1
let abs_difference = (e.ln() - 1.0).abs().check().unwrap();

assert!(abs_difference < 1e-10);

impl UnguardedF64

pub fn log2(self) -> UnguardedF64

Returns the base-2 logarithm of a number, log2(self).

See: f64::log2

Examples

use floatguard::UnguardedF64;

let two = UnguardedF64::new(2.0_f64);
let abs_difference = (two.log2() - 1.0).abs().check().unwrap();
assert!(abs_difference < 1e-10);

let two = two.check().unwrap();
let abs_difference = (two.log2() - 1.0).abs().check().unwrap();
assert!(abs_difference < 1e-10);

impl UnguardedF64

pub fn log10(self) -> UnguardedF64

Returns the base-10 logarithm of a number, log10(self).

See: f64::log10

Examples

use floatguard::UnguardedF64;

let ten = UnguardedF64::new(10.0_f64);
let abs_difference = (ten.log10() - 1.0).abs().check().unwrap();
assert!(abs_difference < 1e-10);

let ten = ten.check().unwrap();
let abs_difference = (ten.log10() - 1.0).abs().check().unwrap();
assert!(abs_difference < 1e-10);

impl UnguardedF64

pub fn log(self, base: impl Into<UnguardedF64>) -> UnguardedF64

Returns the logarithm of a number with a specified base, log(self, base).

See: f64::log

Arguments

base - The base of the logarithm.

Examples

use floatguard::UnguardedF64;

let two = UnguardedF64::new(2.0_f64);
let eight = UnguardedF64::new(8.0_f64);

// log(8, 2) == 3
let abs_difference = (eight.log(two) - 3.0).abs().check().unwrap();

assert!(abs_difference < 1e-10);

impl UnguardedF64

pub fn powi(self, power: i32) -> UnguardedF64

Raises a number to an integer power.

See: f64::powi

Examples

use floatguard::{GuardedF64, UnguardedF64};

let x = UnguardedF64::new(2.0_f64);
let abs_difference = (x.powi(2) - (x * x)).abs().check().unwrap();
assert!(abs_difference <= GuardedF64::EPSILON);

assert!(UnguardedF64::new(f64::NAN).powi(2).check().is_err());

impl UnguardedF64

pub fn powf(self, power: impl Into<UnguardedF64>) -> UnguardedF64

Raises a number to a floating-point power.

See: f64::powf

Examples

use floatguard::{GuardedF64, UnguardedF64};

let x = UnguardedF64::new(2.0_f64);
let cubed = UnguardedF64::new(3.0);
let abs_difference = (x.powf(cubed) - (x * x * x)).abs().check().unwrap();
assert!(abs_difference <= GuardedF64::EPSILON);

let invalid = UnguardedF64::new(f64::NAN);
assert!(invalid.powf(x).check().is_err());

impl UnguardedF64

pub fn sin(self) -> UnguardedF64

Computes the sine of a number (in radians).

See: f64::sin

Examples

use floatguard::GuardedF64;

let x = std::f64::consts::FRAC_PI_2;

let abs_difference = (x.sin() - 1.0).abs();

assert!(abs_difference < 1e-10);

impl UnguardedF64

pub fn asin(self) -> UnguardedF64

Computes the arcsine of a number. Return value is in radians in the range [-π/2, π/2] or invalid if the number is outside the range [-1, 1].

See: f64::asin

Examples

use floatguard::GuardedF64;

let f = GuardedF64::FRAC_PI_2;

// asin(sin(pi/2))
let abs_difference = (f.sin().asin() - GuardedF64::FRAC_PI_2).abs().check().unwrap();

assert!(abs_difference < 1e-10);

impl UnguardedF64

pub fn sinh(self) -> UnguardedF64

Hyperbolic sine function.

See: f64::sinh

Examples

use floatguard::GuardedF64;

let e = GuardedF64::E;
let x = 1.0_f64;

let f = x.sinh();
// Solving sinh() at 1 gives `(e^2-1)/(2e)`
let g = ((e * e) - 1.0) / (2.0 * e);
let abs_difference = (f - g).abs().check().unwrap();

assert!(abs_difference < 1e-10);

impl UnguardedF64

pub fn asinh(self) -> UnguardedF64

Inverse hyperbolic sine function.

See: f64::asinh

Examples

use floatguard::UnguardedF64;

let x = UnguardedF64::new(1.0_f64);
let f = x.sinh().asinh();

let abs_difference = (f - x).abs().check().unwrap();

assert!(abs_difference < 1.0e-10);

impl UnguardedF64

pub fn cos(self) -> UnguardedF64

Computes the cosine of a number (in radians).

See: f64::cos

Examples

use floatguard::GuardedF64;

let x = 2.0 * GuardedF64::PI;

let abs_difference = (x.cos() - 1.0).abs().check().unwrap();

assert!(abs_difference < 1e-10);

impl UnguardedF64

pub fn acos(self) -> UnguardedF64

Computes the arccosine of a number. Return value is in radians in the range [0, π], if the value is in the range [-1, 1].

See: f64::acos

Examples

use floatguard::GuardedF64;

let f = GuardedF64::FRAC_PI_4;

// acos(cos(pi/4))
let abs_difference = (f.cos().acos() - GuardedF64::FRAC_PI_4).abs().check().unwrap();

assert!(abs_difference < 1e-10);

impl UnguardedF64

pub fn cosh(self) -> UnguardedF64

Hyperbolic cosine function.

See: f64::cosh

Examples

use floatguard::UnguardedF64;

let e = UnguardedF64::E;
let x = UnguardedF64::new(1.0_f64);
let f = x.cosh();

// Solving cosh() at 1 gives this result
let g = ((e * e) + 1.0) / (2.0 * e);
let abs_difference = (f - g).abs().check().unwrap();

// Same result
assert!(abs_difference < 1e-10);

impl UnguardedF64

pub fn acosh(self) -> UnguardedF64

Inverse hyperbolic cosine function.

See: f64::acosh

Examples

use floatguard::UnguardedF64;

let x = UnguardedF64::new(1.0);
let f = x.cosh().acosh();

let abs_difference = (f - x).abs().check().unwrap();

assert!(abs_difference < 1.0e-10);

impl UnguardedF64

pub fn sin_cos(self) -> (UnguardedF64, UnguardedF64)

Simultaneously computes the sine and cosine of a number, x. Returns (sin(x), cos(x)).

See: f64::sin_cos

Examples

use floatguard::GuardedF64;

let x = GuardedF64::FRAC_PI_4;
let f = x.sin_cos();

let abs_difference_0 = (f.0 - x.sin()).abs().check().unwrap();
let abs_difference_1 = (f.1 - x.cos()).abs().check().unwrap();

assert!(abs_difference_0 < 1e-10);
assert!(abs_difference_1 < 1e-10);

impl UnguardedF64

pub fn tan(self) -> UnguardedF64

Computes the tangent of a number (in radians).

See: f64::tan

Examples

use floatguard::GuardedF64;

let x = GuardedF64::FRAC_PI_4;
let abs_difference = (x.tan() - 1.0).abs().check().unwrap();

assert!(abs_difference < 1e-14);

impl UnguardedF64

pub fn atan(self) -> UnguardedF64

Computes the arctangent of a number. Return value is in radians in the range [-π/2, π/2].

See: f64::atan

Examples

use floatguard::UnguardedF64;

let f = UnguardedF64::new(1.0);

// atan(tan(1))
let abs_difference = (f.tan().atan() - 1.0).abs().check().unwrap();

assert!(abs_difference < 1e-10)

impl UnguardedF64

pub fn tanh(self) -> UnguardedF64

Computes the hyperbolic tangent of a number.

See: f64::tanh

Examples

use floatguard::GuardedF64;

let x = GuardedF64::new(1.0_f64).unwrap();
let f = x.tanh();

// tanh(1) is approximately 0.7615941559557649
let abs_difference = (f - 0.7615941559557649).abs().check().unwrap();

assert!(abs_difference < 1e-10);

impl UnguardedF64

pub fn atanh(self) -> UnguardedF64

Computes the inverse hyperbolic tangent of a number. Return value is in the range (-∞, ∞) for inputs in the range (-1, 1).

See: f64::atanh

Examples

use floatguard::UnguardedF64;

let x = UnguardedF64::new(0.5_f64);
let f = x.tanh().atanh();

let abs_difference = (f - x).abs().check().unwrap();

assert!(abs_difference < 1e-10);

impl UnguardedF64

pub fn atan2(self, other: impl Into<UnguardedF64>) -> UnguardedF64

Computes the arctangent of self divided by other.

See: f64::atan2

Arguments

other - The GuardedF64 value to divide self by.

Returns

Returns a new GuardedF64 instance containing the result of the arctangent operation.

Examples

use floatguard::UnguardedF64;

let a = UnguardedF64::new(1.0);
let b = UnguardedF64::new(2.0);
assert_eq!(f64::try_from(a.atan2(b)), Ok(0.4636476090008061)); // atan2(1.0, 2.0)

let invalid = UnguardedF64::new(f64::NAN);
assert!(invalid.atan2(a).check().is_err());

impl UnguardedF64

pub const fn new(value: f64) -> Self

Creates a new UnguardedF64 instance.

Returns

Returns a new UnguardedF64 instance containing the provided f64 value.

Trait Implementations

impl Add<&GuardedF64> for &UnguardedF64

fn add(self, rhs: &GuardedF64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<&GuardedF64> for UnguardedF64

fn add(self, rhs: &GuardedF64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<&UnguardedF64> for &GuardedF64

fn add(self, rhs: &UnguardedF64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<&UnguardedF64> for &UnguardedF64

fn add(self, rhs: &UnguardedF64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<&UnguardedF64> for &f64

fn add(self, rhs: &UnguardedF64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<&UnguardedF64> for GuardedF64

fn add(self, rhs: &UnguardedF64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<&UnguardedF64> for UnguardedF64

fn add(self, rhs: &UnguardedF64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<&UnguardedF64> for f64

fn add(self, rhs: &UnguardedF64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<&f64> for &UnguardedF64

fn add(self, rhs: &f64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<&f64> for UnguardedF64

fn add(self, rhs: &f64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<GuardedF64> for &UnguardedF64

fn add(self, rhs: GuardedF64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<GuardedF64> for UnguardedF64

fn add(self, rhs: GuardedF64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<UnguardedF64> for &GuardedF64

fn add(self, rhs: UnguardedF64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<UnguardedF64> for &UnguardedF64

fn add(self, rhs: UnguardedF64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<UnguardedF64> for &f64

fn add(self, rhs: UnguardedF64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<UnguardedF64> for GuardedF64

fn add(self, rhs: UnguardedF64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<UnguardedF64> for f64

fn add(self, rhs: UnguardedF64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<f64> for &UnguardedF64

fn add(self, rhs: f64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add<f64> for UnguardedF64

fn add(self, rhs: f64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl Add for UnguardedF64

fn add(self, rhs: UnguardedF64) -> Self::Output

Adds two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);
    
assert_eq!((value1 + f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the + operator.

impl<T> AddAssign<T> for UnguardedF64

where T: Into<Self>,

fn add_assign(&mut self, rhs: T)

Assigns the result of adding another UnguardedF64 to this one.

Example

use floatguard::{GuardedF64, UnguardedF64};

let mut a = UnguardedF64::from(1.0);
let b = UnguardedF64::from(2.0);
a += b;
assert_eq!(a.check(), GuardedF64::new(3.0));

use floatguard::{GuardedF64, UnguardedF64};

let mut a = UnguardedF64::from(1.0);
let b = 2.0;
a += b;
assert_eq!(a.check(), GuardedF64::new(3.0));

use floatguard::{GuardedF64, UnguardedF64};

let mut a = UnguardedF64::from(1.0);
let b = GuardedF64::new(2.0).unwrap();
a += b;
assert_eq!(a.check(), GuardedF64::new(3.0));

impl Clone for UnguardedF64

fn clone(&self) -> UnguardedF64

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UnguardedF64

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

Formats the value using the given formatter.

impl Default for UnguardedF64

fn default() -> UnguardedF64

Returns the “default value” for a type.

impl Display for UnguardedF64

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

Formats the GuardedF64 as a string.

Returns

Returns a string representation of the inner f64 value.

Example

use floatguard::GuardedF64;

let value = GuardedF64::new(2.0).unwrap();
assert_eq!(value.to_string(), "2");

impl Div<&GuardedF64> for &UnguardedF64

fn div(self, rhs: &GuardedF64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<&GuardedF64> for UnguardedF64

fn div(self, rhs: &GuardedF64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<&UnguardedF64> for &GuardedF64

fn div(self, rhs: &UnguardedF64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<&UnguardedF64> for &UnguardedF64

fn div(self, rhs: &UnguardedF64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<&UnguardedF64> for &f64

fn div(self, rhs: &UnguardedF64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<&UnguardedF64> for GuardedF64

fn div(self, rhs: &UnguardedF64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<&UnguardedF64> for UnguardedF64

fn div(self, rhs: &UnguardedF64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<&UnguardedF64> for f64

fn div(self, rhs: &UnguardedF64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<&f64> for &UnguardedF64

fn div(self, rhs: &f64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<&f64> for UnguardedF64

fn div(self, rhs: &f64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<GuardedF64> for &UnguardedF64

fn div(self, rhs: GuardedF64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<GuardedF64> for UnguardedF64

fn div(self, rhs: GuardedF64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<UnguardedF64> for &GuardedF64

fn div(self, rhs: UnguardedF64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<UnguardedF64> for &UnguardedF64

fn div(self, rhs: UnguardedF64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<UnguardedF64> for &f64

fn div(self, rhs: UnguardedF64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<UnguardedF64> for GuardedF64

fn div(self, rhs: UnguardedF64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<UnguardedF64> for f64

fn div(self, rhs: UnguardedF64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<f64> for &UnguardedF64

fn div(self, rhs: f64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div<f64> for UnguardedF64

fn div(self, rhs: f64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl Div for UnguardedF64

fn div(self, rhs: UnguardedF64) -> Self::Output

Divides one GuardedF64 value by another or a f64 by a GuardedF64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(6.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 / value2), Ok(2.0));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 / f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN / value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the / operator.

impl<T> DivAssign<T> for UnguardedF64

where T: Into<Self>,

fn div_assign(&mut self, rhs: T)

Assigns the result of dividing this UnguardedF64 by another.

Example

use floatguard::{GuardedF64, UnguardedF64};

let mut a = UnguardedF64::from(6.0);
let b = UnguardedF64::from(3.0);
a /= b;
assert_eq!(a.check(), GuardedF64::new(2.0));

use floatguard::{GuardedF64, UnguardedF64};

let mut a = UnguardedF64::from(6.0);
let b = 3.0;
a /= b;
assert_eq!(a.check(), GuardedF64::new(2.0));

use floatguard::{GuardedF64, UnguardedF64};

let mut a = UnguardedF64::from(6.0);
let b = GuardedF64::new(3.0).unwrap();
a /= b;
assert_eq!(a.check(), GuardedF64::new(2.0));

impl From<GuardedF64> for UnguardedF64

fn from(value: GuardedF64) -> Self

Converts a GuardedF64 into an UnguardedF64.

Returns

Returns a new UnguardedF64 instance containing the inner f64 value.

Example

use floatguard::{UnguardedF64, GuardedF64};

let checked_f64 = GuardedF64::new(3.14).unwrap();
let unchecked_f64 = UnguardedF64::from(checked_f64);
assert_eq!(unchecked_f64.check(), GuardedF64::new(3.14));

impl From<f64> for UnguardedF64

fn from(value: f64) -> Self

Converts an f64 into a GuardedF64.

Returns

Returns a GuardedF64 if the value is valid (finite), otherwise returns an error.

Example

use floatguard::{UnguardedF64, GuardedF64, FloatError};

assert_eq!(UnguardedF64::from(3.14).check(), GuardedF64::new(3.14));

assert_eq!(UnguardedF64::from(f64::NAN).check(), Err(FloatError::NaN));

impl Mul<&GuardedF64> for &UnguardedF64

fn mul(self, rhs: &GuardedF64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<&GuardedF64> for UnguardedF64

fn mul(self, rhs: &GuardedF64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<&UnguardedF64> for &GuardedF64

fn mul(self, rhs: &UnguardedF64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<&UnguardedF64> for &UnguardedF64

fn mul(self, rhs: &UnguardedF64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<&UnguardedF64> for &f64

fn mul(self, rhs: &UnguardedF64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<&UnguardedF64> for GuardedF64

fn mul(self, rhs: &UnguardedF64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<&UnguardedF64> for UnguardedF64

fn mul(self, rhs: &UnguardedF64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<&UnguardedF64> for f64

fn mul(self, rhs: &UnguardedF64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<&f64> for &UnguardedF64

fn mul(self, rhs: &f64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<&f64> for UnguardedF64

fn mul(self, rhs: &f64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<GuardedF64> for &UnguardedF64

fn mul(self, rhs: GuardedF64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<GuardedF64> for UnguardedF64

fn mul(self, rhs: GuardedF64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<UnguardedF64> for &GuardedF64

fn mul(self, rhs: UnguardedF64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<UnguardedF64> for &UnguardedF64

fn mul(self, rhs: UnguardedF64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<UnguardedF64> for &f64

fn mul(self, rhs: UnguardedF64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<UnguardedF64> for GuardedF64

fn mul(self, rhs: UnguardedF64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<UnguardedF64> for f64

fn mul(self, rhs: UnguardedF64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<f64> for &UnguardedF64

fn mul(self, rhs: f64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul<f64> for UnguardedF64

fn mul(self, rhs: f64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl Mul for UnguardedF64

fn mul(self, rhs: UnguardedF64) -> Self::Output

Multiplies two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(2.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 * value2), Ok(6.0));
    
assert_eq!((value1 * f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the * operator.

impl<T> MulAssign<T> for UnguardedF64

where T: Into<Self>,

fn mul_assign(&mut self, rhs: T)

Assigns the result of multiplying this UnguardedF64 by another.

Example

use floatguard::{GuardedF64, UnguardedF64};

let mut a = UnguardedF64::from(2.0);
let b = UnguardedF64::from(3.0);
a *= b;
assert_eq!(a.check(), GuardedF64::new(6.0));

use floatguard::{GuardedF64, UnguardedF64};

let mut a = UnguardedF64::from(2.0);
let b = 3.0;
a *= b;
assert_eq!(a.check(), GuardedF64::new(6.0));

use floatguard::{GuardedF64, UnguardedF64};

let mut a = UnguardedF64::from(2.0);
let b = GuardedF64::new(3.0).unwrap();
a *= b;
assert_eq!(a.check(), GuardedF64::new(6.0));

impl Neg for &UnguardedF64

fn neg(self) -> Self::Output

Negates the GuardedF64 or UnguardedF64 value.

Returns

Returns a new Self instance with the negated value. Unlike other operations, this does not default to creating an UnguardedF64 for GuardedF64, as -x is always valid for finite and non-NaN values.

Example

use floatguard::{GuardedF64, FloatError, UnguardedF64};
    
let value = GuardedF64::new(2.0).unwrap();
assert_eq!(-value, -2.0);
    
let value = UnguardedF64::new(2.0);
assert_eq!(f64::try_from(-value), Ok(-2.0));
    
let invalid_value = UnguardedF64::new(f64::NAN);
assert_eq!((-invalid_value).check(), Err(FloatError::NaN));
    
let infinity_value = UnguardedF64::new(f64::INFINITY);
assert_eq!((-infinity_value).check(), Err(FloatError::Infinity));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Neg for UnguardedF64

fn neg(self) -> Self::Output

Negates the GuardedF64 or UnguardedF64 value.

Returns

Returns a new Self instance with the negated value. Unlike other operations, this does not default to creating an UnguardedF64 for GuardedF64, as -x is always valid for finite and non-NaN values.

Example

use floatguard::{GuardedF64, FloatError, UnguardedF64};
    
let value = GuardedF64::new(2.0).unwrap();
assert_eq!(-value, -2.0);
    
let value = UnguardedF64::new(2.0);
assert_eq!(f64::try_from(-value), Ok(-2.0));
    
let invalid_value = UnguardedF64::new(f64::NAN);
assert_eq!((-invalid_value).check(), Err(FloatError::NaN));
    
let infinity_value = UnguardedF64::new(f64::INFINITY);
assert_eq!((-infinity_value).check(), Err(FloatError::Infinity));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Rem<&GuardedF64> for &UnguardedF64

fn rem(self, rhs: &GuardedF64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<&GuardedF64> for UnguardedF64

fn rem(self, rhs: &GuardedF64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<&UnguardedF64> for &GuardedF64

fn rem(self, rhs: &UnguardedF64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<&UnguardedF64> for &UnguardedF64

fn rem(self, rhs: &UnguardedF64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<&UnguardedF64> for &f64

fn rem(self, rhs: &UnguardedF64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<&UnguardedF64> for GuardedF64

fn rem(self, rhs: &UnguardedF64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<&UnguardedF64> for UnguardedF64

fn rem(self, rhs: &UnguardedF64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<&UnguardedF64> for f64

fn rem(self, rhs: &UnguardedF64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<&f64> for &UnguardedF64

fn rem(self, rhs: &f64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<&f64> for UnguardedF64

fn rem(self, rhs: &f64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<GuardedF64> for &UnguardedF64

fn rem(self, rhs: GuardedF64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<GuardedF64> for UnguardedF64

fn rem(self, rhs: GuardedF64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<UnguardedF64> for &GuardedF64

fn rem(self, rhs: UnguardedF64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<UnguardedF64> for &UnguardedF64

fn rem(self, rhs: UnguardedF64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<UnguardedF64> for &f64

fn rem(self, rhs: UnguardedF64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<UnguardedF64> for GuardedF64

fn rem(self, rhs: UnguardedF64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<UnguardedF64> for f64

fn rem(self, rhs: UnguardedF64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<f64> for &UnguardedF64

fn rem(self, rhs: f64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem<f64> for UnguardedF64

fn rem(self, rhs: f64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl Rem for UnguardedF64

fn rem(self, rhs: UnguardedF64) -> Self::Output

Computes the remainder of division between two GuardedF64 values or a GuardedF64 and a f64.

Example

use floatguard::{GuardedF64, UnguardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 % value2), Ok(2.0));
    
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((value1 % f64::NAN).check(), Err(FloatError::NaN));
assert_eq!((f64::NAN % value1).check(), Err(FloatError::NaN));
    
let value1 = UnguardedF64::new(6.0);
assert_eq!((f64::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f64::INFINITY).check(), Err(FloatError::Infinity));
    
let value1 = UnguardedF64::new(f64::INFINITY);
let value2 = UnguardedF64::new(f64::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the % operator.

impl<T> RemAssign<T> for UnguardedF64

where T: Into<Self>,

fn rem_assign(&mut self, rhs: T)

Assigns the result of taking the remainder of this UnguardedF64 divided by another.

Example

use floatguard::{GuardedF64, UnguardedF64};

let mut a = UnguardedF64::from(5.0);
let b = UnguardedF64::from(2.0);
a %= b;
assert_eq!(a.check(), GuardedF64::new(1.0));

use floatguard::{GuardedF64, UnguardedF64};

let mut a = UnguardedF64::from(5.0);
let b = 2.0;
a %= b;
assert_eq!(a.check(), GuardedF64::new(1.0));

use floatguard::{GuardedF64, UnguardedF64};

let mut a = UnguardedF64::from(5.0);
let b = GuardedF64::new(2.0).unwrap();
a %= b;
assert_eq!(a.check(), GuardedF64::new(1.0));

impl Sub<&GuardedF64> for &UnguardedF64

fn sub(self, rhs: &GuardedF64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<&GuardedF64> for UnguardedF64

fn sub(self, rhs: &GuardedF64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<&UnguardedF64> for &GuardedF64

fn sub(self, rhs: &UnguardedF64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<&UnguardedF64> for &UnguardedF64

fn sub(self, rhs: &UnguardedF64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<&UnguardedF64> for &f64

fn sub(self, rhs: &UnguardedF64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<&UnguardedF64> for GuardedF64

fn sub(self, rhs: &UnguardedF64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<&UnguardedF64> for UnguardedF64

fn sub(self, rhs: &UnguardedF64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<&UnguardedF64> for f64

fn sub(self, rhs: &UnguardedF64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<&f64> for &UnguardedF64

fn sub(self, rhs: &f64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<&f64> for UnguardedF64

fn sub(self, rhs: &f64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<GuardedF64> for &UnguardedF64

fn sub(self, rhs: GuardedF64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<GuardedF64> for UnguardedF64

fn sub(self, rhs: GuardedF64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<UnguardedF64> for &GuardedF64

fn sub(self, rhs: UnguardedF64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<UnguardedF64> for &UnguardedF64

fn sub(self, rhs: UnguardedF64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<UnguardedF64> for &f64

fn sub(self, rhs: UnguardedF64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<UnguardedF64> for GuardedF64

fn sub(self, rhs: UnguardedF64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<UnguardedF64> for f64

fn sub(self, rhs: UnguardedF64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<f64> for &UnguardedF64

fn sub(self, rhs: f64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub<f64> for UnguardedF64

fn sub(self, rhs: f64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl Sub for UnguardedF64

fn sub(self, rhs: UnguardedF64) -> Self::Output

Subtracts one GuardedF64 value from another or a f64 from a GuardedF64.

Example

use floatguard::{GuardedF64, FloatError};
    
let value1 = GuardedF64::new(5.0).unwrap();
let value2 = GuardedF64::new(3.0).unwrap();
assert_eq!(f64::try_from(value1 - value2), Ok(2.0));
    
assert_eq!((value1 - f64::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF64

The resulting type after applying the - operator.

impl<T> SubAssign<T> for UnguardedF64

where T: Into<Self>,

fn sub_assign(&mut self, rhs: T)

Assigns the result of subtracting another UnguardedF64 from this one.

Example

use floatguard::{GuardedF64, UnguardedF64};

let mut a = UnguardedF64::from(3.0);
let b = UnguardedF64::from(2.0);
a -= b;
assert_eq!(a.check(), GuardedF64::new(1.0));

use floatguard::{GuardedF64, UnguardedF64};

let mut a = UnguardedF64::from(3.0);
let b = 2.0;
a -= b;
assert_eq!(a.check(), GuardedF64::new(1.0));

use floatguard::{GuardedF64, UnguardedF64};

let mut a = UnguardedF64::from(3.0);
let b = GuardedF64::new(2.0).unwrap();
a -= b;
assert_eq!(a.check(), GuardedF64::new(1.0));

impl TryFrom<UnguardedF64> for GuardedF64

fn try_from(value: UnguardedF64) -> Result<Self, Self::Error>

Converts an UnguardedF64 to GuardedF64.

Returns

Returns a GuardedF64 if the value is valid (finite), otherwise returns an error.

Errors

Returns FloatError if the value is NaN or infinite.

Example

use floatguard::{UnguardedF64, FloatError, GuardedF64};

let valid_value = UnguardedF64::new(2.0);
assert_eq!(valid_value.try_into(), GuardedF64::new(2.0));

let invalid_value = UnguardedF64::new(f64::NAN);
assert_eq!(GuardedF64::try_from(invalid_value), Err(FloatError::NaN));

let inf_value = UnguardedF64::new(f64::INFINITY);
assert_eq!(GuardedF64::try_from(inf_value), Err(FloatError::Infinity));

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<UnguardedF64> for f64

Implementing the ability to convert GuardedF64 to f64 safely.

This conversion will return an error if the value is NaN or infinite.

fn try_from(value: UnguardedF64) -> Result<Self, Self::Error>

Converts a GuardedF64 to f64.

Returns

Returns the inner f64 value if it is valid (finite), otherwise returns an error.

Errors

Returns FloatError if the value is NaN or infinite.

Example

use floatguard::{UnguardedF64, FloatError};

let valid_value = UnguardedF64::new(2.0);
assert_eq!(valid_value.try_into(), Ok(2.0));

let invalid_value = UnguardedF64::new(f64::NAN);
assert_eq!(f64::try_from(invalid_value), Err(FloatError::NaN));

let inf_value = UnguardedF64::new(f64::INFINITY);
assert_eq!(f64::try_from(inf_value), Err(FloatError::Infinity));

type Error = Error

The type returned in the event of a conversion error.

impl Copy for UnguardedF64