`pub struct f16(/* private fields */);`

## Expand description

A 16-bit floating point type implementing the IEEE 754-2008 standard `binary16`

a.k.a “half”
format.

This 16-bit floating point type is intended for efficient storage where the full range and precision of a larger floating point value is not required.

## Implementations§

source§### impl f16

### impl f16

source#### pub const fn from_bits(bits: u16) -> f16

#### pub const fn from_bits(bits: u16) -> f16

Constructs a 16-bit floating point value from the raw bits.

source#### pub fn from_f32(value: f32) -> f16

#### pub fn from_f32(value: f32) -> f16

Constructs a 16-bit floating point value from a 32-bit floating point value.

This operation is lossy. If the 32-bit value is to large to fit in 16-bits, ±∞ will result. NaN values are preserved. 32-bit subnormal values are too tiny to be represented in 16-bits and result in ±0. Exponents that underflow the minimum 16-bit exponent will result in 16-bit subnormals or ±0. All other values are truncated and rounded to the nearest representable 16-bit value.

source#### pub const fn from_f32_const(value: f32) -> f16

#### pub const fn from_f32_const(value: f32) -> f16

Constructs a 16-bit floating point value from a 32-bit floating point value.

This function is identical to `from_f32`

except it never uses hardware
intrinsics, which allows it to be `const`

. `from_f32`

should be preferred
in any non-`const`

context.

This operation is lossy. If the 32-bit value is to large to fit in 16-bits, ±∞ will result. NaN values are preserved. 32-bit subnormal values are too tiny to be represented in 16-bits and result in ±0. Exponents that underflow the minimum 16-bit exponent will result in 16-bit subnormals or ±0. All other values are truncated and rounded to the nearest representable 16-bit value.

source#### pub fn from_f64(value: f64) -> f16

#### pub fn from_f64(value: f64) -> f16

Constructs a 16-bit floating point value from a 64-bit floating point value.

This operation is lossy. If the 64-bit value is to large to fit in 16-bits, ±∞ will result. NaN values are preserved. 64-bit subnormal values are too tiny to be represented in 16-bits and result in ±0. Exponents that underflow the minimum 16-bit exponent will result in 16-bit subnormals or ±0. All other values are truncated and rounded to the nearest representable 16-bit value.

source#### pub const fn from_f64_const(value: f64) -> f16

#### pub const fn from_f64_const(value: f64) -> f16

Constructs a 16-bit floating point value from a 64-bit floating point value.

This function is identical to `from_f64`

except it never uses hardware
intrinsics, which allows it to be `const`

. `from_f64`

should be preferred
in any non-`const`

context.

This operation is lossy. If the 64-bit value is to large to fit in 16-bits, ±∞ will result. NaN values are preserved. 64-bit subnormal values are too tiny to be represented in 16-bits and result in ±0. Exponents that underflow the minimum 16-bit exponent will result in 16-bit subnormals or ±0. All other values are truncated and rounded to the nearest representable 16-bit value.

source#### pub const fn to_le_bytes(self) -> [u8; 2]

#### pub const fn to_le_bytes(self) -> [u8; 2]

Returns the memory representation of the underlying bit representation as a byte array in little-endian byte order.

##### §Examples

```
let bytes = f16::from_f32(12.5).to_le_bytes();
assert_eq!(bytes, [0x40, 0x4A]);
```

source#### pub const fn to_be_bytes(self) -> [u8; 2]

#### pub const fn to_be_bytes(self) -> [u8; 2]

Returns the memory representation of the underlying bit representation as a byte array in big-endian (network) byte order.

##### §Examples

```
let bytes = f16::from_f32(12.5).to_be_bytes();
assert_eq!(bytes, [0x4A, 0x40]);
```

source#### pub const fn to_ne_bytes(self) -> [u8; 2]

#### pub const fn to_ne_bytes(self) -> [u8; 2]

Returns the memory representation of the underlying bit representation as a byte array in native byte order.

As the target platform’s native endianness is used, portable code should use
`to_be_bytes`

or `to_le_bytes`

