Struct real_float::Finite

#[repr(transparent)]
pub struct Finite<F: IsFinite>(_);

Implementations

impl<F: IsFinite> Finite<F>

pub fn new(val: F) -> Self

Creates a new [Real] float, panicking if it’s NaN.

Note that this function will not panic in release mode, unless the strict feature flag is set.

pub fn try_new(val: F) -> Result<Self, InfiniteError>

Attempts to create a new [Real] float.

Errors

If the result is non-finite.

pub fn val(self) -> F

Gets the inner value of this number.

impl<F: IsFinite + Round> Finite<F>

pub fn floor(self) -> Self

pub fn ceil(self) -> Self

pub fn round(self) -> Self

pub fn trunc(self) -> Self

pub fn fract(self) -> Self

impl<F: IsFinite + Signed> Finite<F>

pub fn abs(self) -> Self

Computes the absolute value of self.

pub fn signum(self) -> Self

Returns a number that represents the sign of self.

• 1.0 if the number is positive or +0.0.
• -1.0 if the number is negative or -0.0.

pub fn is_sign_negative(self) -> bool

Returns true if self has a negative sign, including -0.0 and negative infinity.

pub fn is_sign_positive(self) -> bool

Returns true if self has a positive sign, including +0.0 and positive infinity.

impl<F: IsFinite + ToOrd> Finite<F>

pub fn max(self, other: impl IntoInner<F>) -> Self

pub fn min(self, other: impl IntoInner<F>) -> Self

impl<F: IsFinite> Finite<F>

pub fn try_add(self, rhs: impl IntoInner<F>) -> Result<Self, InfiniteError> where
    F: Add<Output = F>, 

Attempts to add two numbers.

Errors

If the result is non-finite.

pub fn try_sub(self, rhs: impl IntoInner<F>) -> Result<Self, InfiniteError> where
    F: Sub<Output = F>, 

Attempts to subtract two numbers.

Errors

If the result is non-finite.

impl<F: IsFinite> Finite<F>

pub fn try_mul(self, rhs: impl IntoInner<F>) -> Result<Self, InfiniteError> where
    F: Mul<Output = F>, 

Attempts to multiply two numbers.

Errors

If the result is non-finite.

pub fn try_div(self, rhs: impl IntoInner<F>) -> Result<Self, InfiniteError> where
    F: Div<Output = F>, 

Attempts to divide self by another number.

Errors

If the result is non-finite.

pub fn try_rem(self, rhs: impl IntoInner<F>) -> Result<Self, InfiniteError> where
    F: Rem<Output = F>, 

Attempts to find the remainder of self / rhs.

Errors

If the result is non-finite.

impl<F: IsFinite + Pow> Finite<F>

pub fn try_powf(self, n: impl IntoInner<F>) -> Result<Self, InfiniteError>

Attempts to raise self to the power n.

Errors

If the result is non-finite.

pub fn try_powi(self, n: i32) -> Result<Self, InfiniteError>

Attempts to raise self to the power n.

Errors

If the result is non-finite.

pub fn try_recip(self) -> Result<Self, InfiniteError>

Attempts to compute the reciprocal (1/x) of self.

Errors

If the result is non-finite.

pub fn try_sqrt(self) -> Result<Self, InfiniteError>

Attempts to find the square root of a number.

Errors

If the result is non-finite.

pub fn try_cbrt(self) -> Result<Self, InfiniteError>

Attempts to find the cube root of a number.

Errors

If the result is non-finite.

pub fn try_hypot(self, other: impl IntoInner<F>) -> Result<Self, InfiniteError>

Attempts to calculate the length of the hypotenuse of a right-angle triangle given legs of length x and y.

Errors

If the output is non-finite.

pub fn powf(self, n: impl IntoInner<F>) -> Self

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

pub fn recip(self) -> Self

pub fn sqrt(self) -> Self

pub fn cbrt(self) -> Self

pub fn hypot(self, other: impl IntoInner<F>) -> Self

impl<F: IsFinite + Exp> Finite<F>

pub fn try_exp(self) -> Result<Self, InfiniteError>

Attempts to find e^(self), the exponential function.

Errors

If the output is non-finite.

pub fn try_exp2(self) -> Result<Self, InfiniteError>

Attempts to find 2^(self).

Errors

If the output is non-finite.

pub fn try_exp_m1(self) -> Result<Self, InfiniteError>

Attempts to find e^(self) - 1 in a way that is accurate even if the number is close to zero.

Errors

If the output is non-finite.

pub fn try_log(self, b: impl IntoInner<F>) -> Result<Self, InfiniteError>

Attempts to find the log base b of self.

Errors

If the result is non-finite.

pub fn try_ln(self) -> Result<Self, InfiniteError>

Attempts to find the natural log (base e) of self.

Errors

If the result is non-finite.

