Struct rustc_apfloat::ieee::IeeeFloat

#[must_use]pub struct IeeeFloat<S> {
    sig: [u128; 1],
    exp: ExpInt,
    category: Category,
    sign: bool,
    marker: PhantomData<S>,
}

Fields

sig: [u128; 1]

Absolute significand value (including the integer bit).

exp: ExpInt

The signed unbiased exponent of the value.

category: Category

What kind of floating point number this is.

sign: bool

Sign bit of the number.

marker: PhantomData<S>

Implementations

impl<S: Semantics> IeeeFloat<S>

fn overflow_result(round: Round) -> StatusAnd<Self>

Handle positive overflow. We either return infinity or the largest finite number. For negative overflow, negate the round argument before calling.

fn round_away_from_zero(&self, round: Round, loss: Loss, bit: usize) -> bool

Returns true if, when truncating the current number, with bit the new LSB, with the given lost fraction and rounding mode, the result would need to be rounded away from zero (i.e., by increasing the signficand). This routine must work for Category::Zero of both signs, and Category::Normal numbers.

fn normalize(mut self: Self, round: Round, mut loss: Loss) -> StatusAnd<Self>

fn from_hexadecimal_string(
    s: &str,
    round: Round
) -> Result<StatusAnd<Self>, ParseError>

fn from_decimal_string(
    s: &str,
    round: Round
) -> Result<StatusAnd<Self>, ParseError>

Trait Implementations

impl<S> Add<IeeeFloat<S>> for IeeeFloat<S> where
    Self: Float, 

type Output = StatusAnd<Self>

The resulting type after applying the + operator.

pub fn add(self, rhs: Self) -> StatusAnd<Self>

Performs the + operation.

impl<S> AddAssign<IeeeFloat<S>> for IeeeFloat<S> where
    Self: Float, 

pub fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<S> Clone for IeeeFloat<S>

pub fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S> Copy for IeeeFloat<S>

impl<S: Semantics> Debug for IeeeFloat<S>

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

Formats the value using the given formatter.

impl<S> Default for IeeeFloat<S> where
    Self: Float, 

pub fn default() -> Self

Returns the "default value" for a type.

impl<S: Semantics> Display for IeeeFloat<S>

Prints this value as a decimal string.

\param precision The maximum number of digits of precision to output. If there are fewer digits available, zero padding will not be used unless the value is integral and small enough to be expressed in precision digits. 0 means to use the natural precision of the number. \param width The maximum number of zeros to consider inserting before falling back to scientific notation. 0 means to always use scientific notation.

\param alternate Indicate whether to remove the trailing zero in fraction part or not. Also setting this parameter to true forces producing of output more similar to default printf behavior. Specifically the lower e is used as exponent delimiter and exponent always contains no less than two digits.

Number precision width Result

---

1.01E+4 5 2 10100 1.01E+4 4 2 1.01E+4 1.01E+4 5 1 1.01E+4 1.01E-2 5 2 0.0101 1.01E-2 4 2 0.0101 1.01E-2 4 1 1.01E-2

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

Formats the value using the given formatter.

impl<S> Div<IeeeFloat<S>> for IeeeFloat<S> where
    Self: Float, 

type Output = StatusAnd<Self>

The resulting type after applying the / operator.

pub fn div(self, rhs: Self) -> StatusAnd<Self>

Performs the / operation.

impl<S> DivAssign<IeeeFloat<S>> for IeeeFloat<S> where
    Self: Float, 

pub fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<S: Semantics> Float for IeeeFloat<S>

pub const BITS: usize

Total number of bits in the in-memory format.

pub const PRECISION: usize

Number of bits in the significand. This includes the integer bit.

pub const MAX_EXP: ExpInt

The largest E such that 2^E is representable; this matches the definition of IEEE 754.

pub const MIN_EXP: ExpInt

The smallest E such that 2^E is a normalized number; this matches the definition of IEEE 754.

pub const ZERO: Self

Positive Zero.

pub const INFINITY: Self

Positive Infinity.

pub const NAN: Self

NaN (Not a Number).

pub fn qnan(payload: Option<u128>) -> Self

Factory for QNaN values.

pub fn snan(payload: Option<u128>) -> Self

Factory for SNaN values.

pub fn largest() -> Self

Largest finite number.

