Struct NonNegativeF32 

pub struct NonNegativeF32 { /* private fields */ }

A 32-bit floating-point number representing a NonNegative value.

Constraints

This type enforces the following constraints:

• Range: x ≥ 0 (non-negative)
• Finite: Excludes NaN and ±∞

Non-negative numbers are commonly used for:

• Counting and magnitudes
• Physical measurements
• Financial values

Examples

Creating a non-negative number:

#![expect(clippy::approx_constant)]
use strict_num_extended::{NonNegativeF32, FloatError};

let pos = NonNegativeF32::new(42.0)?;
assert_eq!(pos.get(), 42.0);

Invalid value (negative):

use strict_num_extended::NonNegativeF32;

let invalid = NonNegativeF32::new(-1.0);
assert!(invalid.is_err());

Implementations

impl NonNegativeF32

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

Creates a new NonNegativeF32 value.

The value must satisfy the constraint: non-negative.

Examples

Valid value:

#![expect(clippy::approx_constant)]
use strict_num_extended::{NonNegativeF32, FloatError};

let value = NonNegativeF32::new(42.0)?;
assert_eq!(value.get(), 42.0);

Invalid value (negative value):

use strict_num_extended::NonNegativeF32;

let invalid = NonNegativeF32::new(-1.0);
assert!(invalid.is_err());

Errors

Returns Err(FloatError) if the value does not satisfy the constraint.

pub const unsafe fn new_unchecked(value: f32) -> Self

Unsafely creates a finite floating-point number (no validation)

Safety

Caller must ensure the value satisfies the constraint. Violating the constraint leads to undefined behavior.

pub const fn get(&self) -> f32

Gets the inner value

Example

use strict_num_extended::FinF32;

let finite = FinF32::new(2.5);
assert_eq!(finite.unwrap().get(), 2.5);

pub const fn value(&self) -> f32

Gets the inner value (alias for get())

Example

use strict_num_extended::FinF32;

let finite = FinF32::new(2.5);
assert_eq!(finite.unwrap().value(), 2.5);

pub const fn new_const(value: f32) -> Self

Creates a value at compile time

Panics

Will panic at compile time or runtime if the value does not satisfy the constraint.

impl NonNegativeF32

pub fn abs(self) -> NonNegativeF32

Computes the absolute value.

The return type is automatically inferred based on the source constraint:

• NonNegative/NonPositive → NonNegative
• NonZero → Positive
• Normalized → Normalized (reflexive)
• Symmetric → Normalized
• Fin → NonNegative

Examples

use strict_num_extended::*;

let neg = NegativeF64::new(-5.0).unwrap();
let abs_val: PositiveF64 = neg.abs();
assert_eq!(abs_val.get(), 5.0);

impl NonNegativeF32

pub fn signum(self) -> NormalizedF32

Computes the sign function.

Returns the sign of the number:

• 1.0 if the number is positive
• 0.0 if the number is zero
• -1.0 if the number is negative

The return type is automatically inferred based on the source constraint:

• Positive types → Normalized (signum in {0, 1})
• Negative types → NegativeNormalized (signum in {-1, 0})
• NonZero types → Symmetric (signum in {-1, 1})
• Fin/Symmetric → Symmetric (signum in {-1, 0, 1})

Examples

use strict_num_extended::*;

let pos = PositiveF64::new(5.0).unwrap();
let sign: NormalizedF64 = pos.signum();
assert_eq!(sign.get(), 1.0);

let neg = NegativeF64::new(-5.0).unwrap();
let sign: NegativeNormalizedF64 = neg.signum();
assert_eq!(sign.get(), -1.0);

impl NonNegativeF32

pub fn sin(self) -> SymmetricF32

Available on crate feature std only.

Computes the sine of the value.

Mathematical Properties

For any finite real input x:

• Range: sin(x) ∈ [-1, 1]
• Output Type: Always returns Symmetric ([-1, 1])
• Defined: sin(x) is defined for all finite inputs

Examples

use strict_num_extended::*;

