Struct GuardedF32 

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

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

Example

use floatguard::{GuardedF32, FloatError};

let checked_f32 = GuardedF32::new(1.0).expect("1.0 is a valid f32 value");
assert_eq!((checked_f32 + 1.0).check(), GuardedF32::new(2.0));

assert_eq!((checked_f32 / 0.0).check(), Err(FloatError::Infinity));

assert_eq!((checked_f32 - f32::INFINITY).check(), Err(FloatError::Infinity));

assert_eq!((checked_f32 % f32::NAN).check(), Err(FloatError::NaN));

Implementations

impl GuardedF32

pub const RADIX: u32 = 2u32

The radix or base of the internal representation of f32.

See: f32::RADIX

impl GuardedF32

pub const MANTISSA_DIGITS: u32 = 24u32

Number of significant digits in base 2.

See: f32::MANTISSA_DIGITS.

impl GuardedF32

pub const DIGITS: u32 = 6u32

Approximate number of significant digits in base 10.

See: f32::DIGITS.

impl GuardedF32

pub const EPSILON: GuardedF32

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

See: f32::EPSILON

impl GuardedF32

pub const MIN: GuardedF32

Smallest finite f32 value.

See: f32::MIN

impl GuardedF32

pub const MIN_POSITIVE: GuardedF32

Smallest positive normal f32 value.

See: f32::MIN_POSITIVE

impl GuardedF32

pub const MAX: GuardedF32

Largest finite f32 value.

See: f32::MAX

impl GuardedF32

pub const MIN_EXP: i32 = -125i32

Minimum possible normal power of 2 exponent.

See: f32::MIN_EXP

impl GuardedF32

pub const MAX_EXP: i32 = 128i32

Maximum possible normal power of 2 exponent.

See: f32::MAX_EXP

impl GuardedF32

pub const MIN_10_EXP: i32 = -37i32

Minimum possible normal power of 10 exponent.

See: f32::MIN_10_EXP

impl GuardedF32

pub const MAX_10_EXP: i32 = 38i32

Maximum possible normal power of 10 exponent.

See: f32::MAX_10_EXP

impl GuardedF32

pub const PI: GuardedF32

Archimedes’ constant (π)

See: std::f32::consts::PI

impl GuardedF32

pub const TAU: GuardedF32

The full circle constant (τ = 2π)

See: std::f32::consts::TAU

impl GuardedF32

pub const FRAC_PI_2: GuardedF32

π/2

See: std::f32::consts::FRAC_PI_2

impl GuardedF32

pub const FRAC_PI_3: GuardedF32

π/3

See: std::f32::consts::FRAC_PI_3

impl GuardedF32

pub const FRAC_PI_4: GuardedF32

π/4

See: std::f32::consts::FRAC_PI_4

impl GuardedF32

pub const FRAC_PI_6: GuardedF32

π/6

See: std::f32::consts::FRAC_PI_6

impl GuardedF32

pub const FRAC_PI_8: GuardedF32

π/8

See: std::f32::consts::FRAC_PI_8

impl GuardedF32

pub const FRAC_1_PI: GuardedF32

1/π

See: std::f32::consts::FRAC_1_PI

impl GuardedF32

pub const FRAC_2_PI: GuardedF32

2/π

See: std::f32::consts::FRAC_2_PI

impl GuardedF32

pub const FRAC_2_SQRT_PI: GuardedF32

1/√π

See: std::f32::consts::FRAC_2_SQRT_PI

impl GuardedF32

pub const SQRT_2: GuardedF32

√2

See: std::f32::consts::SQRT_2

impl GuardedF32

pub const FRAC_1_SQRT_2: GuardedF32

1/√2

See: std::f32::consts::FRAC_1_SQRT_2

impl GuardedF32

pub const E: GuardedF32

Euler’s number (e)

See: std::f32::consts::E

impl GuardedF32

pub const LOG2_E: GuardedF32

log₂(e)

See: std::f32::consts::LOG2_E

impl GuardedF32

pub const LOG2_10: GuardedF32

log₂(10)

See: std::f32::consts::LOG2_10

impl GuardedF32

pub const LOG10_2: GuardedF32

log₁₀(2)

See: std::f32::consts::LOG10_2

impl GuardedF32

pub const LOG10_E: GuardedF32