pub const SMALLEST: Self

Smallest (by magnitude) finite number. Might be denormalized, which implies a relative loss of precision.

pub fn smallest_normalized() -> Self

Smallest (by magnitude) normalized finite number.

pub fn add_r(mut self: Self, rhs: Self, round: Round) -> StatusAnd<Self>

pub fn mul_r(mut self: Self, rhs: Self, round: Round) -> StatusAnd<Self>

pub fn mul_add_r(
    mut self: Self,
    multiplicand: Self,
    addend: Self,
    round: Round
) -> StatusAnd<Self>

pub fn div_r(mut self: Self, rhs: Self, round: Round) -> StatusAnd<Self>

pub fn c_fmod(mut self: Self, rhs: Self) -> StatusAnd<Self>

C fmod, or llvm frem.

pub fn round_to_integral(self, round: Round) -> StatusAnd<Self>

pub fn next_up(mut self: Self) -> StatusAnd<Self>

IEEE-754R 2008 5.3.1: nextUp.

pub fn from_bits(input: u128) -> Self

pub fn from_u128_r(input: u128, round: Round) -> StatusAnd<Self>

pub fn from_str_r(
    mut s: &str,
    mut round: Round
) -> Result<StatusAnd<Self>, ParseError>

pub fn to_bits(self) -> u128

pub fn to_u128_r(
    self,
    width: usize,
    round: Round,
    is_exact: &mut bool
) -> StatusAnd<u128>

pub fn cmp_abs_normal(self, rhs: Self) -> Ordering

pub fn bitwise_eq(self, rhs: Self) -> bool

Bitwise comparison for equality (QNaNs compare equal, 0!=-0).

pub fn is_negative(self) -> bool

IEEE-754R isSignMinus: Returns whether the current value is negative.

pub fn is_denormal(self) -> bool

IEEE-754R isSubnormal(): Returns whether the float is a denormal.

pub fn is_signaling(self) -> bool

Returns true if the float is a signaling NaN.

pub fn category(self) -> Category

pub fn get_exact_inverse(self) -> Option<Self>

If this value has an exact multiplicative inverse, return it.

pub fn ilogb(mut self: Self) -> ExpInt

Returns the exponent of the internal representation of the Float.

pub fn scalbn_r(mut self: Self, exp: ExpInt, round: Round) -> Self

Returns: self * 2^exp for integral exponents. Equivalent to C standard library function ldexp.

pub fn frexp_r(mut self: Self, exp: &mut ExpInt, round: Round) -> Self

Equivalent to C standard library function with the same name.

pub fn sub_r(self, rhs: Self, round: Round) -> StatusAnd<Self>

pub fn mul_add(self, multiplicand: Self, addend: Self) -> StatusAnd<Self>

pub fn ieee_rem(self, rhs: Self) -> StatusAnd<Self>

IEEE remainder.

pub fn next_down(self) -> StatusAnd<Self>

IEEE-754R 2008 5.3.1: nextDown.

pub fn abs(self) -> Self

pub fn copy_sign(self, rhs: Self) -> Self

pub fn from_i128_r(input: i128, round: Round) -> StatusAnd<Self>

pub fn from_i128(input: i128) -> StatusAnd<Self>

pub fn from_u128(input: u128) -> StatusAnd<Self>

pub fn to_i128_r(
    self,
    width: usize,
    round: Round,
    is_exact: &mut bool
) -> StatusAnd<i128>

Converts a floating point number to an integer according to the rounding mode. In case of an invalid operation exception, deterministic values are returned, namely zero for NaNs and the minimal or maximal value respectively for underflow or overflow. If the rounded value is in range but the floating point number is not the exact integer, the C standard doesn't require an inexact exception to be raised. IEEE-854 does require it so we do that.

pub fn to_i128(self, width: usize) -> StatusAnd<i128>

pub fn to_u128(self, width: usize) -> StatusAnd<u128>

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

Implements IEEE minNum semantics. Returns the smaller of the 2 arguments if both are not NaN. If either argument is a NaN, returns the other argument.

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

Implements IEEE maxNum semantics. Returns the larger of the 2 arguments if both are not NaN. If either argument is a NaN, returns the other argument.

pub fn is_normal(self) -> bool

IEEE-754R isNormal: Returns whether the current value is normal.

