Struct NonZeroF64 

pub struct NonZeroF64 { /* private fields */ }

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

Constraints

This type enforces the following constraints:

• Range: x ≠ 0 (non-zero)
• Finite: Excludes NaN and ±∞

Non-zero numbers are useful for:

• Division operations (avoiding divide-by-zero)
• Multiplicative factors
• Scaling operations

Examples

Creating a non-zero value:

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

let nonzero = NonZeroF64::new(42.0)?;
assert_eq!(nonzero.get(), 42.0);

Invalid value (zero):

use strict_num_extended::NonZeroF64;

let invalid = NonZeroF64::new(0.0);
assert!(invalid.is_err());

Implementations

impl NonZeroF64

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

Creates a new NonZeroF64 value.

The value must satisfy the constraint: non-zero.

Examples

Valid value:

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

let value = NonZeroF64::new(1.0)?;
assert_eq!(value.get(), 1.0);

Invalid value (zero value):

use strict_num_extended::NonZeroF64;

let invalid = NonZeroF64::new(0.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 NonZeroF64

pub fn abs(self) -> PositiveF64

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 NonZeroF64

pub fn signum(self) -> SymmetricF64

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 NonZeroF64

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 NonZeroF64

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 NonZeroF64

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 NonZeroF64

pub const fn as_f64(self) -> f64

Returns the inner f64 value

impl NonZeroF64

pub fn try_into_f32_type(self) -> Result<NonZeroF32, 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 NonZeroF64

pub const ONE: Self

One (1.0)

pub const NEG_ONE: Self

Negative one (-1.0)

pub const TWO: Self

Two (2.0)

pub const NEG_TWO: Self

Negative two (-2.0)

pub const HALF: Self

Half (0.5)

pub const NEG_HALF: Self

Negative half (-0.5)

pub const PI: Self

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

pub const NEG_PI: Self

Negative pi

pub const E: Self

Euler’s number, the base of natural logarithms

pub const NEG_E: Self

Negative Euler’s number

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

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 NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NegativeNormalizedF64> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF64> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonPositiveF64> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonZeroF64> for FinF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonZeroF64> for NegativeF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonZeroF64> for NegativeNormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonZeroF64> for NonNegativeF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonZeroF64> for NonPositiveF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroF64) -> 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<NonZeroF64> for PiBoundedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonZeroF64> for PositiveF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonZeroF64> for SymmetricF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonZeroF64> for f64

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 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<Option<FinF64>> for NonZeroF64

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 NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<NegativeNormalizedF64>> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<NonNegativeF64>> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<NonPositiveF64>> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<NonZeroF64>> for NonZeroF64

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 NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<PiBoundedF64>> for NonZeroF64

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 NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<SymmetricF64>> for NonZeroF64

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 NonZeroF64

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 NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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 NonZeroF64

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 NonZeroF64

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 NonZeroF64

type Output = Result<FinF64, 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 NonZeroF64

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 NonZeroF64

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 NonZeroF64

type Output = Result<FinF64, 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 NonZeroF64

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 NonZeroF64

type Output = Result<FinF64, 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 NonZeroF64

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 NonZeroF64

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 NonZeroF64

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 NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for NonZeroF64

fn clone(&self) -> NonZeroF64

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NonZeroF64

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NonZeroF64

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 NonZeroF64

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

Formats the value using the given formatter.

impl Div<FinF64> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NegativeF64> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NegativeNormalizedF64> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF64> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonPositiveF64> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonZeroF64> for FinF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonZeroF64> for NegativeF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonZeroF64> for NegativeNormalizedF64

type Output = FinF64

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonZeroF64> for NonNegativeF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonZeroF64> for NonPositiveF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroF64) -> 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<NonZeroF64> for PiBoundedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonZeroF64> for PositiveF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonZeroF64> for SymmetricF64

type Output = FinF64

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonZeroF64> for f64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroF64) -> 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<Option<FinF64>> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<NegativeF64>> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<NegativeNormalizedF64>> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<NonNegativeF64>> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<NonPositiveF64>> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<NonZeroF64>> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<NormalizedF64>> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<PiBoundedF64>> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<PositiveF64>> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<SymmetricF64>> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<PiBoundedF64> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<PositiveF64> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<NonZeroF64, 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 NonZeroF64

type Output = Result<NonZeroF64, 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 NonZeroF64

type Output = Result<NonZeroF64, 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 NonZeroF64

type Output = Result<NonZeroF64, 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 NonZeroF64