, as appropriate,
instead.

##### §Examples

```
let bytes = f16::from_f32(12.5).to_ne_bytes();
assert_eq!(bytes, if cfg!(target_endian = "big") {
[0x4A, 0x40]
} else {
[0x40, 0x4A]
});
```

source#### pub const fn from_le_bytes(bytes: [u8; 2]) -> f16

#### pub const fn from_le_bytes(bytes: [u8; 2]) -> f16

Creates a floating point value from its representation as a byte array in little endian.

##### §Examples

```
let value = f16::from_le_bytes([0x40, 0x4A]);
assert_eq!(value, f16::from_f32(12.5));
```

source#### pub const fn from_be_bytes(bytes: [u8; 2]) -> f16

#### pub const fn from_be_bytes(bytes: [u8; 2]) -> f16

Creates a floating point value from its representation as a byte array in big endian.

##### §Examples

```
let value = f16::from_be_bytes([0x4A, 0x40]);
assert_eq!(value, f16::from_f32(12.5));
```

source#### pub const fn from_ne_bytes(bytes: [u8; 2]) -> f16

#### pub const fn from_ne_bytes(bytes: [u8; 2]) -> f16

Creates a floating point value from its representation as a byte array in native endian.

As the target platform’s native endianness is used, portable code likely wants to use
`from_be_bytes`

or `from_le_bytes`

, as
appropriate instead.

##### §Examples

```
let value = f16::from_ne_bytes(if cfg!(target_endian = "big") {
[0x4A, 0x40]
} else {
[0x40, 0x4A]
});
assert_eq!(value, f16::from_f32(12.5));
```

source#### pub fn to_f32(self) -> f32

#### pub fn to_f32(self) -> f32

Converts a [`f16`

] value into a `f32`

value.

This conversion is lossless as all 16-bit floating point values can be represented exactly in 32-bit floating point.

source#### pub const fn to_f32_const(self) -> f32

#### pub const fn to_f32_const(self) -> f32

Converts a [`f16`

] value into a `f32`

value.

This function is identical to `to_f32`

except it never uses hardware
intrinsics, which allows it to be `const`

. `to_f32`

should be preferred
in any non-`const`

context.

This conversion is lossless as all 16-bit floating point values can be represented exactly in 32-bit floating point.

source#### pub fn to_f64(self) -> f64

#### pub fn to_f64(self) -> f64

Converts a [`f16`

] value into a `f64`

value.

This conversion is lossless as all 16-bit floating point values can be represented exactly in 64-bit floating point.

source#### pub const fn to_f64_const(self) -> f64

#### pub const fn to_f64_const(self) -> f64

Converts a [`f16`

] value into a `f64`

value.

This function is identical to `to_f64`

except it never uses hardware
intrinsics, which allows it to be `const`

. `to_f64`

should be preferred
in any non-`const`

context.

This conversion is lossless as all 16-bit floating point values can be represented exactly in 64-bit floating point.

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

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

Returns `true`

if this value is `NaN`

and `false`

otherwise.

##### §Examples

```
let nan = f16::NAN;
let f = f16::from_f32(7.0_f32);
assert!(nan.is_nan());
assert!(!f.is_nan());
```

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

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

Returns `true`

if this value is ±∞ and `false`

.
otherwise.

##### §Examples

```
let f = f16::from_f32(7.0f32);
let inf = f16::INFINITY;
let neg_inf = f16::NEG_INFINITY;
let nan = f16::NAN;
assert!(!f.is_infinite());
assert!(!nan.is_infinite());
assert!(inf.is_infinite());
assert!(neg_inf.is_infinite());
```

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

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

Returns `true`

if this number is neither infinite nor `NaN`

.

##### §Examples

```
let f = f16::from_f32(7.0f32);
let inf = f16::INFINITY;
let neg_inf = f16::NEG_INFINITY;
let nan = f16::NAN;
assert!(f.is_finite());
assert!(!nan.is_finite());
assert!(!inf.is_finite());
assert!(!neg_inf.is_finite());
```

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

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

Returns `true`

