Struct NormalizedF64 

pub struct NormalizedF64 { /* private fields */ }

A 64-bit floating-point number representing a Normalized value.

Constraints

This type enforces the following constraints:

• Range: 0 ≤ x ≤ 1 (range [0, 1])
• Finite: Excludes NaN and ±∞

Normalized numbers in [0, 1] are commonly used for:

• Probabilities and percentages
• Color channel values (RGB/RGBA)
• Neural network activations
• Normalized coordinates

Examples

Creating a normalized value:

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

let norm = NormalizedF64::new(0.75)?;
assert_eq!(norm.get(), 0.75);

Invalid value (out of range):

use strict_num_extended::NormalizedF64;

let invalid = NormalizedF64::new(1.5);
assert!(invalid.is_err());

Implementations

impl NormalizedF64

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

Creates a new NormalizedF64 value.

The value must satisfy the constraint: range [0, 1].

Examples

Valid value:

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

let value = NormalizedF64::new(0.5)?;
assert_eq!(value.get(), 0.5);

Invalid value (negative value):

use strict_num_extended::NormalizedF64;

let invalid = NormalizedF64::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: f64) -> 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) -> f64

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) -> f64

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: f64) -> Self

Creates a value at compile time

Panics

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

impl NormalizedF64

pub fn abs(self) -> NormalizedF64

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 NormalizedF64

pub fn signum(self) -> NormalizedF64

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 NormalizedF64

pub fn sin(self) -> SymmetricF64

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 NormalizedF64

pub fn cos(self) -> SymmetricF64

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 NormalizedF64

pub fn tan(self) -> Result<FinF64, 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 NormalizedF64

pub const fn as_f64(self) -> f64

Returns the inner f64 value

impl NormalizedF64

pub fn try_into_f32_type(self) -> Result<NormalizedF32, FloatError>

Attempts to convert to the corresponding F32 type

Errors

Returns Err(FloatError) if the converted value does not satisfy the target constraint (e.g., NaN, infinity, or out of range).

impl NormalizedF64

pub const ZERO: Self

Zero (0.0)

pub const ONE: Self

One (1.0)

pub const HALF: Self

Half (0.5)

pub const FRAC_1_PI: Self

1/pi

pub const FRAC_2_PI: Self

2/pi

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<FinF64> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NegativeF64> for NormalizedF64

type Output = FinF64

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NegativeNormalizedF64> for NormalizedF64

type Output = FinF64

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF64> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonPositiveF64> for NormalizedF64

type Output = FinF64

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonZeroF64> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for FinF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for NegativeF64

type Output = FinF64

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for NegativeNormalizedF64

type Output = FinF64

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for NonNegativeF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for NonPositiveF64

type Output = FinF64

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for PiBoundedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for PositiveF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for Result<FinF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for Result<NegativeF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for Result<NegativeNormalizedF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for Result<NonNegativeF64, FloatError>

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for Result<NonPositiveF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for Result<NonZeroF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for Result<PiBoundedF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for Result<PositiveF64, FloatError>

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for Result<SymmetricF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for SymmetricF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NormalizedF64> for f64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<FinF64>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<NegativeF64>> for NormalizedF64

type Output = Option<FinF64>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<NegativeNormalizedF64>> for NormalizedF64

type Output = Option<FinF64>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<NonNegativeF64>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<NonPositiveF64>> for NormalizedF64

type Output = Option<FinF64>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<NonZeroF64>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<NormalizedF64>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<PiBoundedF64>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<PositiveF64>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<SymmetricF64>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<PiBoundedF64> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<PositiveF64> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Result<FinF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Result<NegativeF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Result<NegativeNormalizedF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Result<NonNegativeF64, FloatError>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Result<NonPositiveF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Result<NonZeroF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Result<PiBoundedF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Result<PositiveF64, FloatError>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Result<SymmetricF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<SymmetricF64> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<f64> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for NormalizedF64

fn clone(&self) -> NormalizedF64

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NormalizedF64

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NormalizedF64

where f64: 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 NormalizedF64

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