let angle: FinF64 = FinF64::new(std::f64::consts::PI / 2.0).unwrap();
let sin_val: SymmetricF64 = angle.sin();
assert_eq!(sin_val.get(), 1.0);

let zero: NonNegativeF64 = NonNegativeF64::new_const(0.0);
let sin_zero: SymmetricF64 = zero.sin();
assert_eq!(sin_zero.get(), 0.0);

impl NonNegativeF32

pub fn cos(self) -> SymmetricF32

Available on crate feature std only.

Computes the cosine of the value.

Mathematical Properties

For any finite real input x:

• Range: cos(x) ∈ [-1, 1]
• Output Type: Always returns Symmetric ([-1, 1])
• Defined: cos(x) is defined for all finite inputs

Examples

use strict_num_extended::*;

let angle: FinF64 = FinF64::new(0.0).unwrap();
let cos_val: SymmetricF64 = angle.cos();
assert_eq!(cos_val.get(), 1.0);

let pi: FinF64 = FinF64::new(std::f64::consts::PI).unwrap();
let cos_pi: SymmetricF64 = pi.cos();
assert!((cos_pi.get() - (-1.0)).abs() < f64::EPSILON);

impl NonNegativeF32

pub fn tan(self) -> Result<FinF32, FloatError>

Available on crate feature std only.

Computes the tangent of the value.

Mathematical Properties

For any finite real input x (excluding π/2 + kπ):

• Range: tan(x) ∈ (-∞, +∞)
• Output Type: Always returns Fin (unbounded)
• Singular Points: Undefined at π/2 + kπ (may return infinity)

Examples

use strict_num_extended::*;

let angle: FinF64 = FinF64::new(0.0).unwrap();
let tan_val: Result<FinF64, FloatError> = angle.tan();
assert_eq!(tan_val.unwrap().get(), 0.0);

let pi_over_4: FinF64 = FinF64::new(std::f64::consts::PI / 4.0).unwrap();
let tan_45: Result<FinF64, FloatError> = pi_over_4.tan();
assert!((tan_45.unwrap().get() - 1.0).abs() < f64::EPSILON);

impl NonNegativeF32

pub const fn as_f32(self) -> f32

Returns the inner f32 value

impl NonNegativeF32

pub const fn as_f32_type(self) -> Self

Creates a clone of the current F32 type instance

This is equivalent to the Clone trait but provides a descriptive name for type conversion context.

impl NonNegativeF32

pub const fn as_f64_type(self) -> NonNegativeF64

Converts to the corresponding F64 type

Since F64 has a larger range than F32, this conversion is always safe in terms of range and precision.

impl NonNegativeF32

pub const ZERO: Self

Zero (0.0)

pub const ONE: Self

One (1.0)

pub const TWO: Self

Two (2.0)

pub const HALF: Self

Half (0.5)

pub const PI: Self

Pi, the ratio of a circle’s circumference to its diameter

pub const E: Self

Euler’s number, the base of natural logarithms

pub const FRAC_1_PI: Self

1/pi

pub const FRAC_2_PI: Self

2/pi

pub const FRAC_PI_2: Self

pi/2

pub const FRAC_PI_3: Self

pi/3

pub const FRAC_PI_4: Self

pi/4

pub const FRAC_PI_6: Self

pi/6

pub const FRAC_PI_8: Self

pi/8

Trait Implementations

impl Add<FinF32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NegativeF32> for NonNegativeF32

type Output = FinF32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NegativeNormalizedF32> for NonNegativeF32

type Output = FinF32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for FinF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for NegativeF32

type Output = FinF32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for NegativeNormalizedF32

type Output = FinF32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for NonPositiveF32

type Output = FinF32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for NonZeroF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for NormalizedF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for PiBoundedF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for PositiveF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for Result<FinF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for Result<NegativeF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for Result<NegativeNormalizedF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for Result<NonNegativeF32, FloatError>

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for Result<NonPositiveF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for Result<NonZeroF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for Result<NormalizedF32, FloatError>

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for Result<PiBoundedF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for Result<PositiveF32, FloatError>

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for Result<SymmetricF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for SymmetricF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF32> for f32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonPositiveF32> for NonNegativeF32