if the number is neither zero, infinite, subnormal, or `NaN`

.

##### §Examples

```
let min = f16::MIN_POSITIVE;
let max = f16::MAX;
let lower_than_min = f16::from_f32(1.0e-10_f32);
let zero = f16::from_f32(0.0_f32);
assert!(min.is_normal());
assert!(max.is_normal());
assert!(!zero.is_normal());
assert!(!f16::NAN.is_normal());
assert!(!f16::INFINITY.is_normal());
// Values between `0` and `min` are Subnormal.
assert!(!lower_than_min.is_normal());
```

source#### pub const fn classify(self) -> FpCategory

#### pub const fn classify(self) -> FpCategory

Returns the floating point category of the number.

If only one property is going to be tested, it is generally faster to use the specific predicate instead.

##### §Examples

```
use std::num::FpCategory;
let num = f16::from_f32(12.4_f32);
let inf = f16::INFINITY;
assert_eq!(num.classify(), FpCategory::Normal);
assert_eq!(inf.classify(), FpCategory::Infinite);
```

source#### pub const fn signum(self) -> f16

#### pub const fn signum(self) -> f16

Returns a number that represents the sign of `self`

.

`1.0`

if the number is positive,`+0.0`

or`INFINITY`

`-1.0`

if the number is negative,`-0.0`

or`NEG_INFINITY`

`NAN`

if the number is`NaN`

##### §Examples

```
let f = f16::from_f32(3.5_f32);
assert_eq!(f.signum(), f16::from_f32(1.0));
assert_eq!(f16::NEG_INFINITY.signum(), f16::from_f32(-1.0));
assert!(f16::NAN.signum().is_nan());
```

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

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

Returns `true`

if and only if `self`

has a positive sign, including `+0.0`

, `NaNs`

with a
positive sign bit and +∞.

##### §Examples

```
let nan = f16::NAN;
let f = f16::from_f32(7.0_f32);
let g = f16::from_f32(-7.0_f32);
assert!(f.is_sign_positive());
assert!(!g.is_sign_positive());
// `NaN` can be either positive or negative
assert!(nan.is_sign_positive() != nan.is_sign_negative());
```

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

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

Returns `true`

if and only if `self`

has a negative sign, including `-0.0`

, `NaNs`

with a
negative sign bit and −∞.

##### §Examples

```
let nan = f16::NAN;
let f = f16::from_f32(7.0f32);
let g = f16::from_f32(-7.0f32);
assert!(!f.is_sign_negative());
assert!(g.is_sign_negative());
// `NaN` can be either positive or negative
assert!(nan.is_sign_positive() != nan.is_sign_negative());
```

source#### pub const fn copysign(self, sign: f16) -> f16

#### pub const fn copysign(self, sign: f16) -> f16

Returns a number composed of the magnitude of `self`

and the sign of `sign`

.

Equal to `self`

if the sign of `self`

and `sign`

are the same, otherwise equal to `-self`

.
If `self`

is NaN, then NaN with the sign of `sign`

is returned.

##### §Examples

```
let f = f16::from_f32(3.5);
assert_eq!(f.copysign(f16::from_f32(0.42)), f16::from_f32(3.5));
assert_eq!(f.copysign(f16::from_f32(-0.42)), f16::from_f32(-3.5));
assert_eq!((-f).copysign(f16::from_f32(0.42)), f16::from_f32(3.5));
assert_eq!((-f).copysign(f16::from_f32(-0.42)), f16::from_f32(-3.5));
assert!(f16::NAN.copysign(f16::from_f32(1.0)).is_nan());
```

source#### pub fn max(self, other: f16) -> f16

#### pub fn max(self, other: f16) -> f16

Returns the maximum of the two numbers.

If one of the arguments is NaN, then the other argument is returned.

##### §Examples

```
let x = f16::from_f32(1.0);
let y = f16::from_f32(2.0);
assert_eq!(x.max(y), y);
```

source#### pub fn min(self, other: f16) -> f16

#### pub fn min(self, other: f16) -> f16

Returns the minimum of the two numbers.

