Struct umath::FFloat

pub struct FFloat<T>(/* private fields */);

Float wrapper that uses ffast-math. This float also implements Ord, Hash, and Eq, as it is not allowed to be NAN.

FFloat<F> is guaranteed to have the same memory layout and ABI as F.

let result = FFloat::new(27.0) * 42109.0;
assert_eq!(*result, 1136943.0);

Safety Notice (for transmuters)

A FFloat is never allowed to be NAN | INF.

Implementations

impl<T: FastFloat> FFloat<T>

pub unsafe fn new(from: T) -> Self

Create a new FFloat from your {f32, f64}.

Safety

• You MUST NEVER call this function with NAN | INF
• You MUST NEVER make the produced FFloat NAN | INF
• You MUST NEVER combine this or any FFloat with any other {FFloat, f32, f64}, if it will produce NAN | INF

// SAFETY: i have verified that 7.0 is infact, not NAN or INF.
let f = unsafe { FFloat::new(7.0) };

Trait Implementations

impl<T: FastFloat> Add<&FFloat<T>> for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the + operator.

fn add(self, FFloat: &FFloat<T>) -> Self::Output

Performs the + operation.

impl<T: FastFloat> Add<&T> for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: FastFloat> Add<T> for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: FastFloat> Add for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the + operator.

fn add(self, FFloat: FFloat<T>) -> Self::Output

Performs the + operation.

impl<T: FastFloat> AddAssign<&FFloat<T>> for FFloat<T>

fn add_assign(&mut self, FFloat: &FFloat<T>)

Performs the += operation.

impl<T: FastFloat> AddAssign<&T> for FFloat<T>

fn add_assign(&mut self, rhs: &T)

Performs the += operation.

impl<T: FastFloat> AddAssign<T> for FFloat<T>

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T: FastFloat> AddAssign for FFloat<T>

fn add_assign(&mut self, FFloat: FFloat<T>)

Performs the += operation.

impl<T: Clone> Clone for FFloat<T>

fn clone(&self) -> FFloat<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: FastFloat + Constants> Constants for FFloat<F>

unsafe fn ε() -> Self

Create a new FFloat representing the machine epsilon.

Safety

• You MUST NEVER turn the produced FFloat into NAN | INF
• You MUST NEVER combine this FFloat with another {FFloat, f32, f64}, to produce a NAN | INF

unsafe fn π() -> Self

Create a new FFloat representing π.

Safety

• You MUST NEVER turn the produced FFloat into NAN | INF
• You MUST NEVER combine this FFloat with another {FFloat, f32, f64}, to produce a NAN | INF

unsafe fn e() -> Self

Create a new FFloat representing eulers number.

Safety

• You MUST NEVER turn the produced FFloat into NAN | INF
• You MUST NEVER combine this FFloat with another {FFloat, f32, f64}, to produce a NAN | INF

impl<F: FastFloat + Constructors> Constructors for FFloat<F>

unsafe fn zero() -> Self

Create a new FFloat representing 0.0.

Safety

• You MUST NEVER turn the produced FFloat into NAN | INF
• You MUST NEVER combine this FFloat with another {FFloat, f32, f64}, to produce a NAN | INF

unsafe fn one() -> Self

Create a new FFloat representing 1.0.

Safety

• You MUST NEVER turn the produced FFloat into NAN | INF
• You MUST NEVER combine this FFloat with another {FFloat, f32, f64}, to produce a NAN | INF

unsafe fn min() -> Self

Create a new FFloat representing the minimum value for the inner float.

Safety

• You MUST NEVER turn the produced FFloat into NAN | INF
• You MUST NEVER combine this FFloat with another {FFloat, f32, f64}, to produce a NAN | INF

unsafe fn max() -> Self

Create a new FFloat representing the maximum value for the inner float.

Safety

• You MUST NEVER turn the produced FFloat into NAN | INF
• You MUST NEVER combine this FFloat with another {FFloat, f32, f64}, to produce a NAN | INF

impl<T: FastFloat> Debug for FFloat<T>

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

Formats the value using the given formatter.

impl<T> Deref for FFloat<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for FFloat<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: FastFloat> Display for FFloat<T>

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

Formats the value using the given formatter.

impl<T: FastFloat> Div<&FFloat<T>> for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the / operator.

fn div(self, FFloat: &FFloat<T>) -> Self::Output

Performs the / operation.

impl<T: FastFloat> Div<&T> for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: FastFloat> Div<T> for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: FastFloat> Div for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the / operator.

fn div(self, FFloat: FFloat<T>) -> Self::Output

Performs the / operation.

impl<T: FastFloat> DivAssign<&FFloat<T>> for FFloat<T>

fn div_assign(&mut self, FFloat: &FFloat<T>)

Performs the /= operation.

impl<T: FastFloat> DivAssign<&T> for FFloat<T>

fn div_assign(&mut self, rhs: &T)

Performs the /= operation.

impl<T: FastFloat> DivAssign<T> for FFloat<T>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: FastFloat> DivAssign for FFloat<T>

fn div_assign(&mut self, FFloat: FFloat<T>)

Performs the /= operation.

impl<F: FastFloat + Float<F>> Float<F> for FFloat<F>

unsafe fn new(from: F) -> Self

Create a new FFloat from your {f32, f64}