log₁₀(e)

See: std::f32::consts::LOG10_E

impl GuardedF32

pub const LN_2: GuardedF32

ln(2)

See: std::f32::consts::LN_2

impl GuardedF32

pub const LN_10: GuardedF32

ln(10)

See: std::f32::consts::LN_10

impl GuardedF32

pub const fn new(value: f32) -> Result<Self, FloatError>

Creates a new GuardedF32 instance.

Returns

Returns a new GuardedF32 instance containing the provided f32 value if it is valid (finite).

Errors

Returns FloatError if the value is NaN or infinite.

Example

use floatguard::{GuardedF32, FloatError};

let valid_value = GuardedF32::new(2.0).unwrap();
assert_eq!(valid_value, 2.0f32);

let invalid_value = GuardedF32::new(f32::NAN);
assert_eq!(invalid_value, Err(FloatError::NaN));

let inf_value = GuardedF32::new(f32::INFINITY);
assert_eq!(inf_value, Err(FloatError::Infinity));

impl GuardedF32

pub const fn abs(self) -> Self

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

See: f32::abs

Examples

use floatguard::{GuardedF32, UnguardedF32};

let checked = GuardedF32::new(3.5_f32).unwrap();
assert_eq!(checked.abs(), 3.5_f32);

let unchecked = UnguardedF32::new(-3.5_f32);
assert_eq!(unchecked.abs().check(), GuardedF32::new(3.5_f32));

impl GuardedF32

pub const fn signum(self) -> Self

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

See: f32::signum

Examples

use floatguard::{GuardedF32, UnguardedF32};

let pos = GuardedF32::new(3.5_f32).unwrap();
let neg = UnguardedF32::new(-3.5_f32);

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

impl GuardedF32

pub fn sqrt(self) -> UnguardedF32

Returns the square root of self.

See: f32::sqrt

Examples

use floatguard::{GuardedF32, FloatError, UnguardedF32};

let positive = GuardedF32::new(4.0_f32).unwrap();
let negative = GuardedF32::new(-4.0_f32).unwrap();
let negative_zero = UnguardedF32::new(-0.0_f32);

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

impl GuardedF32

pub const fn recip(self) -> UnguardedF32

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

See: f32::recip

Examples

use floatguard::{GuardedF32, UnguardedF32};

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

assert!(abs_difference < GuardedF32::EPSILON);

impl GuardedF32

pub fn exp(self) -> UnguardedF32

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

See: f32::exp

Examples

use floatguard::UnguardedF32;

let one = UnguardedF32::new(1.0_f32);

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

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

assert!(abs_difference < 1.0e-7);

impl GuardedF32

pub fn ln(self) -> UnguardedF32

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

See: f32::ln

Examples

use floatguard::UnguardedF32;

let e = UnguardedF32::new(2.718281828459045_f32);

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

assert!(abs_difference < 1.0e-7);

impl GuardedF32

pub fn log2(self) -> UnguardedF32

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

See: f32::log2

Examples

use floatguard::UnguardedF32;

let two = UnguardedF32::new(2.0_f32);
let abs_difference = (two.log2() - 1.0).abs().check().unwrap();
assert!(abs_difference < 1.0e-7);

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

impl GuardedF32

pub fn log10(self) -> UnguardedF32

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

See: f32::log10

Examples

use floatguard::UnguardedF32;

let ten = UnguardedF32::new(10.0_f32);
let abs_difference = (ten.log10() - 1.0).abs().check().unwrap();
assert!(abs_difference < 1.0e-7);

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

impl GuardedF32

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

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

See: f32::log

Arguments

base - The base of the logarithm.

Examples

use floatguard::UnguardedF32;

let two = UnguardedF32::new(2.0_f32);
let eight = UnguardedF32::new(8.0_f32);

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

assert!(abs_difference < 1.0e-7);

impl GuardedF32

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

Raises a number to an integer power.

See: f32::powi

Examples

use floatguard::{GuardedF32, UnguardedF32};

let x = UnguardedF32::new(2.0_f32);
let abs_difference = (x.powi(2) - (x * x)).abs().check().unwrap();
assert!(abs_difference <= GuardedF32::EPSILON);

assert!(UnguardedF32::new(f32::NAN).powi(2).check().is_err());

impl GuardedF32

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