Formats the value using the given formatter.

impl Div<FinF64> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NegativeF64> for NormalizedF64

type Output = NonPositiveF64

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NegativeNormalizedF64> for NormalizedF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF64> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonPositiveF64> for NormalizedF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonZeroF64> for NormalizedF64

type Output = FinF64

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for FinF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for NegativeF64

type Output = Result<NegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for NegativeNormalizedF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for NonNegativeF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for PiBoundedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for PositiveF64

type Output = Result<PositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for Result<FinF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for Result<NegativeF64, FloatError>

type Output = Result<NegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for Result<NegativeNormalizedF64, FloatError>

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for Result<NonNegativeF64, FloatError>

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for Result<NonPositiveF64, FloatError>

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for Result<NonZeroF64, FloatError>

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for Result<PiBoundedF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for Result<PositiveF64, FloatError>

type Output = Result<PositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for Result<SymmetricF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for SymmetricF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NormalizedF64> for f64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<FinF64>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<NegativeF64>> for NormalizedF64

type Output = Option<NonPositiveF64>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<NegativeNormalizedF64>> for NormalizedF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<NonNegativeF64>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<NonPositiveF64>> for NormalizedF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<NonZeroF64>> for NormalizedF64

type Output = Option<FinF64>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<NormalizedF64>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<PiBoundedF64>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<PositiveF64>> for NormalizedF64

type Output = Option<NonNegativeF64>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<SymmetricF64>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<PiBoundedF64> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<PositiveF64> for NormalizedF64

type Output = NonNegativeF64

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Result<FinF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Result<NegativeF64, FloatError>> for NormalizedF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Result<NegativeNormalizedF64, FloatError>> for NormalizedF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Result<NonNegativeF64, FloatError>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Result<NonPositiveF64, FloatError>> for NormalizedF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Result<NonZeroF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Result<PiBoundedF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Result<PositiveF64, FloatError>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Result<SymmetricF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<SymmetricF64> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f64> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl FiniteFloat for NormalizedF64

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<NormalizedF32> for NormalizedF64

fn from(value: NormalizedF32) -> Self

Converts to this type from the input type.

impl From<NormalizedF64> for FinF64

fn from(value: NormalizedF64) -> Self

Converts to this type from the input type.

impl From<NormalizedF64> for NonNegativeF64

fn from(value: NormalizedF64) -> Self

Converts to this type from the input type.

impl From<NormalizedF64> for PiBoundedF64

fn from(value: NormalizedF64) -> Self

Converts to this type from the input type.

impl From<NormalizedF64> for SymmetricF64

fn from(value: NormalizedF64) -> Self

Converts to this type from the input type.

impl From<NormalizedF64> for f64

fn from(value: NormalizedF64) -> Self

Converts to this type from the input type.

impl FromStr for NormalizedF64

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<FinF64> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NegativeF64> for NormalizedF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NegativeNormalizedF64> for NormalizedF64

type Output = NegativeNormalizedF64

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF64> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonPositiveF64> for NormalizedF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonZeroF64> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for FinF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for NegativeF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for NegativeNormalizedF64

type Output = NegativeNormalizedF64

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for NonNegativeF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for PiBoundedF64

type Output = PiBoundedF64

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for PositiveF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for Result<FinF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for Result<NegativeF64, FloatError>

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for Result<NegativeNormalizedF64, FloatError>

type Output = Result<NegativeNormalizedF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for Result<NonNegativeF64, FloatError>

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for Result<NonPositiveF64, FloatError>

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for Result<NonZeroF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<NormalizedF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for Result<PiBoundedF64, FloatError>

type Output = Result<PiBoundedF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for Result<PositiveF64, FloatError>

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for Result<SymmetricF64, FloatError>

type Output = Result<SymmetricF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for SymmetricF64

type Output = SymmetricF64

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NormalizedF64> for f64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<FinF64>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<NegativeF64>> for NormalizedF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<NegativeNormalizedF64>> for NormalizedF64