Safety

• You MUST NEVER call this function with NAN | INF
• You MUST NEVER make the produced FFloat NAN | INF
• You MUST NEVER combine this or any FFloat with any other {FFloat, f32, f64}, if it will produce NAN | INF

fn take(self) -> F

Returns this float

impl<F: FloatMethods + FastFloat + Float<F>> FloatMethods for FFloat<F>

fn trunc(self) -> Self

Refer to f32::trunc Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn fract(self) -> Self

Refer to f32::fract Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn abs(self) -> Self

Refer to f32::abs Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn powi(self, n: i32) -> Self

Refer to f32::powi Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn powf(self, n: Self) -> Self

Refer to f32::powf Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn sqrt(self) -> Self

Refer to f32::sqrt Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn cbrt(self) -> Self

Refer to f32::cbrt Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

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

Refer to f32::hypot Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn exp2(self) -> Self

Refer to f32::exp2 Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

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

Refer to f32::min Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

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

Refer to f32::max Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

impl Hash for FFloat<f32>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Hash for FFloat<f64>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: FastFloat + Trig + Rounding + Log> Log for FFloat<T>

fn log(self, base: Self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn log2(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn log10(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn ln(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

impl<T: FastFloat> Mul<&FFloat<T>> for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the * operator.

fn mul(self, FFloat: &FFloat<T>) -> Self::Output

Performs the * operation.

impl<T: FastFloat> Mul<&T> for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: FastFloat> Mul<T> for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: FastFloat> Mul for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the * operator.

fn mul(self, FFloat: FFloat<T>) -> Self::Output

Performs the * operation.

impl<T: FastFloat> MulAssign<&FFloat<T>> for FFloat<T>

fn mul_assign(&mut self, FFloat: &FFloat<T>)

Performs the *= operation.

impl<T: FastFloat> MulAssign<&T> for FFloat<T>

fn mul_assign(&mut self, rhs: &T)

Performs the *= operation.

impl<T: FastFloat> MulAssign<T> for FFloat<T>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: FastFloat> MulAssign for FFloat<T>

fn mul_assign(&mut self, FFloat: FFloat<T>)

Performs the *= operation.

impl<T: FastFloat> Neg for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: FastFloat> Ord for FFloat<T>

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<T: FastFloat> PartialEq<T> for FFloat<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> PartialEq for FFloat<T>

fn eq(&self, other: &FFloat<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: FastFloat> PartialOrd<T> for FFloat<T>

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<T: FastFloat> PartialOrd for FFloat<T>

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<T: FastFloat> Rem<&FFloat<T>> for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the % operator.

fn rem(self, FFloat: &FFloat<T>) -> Self::Output

Performs the % operation.

impl<T: FastFloat> Rem<&T> for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T: FastFloat> Rem<T> for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T: FastFloat> Rem for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the % operator.

fn rem(self, FFloat: FFloat<T>) -> Self::Output

Performs the % operation.

impl<T: FastFloat> RemAssign<&FFloat<T>> for FFloat<T>

fn rem_assign(&mut self, FFloat: &FFloat<T>)

Performs the %= operation.

impl<T: FastFloat> RemAssign<&T> for FFloat<T>

fn rem_assign(&mut self, rhs: &T)

Performs the %= operation.

impl<T: FastFloat> RemAssign<T> for FFloat<T>

fn rem_assign(&mut self, rhs: T)

Performs the %= operation.

impl<T: FastFloat> RemAssign for FFloat<T>

fn rem_assign(&mut self, FFloat: FFloat<T>)

Performs the %= operation.

impl<T: FastFloat + Trig + Rounding + Log> Rounding for FFloat<T>

fn floor(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn ceil(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn round(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

impl<T: FastFloat> Sub<&FFloat<T>> for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the - operator.

fn sub(self, FFloat: &FFloat<T>) -> Self::Output

Performs the - operation.

impl<T: FastFloat> Sub<&T> for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: FastFloat> Sub<T> for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: FastFloat> Sub for FFloat<T>

type Output = FFloat<T>

The resulting type after applying the - operator.

fn sub(self, FFloat: FFloat<T>) -> Self::Output

Performs the - operation.

impl<T: FastFloat> SubAssign<&FFloat<T>> for FFloat<T>

fn sub_assign(&mut self, FFloat: &FFloat<T>)

Performs the -= operation.

impl<T: FastFloat> SubAssign<&T> for FFloat<T>

fn sub_assign(&mut self, rhs: &T)

Performs the -= operation.

impl<T: FastFloat> SubAssign<T> for FFloat<T>

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T: FastFloat> SubAssign for FFloat<T>

fn sub_assign(&mut self, FFloat: FFloat<T>)

Performs the -= operation.

impl<T: FastFloat + Trig + Rounding + Log> Trig for FFloat<T>

fn sin(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn asin(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn sinh(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn asinh(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn cos(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn acos(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn cosh(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn acosh(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn tan(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn atan(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

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

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn tanh(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

fn atanh(self) -> Self

Please note that calling this function may (although its dependent on the function) incur UB.

These functions are not marked unsafe, as the entire FFloat type is essentially unsafe.

impl<T: Copy> Copy for FFloat<T>

impl<T: FastFloat> Eq for FFloat<T>

impl<T> StructuralPartialEq for FFloat<T>