Raises a number to a floating-point power.

See: f32::powf

Examples

use floatguard::{GuardedF32, UnguardedF32};

let x = UnguardedF32::new(2.0_f32);
let cubed = UnguardedF32::new(3.0);
let abs_difference = (x.powf(cubed) - (x * x * x)).abs().check().unwrap();
assert!(abs_difference <= GuardedF32::EPSILON);

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

impl GuardedF32

pub fn sin(self) -> UnguardedF32

Computes the sine of a number (in radians).

See: f32::sin

Examples

use floatguard::GuardedF32;

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

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

assert!(abs_difference < 1.0e-7);

impl GuardedF32

pub fn asin(self) -> UnguardedF32

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: f32::asin

Examples

use floatguard::GuardedF32;

let f = GuardedF32::FRAC_PI_2;

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

assert!(abs_difference < 1.0e-7);

impl GuardedF32

pub fn sinh(self) -> UnguardedF32

Hyperbolic sine function.

See: f32::sinh

Examples

use floatguard::GuardedF32;

let e = GuardedF32::E;
let x = 1.0_f32;

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 < 1.0e-7);

impl GuardedF32

pub fn asinh(self) -> UnguardedF32

Inverse hyperbolic sine function.

See: f32::asinh

Examples

use floatguard::UnguardedF32;

let x = UnguardedF32::new(1.0_f32);
let f = x.sinh().asinh();

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

assert!(abs_difference < 1.0e-7);

impl GuardedF32

pub fn cos(self) -> UnguardedF32

Computes the cosine of a number (in radians).

See: f32::cos

Examples

use floatguard::GuardedF32;

let x = 2.0 * GuardedF32::PI;

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

assert!(abs_difference < 1.0e-7);

impl GuardedF32

pub fn acos(self) -> UnguardedF32

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: f32::acos

Examples

use floatguard::GuardedF32;

let f = GuardedF32::FRAC_PI_4;

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

assert!(abs_difference < 1.0e-7);

impl GuardedF32

pub fn cosh(self) -> UnguardedF32

Hyperbolic cosine function.

See: f32::cosh

Examples

use floatguard::UnguardedF32;

let e = UnguardedF32::E;
let x = UnguardedF32::new(1.0_f32);
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 < 1.0e-6);

impl GuardedF32

pub fn acosh(self) -> UnguardedF32

Inverse hyperbolic cosine function.

See: f32::acosh

Examples

use floatguard::UnguardedF32;

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

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

assert!(abs_difference < 1.0e-10);

impl GuardedF32

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

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

See: f32::sin_cos

Examples

use floatguard::GuardedF32;

let x = GuardedF32::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 < 1.0e-7);
assert!(abs_difference_1 < 1.0e-7);

impl GuardedF32

pub fn tan(self) -> UnguardedF32

Computes the tangent of a number (in radians).

See: f32::tan

Examples

use floatguard::GuardedF32;

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

assert!(abs_difference < 1e-14);

impl GuardedF32

pub fn atan(self) -> UnguardedF32

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

See: f32::atan

Examples

use floatguard::UnguardedF32;

let f = UnguardedF32::new(1.0);

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

assert!(abs_difference < 1.0e-7)

impl GuardedF32

pub fn tanh(self) -> UnguardedF32

Computes the hyperbolic tangent of a number.

See: f32::tanh

Examples

use floatguard::GuardedF32;

let x = GuardedF32::new(1.0_f32).unwrap();
let f = x.tanh();

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

assert!(abs_difference < 1.0e-7);

impl GuardedF32

pub fn atanh(self) -> UnguardedF32

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

See: f32::atanh

Examples

use floatguard::UnguardedF32;

let x = UnguardedF32::new(0.5_f32);
let f = x.tanh().atanh();

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

assert!(abs_difference < 1.0e-7);

impl GuardedF32

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

Computes the arctangent of self divided by other.

See: f32::atan2

Arguments

other - The GuardedF32 value to divide self by.

Returns

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

Examples

use floatguard::UnguardedF32;

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

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

Methods from Deref<Target = f32>

pub const RADIX: u32 = 2u32

pub const MANTISSA_DIGITS: u32 = 24u32

pub const DIGITS: u32 = 6u32

pub const EPSILON: f32 = 1.1920929E-7f32