type Output = FinF32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonZeroF32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF32> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<FinF32>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: Option<FinF32>) -> Self::Output

Performs the + operation.

impl Add<Option<NegativeF32>> for NonNegativeF32

type Output = Option<FinF32>

The resulting type after applying the + operator.

fn add(self, rhs: Option<NegativeF32>) -> Self::Output

Performs the + operation.

impl Add<Option<NegativeNormalizedF32>> for NonNegativeF32

type Output = Option<FinF32>

The resulting type after applying the + operator.

fn add(self, rhs: Option<NegativeNormalizedF32>) -> Self::Output

Performs the + operation.

impl Add<Option<NonNegativeF32>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: Option<NonNegativeF32>) -> Self::Output

Performs the + operation.

impl Add<Option<NonPositiveF32>> for NonNegativeF32

type Output = Option<FinF32>

The resulting type after applying the + operator.

fn add(self, rhs: Option<NonPositiveF32>) -> Self::Output

Performs the + operation.

impl Add<Option<NonZeroF32>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: Option<NonZeroF32>) -> Self::Output

Performs the + operation.

impl Add<Option<NormalizedF32>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: Option<NormalizedF32>) -> Self::Output

Performs the + operation.

impl Add<Option<PiBoundedF32>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: Option<PiBoundedF32>) -> Self::Output

Performs the + operation.

impl Add<Option<PositiveF32>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: Option<PositiveF32>) -> Self::Output

Performs the + operation.

impl Add<Option<SymmetricF32>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: Option<SymmetricF32>) -> Self::Output

Performs the + operation.

impl Add<PiBoundedF32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<PositiveF32> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Result<FinF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: Result<FinF32, FloatError>) -> Self::Output

Performs the + operation.

impl Add<Result<NegativeF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: Result<NegativeF32, FloatError>) -> Self::Output

Performs the + operation.

impl Add<Result<NegativeNormalizedF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: Result<NegativeNormalizedF32, FloatError>) -> Self::Output

Performs the + operation.

impl Add<Result<NonNegativeF32, FloatError>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: Result<NonNegativeF32, FloatError>) -> Self::Output

Performs the + operation.

impl Add<Result<NonPositiveF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: Result<NonPositiveF32, FloatError>) -> Self::Output

Performs the + operation.

impl Add<Result<NonZeroF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: Result<NonZeroF32, FloatError>) -> Self::Output

Performs the + operation.

impl Add<Result<NormalizedF32, FloatError>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: Result<NormalizedF32, FloatError>) -> Self::Output

Performs the + operation.

impl Add<Result<PiBoundedF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: Result<PiBoundedF32, FloatError>) -> Self::Output

Performs the + operation.

impl Add<Result<PositiveF32, FloatError>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: Result<PositiveF32, FloatError>) -> Self::Output

Performs the + operation.

impl Add<Result<SymmetricF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: Result<SymmetricF32, FloatError>) -> Self::Output

Performs the + operation.

impl Add<SymmetricF32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<f32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for NonNegativeF32

fn clone(&self) -> NonNegativeF32

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NonNegativeF32

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NonNegativeF32

where f32: Deserialize<'de>,

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for NonNegativeF32

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

Formats the value using the given formatter.

impl Div<FinF32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NegativeF32> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NegativeNormalizedF32> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for FinF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for NegativeF32

type Output = Result<NegativeF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for NegativeNormalizedF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for NonPositiveF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for NonZeroF32

type Output = Result<NonZeroF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for NormalizedF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for PiBoundedF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for PositiveF32

type Output = Result<PositiveF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for Result<FinF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for Result<NegativeF32, FloatError>

type Output = Result<NegativeF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for Result<NegativeNormalizedF32, FloatError>

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for Result<NonNegativeF32, FloatError>

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for Result<NonPositiveF32, FloatError>

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for Result<NonZeroF32, FloatError>

type Output = Result<NonZeroF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for Result<NormalizedF32, FloatError>

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for Result<PiBoundedF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for Result<PositiveF32, FloatError>

