Struct f16b 

#[repr(transparent)]
pub struct f16b(u16);

🔬This is a nightly-only experimental API. (f16b #160630)

A 16-bit brain floating-point value.

This type stores values using the bfloat16 encoding. It deliberately exposes only raw-bit construction, comparison, formatting, and lossless widening to f32.

The 16-bit brain floating-point intends to preserve the dynamic range of a 32-bit floating-point value while using half the storage. It does this by using 8 bits for the exponent, the same as f32, but only using 7 bits for the mantissa. See Wikipedia on bfloat16 for more information.

Tuple Fields

0: u16

🔬This is a nightly-only experimental API. (f16b #160630)

Implementations

impl f16b

pub const fn from_bits(bits: u16) -> Self

🔬This is a nightly-only experimental API. (f16b #160630)

Raw transmutation from u16.

This is currently identical to transmute::<u16, f16b>(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.

#![feature(f16b)]
use core::num::f16b;

let v = f16b::from_bits(0x4148);
assert_eq!(f32::from(v), 12.5);

pub const fn to_bits(self) -> u16

🔬This is a nightly-only experimental API. (f16b #160630)

Raw transmutation to u16.

This is currently identical to transmute::<f16b, u16>(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.

#![feature(f16b)]
use core::num::f16b;

assert_eq!(f16b::from_bits(0x4148).to_bits(), 0x4148);

Trait Implementations

impl Clone for f16b

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

where Self:,

Performs copy-assignment from source.

impl Copy for f16b

impl Debug for f16b

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for f16b

fn default() -> Self

Returns the “default value” for a type.

impl From<f16b> for f32

fn from(value: f16b) -> Self

Converts to this type from the input type.

impl LowerExp for f16b

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for f16b

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for f16b

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

#[doc(hidden)]

fn __chaining_lt(&self, other: &Rhs) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

If self == other, returns ControlFlow::Continue(()). Otherwise, returns ControlFlow::Break(self < other).

#[doc(hidden)]

fn __chaining_le(&self, other: &Rhs) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for <= instead of <.

#[doc(hidden)]

fn __chaining_gt(&self, other: &Rhs) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for > instead of <.

#[doc(hidden)]

fn __chaining_ge(&self, other: &Rhs) -> ControlFlow<bool>

🔬This is a nightly-only experimental API. (partial_ord_chaining_methods)

Same as __chaining_lt, but for >= instead of <.

impl UpperExp for f16b

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.