Trait num_traits::float::FloatCore
source · [−]pub trait FloatCore: Num + NumCast + Neg<Output = Self> + PartialOrd + Copy {
Show 29 methods
fn infinity() -> Self;
fn neg_infinity() -> Self;
fn nan() -> Self;
fn neg_zero() -> Self;
fn min_value() -> Self;
fn min_positive_value() -> Self;
fn epsilon() -> Self;
fn max_value() -> Self;
fn classify(self) -> FpCategory;
fn to_degrees(self) -> Self;
fn to_radians(self) -> Self;
fn integer_decode(self) -> (u64, i16, i8);
fn is_nan(self) -> bool { ... }
fn is_infinite(self) -> bool { ... }
fn is_finite(self) -> bool { ... }
fn is_normal(self) -> bool { ... }
fn floor(self) -> Self { ... }
fn ceil(self) -> Self { ... }
fn round(self) -> Self { ... }
fn trunc(self) -> Self { ... }
fn fract(self) -> Self { ... }
fn abs(self) -> Self { ... }
fn signum(self) -> Self { ... }
fn is_sign_positive(self) -> bool { ... }
fn is_sign_negative(self) -> bool { ... }
fn min(self, other: Self) -> Self { ... }
fn max(self, other: Self) -> Self { ... }
fn recip(self) -> Self { ... }
fn powi(self, exp: i32) -> Self { ... }
}
Expand description
Generic trait for floating point numbers that works with no_std
.
This trait implements a subset of the Float
trait.
Required methods
Returns positive infinity.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T) {
assert!(T::infinity() == x);
}
check(f32::INFINITY);
check(f64::INFINITY);
fn neg_infinity() -> Self
fn neg_infinity() -> Self
Returns negative infinity.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T) {
assert!(T::neg_infinity() == x);
}
check(f32::NEG_INFINITY);
check(f64::NEG_INFINITY);
Returns NaN.
Examples
use num_traits::float::FloatCore;
fn check<T: FloatCore>() {
let n = T::nan();
assert!(n != n);
}
check::<f32>();
check::<f64>();
Returns -0.0
.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(n: T) {
let z = T::neg_zero();
assert!(z.is_zero());
assert!(T::one() / z == n);
}
check(f32::NEG_INFINITY);
check(f64::NEG_INFINITY);
Returns the smallest finite value that this type can represent.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T) {
assert!(T::min_value() == x);
}
check(f32::MIN);
check(f64::MIN);
fn min_positive_value() -> Self
fn min_positive_value() -> Self
Returns the smallest positive, normalized value that this type can represent.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T) {
assert!(T::min_positive_value() == x);
}
check(f32::MIN_POSITIVE);
check(f64::MIN_POSITIVE);
Returns epsilon, a small positive value.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T) {
assert!(T::epsilon() == x);
}
check(f32::EPSILON);
check(f64::EPSILON);
Returns the largest finite value that this type can represent.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T) {
assert!(T::max_value() == x);
}
check(f32::MAX);
check(f64::MAX);
fn classify(self) -> FpCategory
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 num_traits::float::FloatCore;
use std::{f32, f64};
use std::num::FpCategory;
fn check<T: FloatCore>(x: T, c: FpCategory) {
assert!(x.classify() == c);
}
check(f32::INFINITY, FpCategory::Infinite);
check(f32::MAX, FpCategory::Normal);
check(f64::NAN, FpCategory::Nan);
check(f64::MIN_POSITIVE, FpCategory::Normal);
check(f64::MIN_POSITIVE / 2.0, FpCategory::Subnormal);
check(0.0f64, FpCategory::Zero);
fn to_degrees(self) -> Self
fn to_degrees(self) -> Self
Converts to degrees, assuming the number is in radians.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(rad: T, deg: T) {
assert!(rad.to_degrees() == deg);
}
check(0.0f32, 0.0);
check(f32::consts::PI, 180.0);
check(f64::consts::FRAC_PI_4, 45.0);
check(f64::INFINITY, f64::INFINITY);
fn to_radians(self) -> Self
fn to_radians(self) -> Self
Converts to radians, assuming the number is in degrees.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(deg: T, rad: T) {
assert!(deg.to_radians() == rad);
}
check(0.0f32, 0.0);
check(180.0, f32::consts::PI);
check(45.0, f64::consts::FRAC_PI_4);
check(f64::INFINITY, f64::INFINITY);
Returns the mantissa, base 2 exponent, and sign as integers, respectively.
The original number can be recovered by sign * mantissa * 2 ^ exponent
.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T, m: u64, e: i16, s:i8) {
let (mantissa, exponent, sign) = x.integer_decode();
assert_eq!(mantissa, m);
assert_eq!(exponent, e);
assert_eq!(sign, s);
}
check(2.0f32, 1 << 23, -22, 1);
check(-2.0f32, 1 << 23, -22, -1);
check(f32::INFINITY, 1 << 23, 105, 1);
check(f64::NEG_INFINITY, 1 << 52, 972, -1);
Provided methods
Returns true
if the number is NaN.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T, p: bool) {
assert!(x.is_nan() == p);
}
check(f32::NAN, true);
check(f32::INFINITY, false);
check(f64::NAN, true);
check(0.0f64, false);
fn is_infinite(self) -> bool
fn is_infinite(self) -> bool
Returns true
if the number is infinite.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T, p: bool) {
assert!(x.is_infinite() == p);
}
check(f32::INFINITY, true);
check(f32::NEG_INFINITY, true);
check(f32::NAN, false);
check(f64::INFINITY, true);
check(f64::NEG_INFINITY, true);
check(0.0f64, false);
Returns true
if the number is neither infinite or NaN.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T, p: bool) {
assert!(x.is_finite() == p);
}
check(f32::INFINITY, false);
check(f32::MAX, true);
check(f64::NEG_INFINITY, false);
check(f64::MIN_POSITIVE, true);
check(f64::NAN, false);
Returns true
if the number is neither zero, infinite, subnormal or NaN.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T, p: bool) {
assert!(x.is_normal() == p);
}
check(f32::INFINITY, false);
check(f32::MAX, true);
check(f64::NEG_INFINITY, false);
check(f64::MIN_POSITIVE, true);
check(0.0f64, false);
Returns the largest integer less than or equal to a number.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T, y: T) {
assert!(x.floor() == y);
}
check(f32::INFINITY, f32::INFINITY);
check(0.9f32, 0.0);
check(1.0f32, 1.0);
check(1.1f32, 1.0);
check(-0.0f64, 0.0);
check(-0.9f64, -1.0);
check(-1.0f64, -1.0);
check(-1.1f64, -2.0);
check(f64::MIN, f64::MIN);
Returns the smallest integer greater than or equal to a number.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T, y: T) {
assert!(x.ceil() == y);
}
check(f32::INFINITY, f32::INFINITY);
check(0.9f32, 1.0);
check(1.0f32, 1.0);
check(1.1f32, 2.0);
check(-0.0f64, 0.0);
check(-0.9f64, -0.0);
check(-1.0f64, -1.0);
check(-1.1f64, -1.0);
check(f64::MIN, f64::MIN);
Returns the nearest integer to a number. Round half-way cases away from 0.0
.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T, y: T) {
assert!(x.round() == y);
}
check(f32::INFINITY, f32::INFINITY);
check(0.4f32, 0.0);
check(0.5f32, 1.0);
check(0.6f32, 1.0);
check(-0.4f64, 0.0);
check(-0.5f64, -1.0);
check(-0.6f64, -1.0);
check(f64::MIN, f64::MIN);
Return the integer part of a number.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T, y: T) {
assert!(x.trunc() == y);
}
check(f32::INFINITY, f32::INFINITY);
check(0.9f32, 0.0);
check(1.0f32, 1.0);
check(1.1f32, 1.0);
check(-0.0f64, 0.0);
check(-0.9f64, -0.0);
check(-1.0f64, -1.0);
check(-1.1f64, -1.0);
check(f64::MIN, f64::MIN);
Returns the fractional part of a number.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T, y: T) {
assert!(x.fract() == y);
}
check(f32::MAX, 0.0);
check(0.75f32, 0.75);
check(1.0f32, 0.0);
check(1.25f32, 0.25);
check(-0.0f64, 0.0);
check(-0.75f64, -0.75);
check(-1.0f64, 0.0);
check(-1.25f64, -0.25);
check(f64::MIN, 0.0);
Computes the absolute value of self
. Returns FloatCore::nan()
if the
number is FloatCore::nan()
.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T, y: T) {
assert!(x.abs() == y);
}
check(f32::INFINITY, f32::INFINITY);
check(1.0f32, 1.0);
check(0.0f64, 0.0);
check(-0.0f64, 0.0);
check(-1.0f64, 1.0);
check(f64::MIN, f64::MAX);
Returns a number that represents the sign of self
.
1.0
if the number is positive,+0.0
orFloatCore::infinity()
-1.0
if the number is negative,-0.0
orFloatCore::neg_infinity()
FloatCore::nan()
if the number isFloatCore::nan()
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T, y: T) {
assert!(x.signum() == y);
}
check(f32::INFINITY, 1.0);
check(3.0f32, 1.0);
check(0.0f32, 1.0);
check(-0.0f64, -1.0);
check(-3.0f64, -1.0);
check(f64::MIN, -1.0);
fn is_sign_positive(self) -> bool
fn is_sign_positive(self) -> bool
Returns true
if self
is positive, including +0.0
and
FloatCore::infinity()
, and since Rust 1.20 also
FloatCore::nan()
.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T, p: bool) {
assert!(x.is_sign_positive() == p);
}
check(f32::INFINITY, true);
check(f32::MAX, true);
check(0.0f32, true);
check(-0.0f64, false);
check(f64::NEG_INFINITY, false);
check(f64::MIN_POSITIVE, true);
check(-f64::NAN, false);
fn is_sign_negative(self) -> bool
fn is_sign_negative(self) -> bool
Returns true
if self
is negative, including -0.0
and
FloatCore::neg_infinity()
, and since Rust 1.20 also
-FloatCore::nan()
.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T, p: bool) {
assert!(x.is_sign_negative() == p);
}
check(f32::INFINITY, false);
check(f32::MAX, false);
check(0.0f32, false);
check(-0.0f64, true);
check(f64::NEG_INFINITY, true);
check(f64::MIN_POSITIVE, false);
check(f64::NAN, false);
Returns the minimum of the two numbers.
If one of the arguments is NaN, then the other argument is returned.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T, y: T, min: T) {
assert!(x.min(y) == min);
}
check(1.0f32, 2.0, 1.0);
check(f32::NAN, 2.0, 2.0);
check(1.0f64, -2.0, -2.0);
check(1.0f64, f64::NAN, 1.0);
Returns the maximum of the two numbers.
If one of the arguments is NaN, then the other argument is returned.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T, y: T, max: T) {
assert!(x.max(y) == max);
}
check(1.0f32, 2.0, 2.0);
check(1.0f32, f32::NAN, 1.0);
check(-1.0f64, 2.0, 2.0);
check(-1.0f64, f64::NAN, -1.0);
Returns the reciprocal (multiplicative inverse) of the number.
Examples
use num_traits::float::FloatCore;
use std::{f32, f64};
fn check<T: FloatCore>(x: T, y: T) {
assert!(x.recip() == y);
assert!(y.recip() == x);
}
check(f32::INFINITY, 0.0);
check(2.0f32, 0.5);
check(-0.25f64, -4.0);
check(-0.0f64, f64::NEG_INFINITY);
Raise a number to an integer power.
Using this function is generally faster than using powf
Examples
use num_traits::float::FloatCore;
fn check<T: FloatCore>(x: T, exp: i32, powi: T) {
assert!(x.powi(exp) == powi);
}
check(9.0f32, 2, 81.0);
check(1.0f32, -2, 1.0);
check(10.0f64, 20, 1e20);
check(4.0f64, -2, 0.0625);
check(-1.0f64, std::i32::MIN, 1.0);