Struct real_float::Real

#[repr(transparent)]
pub struct Real<F: IsNan>(_);

Implementations

impl<F: IsNan> Real<F>

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

Attempts to create a new Real float.

Errors

If the value is NaN.

pub fn val(self) -> F

Gets the inner value of this number.

impl<F: IsNan> Real<F>

pub fn new(val: F) -> Self

Creates a new checked float.

Panics

If the number is NaN. Note that this fn will not panic in release mode, unless the strict feature flag is set.

impl<F: IsNan + ToOrd> Real<F>

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

Returns the larger of two floating point values.

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

Returns the smaller of two floating point values.

impl<F: IsNan + Round> Real<F>

pub fn floor(self) -> Self

Rounds this floating point number to the previous whole number.

pub fn ceil(self) -> Self

Rounds this floating point number to the next whole number.

pub fn round(self) -> Self

Rounds this floating point number to the nearest whole number.

pub fn trunc(self) -> Self

Drops the fractional part of this floating point number.

pub fn fract(self) -> Self

Returns the fractional part of this floating point number.

impl<F: IsNan + Signed> Real<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, +0.0 or INFINITY
• -1.0 if the number is negative, -0.0 or NEG_INFINITY

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: IsNan> Real<F>

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

Attempts to add two numbers.

Errors

If the result is NaN.

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

Attempts to subtract two numbers.

Errors

If the result is NaN.

impl<F: IsNan> Real<F>

pub fn try_neg(self) -> Result<Self, NanError> where
    F: Neg<Output = F>, 

Attempts to negate a number.

Errors

If the result is NaN.

impl<F: IsNan> Real<F>

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

Attempts to multiply two numbers.

Errors

If the result is NaN.

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

Attempts to divide two numbers.

Errors

If the result is NaN.

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

Attempts to find the remainder of two numbers.

Errors

If the result is NaN.

impl<F: IsNan + Pow> Real<F>

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

Attempts to raise self to the power n.

Errors

If the result is NaN.

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

Attempts to raise self to the power n.

Errors

If the result is NaN.

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

Raises self to the power n.

Panics

If the result is NaN.

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

Raises self to the power n.

Panics

If the result is NaN.

pub fn recip(self) -> Self

Computes the reciprocal (1/x) of self.

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

Attempts to find the square root of a number.

Errors

If the result is NaN.

pub fn sqrt(self) -> Self

Computes the square root of a number.

Panics

If the result is NaN.

pub fn cbrt(self) -> Self

Computes the cube root of a number.

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

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

Equivalent to sqrt(x^2 + y^2).

Errors

If the result is NaN.

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

Calculates the length of the hypotenuse of a right-angle triangle given legs of length x and y.

Panics

If the result is NaN.

impl<F: IsNan + Exp> Real<F>

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

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

Errors

If the result is NaN.

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

Attempts to find 2^(self).

Errors

If the result is NaN.

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

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

Errors

If the result is NaN.

pub fn exp(self) -> Self

Computes e^(self), the exponential function.

Panics

If the result is NaN.

pub fn exp2(self) -> Self

Computes 2^(self).

Panics

If the result is NaN.

pub fn exp_m1(self) -> Self

Computes e^(self) - 1 more accurately than performing the operations separately.

Panics

If the result is NaN.

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

Attempts to find the log base b of self.

Errors

If the result is NaN.

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

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

Errors

If the result is NaN.

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

Attempts to find the log base 2 of self.

Errors

If the result is NaN.

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

Attempts to find the log base 10 of self.

Errors

If the result is NaN.

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

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

Errors

If the result is NaN.

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

Computes the log base b of self.

Panics

If the result is NaN.

pub fn ln(self) -> Self

Computes the natural log (base e) of self.

Panics

If the result is NaN.

pub fn log2(self) -> Self

Computes the log base 2 of self.

Panics

If the result is NaN.

pub fn log10(self) -> Self

Computes the log base 10 of self.

Panics

If the result is NaN.

pub fn ln_1p(self) -> Self

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

