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

## Implementations§

source§### impl f128

### impl f128

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.

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

source#### 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) -> f128

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

#116909)

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

`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