pub fn is_finite(self) -> bool

Returns true if the current value is zero, subnormal, or normal.

pub fn is_zero(self) -> bool

Returns true if the float is plus or minus zero.

pub fn is_infinite(self) -> bool

IEEE-754R isInfinite(): Returns whether the float is infinity.

pub fn is_nan(self) -> bool

Returns true if the float is a quiet or signaling NaN.

pub fn is_non_zero(self) -> bool

pub fn is_finite_non_zero(self) -> bool

pub fn is_pos_zero(self) -> bool

pub fn is_neg_zero(self) -> bool

pub fn is_smallest(self) -> bool

Returns true if the number has the smallest possible non-zero magnitude in the current semantics.

pub fn is_largest(self) -> bool

Returns true if the number has the largest possible finite magnitude in the current semantics.

pub fn is_integer(self) -> bool

Returns true if the number is an exact integer.

pub fn scalbn(self, exp: ExpInt) -> Self

pub fn frexp(self, exp: &mut ExpInt) -> Self

impl<S: Semantics, T: Semantics> FloatConvert<IeeeFloat<T>> for IeeeFloat<S>

pub fn convert_r(
    self,
    round: Round,
    loses_info: &mut bool
) -> StatusAnd<IeeeFloat<T>>

Converts a value of one floating point type to another. The return value corresponds to the IEEE754 exceptions. *loses_info records whether the transformation lost information, i.e., whether converting the result back to the original type will produce the original value (this is almost the same as return value == Status::OK, but there are edge cases where this is not so).

pub fn convert(self, loses_info: &mut bool) -> StatusAnd<T>

impl<F: FloatConvert<Self>> From<DoubleFloat<F>> for IeeeFloat<FallbackS<F>>

pub fn from(DoubleFloat(a, b): DoubleFloat<F>) -> Self

Performs the conversion.

impl<F: Float> From<IeeeFloat<FallbackS<F>>> for DoubleFloat<F> where
    F: FloatConvert<IeeeFloat<FallbackExtendedS<F>>>,
    IeeeFloat<FallbackExtendedS<F>>: FloatConvert<F>, 

pub fn from(x: IeeeFloat<FallbackS<F>>) -> Self

Performs the conversion.

impl<S> FromStr for IeeeFloat<S> where
    Self: Float, 

type Err = ParseError

The associated error which can be returned from parsing.

pub fn from_str(s: &str) -> Result<Self, ParseError>

Parses a string s to return a value of this type.

impl<S> Mul<IeeeFloat<S>> for IeeeFloat<S> where
    Self: Float, 

type Output = StatusAnd<Self>

The resulting type after applying the * operator.

pub fn mul(self, rhs: Self) -> StatusAnd<Self>

Performs the * operation.

impl<S> MulAssign<IeeeFloat<S>> for IeeeFloat<S> where
    Self: Float, 

pub fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<S> Neg for IeeeFloat<S>

type Output = Self

The resulting type after applying the - operator.

pub fn neg(mut self: Self) -> Self

Performs the unary - operation.

impl<S: Semantics> PartialEq<IeeeFloat<S>> for IeeeFloat<S>

pub fn eq(&self, rhs: &Self) -> bool

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<S: Semantics> PartialOrd<IeeeFloat<S>> for IeeeFloat<S>

pub fn partial_cmp(&self, rhs: &Self) -> Option<Ordering>

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

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

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

#[must_use]pub fn le(&self, other: &Rhs) -> bool

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

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

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

#[must_use]pub 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<S> Rem<IeeeFloat<S>> for IeeeFloat<S> where
    Self: Float, 

type Output = StatusAnd<Self>

The resulting type after applying the % operator.

pub fn rem(self, rhs: Self) -> StatusAnd<Self>

Performs the % operation.

impl<S> RemAssign<IeeeFloat<S>> for IeeeFloat<S> where
    Self: Float, 

pub fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<S> Sub<IeeeFloat<S>> for IeeeFloat<S> where
    Self: Float, 

type Output = StatusAnd<Self>

The resulting type after applying the - operator.

pub fn sub(self, rhs: Self) -> StatusAnd<Self>

Performs the - operation.

impl<S> SubAssign<IeeeFloat<S>> for IeeeFloat<S> where
    Self: Float, 

pub fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.