If one of the arguments is NaN, then the other argument is returned.

##### §Examples

```
let x = f16::from_f32(1.0);
let y = f16::from_f32(2.0);
assert_eq!(x.min(y), x);
```

source#### pub fn clamp(self, min: f16, max: f16) -> f16

#### pub fn clamp(self, min: f16, max: f16) -> f16

Restrict a value to a certain interval unless it is NaN.

Returns `max`

if `self`

is greater than `max`

, and `min`

if `self`

is less than `min`

.
Otherwise this returns `self`

.

Note that this function returns NaN if the initial value was NaN as well.

##### §Panics

Panics if `min > max`

, `min`

is NaN, or `max`

is NaN.

##### §Examples

```
assert!(f16::from_f32(-3.0).clamp(f16::from_f32(-2.0), f16::from_f32(1.0)) == f16::from_f32(-2.0));
assert!(f16::from_f32(0.0).clamp(f16::from_f32(-2.0), f16::from_f32(1.0)) == f16::from_f32(0.0));
assert!(f16::from_f32(2.0).clamp(f16::from_f32(-2.0), f16::from_f32(1.0)) == f16::from_f32(1.0));
assert!(f16::NAN.clamp(f16::from_f32(-2.0), f16::from_f32(1.0)).is_nan());
```

source#### pub fn total_cmp(&self, other: &Self) -> Ordering

#### pub fn total_cmp(&self, other: &Self) -> Ordering

Returns the ordering between `self`

and `other`

.

Unlike the standard partial comparison between floating point numbers,
this comparison always produces an ordering in accordance to
the `totalOrder`

predicate as defined in the IEEE 754 (2008 revision)
floating point standard. The values are ordered in the following sequence:

- negative quiet NaN
- negative signaling NaN
- negative infinity
- negative numbers
- negative subnormal numbers
- negative zero
- positive zero
- positive subnormal numbers
- positive numbers
- positive infinity
- positive signaling NaN
- positive quiet NaN.

The ordering established by this function does not always agree with the
`PartialOrd`

and `PartialEq`

implementations of `f16`

. For example,
they consider negative and positive zero equal, while `total_cmp`

doesn’t.

The interpretation of the signaling NaN bit follows the definition in the IEEE 754 standard, which may not match the interpretation by some of the older, non-conformant (e.g. MIPS) hardware implementations.

##### §Examples

```
let mut v: Vec<f16> = vec![];
v.push(f16::ONE);
v.push(f16::INFINITY);
v.push(f16::NEG_INFINITY);
v.push(f16::NAN);
v.push(f16::MAX_SUBNORMAL);
v.push(-f16::MAX_SUBNORMAL);
v.push(f16::ZERO);
v.push(f16::NEG_ZERO);
v.push(f16::NEG_ONE);
v.push(f16::MIN_POSITIVE);
v.sort_by(|a, b| a.total_cmp(&b));
assert!(v
.into_iter()
.zip(
[
f16::NEG_INFINITY,
f16::NEG_ONE,
-f16::MAX_SUBNORMAL,
f16::NEG_ZERO,
f16::ZERO,
f16::MAX_SUBNORMAL,
f16::MIN_POSITIVE,
f16::ONE,
f16::INFINITY,
f16::NAN
]
.iter()
)
.all(|(a, b)| a.to_bits() == b.to_bits()));
```

source#### pub const EPSILON: f16 = _

#### pub const EPSILON: f16 = _

[`f16`

]
machine epsilon value

This is the difference between 1.0 and the next largest representable number.

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

#### pub const MANTISSA_DIGITS: u32 = 11u32

Number of [`f16`

] significant digits in base 2

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

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

Maximum possible [`f16`

] power of 10 exponent

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

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

Minimum possible normal [`f16`

] power of 10 exponent

source#### pub const MIN_EXP: i32 = -13i32

#### pub const MIN_EXP: i32 = -13i32

One greater than the minimum possible normal [`f16`

] power of 2 exponent

source#### pub const MIN_POSITIVE: f16 = _

#### pub const MIN_POSITIVE: f16 = _

