Struct rustc_apfloat::ieee::IeeeFloat
source · [−]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
sourceimpl<S: Semantics> IeeeFloat<S>
impl<S: Semantics> IeeeFloat<S>
sourcefn overflow_result(round: Round) -> StatusAnd<Self>
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.
sourcefn round_away_from_zero(&self, round: Round, loss: Loss, bit: usize) -> bool
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(self, round: Round, 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
sourceimpl<S> AddAssign<IeeeFloat<S>> for IeeeFloat<S> where
Self: Float,
impl<S> AddAssign<IeeeFloat<S>> for IeeeFloat<S> where
Self: Float,
sourcefn add_assign(&mut self, rhs: Self)
fn add_assign(&mut self, rhs: Self)
Performs the +=
operation. Read more
sourceimpl<S: Semantics> Display for IeeeFloat<S>
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
sourceimpl<S> DivAssign<IeeeFloat<S>> for IeeeFloat<S> where
Self: Float,
impl<S> DivAssign<IeeeFloat<S>> for IeeeFloat<S> where
Self: Float,
sourcefn div_assign(&mut self, rhs: Self)
fn div_assign(&mut self, rhs: Self)
Performs the /=
operation. Read more
sourceimpl<S: Semantics> Float for IeeeFloat<S>
impl<S: Semantics> Float for IeeeFloat<S>
sourceconst PRECISION: usize = S::PRECISION
const PRECISION: usize = S::PRECISION
Number of bits in the significand. This includes the integer bit.
sourceconst MAX_EXP: ExpInt = S::MAX_EXP
const MAX_EXP: ExpInt = S::MAX_EXP
The largest E such that 2E is representable; this matches the definition of IEEE 754. Read more
sourceconst MIN_EXP: ExpInt = S::MIN_EXP
const MIN_EXP: ExpInt = S::MIN_EXP
The smallest E such that 2E is a normalized number; this matches the definition of IEEE 754. Read more
sourceconst ZERO: Self = IeeeFloat {
sig: [0],
exp: S::MIN_EXP - 1,
category: Category::Zero,
sign: false,
marker: PhantomData,
}
const ZERO: Self = IeeeFloat { sig: [0], exp: S::MIN_EXP - 1, category: Category::Zero, sign: false, marker: PhantomData, }
Positive Zero.
sourceconst INFINITY: Self = IeeeFloat {
sig: [0],
exp: S::MAX_EXP + 1,
category: Category::Infinity,
sign: false,
marker: PhantomData,
}
const INFINITY: Self = IeeeFloat { sig: [0], exp: S::MAX_EXP + 1, category: Category::Infinity, sign: false, marker: PhantomData, }
Positive Infinity.
sourceconst NAN: Self = IeeeFloat {
sig: [S::QNAN_SIGNIFICAND],
exp: S::MAX_EXP + 1,
category: Category::NaN,
sign: false,
marker: PhantomData,
}
const NAN: Self = IeeeFloat { sig: [S::QNAN_SIGNIFICAND], exp: S::MAX_EXP + 1, category: Category::NaN, sign: false, marker: PhantomData, }
NaN (Not a Number).
sourceconst SMALLEST: Self = IeeeFloat {
sig: [1],
exp: S::MIN_EXP,
category: Category::Normal,
sign: false,
marker: PhantomData,
}
const SMALLEST: Self = IeeeFloat { sig: [1], exp: S::MIN_EXP, category: Category::Normal, sign: false, marker: PhantomData, }
Smallest (by magnitude) finite number. Might be denormalized, which implies a relative loss of precision. Read more
sourcefn smallest_normalized() -> Self
fn smallest_normalized() -> Self
Smallest (by magnitude) normalized finite number.
fn add_r(self, rhs: Self, round: Round) -> StatusAnd<Self>
fn mul_r(self, rhs: Self, round: Round) -> StatusAnd<Self>
fn mul_add_r(
self,
multiplicand: Self,
addend: Self,
round: Round
) -> StatusAnd<Self>
fn div_r(self, rhs: Self, round: Round) -> StatusAnd<Self>
fn round_to_integral(self, round: Round) -> StatusAnd<Self>
fn from_bits(input: u128) -> Self
fn from_u128_r(input: u128, round: Round) -> StatusAnd<Self>
fn from_str_r(s: &str, round: Round) -> Result<StatusAnd<Self>, ParseError>
fn to_bits(self) -> u128
fn to_u128_r(
self,
width: usize,
round: Round,
is_exact: &mut bool
) -> StatusAnd<u128>
fn cmp_abs_normal(self, rhs: Self) -> Ordering
sourcefn bitwise_eq(self, rhs: Self) -> bool
fn bitwise_eq(self, rhs: Self) -> bool
Bitwise comparison for equality (QNaNs compare equal, 0!=-0).
sourcefn is_negative(self) -> bool
fn is_negative(self) -> bool
IEEE-754R isSignMinus: Returns whether the current value is negative. Read more
sourcefn is_denormal(self) -> bool
fn is_denormal(self) -> bool
IEEE-754R isSubnormal(): Returns whether the float is a denormal. Read more
sourcefn is_signaling(self) -> bool
fn is_signaling(self) -> bool
Returns true
if the float is a signaling NaN.
fn category(self) -> Category
sourcefn get_exact_inverse(self) -> Option<Self>
fn get_exact_inverse(self) -> Option<Self>
If this value has an exact multiplicative inverse, return it.
sourcefn ilogb(self) -> ExpInt
fn ilogb(self) -> ExpInt
Returns the exponent of the internal representation of the Float. Read more
sourcefn scalbn_r(self, exp: ExpInt, round: Round) -> Self
fn scalbn_r(self, exp: ExpInt, round: Round) -> Self
Returns: self * 2exp for integral exponents.
Equivalent to C standard library function ldexp
. Read more
sourcefn frexp_r(self, exp: &mut ExpInt, round: Round) -> Self
fn frexp_r(self, exp: &mut ExpInt, round: Round) -> Self
Equivalent to C standard library function with the same name. Read more
fn sub_r(self, rhs: Self, round: Round) -> StatusAnd<Self>
fn mul_add(self, multiplicand: Self, addend: Self) -> StatusAnd<Self>
fn abs(self) -> Self
fn copy_sign(self, rhs: Self) -> Self
fn from_i128_r(input: i128, round: Round) -> StatusAnd<Self>
fn from_i128(input: i128) -> StatusAnd<Self>
fn from_u128(input: u128) -> StatusAnd<Self>
sourcefn to_i128_r(
self,
width: usize,
round: Round,
is_exact: &mut bool
) -> StatusAnd<i128>
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. Read more
fn to_i128(self, width: usize) -> StatusAnd<i128>
fn to_u128(self, width: usize) -> StatusAnd<u128>
sourcefn min(self, other: Self) -> Self
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. Read more
sourcefn max(self, other: Self) -> Self
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. Read more
sourcefn is_normal(self) -> bool
fn is_normal(self) -> bool
IEEE-754R isNormal: Returns whether the current value is normal. Read more
sourcefn is_finite(self) -> bool
fn is_finite(self) -> bool
Returns true
if the current value is zero, subnormal, or
normal. Read more
sourcefn is_infinite(self) -> bool
fn is_infinite(self) -> bool
IEEE-754R isInfinite(): Returns whether the float is infinity.
fn is_non_zero(self) -> bool
fn is_finite_non_zero(self) -> bool
fn is_pos_zero(self) -> bool
fn is_neg_zero(self) -> bool
sourcefn is_smallest(self) -> bool
fn is_smallest(self) -> bool
Returns true
if the number has the smallest possible non-zero
magnitude in the current semantics. Read more
sourcefn is_largest(self) -> bool
fn is_largest(self) -> bool
Returns true
if the number has the largest possible finite
magnitude in the current semantics. Read more
sourcefn is_integer(self) -> bool
fn is_integer(self) -> bool
Returns true
if the number is an exact integer.
fn scalbn(self, exp: ExpInt) -> Self
fn frexp(self, exp: &mut ExpInt) -> Self
sourceimpl<S: Semantics, T: Semantics> FloatConvert<IeeeFloat<T>> for IeeeFloat<S>
impl<S: Semantics, T: Semantics> FloatConvert<IeeeFloat<T>> for IeeeFloat<S>
sourcefn convert_r(
self,
round: Round,
loses_info: &mut bool
) -> StatusAnd<IeeeFloat<T>>
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). Read more
fn convert(self, loses_info: &mut bool) -> StatusAnd<T>
sourceimpl<F: FloatConvert<Self>> From<DoubleFloat<F>> for IeeeFloat<FallbackS<F>>
impl<F: FloatConvert<Self>> From<DoubleFloat<F>> for IeeeFloat<FallbackS<F>>
sourcefn from(DoubleFloat: DoubleFloat<F>) -> Self
fn from(DoubleFloat: DoubleFloat<F>) -> Self
Converts to this type from the input type.
sourceimpl<F: Float> From<IeeeFloat<FallbackS<F>>> for DoubleFloat<F> where
F: FloatConvert<IeeeFloat<FallbackExtendedS<F>>>,
IeeeFloat<FallbackExtendedS<F>>: FloatConvert<F>,
impl<F: Float> From<IeeeFloat<FallbackS<F>>> for DoubleFloat<F> where
F: FloatConvert<IeeeFloat<FallbackExtendedS<F>>>,
IeeeFloat<FallbackExtendedS<F>>: FloatConvert<F>,
sourceimpl<S> FromStr for IeeeFloat<S> where
Self: Float,
impl<S> FromStr for IeeeFloat<S> where
Self: Float,
type Err = ParseError
type Err = ParseError
The associated error which can be returned from parsing.
sourceimpl<S> MulAssign<IeeeFloat<S>> for IeeeFloat<S> where
Self: Float,
impl<S> MulAssign<IeeeFloat<S>> for IeeeFloat<S> where
Self: Float,
sourcefn mul_assign(&mut self, rhs: Self)
fn mul_assign(&mut self, rhs: Self)
Performs the *=
operation. Read more
sourceimpl<S: Semantics> PartialOrd<IeeeFloat<S>> for IeeeFloat<S>
impl<S: Semantics> PartialOrd<IeeeFloat<S>> for IeeeFloat<S>
sourcefn partial_cmp(&self, rhs: &Self) -> Option<Ordering>
fn partial_cmp(&self, rhs: &Self) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl<S> RemAssign<IeeeFloat<S>> for IeeeFloat<S> where
Self: Float,
impl<S> RemAssign<IeeeFloat<S>> for IeeeFloat<S> where
Self: Float,
sourcefn rem_assign(&mut self, rhs: Self)
fn rem_assign(&mut self, rhs: Self)
Performs the %=
operation. Read more
sourceimpl<S> SubAssign<IeeeFloat<S>> for IeeeFloat<S> where
Self: Float,
impl<S> SubAssign<IeeeFloat<S>> for IeeeFloat<S> where
Self: Float,
sourcefn sub_assign(&mut self, rhs: Self)
fn sub_assign(&mut self, rhs: Self)
Performs the -=
operation. Read more
impl<S> Copy for IeeeFloat<S>
Auto Trait Implementations
impl<S> RefUnwindSafe for IeeeFloat<S> where
S: RefUnwindSafe,
impl<S> Send for IeeeFloat<S> where
S: Send,
impl<S> Sync for IeeeFloat<S> where
S: Sync,
impl<S> Unpin for IeeeFloat<S> where
S: Unpin,
impl<S> UnwindSafe for IeeeFloat<S> where
S: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more
Layout
Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...)
attributes. Please see the Rust Reference’s “Type Layout” chapter for details on type layout guarantees.
Size: 24 bytes