Struct NonPositiveF64 

pub struct NonPositiveF64 { /* private fields */ }

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

Constraints

This type enforces the following constraints:

• Range: x ≤ 0 (non-positive)
• Finite: Excludes NaN and ±∞

Non-positive numbers are commonly used for:

• Losses and debts
• Temperature below zero
• Directions and offsets

Examples

Creating a non-positive number:

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

let neg = NonPositiveF64::new(-42.0)?;
assert_eq!(neg.get(), -42.0);

Invalid value (positive):

use strict_num_extended::NonPositiveF64;

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

Implementations

impl NonPositiveF64

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

Creates a new NonPositiveF64 value.

The value must satisfy the constraint: non-positive.

Examples

Valid value:

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

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

Invalid value (positive value):

use strict_num_extended::NonPositiveF64;

let invalid = NonPositiveF64::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 NonPositiveF64

pub fn abs(self) -> NonNegativeF64

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 NonPositiveF64

pub fn signum(self) -> NegativeNormalizedF64

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 NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

pub const fn as_f64(self) -> f64

Returns the inner f64 value

impl NonPositiveF64

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

pub const ZERO: Self

Zero (0.0)

pub const NEG_ONE: Self

Negative one (-1.0)

pub const NEG_TWO: Self

Negative two (-2.0)

pub const NEG_HALF: Self

Negative half (-0.5)

pub const NEG_PI: Self

Negative pi

pub const NEG_E: Self

Negative Euler’s number

Trait Implementations

impl Add<FinF64> for NonPositiveF64

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 NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NegativeNormalizedF64> for NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonNegativeF64> for NonPositiveF64

type Output = FinF64

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonPositiveF64> for FinF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonPositiveF64> for NegativeF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonPositiveF64> for NegativeNormalizedF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonPositiveF64> for NonNegativeF64

type Output = FinF64

The resulting type after applying the + operator.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonPositiveF64> for PositiveF64

type Output = FinF64

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonPositiveF64> for SymmetricF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<NonPositiveF64> for f64

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

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 NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<NegativeNormalizedF64>> for NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<NonNegativeF64>> for NonPositiveF64

type Output = Option<FinF64>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<NonPositiveF64>> for NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<NonZeroF64>> for NonPositiveF64

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 NonPositiveF64

type Output = Option<FinF64>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<PiBoundedF64>> for NonPositiveF64

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 NonPositiveF64

type Output = Option<FinF64>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Option<SymmetricF64>> for NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

type Output = FinF64

The resulting type after applying the + operator.

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

Performs the + operation.

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

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 NonPositiveF64

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

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

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 NonPositiveF64

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

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 NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for NonPositiveF64

fn clone(&self) -> NonPositiveF64

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NonPositiveF64

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NonPositiveF64

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 NonPositiveF64

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

Formats the value using the given formatter.

impl Div<FinF64> for NonPositiveF64

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 NonPositiveF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NegativeNormalizedF64> for NonPositiveF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonNegativeF64> for NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonPositiveF64> for FinF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonPositiveF64> for NegativeF64

type Output = Result<PositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonPositiveF64> for NegativeNormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonPositiveF64> for NonNegativeF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonPositiveF64> for PositiveF64

type Output = Result<NegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<PositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<NonZeroF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<NegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonPositiveF64> for SymmetricF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<NonPositiveF64> for f64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

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 NonPositiveF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<NegativeNormalizedF64>> for NonPositiveF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<NonNegativeF64>> for NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<NonPositiveF64>> for NonPositiveF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<NonZeroF64>> for NonPositiveF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<NormalizedF64>> for NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<PiBoundedF64>> for NonPositiveF64

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 NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Option<SymmetricF64>> for NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

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

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 NonPositiveF64

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

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

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

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

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 NonPositiveF64

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

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 NonPositiveF64

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

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 NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl FiniteFloat for NonPositiveF64

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 NonPositiveF64

fn from(value: NegativeF64) -> Self

Converts to this type from the input type.

impl From<NegativeNormalizedF64> for NonPositiveF64

fn from(value: NegativeNormalizedF64) -> Self

Converts to this type from the input type.

impl From<NonPositiveF32> for NonPositiveF64

fn from(value: NonPositiveF32) -> Self

Converts to this type from the input type.

impl From<NonPositiveF64> for FinF64

fn from(value: NonPositiveF64) -> Self

Converts to this type from the input type.

impl From<NonPositiveF64> for f64

fn from(value: NonPositiveF64) -> Self

Converts to this type from the input type.

impl FromStr for NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NegativeNormalizedF64> for NonPositiveF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonNegativeF64> for NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonPositiveF64> for FinF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonPositiveF64> for NegativeF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonPositiveF64> for NegativeNormalizedF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonPositiveF64> for NonNegativeF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonPositiveF64> for PositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonPositiveF64> for SymmetricF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<NonPositiveF64> for f64

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

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 NonPositiveF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<NegativeNormalizedF64>> for NonPositiveF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<NonNegativeF64>> for NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<NonPositiveF64>> for NonPositiveF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<NonZeroF64>> for NonPositiveF64

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 NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<PiBoundedF64>> for NonPositiveF64

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 NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Option<SymmetricF64>> for NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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 NonPositiveF64

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

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

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

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

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 NonPositiveF64

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

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 NonPositiveF64

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

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 NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for NonPositiveF64

type Output = NonNegativeF64

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Ord for NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

type Output = FinF64

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NegativeNormalizedF64> for NonPositiveF64

type Output = FinF64

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonNegativeF64> for NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonPositiveF64> for FinF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonPositiveF64> for NegativeF64

type Output = FinF64

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonPositiveF64> for NegativeNormalizedF64

type Output = FinF64

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonPositiveF64> for NonNegativeF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the - operator.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonPositiveF64> for PositiveF64

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<NonNegativeF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonPositiveF64> for SymmetricF64

type Output = Result<FinF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<NonPositiveF64> for f64

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

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 NonPositiveF64

type Output = Option<FinF64>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<NegativeNormalizedF64>> for NonPositiveF64

type Output = Option<FinF64>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<NonNegativeF64>> for NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<NonPositiveF64>> for NonPositiveF64

type Output = Option<FinF64>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<NonZeroF64>> for NonPositiveF64

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 NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<PiBoundedF64>> for NonPositiveF64

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 NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Option<SymmetricF64>> for NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

type Output = Result<NonPositiveF64, FloatError>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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 NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

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

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 NonPositiveF64

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 NonPositiveF64

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

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 NonPositiveF64

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

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 NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

type Output = FinF64

The resulting type after applying the - operator.

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

Performs the - operation.

impl TryFrom<FinF64> for NonPositiveF64

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

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 NegativeF64

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

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

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

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

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

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

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

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 NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

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 NonPositiveF64

impl Eq for NonPositiveF64