Smallest positive normal [`f16`

] value

source#### pub const NEG_INFINITY: f16 = _

#### pub const NEG_INFINITY: f16 = _

[`f16`

] negative infinity (-∞)

source#### pub const MIN_POSITIVE_SUBNORMAL: f16 = _

#### pub const MIN_POSITIVE_SUBNORMAL: f16 = _

Minimum positive subnormal [`f16`

] value

source#### pub const MAX_SUBNORMAL: f16 = _

#### pub const MAX_SUBNORMAL: f16 = _

Maximum subnormal [`f16`

] value

source#### pub const FRAC_1_SQRT_2: f16 = _

#### pub const FRAC_1_SQRT_2: f16 = _

[`f16`

] 1/√2

source#### pub const FRAC_2_SQRT_PI: f16 = _

#### pub const FRAC_2_SQRT_PI: f16 = _

[`f16`

] 2/√π

## Trait Implementations§

source§### impl AddAssign<&f16> for f16

### impl AddAssign<&f16> for f16

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

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

`+=`

operation. Read moresource§### impl AddAssign for f16

### impl AddAssign for f16

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

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

`+=`

operation. Read moresource§### impl AsPrimitive<bf16> for f16

### impl AsPrimitive<bf16> for f16

source§### impl AsPrimitive<f16> for bf16

### impl AsPrimitive<f16> for bf16

source§### impl AsPrimitive<f16> for f16

### impl AsPrimitive<f16> for f16

source§### impl AsPrimitive<f16> for f32

### impl AsPrimitive<f16> for f32

source§### impl AsPrimitive<f16> for f64

### impl AsPrimitive<f16> for f64

source§### impl AsPrimitive<f16> for i16

### impl AsPrimitive<f16> for i16

source§### impl AsPrimitive<f16> for i32

### impl AsPrimitive<f16> for i32

source§### impl AsPrimitive<f16> for i64

### impl AsPrimitive<f16> for i64

source§### impl AsPrimitive<f16> for i8

### impl AsPrimitive<f16> for i8

source§### impl AsPrimitive<f16> for isize

### impl AsPrimitive<f16> for isize

source§### impl AsPrimitive<f16> for u16

### impl AsPrimitive<f16> for u16

source§### impl AsPrimitive<f16> for u32

### impl AsPrimitive<f16> for u32

source§### impl AsPrimitive<f16> for u64

### impl AsPrimitive<f16> for u64

source§### impl AsPrimitive<f16> for u8

### impl AsPrimitive<f16> for u8

source§### impl AsPrimitive<f16> for usize

### impl AsPrimitive<f16> for usize

source§### impl AsPrimitive<f32> for f16

### impl AsPrimitive<f32> for f16

source§### impl AsPrimitive<f64> for f16

### impl AsPrimitive<f64> for f16

source§### impl AsPrimitive<i16> for f16

### impl AsPrimitive<i16> for f16

source§### impl AsPrimitive<i32> for f16

### impl AsPrimitive<i32> for f16

source§### impl AsPrimitive<i64> for f16

### impl AsPrimitive<i64> for f16

source§### impl AsPrimitive<i8> for f16

### impl AsPrimitive<i8> for f16

source§### impl AsPrimitive<isize> for f16

### impl AsPrimitive<isize> for f16

source§### impl AsPrimitive<u16> for f16

### impl AsPrimitive<u16> for f16

source§### impl AsPrimitive<u32> for f16

### impl AsPrimitive<u32> for f16

source§### impl AsPrimitive<u64> for f16

### impl AsPrimitive<u64> for f16

source§### impl AsPrimitive<u8> for f16

### impl AsPrimitive<u8> for f16

source§### impl AsPrimitive<usize> for f16

### impl AsPrimitive<usize> for f16

source§### impl DivAssign<&f16> for f16

### impl DivAssign<&f16> for f16

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

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

`/=`

operation. Read moresource§### impl DivAssign for f16

### impl DivAssign for f16

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

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

`/=`

operation. Read moresource§### impl Float for f16

### impl Float for f16

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