Panics

If the result is NaN.

impl<F: IsNan + Trig> Real<F>

pub fn try_sin(self) -> Result<Self, NanError>

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

Errors

If the output is NaN (caused if the input is ±infinity).

pub fn try_cos(self) -> Result<Self, NanError>

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

Errors

If the output is NaN (caused if the input is ±infinity).

pub fn try_sin_cos(self) -> Result<(Self, Self), NanError>

Attempts to compute both the sine and cosine of a number simultaneously (in radians).

Errors

If the output is NaN (caused if the input is ±infinity).

pub fn sin(self) -> Self

Computes the sine of a number.

Panics

If the output is NaN (caused if the input is ±infinity).

pub fn cos(self) -> Self

Computes the cosine of a number.

Panics

If the output is NaN (caused if the input is ±infinity).

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

Computes the sine and cosine of a number simultaneously.

Panics

If the output is NaN (caused if the input is ±infinity).

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

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

Errors

If the result is NaN (caused if the input is ±infinity).

pub fn tan(self) -> Self

Computes the tangent of a number.

Panics

If the result is NaN (caused if the input is ±infinity).

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

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, NanError>

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 asin(self) -> Self

Computes the arcsine of a number.

Panics

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

pub fn acos(self) -> Self

Computes the arccosine of a number.

Panics

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

pub fn atan(self) -> Self

Computes the arctangent of a number.

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

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

Errors

If the output is NaN.

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

Computes the four quadrant arctangent of self (y) and other (x) in radians.

Panics

If the output is NaN.

Trait Implementations

impl<F: IsNan + Add<Output = F>, Rhs: IntoInner<F>> Add<Rhs> for Real<F>

type Output = Real<F>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F: IsNan + Add<Output = F>, Rhs: IntoInner<F>> AddAssign<Rhs> for Real<F>

fn add_assign(&mut self, rhs: Rhs)

Performs the += operation.

impl<F: Clone + IsNan> Clone for Real<F>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Debug + IsNan> Debug for Real<F>

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

Formats the value using the given formatter.

impl<F: Default + IsNan> Default for Real<F>

fn default() -> Real<F>

Returns the “default value” for a type.

impl<F: IsNan + Div<Output = F>, Rhs: IntoInner<F>> Div<Rhs> for Real<F>

type Output = Real<F>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<F: IsNan + Div<Output = F>, Rhs: IntoInner<F>> DivAssign<Rhs> for Real<F>

fn div_assign(&mut self, rhs: Rhs)

Performs the /= operation.

impl<F: IsNan + Mul<Output = F>, Rhs: IntoInner<F>> Mul<Rhs> for Real<F>

type Output = Real<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: IsNan + Mul<Output = F>, Rhs: IntoInner<F>> MulAssign<Rhs> for Real<F>

fn mul_assign(&mut self, rhs: Rhs)

Performs the *= operation.

impl<F: IsNan + Neg<Output = F>> Neg for Real<F>

type Output = Real<F>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<F: IsNan + ToOrd> Ord for Real<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: IsNan + ToOrd, Rhs: IntoInner<F> + Copy> PartialEq<Rhs> for Real<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: IsNan + ToOrd, Rhs: IntoInner<F> + Copy> PartialOrd<Rhs> for Real<F>

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

type Output = Real<F>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<F: IsNan + Rem<Output = F>, Rhs: IntoInner<F>> RemAssign<Rhs> for Real<F>

fn rem_assign(&mut self, rhs: Rhs)

Performs the %= operation.

impl<F: IsNan + Sub<Output = F>, Rhs: IntoInner<F>> Sub<Rhs> for Real<F>

type Output = Real<F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F: IsNan + Sub<Output = F>, Rhs: IntoInner<F>> SubAssign<Rhs> for Real<F>

fn sub_assign(&mut self, rhs: Rhs)

Performs the -= operation.

impl<F: Copy + IsNan> Copy for Real<F>

impl<F: IsNan + ToOrd> Eq for Real<F>