type Output = Result<PositiveF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for Result<SymmetricF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for SymmetricF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF32> for f32

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonPositiveF32> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonZeroF32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF32> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<FinF32>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Option<FinF32>) -> Self::Output

Performs the / operation.

impl Div<Option<NegativeF32>> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Option<NegativeF32>) -> Self::Output

Performs the / operation.

impl Div<Option<NegativeNormalizedF32>> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Option<NegativeNormalizedF32>) -> Self::Output

Performs the / operation.

impl Div<Option<NonNegativeF32>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Option<NonNegativeF32>) -> Self::Output

Performs the / operation.

impl Div<Option<NonPositiveF32>> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Option<NonPositiveF32>) -> Self::Output

Performs the / operation.

impl Div<Option<NonZeroF32>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Option<NonZeroF32>) -> Self::Output

Performs the / operation.

impl Div<Option<NormalizedF32>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Option<NormalizedF32>) -> Self::Output

Performs the / operation.

impl Div<Option<PiBoundedF32>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Option<PiBoundedF32>) -> Self::Output

Performs the / operation.

impl Div<Option<PositiveF32>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Option<PositiveF32>) -> Self::Output

Performs the / operation.

impl Div<Option<SymmetricF32>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Option<SymmetricF32>) -> Self::Output

Performs the / operation.

impl Div<PiBoundedF32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<PositiveF32> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Result<FinF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Result<FinF32, FloatError>) -> Self::Output

Performs the / operation.

impl Div<Result<NegativeF32, FloatError>> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Result<NegativeF32, FloatError>) -> Self::Output

Performs the / operation.

impl Div<Result<NegativeNormalizedF32, FloatError>> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Result<NegativeNormalizedF32, FloatError>) -> Self::Output

Performs the / operation.

impl Div<Result<NonNegativeF32, FloatError>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Result<NonNegativeF32, FloatError>) -> Self::Output

Performs the / operation.

impl Div<Result<NonPositiveF32, FloatError>> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Result<NonPositiveF32, FloatError>) -> Self::Output

Performs the / operation.

impl Div<Result<NonZeroF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Result<NonZeroF32, FloatError>) -> Self::Output

Performs the / operation.

impl Div<Result<NormalizedF32, FloatError>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Result<NormalizedF32, FloatError>) -> Self::Output

Performs the / operation.

impl Div<Result<PiBoundedF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Result<PiBoundedF32, FloatError>) -> Self::Output

Performs the / operation.

impl Div<Result<PositiveF32, FloatError>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Result<PositiveF32, FloatError>) -> Self::Output

Performs the / operation.

impl Div<Result<SymmetricF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: Result<SymmetricF32, FloatError>) -> Self::Output

Performs the / operation.

impl Div<SymmetricF32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl FiniteFloat for NonNegativeF32

fn new<T: IntoF64>(value: T) -> Result<Self, FloatError>

Creates a new instance from a value that can be converted to f64

fn as_f64(&self) -> f64

Converts the value to f64

impl From<NonNegativeF32> for FinF32

fn from(value: NonNegativeF32) -> Self

Converts to this type from the input type.

impl From<NonNegativeF32> for NonNegativeF64

fn from(value: NonNegativeF32) -> Self

Converts to this type from the input type.

impl From<NonNegativeF32> for f32

fn from(value: NonNegativeF32) -> Self

Converts to this type from the input type.

impl From<NormalizedF32> for NonNegativeF32

fn from(value: NormalizedF32) -> Self

Converts to this type from the input type.

impl From<PositiveF32> for NonNegativeF32

fn from(value: PositiveF32) -> Self

Converts to this type from the input type.

impl FromStr for NonNegativeF32

