# Primitive Type f128

`f128`

#116909)## Expand description

A 128-bit floating point type (specifically, the “binary128” type defined in IEEE 754-2008).

This type is very similar to `f32`

and `f64`

, but has increased precision by using twice
as many bits as `f64`

. Please see [the documentation for `f32`

or Wikipedia on
quad-precision values for more information.

Note that no platforms have hardware support for `f128`

without enabling target specific features,
as for all instruction set architectures `f128`

is considered an optional feature.
Only Power ISA (“PowerPC”) and RISCV specify it, and only certain microarchitectures
actually implement it. For x86-64 and AArch64, ISA support is not even specified,
so it will always be a software implementation significantly slower than `f64`

.

## Implementations§

source§### impl f128

### impl f128

source#### pub const RADIX: u32 = 2u32

🔬This is a nightly-only experimental API. (`f128`

#116909)

#### pub const RADIX: u32 = 2u32

`f128`

#116909)The radix or base of the internal representation of `f128`

.

source#### pub const MANTISSA_DIGITS: u32 = 113u32

🔬This is a nightly-only experimental API. (`f128`

#116909)

#### pub const MANTISSA_DIGITS: u32 = 113u32

`f128`

#116909)Number of significant digits in base 2.

source#### pub const DIGITS: u32 = 33u32

🔬This is a nightly-only experimental API. (`f128`

#116909)

#### pub const DIGITS: u32 = 33u32

`f128`

#116909)Approximate number of significant digits in base 10.

This is the maximum *x* such that any decimal number with *x*
significant digits can be converted to `f128`

and back without loss.

Equal to floor(log_{10} 2^{MANTISSA_DIGITS − 1}).

source#### pub const EPSILON: f128 = {transmute(0x3f8f0000000000000000000000000000): f128}

🔬This is a nightly-only experimental API. (`f128`

#116909)

#### pub const EPSILON: f128 = {transmute(0x3f8f0000000000000000000000000000): f128}

`f128`

#116909)Machine epsilon value for `f128`

.

This is the difference between `1.0`

and the next larger representable number.

Equal to 2^{1 − MANTISSA_DIGITS}.

source#### pub const MIN: f128 = {transmute(0xfffeffffffffffffffffffffffffffff): f128}

🔬This is a nightly-only experimental API. (`f128`

#116909)

#### pub const MIN: f128 = {transmute(0xfffeffffffffffffffffffffffffffff): f128}

`f128`

#116909)Smallest finite `f128`

value.

Equal to −`MAX`

.

source#### pub const MIN_POSITIVE: f128 = {transmute(0x00010000000000000000000000000000): f128}

🔬This is a nightly-only experimental API. (`f128`

#116909)

#### pub const MIN_POSITIVE: f128 = {transmute(0x00010000000000000000000000000000): f128}

`f128`

#116909)Smallest positive normal `f128`

value.

Equal to 2^{MIN_EXP − 1}.

source#### pub const MAX: f128 = {transmute(0x7ffeffffffffffffffffffffffffffff): f128}

🔬This is a nightly-only experimental API. (`f128`

#116909)

#### pub const MAX: f128 = {transmute(0x7ffeffffffffffffffffffffffffffff): f128}

`f128`

#116909)Largest finite `f128`

value.

Equal to
(1 − 2^{−MANTISSA_DIGITS}) 2^{MAX_EXP}.

source#### pub const MIN_EXP: i32 = -16_381i32

🔬This is a nightly-only experimental API. (`f128`

#116909)

#### pub const MIN_EXP: i32 = -16_381i32

`f128`

#116909)One greater than the minimum possible normal power of 2 exponent.

If *x* = `MIN_EXP`

, then normal numbers
≥ 0.5 × 2^{x}.

source#### pub const MAX_EXP: i32 = 16_384i32

🔬This is a nightly-only experimental API. (`f128`

#116909)

#### pub const MAX_EXP: i32 = 16_384i32

`f128`

#116909)Maximum possible power of 2 exponent.

If *x* = `MAX_EXP`

, then normal numbers
< 1 × 2^{x}.

source#### pub const MIN_10_EXP: i32 = -4_931i32

🔬This is a nightly-only experimental API. (`f128`

#116909)

#### pub const MIN_10_EXP: i32 = -4_931i32

`f128`

#116909)Minimum *x* for which 10^{x} is normal.

Equal to ceil(log_{10} `MIN_POSITIVE`

).

source#### pub const MAX_10_EXP: i32 = 4_932i32

🔬This is a nightly-only experimental API. (`f128`

#116909)

#### pub const MAX_10_EXP: i32 = 4_932i32

`f128`

#116909)Maximum *x* for which 10^{x} is normal.

Equal to floor(log_{10} `MAX`

).

source#### pub const fn is_nan(self) -> bool

🔬This is a nightly-only experimental API. (`f128`

#116909)

#### pub const fn is_nan(self) -> bool

`f128`

#116909)Returns `true`

if this value is NaN.

source#### pub fn is_sign_positive(self) -> bool

🔬This is a nightly-only experimental API. (`f128`

#116909)

#### pub fn is_sign_positive(self) -> bool

`f128`

#116909)Returns `true`

if `self`

has a positive sign, including `+0.0`

, NaNs with
positive sign bit and positive infinity. Note that IEEE 754 doesn’t assign any
meaning to the sign bit in case of a NaN, and as Rust doesn’t guarantee that
the bit pattern of NaNs are conserved over arithmetic operations, the result of
`is_sign_positive`

on a NaN might produce an unexpected result in some cases.
See explanation of NaN as a special value for more info.

```
#![feature(f128)]
let f = 7.0_f128;
let g = -7.0_f128;
assert!(f.is_sign_positive());
assert!(!g.is_sign_positive());
```

Runsource#### pub fn is_sign_negative(self) -> bool

🔬This is a nightly-only experimental API. (`f128`

#116909)

#### pub fn is_sign_negative(self) -> bool

`f128`

#116909)Returns `true`

if `self`

has a negative sign, including `-0.0`

, NaNs with
negative sign bit and negative infinity. Note that IEEE 754 doesn’t assign any
meaning to the sign bit in case of a NaN, and as Rust doesn’t guarantee that
the bit pattern of NaNs are conserved over arithmetic operations, the result of
`is_sign_negative`

on a NaN might produce an unexpected result in some cases.
See explanation of NaN as a special value for more info.

```
#![feature(f128)]
let f = 7.0_f128;
let g = -7.0_f128;
assert!(!f.is_sign_negative());
assert!(g.is_sign_negative());
```

Runsource#### pub fn to_bits(self) -> u128

🔬This is a nightly-only experimental API. (`f128`

#116909)

#### pub fn to_bits(self) -> u128

`f128`

#116909)Raw transmutation to `u128`

.

This is currently identical to `transmute::<f128, u128>(self)`

on all platforms.

See `from_bits`

for some discussion of the
portability of this operation (there are almost no issues).

Note that this function is distinct from `as`

casting, which attempts to
preserve the *numeric* value, and not the bitwise value.

source#### pub fn from_bits(v: u128) -> Self

🔬This is a nightly-only experimental API. (`f128`

#116909)

#### pub fn from_bits(v: u128) -> Self

`f128`

#116909)Raw transmutation from `u128`

.

This is currently identical to `transmute::<u128, f128>(v)`

on all platforms.
It turns out this is incredibly portable, for two reasons:

- Floats and Ints have the same endianness on all supported platforms.
- IEEE 754 very precisely specifies the bit layout of floats.

However there is one caveat: prior to the 2008 version of IEEE 754, how to interpret the NaN signaling bit wasn’t actually specified. Most platforms (notably x86 and ARM) picked the interpretation that was ultimately standardized in 2008, but some didn’t (notably MIPS). As a result, all signaling NaNs on MIPS are quiet NaNs on x86, and vice-versa.

Rather than trying to preserve signaling-ness cross-platform, this implementation favors preserving the exact bits. This means that any payloads encoded in NaNs will be preserved even if the result of this method is sent over the network from an x86 machine to a MIPS one.

If the results of this method are only manipulated by the same architecture that produced them, then there is no portability concern.

If the input isn’t NaN, then there is no portability concern.

If you don’t care about signalingness (very likely), then there is no portability concern.

Note that this function is distinct from `as`

casting, which attempts to
preserve the *numeric* value, and not the bitwise value.

## Trait Implementations§

1.22.0 · source§### impl AddAssign<&f128> for f128

### impl AddAssign<&f128> for f128

source§#### fn add_assign(&mut self, other: &f128)

#### fn add_assign(&mut self, other: &f128)

`+=`

operation. Read more1.8.0 · source§### impl AddAssign for f128

### impl AddAssign for f128

source§#### fn add_assign(&mut self, other: f128)

#### fn add_assign(&mut self, other: f128)

`+=`

operation. Read more1.22.0 · source§### impl DivAssign<&f128> for f128

### impl DivAssign<&f128> for f128

source§#### fn div_assign(&mut self, other: &f128)

#### fn div_assign(&mut self, other: &f128)

`/=`

operation. Read more1.8.0 · source§### impl DivAssign for f128

### impl DivAssign for f128

source§#### fn div_assign(&mut self, other: f128)

#### fn div_assign(&mut self, other: f128)

`/=`

operation. Read more1.22.0 · source§### impl MulAssign<&f128> for f128

### impl MulAssign<&f128> for f128

source§#### fn mul_assign(&mut self, other: &f128)

#### fn mul_assign(&mut self, other: &f128)

`*=`

operation. Read more1.8.0 · source§### impl MulAssign for f128

### impl MulAssign for f128

source§#### fn mul_assign(&mut self, other: f128)

#### fn mul_assign(&mut self, other: f128)

`*=`

operation. Read more1.0.0 (const: unstable) · source§### impl PartialEq for f128

### impl PartialEq for f128

1.0.0 · source§### impl PartialOrd for f128

### impl PartialOrd for f128

source§#### fn le(&self, other: &f128) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read more1.0.0 · source§### impl Rem for f128

### impl Rem for f128

The remainder from the division of two floats.

The remainder has the same sign as the dividend and is computed as:
`x - (x / y).trunc() * y`

.

#### §Examples

```
let x: f32 = 50.50;
let y: f32 = 8.125;
let remainder = x - (x / y).trunc() * y;
// The answer to both operations is 1.75
assert_eq!(x % y, remainder);
```

Run1.22.0 · source§### impl RemAssign<&f128> for f128

### impl RemAssign<&f128> for f128

source§#### fn rem_assign(&mut self, other: &f128)

#### fn rem_assign(&mut self, other: &f128)

`%=`

operation. Read more1.8.0 · source§### impl RemAssign for f128

### impl RemAssign for f128

source§#### fn rem_assign(&mut self, other: f128)

#### fn rem_assign(&mut self, other: f128)

`%=`

operation. Read more1.22.0 · source§### impl SubAssign<&f128> for f128

### impl SubAssign<&f128> for f128

source§#### fn sub_assign(&mut self, other: &f128)

#### fn sub_assign(&mut self, other: &f128)

`-=`

operation. Read more1.8.0 · source§### impl SubAssign for f128

### impl SubAssign for f128

source§#### fn sub_assign(&mut self, other: f128)

#### fn sub_assign(&mut self, other: f128)

`-=`

operation. Read more