#### fn neg_infinity() -> Self

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

#### fn min_value() -> Self

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

#### fn min_positive_value() -> Self

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

#### fn max_value() -> Self

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

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

`true`

if this value is positive infinity or negative infinity and
false otherwise. Read moresource§#### fn classify(self) -> FpCategory

#### fn classify(self) -> FpCategory

source§#### fn ceil(self) -> Self

#### fn ceil(self) -> Self

source§#### fn round(self) -> Self

#### fn round(self) -> Self

`0.0`

. Read moresource§#### fn is_sign_positive(self) -> bool

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

`true`

if `self`

is positive, including `+0.0`

,
`Float::infinity()`

, and since Rust 1.20 also `Float::nan()`

. Read moresource§#### fn is_sign_negative(self) -> bool

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

`true`

if `self`

is negative, including `-0.0`

,
`Float::neg_infinity()`

, and since Rust 1.20 also `-Float::nan()`

. Read moresource§#### fn mul_add(self, a: Self, b: Self) -> Self

#### fn mul_add(self, a: Self, b: Self) -> Self

`(self * a) + b`

with only one rounding
error, yielding a more accurate result than an unfused multiply-add. Read moresource§#### fn log(self, base: Self) -> Self

#### fn log(self, base: Self) -> Self

source§#### fn to_degrees(self) -> Self

#### fn to_degrees(self) -> Self

source§#### fn to_radians(self) -> Self

#### fn to_radians(self) -> Self

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

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

`x`

and `y`

. Read moresource§#### fn asin(self) -> Self

#### fn asin(self) -> Self

source§#### fn acos(self) -> Self

#### fn acos(self) -> Self

source§#### fn atan(self) -> Self

#### fn atan(self) -> Self

source§#### fn exp_m1(self) -> Self

#### fn exp_m1(self) -> Self

`e^(self) - 1`

in a way that is accurate even if the
number is close to zero. Read moresource§#### fn ln_1p(self) -> Self

#### fn ln_1p(self) -> Self

`ln(1+n)`

(natural logarithm) more accurately than if
the operations were performed separately. Read moresource§### impl FloatConst for f16

### impl FloatConst for f16

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

#### fn FRAC_1_SQRT_2() -> Self

`1.0 / sqrt(2.0)`

.source§#### fn FRAC_2_SQRT_PI() -> Self

#### fn FRAC_2_SQRT_PI() -> Self

`2.0 / sqrt(π)`

.source§### impl FloatCore for f16

### impl FloatCore for f16

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

#### fn neg_infinity() -> Self

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

#### fn min_value() -> Self

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

#### fn min_positive_value() -> Self

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

#### fn max_value() -> Self

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

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

`true`

if the number is infinite. Read moresource§#### fn is_normal(self) -> bool

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

`true`

if the number is neither zero, infinite, subnormal or NaN. Read moresource§#### fn classify(self) -> FpCategory

#### fn classify(self) -> FpCategory

source§#### fn ceil(self) -> Self

#### fn ceil(self) -> Self

source§#### fn round(self) -> Self

#### fn round(self) -> Self

`0.0`

. Read moresource§#### fn abs(self) -> Self

#### fn abs(self) -> Self

`self`

. Returns `FloatCore::nan()`

if the
number is `FloatCore::nan()`

. Read moresource§#### fn is_sign_positive(self) -> bool

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

`true`

if `self`

is positive, including `+0.0`

and
`FloatCore::infinity()`

, and since Rust 1.20 also
`FloatCore::nan()`

. Read moresource§#### fn is_sign_negative(self) -> bool

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

`true`

if `self`

is negative, including `-0.0`

and
`FloatCore::neg_infinity()`

, and since Rust 1.20 also
`-FloatCore::nan()`

. Read moresource§#### fn recip(self) -> Self

#### fn recip(self) -> Self

source§#### fn to_degrees(self) -> Self

#### fn to_degrees(self) -> Self

source§#### fn to_radians(self) -> Self

#### fn to_radians(self) -> Self

source§### impl FromPrimitive for f16