type Err = ParseFloatError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Mul<FinF32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NegativeF32> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NegativeNormalizedF32> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for FinF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for NegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for NegativeNormalizedF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for NonPositiveF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for NonZeroF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for NormalizedF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for PiBoundedF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for PositiveF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for Result<FinF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for Result<NegativeF32, FloatError>

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for Result<NegativeNormalizedF32, FloatError>

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for Result<NonNegativeF32, FloatError>

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for Result<NonPositiveF32, FloatError>

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for Result<NonZeroF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for Result<NormalizedF32, FloatError>

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for Result<PiBoundedF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for Result<PositiveF32, FloatError>

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for Result<SymmetricF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for SymmetricF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF32> for f32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonPositiveF32> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonZeroF32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF32> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<FinF32>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<FinF32>) -> Self::Output

Performs the * operation.

impl Mul<Option<NegativeF32>> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<NegativeF32>) -> Self::Output

Performs the * operation.

impl Mul<Option<NegativeNormalizedF32>> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<NegativeNormalizedF32>) -> Self::Output

Performs the * operation.

impl Mul<Option<NonNegativeF32>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<NonNegativeF32>) -> Self::Output

Performs the * operation.

impl Mul<Option<NonPositiveF32>> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<NonPositiveF32>) -> Self::Output

Performs the * operation.

impl Mul<Option<NonZeroF32>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<NonZeroF32>) -> Self::Output

Performs the * operation.

impl Mul<Option<NormalizedF32>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<NormalizedF32>) -> Self::Output

Performs the * operation.

impl Mul<Option<PiBoundedF32>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<PiBoundedF32>) -> Self::Output

Performs the * operation.

impl Mul<Option<PositiveF32>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<PositiveF32>) -> Self::Output

Performs the * operation.

impl Mul<Option<SymmetricF32>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<SymmetricF32>) -> Self::Output

Performs the * operation.

impl Mul<PiBoundedF32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<PositiveF32> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Result<FinF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Result<FinF32, FloatError>) -> Self::Output

Performs the * operation.

impl Mul<Result<NegativeF32, FloatError>> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Result<NegativeF32, FloatError>) -> Self::Output

Performs the * operation.

impl Mul<Result<NegativeNormalizedF32, FloatError>> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Result<NegativeNormalizedF32, FloatError>) -> Self::Output

Performs the * operation.

impl Mul<Result<NonNegativeF32, FloatError>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Result<NonNegativeF32, FloatError>) -> Self::Output

Performs the * operation.

impl Mul<Result<NonPositiveF32, FloatError>> for NonNegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Result<NonPositiveF32, FloatError>) -> Self::Output

Performs the * operation.

impl Mul<Result<NonZeroF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Result<NonZeroF32, FloatError>) -> Self::Output

Performs the * operation.

impl Mul<Result<NormalizedF32, FloatError>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Result<NormalizedF32, FloatError>) -> Self::Output

Performs the * operation.

impl Mul<Result<PiBoundedF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Result<PiBoundedF32, FloatError>) -> Self::Output

Performs the * operation.

impl Mul<Result<PositiveF32, FloatError>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Result<PositiveF32, FloatError>) -> Self::Output

Performs the * operation.

impl Mul<Result<SymmetricF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: Result<SymmetricF32, FloatError>) -> Self::Output

Performs the * operation.

impl Mul<SymmetricF32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for NonNegativeF32

type Output = NonPositiveF32

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Ord for NonNegativeF32

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

This method returns an Ordering between self and other.

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 for NonNegativeF32

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for NonNegativeF32

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

This method returns an ordering between self and other values if one exists.

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 Serialize for NonNegativeF32

where f32: Serialize,

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<FinF32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NegativeF32> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NegativeNormalizedF32> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for FinF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for NegativeF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for NegativeNormalizedF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for NonPositiveF32

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for NonZeroF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for NormalizedF32

type Output = FinF32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for PiBoundedF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for PositiveF32

type Output = FinF32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for Result<FinF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for Result<NegativeF32, FloatError>

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for Result<NegativeNormalizedF32, FloatError>

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for Result<NonNegativeF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for Result<NonPositiveF32, FloatError>

type Output = Result<NonPositiveF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for Result<NonZeroF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for Result<NormalizedF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for Result<PiBoundedF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for Result<PositiveF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for Result<SymmetricF32, FloatError>

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for SymmetricF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF32> for f32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonPositiveF32> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonZeroF32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF32> for NonNegativeF32