pub fn try_log2(self) -> Result<Self, InfiniteError>

Attempts to find the log base 2 of self.

Errors

If the result is non-finite.

pub fn try_log10(self) -> Result<Self, InfiniteError>

Attempts to find the log base 10 of self.

Errors

If the output is non-finite.

pub fn try_ln_1p(self) -> Result<Self, InfiniteError>

Attempts to find ln(1+n) (natural logarithm) more accurately than if the operations were performed separately.

Errors

If the output is non-finite.

pub fn exp(self) -> Self

pub fn exp2(self) -> Self

pub fn exp_m1(self) -> Self

pub fn log(self, base: impl IntoInner<F>) -> Self

pub fn ln(self) -> Self

pub fn log2(self) -> Self

pub fn log10(self) -> Self

pub fn ln_1p(self) -> Self

impl<F: IsFinite + Trig> Finite<F>

pub fn try_tan(self) -> Result<Self, InfiniteError>

Attempts to compute the tangent of a number (in radians).

Errors

If the output is non-finite.

pub fn try_asin(self) -> Result<Self, InfiniteError>

Attempts to compute the arcsine of a number (in radians).

Errors

If the output is NaN (caused if the magnitude of the input exceeds 1).

pub fn try_acos(self) -> Result<Self, InfiniteError>

Attempts to compute the arccosine of a number (in radians).

Errors

If the output is NaN (caused if the magnitude of the input exceeds 1).

pub fn try_atan2(self, other: impl IntoInner<F>) -> Result<Self, InfiniteError>

Attempts to ompute the four quadrant arctangent of self (y) and other (x) in radians.

Errors

If the output is NaN or non-finite.

pub fn sin(self) -> Self

pub fn cos(self) -> Self

pub fn sin_cos(self) -> (Self, Self)

pub fn tan(self) -> Self

pub fn asin(self) -> Self

pub fn acos(self) -> Self

pub fn atan(self) -> Self

pub fn atan2(self, other: impl IntoInner<F>) -> Self

Trait Implementations

impl<F: Add<Output = F> + IsFinite, Rhs: IntoInner<F>> Add<Rhs> for Finite<F>

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F: AddAssign + IsFinite, Rhs: IntoInner<F>> AddAssign<Rhs> for Finite<F>

fn add_assign(&mut self, rhs: Rhs)

Performs the += operation.

impl<F: Clone + IsFinite> Clone for Finite<F>

fn clone(&self) -> Finite<F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Debug + IsFinite> Debug for Finite<F>

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

Formats the value using the given formatter.

impl<F: Default + IsFinite> Default for Finite<F>

fn default() -> Finite<F>

Returns the “default value” for a type.

impl<F: Div<Output = F> + IsFinite, Rhs: IntoInner<F>> Div<Rhs> for Finite<F>

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl<F: DivAssign + IsFinite, Rhs: IntoInner<F>> DivAssign<Rhs> for Finite<F>

fn div_assign(&mut self, rhs: Rhs)

Performs the /= operation.

impl<F: Mul<Output = F> + IsFinite, Rhs: IntoInner<F>> Mul<Rhs> for Finite<F>

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: MulAssign + IsFinite, Rhs: IntoInner<F>> MulAssign<Rhs> for Finite<F>

fn mul_assign(&mut self, rhs: Rhs)

Performs the *= operation.

impl<F: Neg<Output = F> + IsFinite> Neg for Finite<F>

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<F: IsFinite + ToOrd> Ord for Finite<F>

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<F: IsFinite + ToOrd, Rhs: IntoInner<F> + Copy> PartialEq<Rhs> for Finite<F>

fn eq(&self, rhs: &Rhs) -> 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 !=.

impl<F: IsFinite + ToOrd> PartialOrd<F> for Finite<F>

fn partial_cmp(&self, rhs: &F) -> 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<F: IsFinite + ToOrd> PartialOrd<Finite<F>> for Finite<F>

fn partial_cmp(&self, rhs: &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<F: Rem<Output = F> + IsFinite, Rhs: IntoInner<F>> Rem<Rhs> for Finite<F>

type Output = Self

The resulting type after applying the % operator.

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

Performs the % operation.

impl<F: RemAssign + IsFinite, Rhs: IntoInner<F>> RemAssign<Rhs> for Finite<F>

fn rem_assign(&mut self, rhs: Rhs)

Performs the %= operation.

impl<F: Sub<Output = F> + IsFinite, Rhs: IntoInner<F>> Sub<Rhs> for Finite<F>

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F: SubAssign + IsFinite, Rhs: IntoInner<F>> SubAssign<Rhs> for Finite<F>

fn sub_assign(&mut self, rhs: Rhs)

Performs the -= operation.

impl<F: Copy + IsFinite> Copy for Finite<F>

impl<F: IsFinite + ToOrd> Eq for Finite<F>