type Output = Option<NegativeNormalizedF64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<NonNegativeF64>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<NonPositiveF64>> for NormalizedF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<NonZeroF64>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<NormalizedF64>> for NormalizedF64

type Output = Option<NormalizedF64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<PiBoundedF64>> for NormalizedF64

type Output = Option<PiBoundedF64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<PositiveF64>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<SymmetricF64>> for NormalizedF64

type Output = Option<SymmetricF64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<PiBoundedF64> for NormalizedF64

type Output = PiBoundedF64

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<PositiveF64> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Result<FinF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Result<NegativeF64, FloatError>> for NormalizedF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Result<NegativeNormalizedF64, FloatError>> for NormalizedF64

type Output = Result<NegativeNormalizedF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Result<NonNegativeF64, FloatError>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Result<NonPositiveF64, FloatError>> for NormalizedF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Result<NonZeroF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<NormalizedF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Result<PiBoundedF64, FloatError>> for NormalizedF64

type Output = Result<PiBoundedF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Result<PositiveF64, FloatError>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Result<SymmetricF64, FloatError>> for NormalizedF64

type Output = Result<SymmetricF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<SymmetricF64> for NormalizedF64

type Output = SymmetricF64

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f64> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for NormalizedF64

type Output = NormalizedF64

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for NormalizedF64

type Output = NegativeNormalizedF64

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Ord for NormalizedF64

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 NormalizedF64

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 NormalizedF64

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 NormalizedF64

where f64: 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<FinF64> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NegativeF64> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NegativeNormalizedF64> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF64> for NormalizedF64

type Output = FinF64

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonPositiveF64> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonZeroF64> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for FinF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for NegativeF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for NegativeNormalizedF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for NonNegativeF64

type Output = FinF64

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for PiBoundedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for PositiveF64

type Output = FinF64

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for Result<FinF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for Result<NegativeF64, FloatError>

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for Result<NegativeNormalizedF64, FloatError>

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for Result<NonNegativeF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for Result<NonPositiveF64, FloatError>

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for Result<NonZeroF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for Result<PiBoundedF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for Result<PositiveF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for Result<SymmetricF64, FloatError>

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for SymmetricF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NormalizedF64> for f64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<FinF64>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<NegativeF64>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<NegativeNormalizedF64>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<NonNegativeF64>> for NormalizedF64

type Output = Option<FinF64>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<NonPositiveF64>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<NonZeroF64>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<NormalizedF64>> for NormalizedF64

type Output = Option<FinF64>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<PiBoundedF64>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<PositiveF64>> for NormalizedF64

type Output = Option<FinF64>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<SymmetricF64>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<PiBoundedF64> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<PositiveF64> for NormalizedF64

type Output = FinF64

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Result<FinF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Result<NegativeF64, FloatError>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Result<NegativeNormalizedF64, FloatError>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Result<NonNegativeF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Result<NonPositiveF64, FloatError>> for NormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Result<NonZeroF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Result<PiBoundedF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Result<PositiveF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Result<SymmetricF64, FloatError>> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<SymmetricF64> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<f64> for NormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for NormalizedF64

type Output = FinF64

The resulting type after applying the - operator.

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

Performs the - operation.

impl TryFrom<FinF64> for NormalizedF64

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NegativeF64> for NormalizedF64

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NegativeNormalizedF64> for NormalizedF64

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NonNegativeF64> for NormalizedF64

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<NonPositiveF64> for NormalizedF64

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NonZeroF64> for NormalizedF64

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NormalizedF64> for NegativeF64

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NormalizedF64> for NegativeNormalizedF64

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NormalizedF64> for NonPositiveF64

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NormalizedF64> for NonZeroF64

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NormalizedF64> for NormalizedF32

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<NormalizedF64> for PositiveF64

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<PiBoundedF64> for NormalizedF64

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<PositiveF64> for NormalizedF64

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<SymmetricF64> for NormalizedF64

type Error = FloatError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<f32> for NormalizedF64

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 NormalizedF64

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 NormalizedF64

impl Eq for NormalizedF64