type Output = FinF32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<FinF32>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<FinF32>) -> Self::Output

Performs the - operation.

impl Sub<Option<NegativeF32>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<NegativeF32>) -> Self::Output

Performs the - operation.

impl Sub<Option<NegativeNormalizedF32>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<NegativeNormalizedF32>) -> Self::Output

Performs the - operation.

impl Sub<Option<NonNegativeF32>> for NonNegativeF32

type Output = Option<FinF32>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<NonNegativeF32>) -> Self::Output

Performs the - operation.

impl Sub<Option<NonPositiveF32>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<NonPositiveF32>) -> Self::Output

Performs the - operation.

impl Sub<Option<NonZeroF32>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<NonZeroF32>) -> Self::Output

Performs the - operation.

impl Sub<Option<NormalizedF32>> for NonNegativeF32

type Output = Option<FinF32>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<NormalizedF32>) -> Self::Output

Performs the - operation.

impl Sub<Option<PiBoundedF32>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<PiBoundedF32>) -> Self::Output

Performs the - operation.

impl Sub<Option<PositiveF32>> for NonNegativeF32

type Output = Option<FinF32>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<PositiveF32>) -> Self::Output

Performs the - operation.

impl Sub<Option<SymmetricF32>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<SymmetricF32>) -> Self::Output

Performs the - operation.

impl Sub<PiBoundedF32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<PositiveF32> for NonNegativeF32

type Output = FinF32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Result<FinF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: Result<FinF32, FloatError>) -> Self::Output

Performs the - operation.

impl Sub<Result<NegativeF32, FloatError>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: Result<NegativeF32, FloatError>) -> Self::Output

Performs the - operation.

impl Sub<Result<NegativeNormalizedF32, FloatError>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: Result<NegativeNormalizedF32, FloatError>) -> Self::Output

Performs the - operation.

impl Sub<Result<NonNegativeF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: Result<NonNegativeF32, FloatError>) -> Self::Output

Performs the - operation.

impl Sub<Result<NonPositiveF32, FloatError>> for NonNegativeF32

type Output = Result<NonNegativeF32, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: Result<NonPositiveF32, FloatError>) -> Self::Output

Performs the - operation.

impl Sub<Result<NonZeroF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: Result<NonZeroF32, FloatError>) -> Self::Output

Performs the - operation.

impl Sub<Result<NormalizedF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: Result<NormalizedF32, FloatError>) -> Self::Output

Performs the - operation.

impl Sub<Result<PiBoundedF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: Result<PiBoundedF32, FloatError>) -> Self::Output

Performs the - operation.

impl Sub<Result<PositiveF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: Result<PositiveF32, FloatError>) -> Self::Output

Performs the - operation.

impl Sub<Result<SymmetricF32, FloatError>> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: Result<SymmetricF32, FloatError>) -> Self::Output

Performs the - operation.

impl Sub<SymmetricF32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<f32> for NonNegativeF32

type Output = Result<FinF32, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for NonNegativeF32

type Output = FinF32

The resulting type after applying the - operator.

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

Performs the - operation.

impl TryFrom<FinF32> for NonNegativeF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NegativeF32> for NonNegativeF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NegativeNormalizedF32> for NonNegativeF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NonNegativeF32> for NegativeF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NonNegativeF32> for NegativeNormalizedF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NonNegativeF32> for NonPositiveF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NonNegativeF32> for NonZeroF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NonNegativeF32> for NormalizedF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NonNegativeF32> for PiBoundedF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NonNegativeF32> for PositiveF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NonNegativeF32> for SymmetricF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NonNegativeF64> for NonNegativeF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NonPositiveF32> for NonNegativeF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NonZeroF32> for NonNegativeF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<PiBoundedF32> for NonNegativeF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<SymmetricF32> for NonNegativeF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<f32> for NonNegativeF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<f64> for NonNegativeF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Copy for NonNegativeF32

impl Eq for NonNegativeF32