pub const MIN: f32 = -3.40282347E+38f32

pub const MIN_POSITIVE: f32 = 1.17549435E-38f32

pub const MAX: f32 = 3.40282347E+38f32

pub const MIN_EXP: i32 = -125i32

pub const MAX_EXP: i32 = 128i32

pub const MIN_10_EXP: i32 = -37i32

pub const MAX_10_EXP: i32 = 38i32

pub const NAN: f32 = NaN_f32

pub const INFINITY: f32 = +Inf_f32

pub const NEG_INFINITY: f32 = -Inf_f32

pub fn total_cmp(&self, other: &f32) -> Ordering

Returns the ordering between self and other.

Unlike the standard partial comparison between floating point numbers, this comparison always produces an ordering in accordance to the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard. The values are ordered in the following sequence:

• negative quiet NaN
• negative signaling NaN
• negative infinity
• negative numbers
• negative subnormal numbers
• negative zero
• positive zero
• positive subnormal numbers
• positive numbers
• positive infinity
• positive signaling NaN
• positive quiet NaN.

The ordering established by this function does not always agree with the PartialOrd and PartialEq implementations of f32. For example, they consider negative and positive zero equal, while total_cmp doesn’t.

The interpretation of the signaling NaN bit follows the definition in the IEEE 754 standard, which may not match the interpretation by some of the older, non-conformant (e.g. MIPS) hardware implementations.

Example

struct GoodBoy {
    name: String,
    weight: f32,
}

let mut bois = vec![
    GoodBoy { name: "Pucci".to_owned(), weight: 0.1 },
    GoodBoy { name: "Woofer".to_owned(), weight: 99.0 },
    GoodBoy { name: "Yapper".to_owned(), weight: 10.0 },
    GoodBoy { name: "Chonk".to_owned(), weight: f32::INFINITY },
    GoodBoy { name: "Abs. Unit".to_owned(), weight: f32::NAN },
    GoodBoy { name: "Floaty".to_owned(), weight: -5.0 },
];

bois.sort_by(|a, b| a.weight.total_cmp(&b.weight));

// `f32::NAN` could be positive or negative, which will affect the sort order.
if f32::NAN.is_sign_negative() {
    assert!(bois.into_iter().map(|b| b.weight)
        .zip([f32::NAN, -5.0, 0.1, 10.0, 99.0, f32::INFINITY].iter())
        .all(|(a, b)| a.to_bits() == b.to_bits()))
} else {
    assert!(bois.into_iter().map(|b| b.weight)
        .zip([-5.0, 0.1, 10.0, 99.0, f32::INFINITY, f32::NAN].iter())
        .all(|(a, b)| a.to_bits() == b.to_bits()))
}

Trait Implementations

impl Add<&GuardedF32> for &GuardedF32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<&GuardedF32> for &UnguardedF32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<&GuardedF32> for &f32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<&GuardedF32> for GuardedF32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<&GuardedF32> for UnguardedF32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<&GuardedF32> for f32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<&UnguardedF32> for &GuardedF32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<&UnguardedF32> for GuardedF32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<&f32> for &GuardedF32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<&f32> for GuardedF32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<GuardedF32> for &GuardedF32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<GuardedF32> for &UnguardedF32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<GuardedF32> for &f32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<GuardedF32> for UnguardedF32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<GuardedF32> for f32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<UnguardedF32> for &GuardedF32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<UnguardedF32> for GuardedF32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<f32> for &GuardedF32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add<f32> for GuardedF32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Add for GuardedF32

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

Adds two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!((value1 + value2).check().unwrap(), 5.0);