### impl FromPrimitive for f16

source§#### fn from_i64(n: i64) -> Option<Self>

#### fn from_i64(n: i64) -> Option<Self>

`i64`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_u64(n: u64) -> Option<Self>

#### fn from_u64(n: u64) -> Option<Self>

`u64`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_i8(n: i8) -> Option<Self>

#### fn from_i8(n: i8) -> Option<Self>

`i8`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_u8(n: u8) -> Option<Self>

#### fn from_u8(n: u8) -> Option<Self>

`u8`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_i16(n: i16) -> Option<Self>

#### fn from_i16(n: i16) -> Option<Self>

`i16`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_u16(n: u16) -> Option<Self>

#### fn from_u16(n: u16) -> Option<Self>

`u16`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_i32(n: i32) -> Option<Self>

#### fn from_i32(n: i32) -> Option<Self>

`i32`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_u32(n: u32) -> Option<Self>

#### fn from_u32(n: u32) -> Option<Self>

`u32`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_f32(n: f32) -> Option<Self>

#### fn from_f32(n: f32) -> Option<Self>

`f32`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_f64(n: f64) -> Option<Self>

#### fn from_f64(n: f64) -> Option<Self>

`f64`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned. Read moresource§#### fn from_isize(n: isize) -> Option<Self>

#### fn from_isize(n: isize) -> Option<Self>

`isize`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_i128(n: i128) -> Option<Self>

#### fn from_i128(n: i128) -> Option<Self>

`i128`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned. Read moresource§#### fn from_usize(n: usize) -> Option<Self>

#### fn from_usize(n: usize) -> Option<Self>

`usize`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§### impl MulAssign<&f16> for f16

### impl MulAssign<&f16> for f16

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

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

`*=`

operation. Read moresource§### impl MulAssign for f16

### impl MulAssign for f16

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

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

`*=`

operation. Read moresource§### impl Num for f16

### impl Num for f16

#### type FromStrRadixErr = <f32 as Num>::FromStrRadixErr

source§#### fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>

#### fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>

`2..=36`

). Read moresource§### impl PartialOrd for f16

### impl PartialOrd for f16

source§### impl RemAssign<&f16> for f16

### impl RemAssign<&f16> for f16

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

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

`%=`

operation. Read moresource§### impl RemAssign for f16

### impl RemAssign for f16

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

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

`%=`

operation. Read moresource§### impl SubAssign<&f16> for f16

### impl SubAssign<&f16> for f16

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

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

`-=`

operation. Read moresource§### impl SubAssign for f16

### impl SubAssign for f16

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

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

`-=`

operation. Read moresource§### impl ToPrimitive for f16

### impl ToPrimitive for f16

source§#### fn to_i64(&self) -> Option<i64>

#### fn to_i64(&self) -> Option<i64>

`self`

to an `i64`

. If the value cannot be
represented by an `i64`

, then `None`

is returned.source§#### fn to_u64(&self) -> Option<u64>

#### fn to_u64(&self) -> Option<u64>

`self`

to a `u64`

. If the value cannot be
represented by a `u64`

, then `None`

is returned.source§#### fn to_i8(&self) -> Option<i8>

#### fn to_i8(&self) -> Option<i8>

`self`

to an `i8`

. If the value cannot be
represented by an `i8`

, then `None`

is returned.source§#### fn to_u8(&self) -> Option<u8>

#### fn to_u8(&self) -> Option<u8>

`self`

to a `u8`

. If the value cannot be
represented by a `u8`

, then `None`

is returned.source§#### fn to_i16(&self) -> Option<i16>

#### fn to_i16(&self) -> Option<i16>

`self`

to an `i16`

. If the value cannot be
represented by an `i16`

, then `None`

is returned.source§#### fn to_u16(&self) -> Option<u16>

#### fn to_u16(&self) -> Option<u16>

`self`

to a `u16`

. If the value cannot be
represented by a `u16`

, then `None`

is returned.source§#### fn to_i32(&self) -> Option<i32>

#### fn to_i32(&self) -> Option<i32>

