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

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.

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.

Converts an f16 into the underlying bit representation.

Converts an f16 into the underlying bit representation.

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.

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.

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());

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());

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());

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());

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);

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());

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());

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());