Struct half::f16

pub struct f16(_);

The 16-bit floating point type.

Methods

impl f16

pub fn from_bits(bits: u16) -> f16

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

pub fn from_f32(value: f32) -> f16

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

If the 32-bit value is to large to fit in 16-bits, +/- infinity 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.

pub fn from_f64(value: f64) -> f16

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

If the 64-bit value is to large to fit in 16-bits, +/- infinity 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.

pub fn to_bits(self) -> u16

Converts an f16 into the underlying bit representation.

pub fn as_bits(self) -> u16

Deprecated since 1.2.0:

renamed to to_bits

Converts an f16 into the underlying bit representation.

pub fn to_f32(self) -> f32

Converts an f16 value in a f32 value.

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

pub fn to_f64(self) -> f64

Converts an f16 value in a f64 value.

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

pub fn is_nan(self) -> bool

Returns true if this value is NaN and false otherwise.

Examples

use half::f16;

let nan = half::consts::NAN;
let f = f16::from_f32(7.0_f32);

assert!(nan.is_nan());
assert!(!f.is_nan());

pub fn is_infinite(self) -> bool

Returns true if this value is positive infinity or negative infinity and false otherwise.

Examples

use half::f16;

let f = f16::from_f32(7.0f32);
let inf = half::consts::INFINITY;
let neg_inf = half::consts::NEG_INFINITY;
let nan = half::consts::NAN;

assert!(!f.is_infinite());
assert!(!nan.is_infinite());

assert!(inf.is_infinite());
assert!(neg_inf.is_infinite());

pub fn is_finite(self) -> bool

Returns true if this number is neither infinite nor NaN.

Examples

use half::f16;

let f = f16::from_f32(7.0f32);
let inf = half::consts::INFINITY;
let neg_inf = half::consts::NEG_INFINITY;
let nan = half::consts::NAN;

assert!(f.is_finite());

assert!(!nan.is_finite());
assert!(!inf.is_finite());
assert!(!neg_inf.is_finite());

pub fn is_normal(self) -> bool

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

Examples

use half::f16;

let min = half::consts::MIN_POSITIVE;
let max = half::consts::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!(!half::consts::NAN.is_normal());
assert!(!half::consts::INFINITY.is_normal());
// Values between `0` and `min` are Subnormal.
assert!(!lower_than_min.is_normal());

pub 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;
use half::f16;

let num = f16::from_f32(12.4_f32);
let inf = half::consts::INFINITY;

assert_eq!(num.classify(), FpCategory::Normal);
assert_eq!(inf.classify(), FpCategory::Infinite);

pub 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

use half::f16;

let f = f16::from_f32(3.5_f32);

assert_eq!(f.signum(), f16::from_f32(1.0));
assert_eq!(half::consts::NEG_INFINITY.signum(), f16::from_f32(-1.0));

assert!(half::consts::NAN.signum().is_nan());

pub fn is_sign_positive(self) -> bool

Returns true if and only if self has a positive sign, including +0.0, NaNs with positive sign bit and positive infinity.

Examples

use half::f16;

let nan = half::consts::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());

pub fn is_sign_negative(self) -> bool

Returns true if and only if self has a negative sign, including -0.0, NaNs with negative sign bit and negative infinity.

Examples

use half::f16;

let nan = half::consts::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());

Trait Implementations

impl From<f16> for f32

fn from(x: f16) -> f32

Performs the conversion.

impl From<f16> for f64

fn from(x: f16) -> f64

Performs the conversion.

impl From<i8> for f16

fn from(x: i8) -> f16

Performs the conversion.

impl From<u8> for f16

fn from(x: u8) -> f16

Performs the conversion.

impl PartialEq<f16> for f16

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd<f16> 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: &f16) -> bool

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl UpperExp for f16

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

Formats the value using the given formatter.

impl Debug for f16

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

Formats the value using the given formatter.

impl LowerExp for f16

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

Formats the value using the given formatter.

impl Display for f16

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

Formats the value using the given formatter.

impl FromStr for f16

type Err = ParseFloatError

The associated error which can be returned from parsing.

fn from_str(src: &str) -> Result<f16, ParseFloatError>

Parses a string s to return a value of this type.

impl Copy for f16

impl Clone for f16

fn clone(&self) -> f16

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for f16

fn default() -> f16

Returns the "default value" for a type.