type Output = Result<NonZeroF64, 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 NonZeroF64

type Output = Result<NonZeroF64, 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 NonZeroF64

type Output = Result<NonZeroF64, 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 NonZeroF64

type Output = Result<NonZeroF64, 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 NonZeroF64

type Output = Result<NonZeroF64, 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 NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<SymmetricF64> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f64> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl FiniteFloat for NonZeroF64

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<NegativeF64> for NonZeroF64

fn from(value: NegativeF64) -> Self

Converts to this type from the input type.

impl From<NonZeroF32> for NonZeroF64

fn from(value: NonZeroF32) -> Self

Converts to this type from the input type.

impl From<NonZeroF64> for FinF64

fn from(value: NonZeroF64) -> Self

Converts to this type from the input type.

impl From<NonZeroF64> for f64

fn from(value: NonZeroF64) -> Self

Converts to this type from the input type.

impl From<PositiveF64> for NonZeroF64

fn from(value: PositiveF64) -> Self

Converts to this type from the input type.

impl FromStr for NonZeroF64

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 NonZeroF64

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 NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NegativeNormalizedF64> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF64> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonPositiveF64> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonZeroF64> for FinF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonZeroF64> for NegativeF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonZeroF64> for NegativeNormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonZeroF64> for NonNegativeF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonZeroF64> for NonPositiveF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroF64) -> 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<NonZeroF64> for PiBoundedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonZeroF64> for PositiveF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonZeroF64> for SymmetricF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonZeroF64> for f64

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 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<Option<FinF64>> for NonZeroF64

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 NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<NegativeNormalizedF64>> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<NonNegativeF64>> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<NonPositiveF64>> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<NonZeroF64>> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<NormalizedF64>> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<PiBoundedF64>> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<PositiveF64>> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<SymmetricF64>> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<PiBoundedF64> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<PositiveF64> for NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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 NonZeroF64

type Output = Result<NonZeroF64, 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 NonZeroF64

type Output = Result<FinF64, 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 NonZeroF64

type Output = Result<FinF64, 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 NonZeroF64

type Output = Result<FinF64, 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 NonZeroF64

type Output = Result<NonZeroF64, 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 NonZeroF64

type Output = Result<FinF64, 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 NonZeroF64

type Output = Result<FinF64, 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 NonZeroF64

type Output = Result<NonZeroF64, 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 NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<SymmetricF64> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f64> for NonZeroF64

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 NonZeroF64

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for NonZeroF64

type Output = NonZeroF64

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Ord for NonZeroF64

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 NonZeroF64

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 NonZeroF64

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 NonZeroF64

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 NonZeroF64

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 NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NegativeNormalizedF64> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF64> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonPositiveF64> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonZeroF64> for FinF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonZeroF64> for NegativeF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonZeroF64> for NegativeNormalizedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonZeroF64> for NonNegativeF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonZeroF64> for NonPositiveF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroF64) -> 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<NonZeroF64> for PiBoundedF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonZeroF64> for PositiveF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonZeroF64> for SymmetricF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonZeroF64> for f64

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 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<Option<FinF64>> for NonZeroF64

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 NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<NegativeNormalizedF64>> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<NonNegativeF64>> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<NonPositiveF64>> for NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<NonZeroF64>> for NonZeroF64

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 NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<PiBoundedF64>> for NonZeroF64

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 NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<SymmetricF64>> for NonZeroF64

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 NonZeroF64

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 NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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 NonZeroF64

type Output = Result<FinF64, 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 NonZeroF64

type Output = Result<FinF64, 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 NonZeroF64

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 NonZeroF64

type Output = Result<FinF64, 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 NonZeroF64

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 NonZeroF64

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 NonZeroF64

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 NonZeroF64

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 NonZeroF64

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 NonZeroF64

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 NonZeroF64

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 NonZeroF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl TryFrom<FinF64> for NonZeroF64

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<NegativeNormalizedF64> for NonZeroF64

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 NonZeroF64

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 NonZeroF64

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 NegativeF64

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<NonZeroF64> for NegativeNormalizedF64

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<NonZeroF64> for NonNegativeF64

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

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<NonZeroF64> for NonZeroF32

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<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<NonZeroF64> for PiBoundedF64

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<NonZeroF64> for PositiveF64

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<NonZeroF64> for SymmetricF64

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 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<PiBoundedF64> for NonZeroF64

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<SymmetricF64> for NonZeroF64

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 NonZeroF64

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 NonZeroF64

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 NonZeroF64

impl Eq for NonZeroF64