# 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§

source§### impl<S: Semantics> IeeeFloat<S>

### impl<S: Semantics> IeeeFloat<S>

source#### fn 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.

source#### fn 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§

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

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

source§#### fn add_assign(&mut self, rhs: Self)

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

`+=`

operation. Read moresource§### impl<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

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

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

source§#### fn div_assign(&mut self, rhs: Self)

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

`/=`

operation. Read moresource§### impl<S: Semantics> Float for IeeeFloat<S>

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

source§#### const PRECISION: usize = S::PRECISION

#### const PRECISION: usize = S::PRECISION

source§#### const MAX_EXP: ExpInt = S::MAX_EXP

#### const MAX_EXP: ExpInt = S::MAX_EXP

^{E}is representable; this matches the definition of IEEE 754.

source§#### const MIN_EXP: ExpInt = S::MIN_EXP

#### const MIN_EXP: ExpInt = S::MIN_EXP

^{E}is a normalized number; this matches the definition of IEEE 754.

source§#### const SMALLEST: Self = _

#### const SMALLEST: Self = _

source§#### fn smallest_normalized() -> Self

#### fn smallest_normalized() -> Self

#### 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

source§#### fn bitwise_eq(self, rhs: Self) -> bool

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

source§#### fn is_negative(self) -> bool

#### fn is_negative(self) -> bool

source§#### fn is_denormal(self) -> bool

#### fn is_denormal(self) -> bool

source§#### fn is_signaling(self) -> bool

#### fn is_signaling(self) -> bool

`true`

if the float is a signaling NaN.#### fn category(self) -> Category

source§#### fn get_exact_inverse(self) -> Option<Self>

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

source§#### fn ilogb(self) -> ExpInt

#### fn ilogb(self) -> ExpInt

source§#### fn scalbn_r(self, exp: ExpInt, round: Round) -> Self

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

^{exp}for integral exponents. Equivalent to C standard library function

`ldexp`

.source§#### fn frexp_r(self, exp: &mut ExpInt, round: Round) -> Self

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

#### 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>

source§#### fn 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>

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

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

source§#### fn min(self, other: Self) -> Self

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

source§#### fn max(self, other: Self) -> Self

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

source§#### fn is_normal(self) -> bool

#### fn is_normal(self) -> bool

source§#### fn is_finite(self) -> bool

#### fn is_finite(self) -> bool

`true`

if the current value is zero, subnormal, or
normal. Read moresource§#### fn is_infinite(self) -> bool

#### fn is_infinite(self) -> bool

#### 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

source§#### fn is_smallest(self) -> bool

#### fn is_smallest(self) -> bool

`true`

if the number has the smallest possible non-zero
magnitude in the current semantics.source§#### fn is_largest(self) -> bool

#### fn is_largest(self) -> bool

`true`

if the number has the largest possible finite
magnitude in the current semantics.source§#### fn is_integer(self) -> bool

#### fn is_integer(self) -> bool

`true`

if the number is an exact integer.#### fn scalbn(self, exp: ExpInt) -> Self

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

source§### impl<S: Semantics, T: Semantics> FloatConvert<IeeeFloat<T>> for IeeeFloat<S>

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

source§#### fn 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>>

`value == Status::OK`

,
but there are edge cases where this is not so).#### fn convert(self, loses_info: &mut bool) -> StatusAnd<T>

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

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

source§#### fn from(DoubleFloat: DoubleFloat<F>) -> Self

#### fn from(DoubleFloat: DoubleFloat<F>) -> Self

source§### impl<F> From<IeeeFloat<FallbackS<F>>> for DoubleFloat<F>where
F: FloatConvert<IeeeFloat<FallbackExtendedS<F>>> + Float,
IeeeFloat<FallbackExtendedS<F>>: FloatConvert<F>,

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

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

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

§#### type Err = ParseError

#### type Err = ParseError

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

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

source§#### fn mul_assign(&mut self, rhs: Self)

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

`*=`

operation. Read moresource§### impl<S: Semantics> PartialOrd<IeeeFloat<S>> for IeeeFloat<S>

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

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl<S> RemAssign<IeeeFloat<S>> for IeeeFloat<S>where
Self: Float,

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

source§#### fn rem_assign(&mut self, rhs: Self)

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

`%=`

operation. Read moresource§### impl<S> SubAssign<IeeeFloat<S>> for IeeeFloat<S>where
Self: Float,

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

source§#### fn sub_assign(&mut self, rhs: Self)

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

`-=`

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§

## 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