assert_eq!((value1 + f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the + operator.

impl Clone for GuardedF32

fn clone(&self) -> GuardedF32

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GuardedF32

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

Formats the value using the given formatter.

impl Default for GuardedF32

fn default() -> GuardedF32

Returns the “default value” for a type.

impl Deref for GuardedF32

fn deref(&self) -> &Self::Target

Dereferences GuardedF32 to its inner f32 value.

Returns

Returns a reference to the inner f32 value.

Example

use floatguard::GuardedF32;

let value = GuardedF32::new(2.0).unwrap();
assert_eq!(*value, 2.0);

type Target = f32

The resulting type after dereferencing.

impl Display for GuardedF32

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

Formats the GuardedF32 as a string.

Returns

Returns a string representation of the inner f32 value.

Example

use floatguard::GuardedF32;

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

impl Div<&GuardedF32> for &GuardedF32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<&GuardedF32> for &UnguardedF32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<&GuardedF32> for &f32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<&GuardedF32> for GuardedF32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<&GuardedF32> for UnguardedF32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<&GuardedF32> for f32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<&UnguardedF32> for &GuardedF32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<&UnguardedF32> for GuardedF32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<&f32> for &GuardedF32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<&f32> for GuardedF32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<GuardedF32> for &GuardedF32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<GuardedF32> for &UnguardedF32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<GuardedF32> for &f32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<GuardedF32> for UnguardedF32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<GuardedF32> for f32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<UnguardedF32> for &GuardedF32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<UnguardedF32> for GuardedF32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<f32> for &GuardedF32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div<f32> for GuardedF32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl Div for GuardedF32

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

Divides one GuardedF32 value by another or a f32 by a GuardedF32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(6.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 / value2), Ok(2.0));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / 0.0).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 / f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN / value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY / value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 / f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 / value2).check(), Err(FloatError::NaN));
assert_eq!((value2 / value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the / operator.

impl From<GuardedF32> for UnguardedF32

fn from(value: GuardedF32) -> Self

Converts a GuardedF32 into an UnguardedF32.

Returns

Returns a new UnguardedF32 instance containing the inner f32 value.

Example

use floatguard::{UnguardedF32, GuardedF32};

let checked_f32 = GuardedF32::new(3.14).unwrap();
let unchecked_f32 = UnguardedF32::from(checked_f32);
assert_eq!(unchecked_f32.check(), GuardedF32::new(3.14));

impl From<GuardedF32> for f32

Implementing the ability to convert GuardedF32 to f32 safely.

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

fn from(value: GuardedF32) -> Self

Converts a GuardedF32 to f32.

Returns

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

Errors

Returns FloatError if the value is NaN or infinite.

Example

use floatguard::{GuardedF32, FloatError};

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

let invalid_value = GuardedF32::try_from(f32::NAN);
assert_eq!(invalid_value, Err(FloatError::NaN));

let inf_value = GuardedF32::try_from(f32::INFINITY);
assert_eq!(inf_value, Err(FloatError::Infinity));

impl Mul<&GuardedF32> for &GuardedF32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<&GuardedF32> for &UnguardedF32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<&GuardedF32> for &f32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<&GuardedF32> for GuardedF32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<&GuardedF32> for UnguardedF32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<&GuardedF32> for f32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<&UnguardedF32> for &GuardedF32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<&UnguardedF32> for GuardedF32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<&f32> for &GuardedF32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<&f32> for GuardedF32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<GuardedF32> for &GuardedF32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<GuardedF32> for &UnguardedF32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<GuardedF32> for &f32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<GuardedF32> for UnguardedF32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<GuardedF32> for f32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<UnguardedF32> for &GuardedF32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<UnguardedF32> for GuardedF32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<f32> for &GuardedF32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul<f32> for GuardedF32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Mul for GuardedF32

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

Multiplies two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(2.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 * value2), Ok(6.0));

assert_eq!((value1 * f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the * operator.

impl Neg for &GuardedF32

fn neg(self) -> Self::Output

Negates the GuardedF32 or UnguardedF32 value.

Returns

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

Example

use floatguard::{GuardedF32, FloatError, UnguardedF32};

let value = GuardedF32::new(2.0).unwrap();
assert_eq!(-value, -2.0);

let value = UnguardedF32::new(2.0);
assert_eq!(f32::try_from(-value), Ok(-2.0));

let invalid_value = UnguardedF32::new(f32::NAN);
assert_eq!((-invalid_value).check(), Err(FloatError::NaN));

let infinity_value = UnguardedF32::new(f32::INFINITY);
assert_eq!((-infinity_value).check(), Err(FloatError::Infinity));

type Output = GuardedF32

The resulting type after applying the - operator.

impl Neg for GuardedF32

fn neg(self) -> Self::Output

Negates the GuardedF32 or UnguardedF32 value.

Returns

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

Example

use floatguard::{GuardedF32, FloatError, UnguardedF32};

let value = GuardedF32::new(2.0).unwrap();
assert_eq!(-value, -2.0);

let value = UnguardedF32::new(2.0);
assert_eq!(f32::try_from(-value), Ok(-2.0));

let invalid_value = UnguardedF32::new(f32::NAN);
assert_eq!((-invalid_value).check(), Err(FloatError::NaN));

let infinity_value = UnguardedF32::new(f32::INFINITY);
assert_eq!((-infinity_value).check(), Err(FloatError::Infinity));

type Output = GuardedF32

The resulting type after applying the - operator.

impl Ord for GuardedF32

fn cmp(&self, other: &Self) -> Ordering

Compares two GuardedF32 values.

Returns

Returns Ordering if both values are valid (finite), otherwise panics.

Example

use floatguard::GuardedF32;

let a = GuardedF32::new(2.0).unwrap();
let b = GuardedF32::new(3.0).unwrap();
assert_eq!(a.cmp(&b), std::cmp::Ordering::Less);
assert_eq!(b.cmp(&a), std::cmp::Ordering::Greater);
assert_eq!(a.cmp(&a), std::cmp::Ordering::Equal);

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq<GuardedF32> for f32

fn eq(&self, other: &GuardedF32) -> bool

Compares f32 with GuardedF32 for equality.

Returns

Returns true if f32 is finite and equal to GuardedF32, otherwise returns false.

Example

use floatguard::GuardedF32;

let a = 2.0;
let b = GuardedF32::new(2.0).unwrap();
assert_eq!(a, b);

let a_invalid = f32::NAN;
let b_invalid = GuardedF32::new(2.0).unwrap();
assert_ne!(a_invalid, b_invalid);

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<f32> for GuardedF32

fn eq(&self, other: &f32) -> bool

Compares GuardedF32 with f32 for equality.

Returns

Returns true if GuardedF32 is valid (finite) and equal to f32, otherwise returns false.

Example

use floatguard::GuardedF32;

let a = GuardedF32::new(2.0).unwrap();
let b = 2.0;
assert_eq!(a, b);

let invalid = f32::NAN;
assert_ne!(a, invalid);

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for GuardedF32

fn eq(&self, other: &Self) -> bool

Compares two GuardedF32 values for equality.

Returns

Returns true if both values are valid (finite) and equal, otherwise returns false.

Example

use floatguard::GuardedF32;

let a = GuardedF32::new(2.0).unwrap();
let b = GuardedF32::new(2.0).unwrap();
assert_eq!(a, b);

let a_invalid = GuardedF32::new(2.0);
let b_invalid = GuardedF32::new(f32::NAN);
assert_ne!(a_invalid, b_invalid);

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<GuardedF32> for f32

fn partial_cmp(&self, other: &GuardedF32) -> Option<Ordering>

Compares f32 with GuardedF32.

Returns

Returns Some(Ordering) if both values are finite, otherwise returns None.

Example

use floatguard::GuardedF32;
use std::cmp::Ordering;

let a = GuardedF32::new(2.0).unwrap();
let b = 3.0;
assert_eq!(a > b, false);
assert_eq!(a >= b, false);
assert_eq!(a < b, true);
assert_eq!(a <= b, true);

assert_eq!(f32::NAN.partial_cmp(&b), None);

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<f32> for GuardedF32

fn partial_cmp(&self, other: &f32) -> Option<Ordering>

Compares GuardedF32 with f32.

Returns

Returns Some(Ordering) if both values are valid (finite), otherwise returns None.

Example

use floatguard::GuardedF32;

let a = GuardedF32::new(2.0).unwrap();
let b = 3.0;
assert_eq!(a < b, true);
assert_eq!(a <= b, true);
assert_eq!(a > b, false);
assert_eq!(a >= b, false);

let b_invalid = f32::NAN;
assert_eq!(a.partial_cmp(&b_invalid), None);

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd for GuardedF32

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

Compares two GuardedF32 values.

Returns

Returns Some(Ordering) if both values are valid (finite), otherwise returns None.

Example

use floatguard::GuardedF32;

let a = GuardedF32::new(2.0).unwrap();
let b = GuardedF32::new(3.0).unwrap();
assert_eq!(a < b, true);
assert_eq!(a <= b, true);
assert_eq!(a > b, false);
assert_eq!(a >= b, false);

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Rem<&GuardedF32> for &GuardedF32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<&GuardedF32> for &UnguardedF32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<&GuardedF32> for &f32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<&GuardedF32> for GuardedF32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<&GuardedF32> for UnguardedF32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<&GuardedF32> for f32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<&UnguardedF32> for &GuardedF32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<&UnguardedF32> for GuardedF32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<&f32> for &GuardedF32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<&f32> for GuardedF32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<GuardedF32> for &GuardedF32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<GuardedF32> for &UnguardedF32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<GuardedF32> for &f32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<GuardedF32> for UnguardedF32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<GuardedF32> for f32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<UnguardedF32> for &GuardedF32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<UnguardedF32> for GuardedF32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<f32> for &GuardedF32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem<f32> for GuardedF32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Rem for GuardedF32

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

Computes the remainder of division between two GuardedF32 values or a GuardedF32 and a f32.

Example

use floatguard::{GuardedF32, UnguardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 % value2), Ok(2.0));

assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % 0.0).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((value1 % f32::NAN).check(), Err(FloatError::NaN));
assert_eq!((f32::NAN % value1).check(), Err(FloatError::NaN));

let value1 = UnguardedF32::new(6.0);
assert_eq!((f32::INFINITY % value1).check(), Err(FloatError::Infinity));
assert_eq!((value1 % f32::INFINITY).check(), Err(FloatError::Infinity));

let value1 = UnguardedF32::new(f32::INFINITY);
let value2 = UnguardedF32::new(f32::NAN);
assert_eq!((value1 % value2).check(), Err(FloatError::NaN));
assert_eq!((value2 % value1).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the % operator.

impl Sub<&GuardedF32> for &GuardedF32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<&GuardedF32> for &UnguardedF32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<&GuardedF32> for &f32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<&GuardedF32> for GuardedF32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<&GuardedF32> for UnguardedF32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<&GuardedF32> for f32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<&UnguardedF32> for &GuardedF32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<&UnguardedF32> for GuardedF32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<&f32> for &GuardedF32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<&f32> for GuardedF32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<GuardedF32> for &GuardedF32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<GuardedF32> for &UnguardedF32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<GuardedF32> for &f32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<GuardedF32> for UnguardedF32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<GuardedF32> for f32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<UnguardedF32> for &GuardedF32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<UnguardedF32> for GuardedF32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<f32> for &GuardedF32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub<f32> for GuardedF32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl Sub for GuardedF32

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

Subtracts one GuardedF32 value from another or a f32 from a GuardedF32.

Example

use floatguard::{GuardedF32, FloatError};

let value1 = GuardedF32::new(5.0).unwrap();
let value2 = GuardedF32::new(3.0).unwrap();
assert_eq!(f32::try_from(value1 - value2), Ok(2.0));

assert_eq!((value1 - f32::NAN).check(), Err(FloatError::NaN));

type Output = UnguardedF32

The resulting type after applying the - operator.

impl TryFrom<UnguardedF32> for GuardedF32

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

Converts an UnguardedF32 to GuardedF32.

Returns

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

Errors

Returns FloatError if the value is NaN or infinite.

Example

use floatguard::{UnguardedF32, FloatError, GuardedF32};

let valid_value = UnguardedF32::new(2.0);
assert_eq!(valid_value.try_into(), GuardedF32::new(2.0));

let invalid_value = UnguardedF32::new(f32::NAN);
assert_eq!(GuardedF32::try_from(invalid_value), Err(FloatError::NaN));

let inf_value = UnguardedF32::new(f32::INFINITY);
assert_eq!(GuardedF32::try_from(inf_value), Err(FloatError::Infinity));

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<f32> for GuardedF32

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

Converts a f32 to GuardedF32.

Returns

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

Errors

Returns FloatError if the value is NaN or infinite.

Example

use floatguard::{GuardedF32, FloatError};

let valid_value = GuardedF32::new(2.0);
assert!(valid_value.is_ok());

let invalid_value = GuardedF32::new(f32::NAN);
assert!(invalid_value.is_err());

let inf_value = GuardedF32::new(f32::INFINITY);
assert!(inf_value.is_err());

type Error = Error

The type returned in the event of a conversion error.

impl Copy for GuardedF32

impl Eq for GuardedF32