Reorder Float methods in trait definition and make consistent in impls
This commit is contained in:
Brendan Zabarauskas
parent
42450ef022
commit
2d9dfc6479
3 changed files with 277 additions and 302 deletions
|
|
@ -218,8 +218,9 @@ impl Signed for f32 {
|
|||
unsafe { intrinsics::fabsf32(*self) }
|
||||
}
|
||||
|
||||
/// The positive difference of two numbers. Returns `0.0` if the number is less than or
|
||||
/// equal to `other`, otherwise the difference between`self` and `other` is returned.
|
||||
/// The positive difference of two numbers. Returns `0.0` if the number is
|
||||
/// less than or equal to `other`, otherwise the difference between`self`
|
||||
/// and `other` is returned.
|
||||
#[inline]
|
||||
fn abs_sub(&self, other: &f32) -> f32 {
|
||||
unsafe { cmath::fdimf(*self, *other) }
|
||||
|
|
@ -257,20 +258,6 @@ impl Bounded for f32 {
|
|||
impl Primitive for f32 {}
|
||||
|
||||
impl Float for f32 {
|
||||
fn powi(self, n: i32) -> f32 {
|
||||
unsafe { intrinsics::powif32(self, n) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn max(self, other: f32) -> f32 {
|
||||
unsafe { cmath::fmaxf(self, other) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn min(self, other: f32) -> f32 {
|
||||
unsafe { cmath::fminf(self, other) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn nan() -> f32 { 0.0 / 0.0 }
|
||||
|
||||
|
|
@ -305,8 +292,9 @@ impl Float for f32 {
|
|||
self.classify() == FPNormal
|
||||
}
|
||||
|
||||
/// 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.
|
||||
/// 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.
|
||||
fn classify(self) -> FPCategory {
|
||||
static EXP_MASK: u32 = 0x7f800000;
|
||||
static MAN_MASK: u32 = 0x007fffff;
|
||||
|
|
@ -342,13 +330,15 @@ impl Float for f32 {
|
|||
#[inline]
|
||||
fn max_10_exp(_: Option<f32>) -> int { 38 }
|
||||
|
||||
/// Constructs a floating point number by multiplying `x` by 2 raised to the power of `exp`
|
||||
/// Constructs a floating point number by multiplying `x` by 2 raised to the
|
||||
/// power of `exp`
|
||||
#[inline]
|
||||
fn ldexp(x: f32, exp: int) -> f32 {
|
||||
unsafe { cmath::ldexpf(x, exp as c_int) }
|
||||
}
|
||||
|
||||
/// Breaks the number into a normalized fraction and a base-2 exponent, satisfying:
|
||||
/// Breaks the number into a normalized fraction and a base-2 exponent,
|
||||
/// satisfying:
|
||||
///
|
||||
/// - `self = x * pow(2, exp)`
|
||||
/// - `0.5 <= abs(x) < 1.0`
|
||||
|
|
@ -361,34 +351,6 @@ impl Float for f32 {
|
|||
}
|
||||
}
|
||||
|
||||
/// Returns the exponential of the number, minus `1`, in a way that is accurate
|
||||
/// even if the number is close to zero
|
||||
#[inline]
|
||||
fn exp_m1(self) -> f32 {
|
||||
unsafe { cmath::expm1f(self) }
|
||||
}
|
||||
|
||||
/// Returns the natural logarithm of the number plus `1` (`ln(1+n)`) more accurately
|
||||
/// than if the operations were performed separately
|
||||
#[inline]
|
||||
fn ln_1p(self) -> f32 {
|
||||
unsafe { cmath::log1pf(self) }
|
||||
}
|
||||
|
||||
/// Fused multiply-add. Computes `(self * a) + b` with only one rounding error. This
|
||||
/// produces a more accurate result with better performance than a separate multiplication
|
||||
/// operation followed by an add.
|
||||
#[inline]
|
||||
fn mul_add(self, a: f32, b: f32) -> f32 {
|
||||
unsafe { intrinsics::fmaf32(self, a, b) }
|
||||
}
|
||||
|
||||
/// Returns the next representable floating-point value in the direction of `other`
|
||||
#[inline]
|
||||
fn next_after(self, other: f32) -> f32 {
|
||||
unsafe { cmath::nextafterf(self, other) }
|
||||
}
|
||||
|
||||
/// Returns the mantissa, exponent and sign as integers.
|
||||
fn integer_decode(self) -> (u64, i16, i8) {
|
||||
let bits: u32 = unsafe { cast::transmute(self) };
|
||||
|
|
@ -404,6 +366,13 @@ impl Float for f32 {
|
|||
(mantissa as u64, exponent, sign)
|
||||
}
|
||||
|
||||
/// Returns the next representable floating-point value in the direction of
|
||||
/// `other`.
|
||||
#[inline]
|
||||
fn next_after(self, other: f32) -> f32 {
|
||||
unsafe { cmath::nextafterf(self, other) }
|
||||
}
|
||||
|
||||
/// Round half-way cases toward `NEG_INFINITY`
|
||||
#[inline]
|
||||
fn floor(self) -> f32 {
|
||||
|
|
@ -437,6 +406,63 @@ impl Float for f32 {
|
|||
#[inline]
|
||||
fn fract(self) -> f32 { self - self.trunc() }
|
||||
|
||||
#[inline]
|
||||
fn max(self, other: f32) -> f32 {
|
||||
unsafe { cmath::fmaxf(self, other) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn min(self, other: f32) -> f32 {
|
||||
unsafe { cmath::fminf(self, other) }
|
||||
}
|
||||
|
||||
/// Fused multiply-add. Computes `(self * a) + b` with only one rounding
|
||||
/// error. This produces a more accurate result with better performance than
|
||||
/// a separate multiplication operation followed by an add.
|
||||
#[inline]
|
||||
fn mul_add(self, a: f32, b: f32) -> f32 {
|
||||
unsafe { intrinsics::fmaf32(self, a, b) }
|
||||
}
|
||||
|
||||
/// The reciprocal (multiplicative inverse) of the number
|
||||
#[inline]
|
||||
fn recip(self) -> f32 { 1.0 / self }
|
||||
|
||||
fn powi(self, n: i32) -> f32 {
|
||||
unsafe { intrinsics::powif32(self, n) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn powf(self, n: f32) -> f32 {
|
||||
unsafe { intrinsics::powf32(self, n) }
|
||||
}
|
||||
|
||||
/// sqrt(2.0)
|
||||
#[inline]
|
||||
fn sqrt2() -> f32 { 1.41421356237309504880168872420969808 }
|
||||
|
||||
/// 1.0 / sqrt(2.0)
|
||||
#[inline]
|
||||
fn frac_1_sqrt2() -> f32 { 0.707106781186547524400844362104849039 }
|
||||
|
||||
#[inline]
|
||||
fn sqrt(self) -> f32 {
|
||||
unsafe { intrinsics::sqrtf32(self) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn rsqrt(self) -> f32 { self.sqrt().recip() }
|
||||
|
||||
#[inline]
|
||||
fn cbrt(self) -> f32 {
|
||||
unsafe { cmath::cbrtf(self) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn hypot(self, other: f32) -> f32 {
|
||||
unsafe { cmath::hypotf(self, other) }
|
||||
}
|
||||
|
||||
/// Archimedes' constant
|
||||
#[inline]
|
||||
fn pi() -> f32 { 3.14159265358979323846264338327950288 }
|
||||
|
|
@ -477,61 +503,6 @@ impl Float for f32 {
|
|||
#[inline]
|
||||
fn frac_2_sqrtpi() -> f32 { 1.12837916709551257389615890312154517 }
|
||||
|
||||
/// sqrt(2.0)
|
||||
#[inline]
|
||||
fn sqrt2() -> f32 { 1.41421356237309504880168872420969808 }
|
||||
|
||||
/// 1.0 / sqrt(2.0)
|
||||
#[inline]
|
||||
fn frac_1_sqrt2() -> f32 { 0.707106781186547524400844362104849039 }
|
||||
|
||||
/// Euler's number
|
||||
#[inline]
|
||||
fn e() -> f32 { 2.71828182845904523536028747135266250 }
|
||||
|
||||
/// log2(e)
|
||||
#[inline]
|
||||
fn log2_e() -> f32 { 1.44269504088896340735992468100189214 }
|
||||
|
||||
/// log10(e)
|
||||
#[inline]
|
||||
fn log10_e() -> f32 { 0.434294481903251827651128918916605082 }
|
||||
|
||||
/// ln(2.0)
|
||||
#[inline]
|
||||
fn ln_2() -> f32 { 0.693147180559945309417232121458176568 }
|
||||
|
||||
/// ln(10.0)
|
||||
#[inline]
|
||||
fn ln_10() -> f32 { 2.30258509299404568401799145468436421 }
|
||||
|
||||
/// The reciprocal (multiplicative inverse) of the number
|
||||
#[inline]
|
||||
fn recip(self) -> f32 { 1.0 / self }
|
||||
|
||||
#[inline]
|
||||
fn powf(self, n: f32) -> f32 {
|
||||
unsafe { intrinsics::powf32(self, n) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn sqrt(self) -> f32 {
|
||||
unsafe { intrinsics::sqrtf32(self) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn rsqrt(self) -> f32 { self.sqrt().recip() }
|
||||
|
||||
#[inline]
|
||||
fn cbrt(self) -> f32 {
|
||||
unsafe { cmath::cbrtf(self) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn hypot(self, other: f32) -> f32 {
|
||||
unsafe { cmath::hypotf(self, other) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn sin(self) -> f32 {
|
||||
unsafe { intrinsics::sinf32(self) }
|
||||
|
|
@ -573,6 +544,26 @@ impl Float for f32 {
|
|||
(self.sin(), self.cos())
|
||||
}
|
||||
|
||||
/// Euler's number
|
||||
#[inline]
|
||||
fn e() -> f32 { 2.71828182845904523536028747135266250 }
|
||||
|
||||
/// log2(e)
|
||||
#[inline]
|
||||
fn log2_e() -> f32 { 1.44269504088896340735992468100189214 }
|
||||
|
||||
/// log10(e)
|
||||
#[inline]
|
||||
fn log10_e() -> f32 { 0.434294481903251827651128918916605082 }
|
||||
|
||||
/// ln(2.0)
|
||||
#[inline]
|
||||
fn ln_2() -> f32 { 0.693147180559945309417232121458176568 }
|
||||
|
||||
/// ln(10.0)
|
||||
#[inline]
|
||||
fn ln_10() -> f32 { 2.30258509299404568401799145468436421 }
|
||||
|
||||
/// Returns the exponential of the number
|
||||
#[inline]
|
||||
fn exp(self) -> f32 {
|
||||
|
|
@ -585,6 +576,13 @@ impl Float for f32 {
|
|||
unsafe { intrinsics::exp2f32(self) }
|
||||
}
|
||||
|
||||
/// Returns the exponential of the number, minus `1`, in a way that is
|
||||
/// accurate even if the number is close to zero
|
||||
#[inline]
|
||||
fn exp_m1(self) -> f32 {
|
||||
unsafe { cmath::expm1f(self) }
|
||||
}
|
||||
|
||||
/// Returns the natural logarithm of the number
|
||||
#[inline]
|
||||
fn ln(self) -> f32 {
|
||||
|
|
@ -607,6 +605,13 @@ impl Float for f32 {
|
|||
unsafe { intrinsics::log10f32(self) }
|
||||
}
|
||||
|
||||
/// Returns the natural logarithm of the number plus `1` (`ln(1+n)`) more
|
||||
/// accurately than if the operations were performed separately
|
||||
#[inline]
|
||||
fn ln_1p(self) -> f32 {
|
||||
unsafe { cmath::log1pf(self) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn sinh(self) -> f32 {
|
||||
unsafe { cmath::sinhf(self) }
|
||||
|
|
|
|||
|
|
@ -265,16 +265,6 @@ impl Bounded for f64 {
|
|||
impl Primitive for f64 {}
|
||||
|
||||
impl Float for f64 {
|
||||
#[inline]
|
||||
fn max(self, other: f64) -> f64 {
|
||||
unsafe { cmath::fmax(self, other) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn min(self, other: f64) -> f64 {
|
||||
unsafe { cmath::fmin(self, other) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn nan() -> f64 { 0.0 / 0.0 }
|
||||
|
||||
|
|
@ -309,8 +299,9 @@ impl Float for f64 {
|
|||
self.classify() == FPNormal
|
||||
}
|
||||
|
||||
/// 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.
|
||||
/// 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.
|
||||
fn classify(self) -> FPCategory {
|
||||
static EXP_MASK: u64 = 0x7ff0000000000000;
|
||||
static MAN_MASK: u64 = 0x000fffffffffffff;
|
||||
|
|
@ -346,13 +337,15 @@ impl Float for f64 {
|
|||
#[inline]
|
||||
fn max_10_exp(_: Option<f64>) -> int { 308 }
|
||||
|
||||
/// Constructs a floating point number by multiplying `x` by 2 raised to the power of `exp`
|
||||
/// Constructs a floating point number by multiplying `x` by 2 raised to the
|
||||
/// power of `exp`
|
||||
#[inline]
|
||||
fn ldexp(x: f64, exp: int) -> f64 {
|
||||
unsafe { cmath::ldexp(x, exp as c_int) }
|
||||
}
|
||||
|
||||
/// Breaks the number into a normalized fraction and a base-2 exponent, satisfying:
|
||||
/// Breaks the number into a normalized fraction and a base-2 exponent,
|
||||
/// satisfying:
|
||||
///
|
||||
/// - `self = x * pow(2, exp)`
|
||||
/// - `0.5 <= abs(x) < 1.0`
|
||||
|
|
@ -365,34 +358,6 @@ impl Float for f64 {
|
|||
}
|
||||
}
|
||||
|
||||
/// Returns the exponential of the number, minus `1`, in a way that is accurate
|
||||
/// even if the number is close to zero
|
||||
#[inline]
|
||||
fn exp_m1(self) -> f64 {
|
||||
unsafe { cmath::expm1(self) }
|
||||
}
|
||||
|
||||
/// Returns the natural logarithm of the number plus `1` (`ln(1+n)`) more accurately
|
||||
/// than if the operations were performed separately
|
||||
#[inline]
|
||||
fn ln_1p(self) -> f64 {
|
||||
unsafe { cmath::log1p(self) }
|
||||
}
|
||||
|
||||
/// Fused multiply-add. Computes `(self * a) + b` with only one rounding error. This
|
||||
/// produces a more accurate result with better performance than a separate multiplication
|
||||
/// operation followed by an add.
|
||||
#[inline]
|
||||
fn mul_add(self, a: f64, b: f64) -> f64 {
|
||||
unsafe { intrinsics::fmaf64(self, a, b) }
|
||||
}
|
||||
|
||||
/// Returns the next representable floating-point value in the direction of `other`
|
||||
#[inline]
|
||||
fn next_after(self, other: f64) -> f64 {
|
||||
unsafe { cmath::nextafter(self, other) }
|
||||
}
|
||||
|
||||
/// Returns the mantissa, exponent and sign as integers.
|
||||
fn integer_decode(self) -> (u64, i16, i8) {
|
||||
let bits: u64 = unsafe { cast::transmute(self) };
|
||||
|
|
@ -408,6 +373,13 @@ impl Float for f64 {
|
|||
(mantissa, exponent, sign)
|
||||
}
|
||||
|
||||
/// Returns the next representable floating-point value in the direction of
|
||||
/// `other`.
|
||||
#[inline]
|
||||
fn next_after(self, other: f64) -> f64 {
|
||||
unsafe { cmath::nextafter(self, other) }
|
||||
}
|
||||
|
||||
/// Round half-way cases toward `NEG_INFINITY`
|
||||
#[inline]
|
||||
fn floor(self) -> f64 {
|
||||
|
|
@ -441,6 +413,64 @@ impl Float for f64 {
|
|||
#[inline]
|
||||
fn fract(self) -> f64 { self - self.trunc() }
|
||||
|
||||
#[inline]
|
||||
fn max(self, other: f64) -> f64 {
|
||||
unsafe { cmath::fmax(self, other) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn min(self, other: f64) -> f64 {
|
||||
unsafe { cmath::fmin(self, other) }
|
||||
}
|
||||
|
||||
/// Fused multiply-add. Computes `(self * a) + b` with only one rounding
|
||||
/// error. This produces a more accurate result with better performance than
|
||||
/// a separate multiplication operation followed by an add.
|
||||
#[inline]
|
||||
fn mul_add(self, a: f64, b: f64) -> f64 {
|
||||
unsafe { intrinsics::fmaf64(self, a, b) }
|
||||
}
|
||||
|
||||
/// The reciprocal (multiplicative inverse) of the number
|
||||
#[inline]
|
||||
fn recip(self) -> f64 { 1.0 / self }
|
||||
|
||||
#[inline]
|
||||
fn powf(self, n: f64) -> f64 {
|
||||
unsafe { intrinsics::powf64(self, n) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn powi(self, n: i32) -> f64 {
|
||||
unsafe { intrinsics::powif64(self, n) }
|
||||
}
|
||||
|
||||
/// sqrt(2.0)
|
||||
#[inline]
|
||||
fn sqrt2() -> f64 { 1.41421356237309504880168872420969808 }
|
||||
|
||||
/// 1.0 / sqrt(2.0)
|
||||
#[inline]
|
||||
fn frac_1_sqrt2() -> f64 { 0.707106781186547524400844362104849039 }
|
||||
|
||||
#[inline]
|
||||
fn sqrt(self) -> f64 {
|
||||
unsafe { intrinsics::sqrtf64(self) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn rsqrt(self) -> f64 { self.sqrt().recip() }
|
||||
|
||||
#[inline]
|
||||
fn cbrt(self) -> f64 {
|
||||
unsafe { cmath::cbrt(self) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn hypot(self, other: f64) -> f64 {
|
||||
unsafe { cmath::hypot(self, other) }
|
||||
}
|
||||
|
||||
/// Archimedes' constant
|
||||
#[inline]
|
||||
fn pi() -> f64 { 3.14159265358979323846264338327950288 }
|
||||
|
|
@ -481,66 +511,6 @@ impl Float for f64 {
|
|||
#[inline]
|
||||
fn frac_2_sqrtpi() -> f64 { 1.12837916709551257389615890312154517 }
|
||||
|
||||
/// sqrt(2.0)
|
||||
#[inline]
|
||||
fn sqrt2() -> f64 { 1.41421356237309504880168872420969808 }
|
||||
|
||||
/// 1.0 / sqrt(2.0)
|
||||
#[inline]
|
||||
fn frac_1_sqrt2() -> f64 { 0.707106781186547524400844362104849039 }
|
||||
|
||||
/// Euler's number
|
||||
#[inline]
|
||||
fn e() -> f64 { 2.71828182845904523536028747135266250 }
|
||||
|
||||
/// log2(e)
|
||||
#[inline]
|
||||
fn log2_e() -> f64 { 1.44269504088896340735992468100189214 }
|
||||
|
||||
/// log10(e)
|
||||
#[inline]
|
||||
fn log10_e() -> f64 { 0.434294481903251827651128918916605082 }
|
||||
|
||||
/// ln(2.0)
|
||||
#[inline]
|
||||
fn ln_2() -> f64 { 0.693147180559945309417232121458176568 }
|
||||
|
||||
/// ln(10.0)
|
||||
#[inline]
|
||||
fn ln_10() -> f64 { 2.30258509299404568401799145468436421 }
|
||||
|
||||
/// The reciprocal (multiplicative inverse) of the number
|
||||
#[inline]
|
||||
fn recip(self) -> f64 { 1.0 / self }
|
||||
|
||||
#[inline]
|
||||
fn powf(self, n: f64) -> f64 {
|
||||
unsafe { intrinsics::powf64(self, n) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn powi(self, n: i32) -> f64 {
|
||||
unsafe { intrinsics::powif64(self, n) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn sqrt(self) -> f64 {
|
||||
unsafe { intrinsics::sqrtf64(self) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn rsqrt(self) -> f64 { self.sqrt().recip() }
|
||||
|
||||
#[inline]
|
||||
fn cbrt(self) -> f64 {
|
||||
unsafe { cmath::cbrt(self) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn hypot(self, other: f64) -> f64 {
|
||||
unsafe { cmath::hypot(self, other) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn sin(self) -> f64 {
|
||||
unsafe { intrinsics::sinf64(self) }
|
||||
|
|
@ -582,6 +552,26 @@ impl Float for f64 {
|
|||
(self.sin(), self.cos())
|
||||
}
|
||||
|
||||
/// Euler's number
|
||||
#[inline]
|
||||
fn e() -> f64 { 2.71828182845904523536028747135266250 }
|
||||
|
||||
/// log2(e)
|
||||
#[inline]
|
||||
fn log2_e() -> f64 { 1.44269504088896340735992468100189214 }
|
||||
|
||||
/// log10(e)
|
||||
#[inline]
|
||||
fn log10_e() -> f64 { 0.434294481903251827651128918916605082 }
|
||||
|
||||
/// ln(2.0)
|
||||
#[inline]
|
||||
fn ln_2() -> f64 { 0.693147180559945309417232121458176568 }
|
||||
|
||||
/// ln(10.0)
|
||||
#[inline]
|
||||
fn ln_10() -> f64 { 2.30258509299404568401799145468436421 }
|
||||
|
||||
/// Returns the exponential of the number
|
||||
#[inline]
|
||||
fn exp(self) -> f64 {
|
||||
|
|
@ -594,6 +584,13 @@ impl Float for f64 {
|
|||
unsafe { intrinsics::exp2f64(self) }
|
||||
}
|
||||
|
||||
/// Returns the exponential of the number, minus `1`, in a way that is
|
||||
/// accurate even if the number is close to zero
|
||||
#[inline]
|
||||
fn exp_m1(self) -> f64 {
|
||||
unsafe { cmath::expm1(self) }
|
||||
}
|
||||
|
||||
/// Returns the natural logarithm of the number
|
||||
#[inline]
|
||||
fn ln(self) -> f64 {
|
||||
|
|
@ -616,6 +613,13 @@ impl Float for f64 {
|
|||
unsafe { intrinsics::log10f64(self) }
|
||||
}
|
||||
|
||||
/// Returns the natural logarithm of the number plus `1` (`ln(1+n)`) more
|
||||
/// accurately than if the operations were performed separately
|
||||
#[inline]
|
||||
fn ln_1p(self) -> f64 {
|
||||
unsafe { cmath::log1p(self) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn sinh(self) -> f64 {
|
||||
unsafe { cmath::sinh(self) }
|
||||
|
|
|
|||
|
|
@ -329,166 +329,94 @@ pub enum FPCategory {
|
|||
// FIXME(#8888): Several of these functions have a parameter named
|
||||
// `unused_self`. Removing it requires #8888 to be fixed.
|
||||
pub trait Float: Signed + Primitive {
|
||||
/// Returns the maximum of the two numbers.
|
||||
fn max(self, other: Self) -> Self;
|
||||
/// Returns the minimum of the two numbers.
|
||||
fn min(self, other: Self) -> Self;
|
||||
|
||||
/// Returns the NaN value.
|
||||
fn nan() -> Self;
|
||||
|
||||
/// Returns the infinite value.
|
||||
fn infinity() -> Self;
|
||||
|
||||
/// Returns the negative infinite value.
|
||||
fn neg_infinity() -> Self;
|
||||
|
||||
/// Returns -0.0.
|
||||
fn neg_zero() -> Self;
|
||||
|
||||
/// Returns true if this value is NaN and false otherwise.
|
||||
fn is_nan(self) -> bool;
|
||||
|
||||
/// Returns true if this value is positive infinity or negative infinity and false otherwise.
|
||||
/// Returns true if this value is positive infinity or negative infinity and
|
||||
/// false otherwise.
|
||||
fn is_infinite(self) -> bool;
|
||||
|
||||
/// Returns true if this number is neither infinite nor NaN.
|
||||
fn is_finite(self) -> bool;
|
||||
|
||||
/// Returns true if this number is neither zero, infinite, denormal, or NaN.
|
||||
fn is_normal(self) -> bool;
|
||||
|
||||
/// Returns the category that this number falls into.
|
||||
fn classify(self) -> FPCategory;
|
||||
|
||||
/// Returns the number of binary digits of mantissa that this type supports.
|
||||
fn mantissa_digits(unused_self: Option<Self>) -> uint;
|
||||
|
||||
/// Returns the number of binary digits of exponent that this type supports.
|
||||
fn digits(unused_self: Option<Self>) -> uint;
|
||||
|
||||
/// Returns the smallest positive number that this type can represent.
|
||||
fn epsilon() -> Self;
|
||||
|
||||
/// Returns the minimum binary exponent that this type can represent.
|
||||
fn min_exp(unused_self: Option<Self>) -> int;
|
||||
|
||||
/// Returns the maximum binary exponent that this type can represent.
|
||||
fn max_exp(unused_self: Option<Self>) -> int;
|
||||
|
||||
/// Returns the minimum base-10 exponent that this type can represent.
|
||||
fn min_10_exp(unused_self: Option<Self>) -> int;
|
||||
|
||||
/// Returns the maximum base-10 exponent that this type can represent.
|
||||
fn max_10_exp(unused_self: Option<Self>) -> int;
|
||||
|
||||
/// Constructs a floating point number created by multiplying `x` by 2 raised to the power of
|
||||
/// `exp`.
|
||||
/// Constructs a floating point number created by multiplying `x` by 2
|
||||
/// raised to the power of `exp`.
|
||||
fn ldexp(x: Self, exp: int) -> Self;
|
||||
|
||||
/// Breaks the number into a normalized fraction and a base-2 exponent, satisfying:
|
||||
/// Breaks the number into a normalized fraction and a base-2 exponent,
|
||||
/// satisfying:
|
||||
///
|
||||
/// * `self = x * pow(2, exp)`
|
||||
///
|
||||
/// * `0.5 <= abs(x) < 1.0`
|
||||
fn frexp(self) -> (Self, int);
|
||||
|
||||
/// Returns the exponential of the number, minus 1, in a way that is accurate even if the
|
||||
/// number is close to zero.
|
||||
fn exp_m1(self) -> Self;
|
||||
|
||||
/// Returns the natural logarithm of the number plus 1 (`ln(1+n)`) more accurately than if the
|
||||
/// operations were performed separately.
|
||||
fn ln_1p(self) -> Self;
|
||||
|
||||
/// Fused multiply-add. Computes `(self * a) + b` with only one rounding error. This produces a
|
||||
/// more accurate result with better performance than a separate multiplication operation
|
||||
/// followed by an add.
|
||||
fn mul_add(self, a: Self, b: Self) -> Self;
|
||||
|
||||
/// Returns the next representable floating-point value in the direction of `other`.
|
||||
fn next_after(self, other: Self) -> Self;
|
||||
|
||||
/// Returns the mantissa, exponent and sign as integers, respectively.
|
||||
fn integer_decode(self) -> (u64, i16, i8);
|
||||
|
||||
/// Returns the next representable floating-point value in the direction of
|
||||
/// `other`.
|
||||
fn next_after(self, other: Self) -> Self;
|
||||
|
||||
/// Return the largest integer less than or equal to a number.
|
||||
fn floor(self) -> Self;
|
||||
|
||||
/// Return the smallest integer greater than or equal to a number.
|
||||
fn ceil(self) -> Self;
|
||||
|
||||
/// Return the nearest integer to a number. Round half-way cases away from
|
||||
/// `0.0`.
|
||||
fn round(self) -> Self;
|
||||
|
||||
/// Return the integer part of a number.
|
||||
fn trunc(self) -> Self;
|
||||
|
||||
/// Return the fractional part of a number.
|
||||
fn fract(self) -> Self;
|
||||
|
||||
/// Archimedes' constant.
|
||||
fn pi() -> Self;
|
||||
|
||||
/// 2.0 * pi.
|
||||
fn two_pi() -> Self;
|
||||
|
||||
/// pi / 2.0.
|
||||
fn frac_pi_2() -> Self;
|
||||
|
||||
/// pi / 3.0.
|
||||
fn frac_pi_3() -> Self;
|
||||
|
||||
/// pi / 4.0.
|
||||
fn frac_pi_4() -> Self;
|
||||
|
||||
/// pi / 6.0.
|
||||
fn frac_pi_6() -> Self;
|
||||
|
||||
/// pi / 8.0.
|
||||
fn frac_pi_8() -> Self;
|
||||
|
||||
/// 1.0 / pi.
|
||||
fn frac_1_pi() -> Self;
|
||||
|
||||
/// 2.0 / pi.
|
||||
fn frac_2_pi() -> Self;
|
||||
|
||||
/// 2.0 / sqrt(pi).
|
||||
fn frac_2_sqrtpi() -> Self;
|
||||
|
||||
/// sqrt(2.0).
|
||||
fn sqrt2() -> Self;
|
||||
|
||||
/// 1.0 / sqrt(2.0).
|
||||
fn frac_1_sqrt2() -> Self;
|
||||
|
||||
/// Euler's number.
|
||||
fn e() -> Self;
|
||||
|
||||
/// log2(e).
|
||||
fn log2_e() -> Self;
|
||||
|
||||
/// log10(e).
|
||||
fn log10_e() -> Self;
|
||||
|
||||
/// ln(2.0).
|
||||
fn ln_2() -> Self;
|
||||
|
||||
/// ln(10.0).
|
||||
fn ln_10() -> Self;
|
||||
/// Returns the maximum of the two numbers.
|
||||
fn max(self, other: Self) -> Self;
|
||||
/// Returns the minimum of the two numbers.
|
||||
fn min(self, other: Self) -> Self;
|
||||
|
||||
/// Fused multiply-add. Computes `(self * a) + b` with only one rounding
|
||||
/// error. This produces a more accurate result with better performance than
|
||||
/// a separate multiplication operation followed by an add.
|
||||
fn mul_add(self, a: Self, b: Self) -> Self;
|
||||
/// Take the reciprocal (inverse) of a number, `1/x`.
|
||||
fn recip(self) -> Self;
|
||||
|
||||
/// Raise a number to a power.
|
||||
fn powf(self, n: Self) -> Self;
|
||||
|
||||
/// Raise a number to an integer power.
|
||||
///
|
||||
/// Using this function is generally faster than using `powf`
|
||||
fn powi(self, n: i32) -> Self;
|
||||
/// Raise a number to a floating point power.
|
||||
fn powf(self, n: Self) -> Self;
|
||||
|
||||
/// sqrt(2.0).
|
||||
fn sqrt2() -> Self;
|
||||
/// 1.0 / sqrt(2.0).
|
||||
fn frac_1_sqrt2() -> Self;
|
||||
|
||||
/// Take the square root of a number.
|
||||
fn sqrt(self) -> Self;
|
||||
|
|
@ -500,6 +428,27 @@ pub trait Float: Signed + Primitive {
|
|||
/// legs of length `x` and `y`.
|
||||
fn hypot(self, other: Self) -> Self;
|
||||
|
||||
/// Archimedes' constant.
|
||||
fn pi() -> Self;
|
||||
/// 2.0 * pi.
|
||||
fn two_pi() -> Self;
|
||||
/// pi / 2.0.
|
||||
fn frac_pi_2() -> Self;
|
||||
/// pi / 3.0.
|
||||
fn frac_pi_3() -> Self;
|
||||
/// pi / 4.0.
|
||||
fn frac_pi_4() -> Self;
|
||||
/// pi / 6.0.
|
||||
fn frac_pi_6() -> Self;
|
||||
/// pi / 8.0.
|
||||
fn frac_pi_8() -> Self;
|
||||
/// 1.0 / pi.
|
||||
fn frac_1_pi() -> Self;
|
||||
/// 2.0 / pi.
|
||||
fn frac_2_pi() -> Self;
|
||||
/// 2.0 / sqrt(pi).
|
||||
fn frac_2_sqrtpi() -> Self;
|
||||
|
||||
/// Computes the sine of a number (in radians).
|
||||
fn sin(self) -> Self;
|
||||
/// Computes the cosine of a number (in radians).
|
||||
|
|
@ -525,10 +474,24 @@ pub trait Float: Signed + Primitive {
|
|||
/// `(sin(x), cos(x))`.
|
||||
fn sin_cos(self) -> (Self, Self);
|
||||
|
||||
/// Euler's number.
|
||||
fn e() -> Self;
|
||||
/// log2(e).
|
||||
fn log2_e() -> Self;
|
||||
/// log10(e).
|
||||
fn log10_e() -> Self;
|
||||
/// ln(2.0).
|
||||
fn ln_2() -> Self;
|
||||
/// ln(10.0).
|
||||
fn ln_10() -> Self;
|
||||
|
||||
/// Returns `e^(self)`, (the exponential function).
|
||||
fn exp(self) -> Self;
|
||||
/// Returns 2 raised to the power of the number, `2^(self)`.
|
||||
fn exp2(self) -> Self;
|
||||
/// Returns the exponential of the number, minus 1, in a way that is
|
||||
/// accurate even if the number is close to zero.
|
||||
fn exp_m1(self) -> Self;
|
||||
/// Returns the natural logarithm of the number.
|
||||
fn ln(self) -> Self;
|
||||
/// Returns the logarithm of the number with respect to an arbitrary base.
|
||||
|
|
@ -537,6 +500,9 @@ pub trait Float: Signed + Primitive {
|
|||
fn log2(self) -> Self;
|
||||
/// Returns the base 10 logarithm of the number.
|
||||
fn log10(self) -> Self;
|
||||
/// Returns the natural logarithm of the number plus 1 (`ln(1+n)`) more
|
||||
/// accurately than if the operations were performed separately.
|
||||
fn ln_1p(self) -> Self;
|
||||
|
||||
/// Hyperbolic sine function.
|
||||
fn sinh(self) -> Self;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue