Struct F16 

#[repr(transparent)]
pub struct F16 {
    pub bits: u16,
}

A newtype containing the raw bits of an IEEE 754 binary16 floating point number.

Values of this type are hashable and have a well-defined total order: the one given by Self::total_cmp. As a consequence, +0.0 is not equal to -0.0, and NaN compares equal to NaN if both NaN values have exactly the same bit pattern.

Features

Crate feature f16 enables use of the Rust f16 primitive type, which is a nightly-only language feature that’s only functional on certain architectures.

Fields

bits: u16

The raw bits representing this float value.

Implementations

impl F16

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

Constructs a wrapped float from the raw float bits.

pub const fn to_bits(&self) -> u16

Returns the raw float bits.

impl F16

pub const BITS: usize = 16

Number of total bits in the representation.

pub const EXP_BITS: usize = 5

Number of bits in the exponent representation.

pub const MANTISSA_BITS: usize

Number of bits in the mantissa representation.

pub const MANTISSA_DIGITS: usize

Number of significant digits in base 2.

Note that the size of the mantissa in the bitwise representation is one smaller than this, since the leading 1 is not stored explicitly.

pub const ZERO: Self

Positive zero (+0.0).

pub const ONE: Self

Positive one (+1.0).

pub const INFINITY: Self

Positive infinity (+∞).

pub const SNAN: Self

Not a Number (NaN) with sign bit 0, is_quiet bit 0, and arbitrary payload.

pub const QNAN: Self

Not a Number (NaN) with sign bit 0, is_quiet bit 1, and arbitrary payload.

pub const NEG_ZERO: Self

Negative zero (−0.0).

pub const NEG_ONE: Self

Negative one (−1.0).

pub const NEG_INFINITY: Self

Negative infinity (−∞).

pub const NEG_SNAN: Self

Not a Number (NaN) with sign bit 1, is_quiet bit 0, and arbitrary payload.

pub const NEG_QNAN: Self

Not a Number (NaN) with sign bit 1, is_quiet bit 1, and arbitrary payload.

pub const MAX: Self

The positive normal value with the greatest possible absolute magnitude.

pub const MIN: Self

The negative normal value with the greatest possible absolute magnitude.

pub const MIN_POSITIVE: Self

The positive normal value with the least possible absolute magnitude.

pub const MAX_NEGATIVE: Self

The negative normal value with the least possible absolute magnitude.

pub const fn is_sign_positive(&self) -> bool

Returns true if self has a positive sign, including +0.0, +∞, and NaN with positive sign bit.

pub const fn is_sign_negative(&self) -> bool

Returns true if self has a negative sign, including -0.0, -∞, and NaN with negative sign bit.

pub const fn classify(&self) -> FpCategory

Returns the floating point category of the number.

pub const fn is_zero(&self) -> bool

Returns true if the number is +0.0 or -0.0.

pub const fn is_subnormal(&self) -> bool

Returns true if the number is subnormal.

pub const fn is_normal(&self) -> bool

Returns true if the number is neither zero, infinite, subnormal, or NaN.

pub const fn is_infinite(&self) -> bool

Returns true if the number is subnormal.

pub const fn is_nan(&self) -> bool

Returns true if this value is NaN.

pub const fn is_finite(&self) -> bool

Returns true if this number is neither infinite nor NaN.

pub const fn abs(&self) -> Self

Computes the absolute value of self.

The result is always exact. The result will always test true with Self::is_sign_positive.

pub const fn neg(&self) -> Self

Computes the negation of self.

The result is always exact.

pub const fn signum(&self) -> Self

Returns a number that represents the sign of self.

• Self::ONE if the number is positive, including +0.0 or +∞
• Self::NEG_ONE if the number is negative, including -0.0 or -∞
• self if the number is NaN

pub const fn copysign(&self, sign: Self) -> Self

Returns a number composed of the magnitude of self and the sign of sign.

pub const fn total_cmp(&self, rhs: Self) -> Ordering

Returns the ordering between self and rhs.

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

pub const fn clamp(&self, min: Self, max: Self) -> Self

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.

Trait Implementations

impl Clone for F16

fn clone(&self) -> F16

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for F16

impl Debug for F16

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

Formats the value using the given formatter.

impl Default for F16

fn default() -> Self

Returns Self::ZERO.

impl Eq for F16

impl Hash for F16

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for F16

fn cmp(&self, rhs: &Self) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for F16

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for F16

fn partial_cmp(&self, rhs: &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.

impl StructuralPartialEq for F16