Struct F16 

pub struct F16(/* private fields */);

Methods from Deref<Target = f16>

pub const DIGITS: u32 = 3

pub const EPSILON: f16

pub const INFINITY: f16

pub const MANTISSA_DIGITS: u32 = 11

pub const MAX: f16

pub const MAX_10_EXP: i32 = 4

pub const MAX_EXP: i32 = 16

pub const MIN: f16

pub const MIN_10_EXP: i32 = -4

pub const MIN_EXP: i32 = -13

pub const MIN_POSITIVE: f16

pub const NAN: f16

pub const NEG_INFINITY: f16

pub const RADIX: u32 = 2

pub const MIN_POSITIVE_SUBNORMAL: f16

pub const MAX_SUBNORMAL: f16

pub const ONE: f16

pub const ZERO: f16

pub const NEG_ZERO: f16

pub const NEG_ONE: f16

pub const E: f16

pub const PI: f16

pub const FRAC_1_PI: f16

pub const FRAC_1_SQRT_2: f16

pub const FRAC_2_PI: f16

pub const FRAC_2_SQRT_PI: f16

pub const FRAC_PI_2: f16

pub const FRAC_PI_3: f16

pub const FRAC_PI_4: f16

pub const FRAC_PI_6: f16

pub const FRAC_PI_8: f16

pub const LN_10: f16

pub const LN_2: f16

pub const LOG10_E: f16

pub const LOG10_2: f16

pub const LOG2_E: f16

pub const LOG2_10: f16

pub const SQRT_2: f16

pub fn total_cmp(&self, other: &f16) -> 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()));

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 Debug for F16

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

Formats the value using the given formatter.

impl Deref for F16

type Target = f16

The resulting type after dereferencing.

fn deref(&self) -> &<F16 as Deref>::Target

Dereferences the value.

impl Hash for F16

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

where H: Hasher,

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, other: &F16) -> 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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for F16

fn partial_cmp(&self, other: &F16) -> 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 Copy for F16

impl Eq for F16

impl StructuralPartialEq for F16