`self`

to an `i32`

. If the value cannot be
represented by an `i32`

, then `None`

is returned.source§#### fn to_u32(&self) -> Option<u32>

#### fn to_u32(&self) -> Option<u32>

`self`

to a `u32`

. If the value cannot be
represented by a `u32`

, then `None`

is returned.source§#### fn to_f32(&self) -> Option<f32>

#### fn to_f32(&self) -> Option<f32>

`self`

to an `f32`

. Overflows may map to positive
or negative inifinity, otherwise `None`

is returned if the value cannot
be represented by an `f32`

.source§#### fn to_f64(&self) -> Option<f64>

#### fn to_f64(&self) -> Option<f64>

`self`

to an `f64`

. Overflows may map to positive
or negative inifinity, otherwise `None`

is returned if the value cannot
be represented by an `f64`

. Read moresource§#### fn to_isize(&self) -> Option<isize>

#### fn to_isize(&self) -> Option<isize>

`self`

to an `isize`

. If the value cannot be
represented by an `isize`

, then `None`

is returned.source§#### fn to_i128(&self) -> Option<i128>

#### fn to_i128(&self) -> Option<i128>

`self`

to an `i128`

. If the value cannot be
represented by an `i128`

(`i64`

under the default implementation), then
`None`

is returned. Read more### impl Copy for f16

## Auto Trait Implementations§

### impl Freeze for f16

### impl RefUnwindSafe for f16

### impl Send for f16

### impl Sync for f16

### impl Unpin for f16

### impl UnwindSafe for f16

## Blanket Implementations§

source§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

source§#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

source§### impl<T> CloneToUninit for Twhere
T: Clone,

### impl<T> CloneToUninit for Twhere
T: Clone,

source§#### default unsafe fn clone_to_uninit(&self, dst: *mut T)

#### default unsafe fn clone_to_uninit(&self, dst: *mut T)

`clone_to_uninit`

)source§### impl<T> CloneToUninit for Twhere
T: Copy,

### impl<T> CloneToUninit for Twhere
T: Copy,

source§#### unsafe fn clone_to_uninit(&self, dst: *mut T)

#### unsafe fn clone_to_uninit(&self, dst: *mut T)

`clone_to_uninit`

)source§### impl<T> LowerBounded for Twhere
T: Bounded,

### impl<T> LowerBounded for Twhere
T: Bounded,

source§### impl<T> Real for Twhere
T: Float,

### impl<T> Real for Twhere
T: Float,

source§#### fn min_positive_value() -> T

#### fn min_positive_value() -> T

source§#### fn round(self) -> T

#### fn round(self) -> T

`0.0`

. Read moresource§#### fn is_sign_positive(self) -> bool

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

`true`

if `self`

is positive, including `+0.0`

,
`Float::infinity()`

, and with newer versions of Rust `f64::NAN`

. Read moresource§#### fn is_sign_negative(self) -> bool

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

`true`

if `self`

is negative, including `-0.0`

,
`Float::neg_infinity()`

, and with newer versions of Rust `-f64::NAN`

. Read moresource§#### fn mul_add(self, a: T, b: T) -> T

#### fn mul_add(self, a: T, b: T) -> T

`(self * a) + b`

with only one rounding
error, yielding a more accurate result than an unfused multiply-add. Read moresource§#### fn log(self, base: T) -> T

#### fn log(self, base: T) -> T

source§#### fn to_degrees(self) -> T

#### fn to_degrees(self) -> T

source§#### fn to_radians(self) -> T

#### fn to_radians(self) -> T

source§#### fn hypot(self, other: T) -> T

#### fn hypot(self, other: T) -> T

`x`

and `y`

. Read moresource§#### fn asin(self) -> T

#### fn asin(self) -> T

source§#### fn acos(self) -> T

#### fn acos(self) -> T

source§#### fn atan(self) -> T

#### fn atan(self) -> T

source§#### fn exp_m1(self) -> T

#### fn exp_m1(self) -> T

`e^(self) - 1`

in a way that is accurate even if the
number is close to zero. Read more