diff options
Diffstat (limited to 'src/libstd')
| -rw-r--r-- | src/libstd/num/f32.rs | 268 | ||||
| -rw-r--r-- | src/libstd/num/f64.rs | 275 | ||||
| -rw-r--r-- | src/libstd/num/mod.rs | 154 |
3 files changed, 8 insertions, 689 deletions
diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index 29c206b32fc..cf02d5b0d5f 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -18,7 +18,6 @@ use prelude::*; use from_str::FromStr; use intrinsics; use libc::c_int; -use mem; use num::strconv; use num::{FPCategory, FPNaN, FPInfinite , FPZero, FPSubnormal, FPNormal}; use num; @@ -69,82 +68,7 @@ mod cmath { } } -impl Float for f32 { - #[inline] - fn nan() -> f32 { NAN } - - #[inline] - fn infinity() -> f32 { INFINITY } - - #[inline] - fn neg_infinity() -> f32 { NEG_INFINITY } - - #[inline] - fn neg_zero() -> f32 { -0.0 } - - /// Returns `true` if the number is NaN - #[inline] - fn is_nan(self) -> bool { self != self } - - /// Returns `true` if the number is infinite - #[inline] - fn is_infinite(self) -> bool { - self == Float::infinity() || self == Float::neg_infinity() - } - - /// Returns `true` if the number is neither infinite or NaN - #[inline] - fn is_finite(self) -> bool { - !(self.is_nan() || self.is_infinite()) - } - - /// Returns `true` if the number is neither zero, infinite, subnormal or NaN - #[inline] - fn is_normal(self) -> bool { - 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. - fn classify(self) -> FPCategory { - static EXP_MASK: u32 = 0x7f800000; - static MAN_MASK: u32 = 0x007fffff; - - let bits: u32 = unsafe { mem::transmute(self) }; - match (bits & MAN_MASK, bits & EXP_MASK) { - (0, 0) => FPZero, - (_, 0) => FPSubnormal, - (0, EXP_MASK) => FPInfinite, - (_, EXP_MASK) => FPNaN, - _ => FPNormal, - } - } - - #[inline] - fn mantissa_digits(_: Option<f32>) -> uint { MANTISSA_DIGITS } - - #[inline] - fn digits(_: Option<f32>) -> uint { DIGITS } - - #[inline] - fn epsilon() -> f32 { EPSILON } - - #[inline] - fn min_exp(_: Option<f32>) -> int { MIN_EXP } - - #[inline] - fn max_exp(_: Option<f32>) -> int { MAX_EXP } - - #[inline] - fn min_10_exp(_: Option<f32>) -> int { MIN_10_EXP } - - #[inline] - fn max_10_exp(_: Option<f32>) -> int { MAX_10_EXP } - - #[inline] - fn min_pos_value(_: Option<f32>) -> f32 { MIN_POS_VALUE } - +impl FloatMath for f32 { /// Constructs a floating point number by multiplying `x` by 2 raised to the /// power of `exp` #[inline] @@ -166,21 +90,6 @@ impl Float for f32 { } } - /// Returns the mantissa, exponent and sign as integers. - fn integer_decode(self) -> (u64, i16, i8) { - let bits: u32 = unsafe { mem::transmute(self) }; - let sign: i8 = if bits >> 31 == 0 { 1 } else { -1 }; - let mut exponent: i16 = ((bits >> 23) & 0xff) as i16; - let mantissa = if exponent == 0 { - (bits & 0x7fffff) << 1 - } else { - (bits & 0x7fffff) | 0x800000 - }; - // Exponent bias + mantissa shift - exponent -= 127 + 23; - (mantissa as u64, exponent, sign) - } - /// Returns the next representable floating-point value in the direction of /// `other`. #[inline] @@ -188,39 +97,6 @@ impl Float for f32 { unsafe { cmath::nextafterf(self, other) } } - /// Round half-way cases toward `NEG_INFINITY` - #[inline] - fn floor(self) -> f32 { - unsafe { intrinsics::floorf32(self) } - } - - /// Round half-way cases toward `INFINITY` - #[inline] - fn ceil(self) -> f32 { - unsafe { intrinsics::ceilf32(self) } - } - - /// Round half-way cases away from `0.0` - #[inline] - fn round(self) -> f32 { - unsafe { intrinsics::roundf32(self) } - } - - /// The integer part of the number (rounds towards `0.0`) - #[inline] - fn trunc(self) -> f32 { - unsafe { intrinsics::truncf32(self) } - } - - /// The fractional part of the number, satisfying: - /// - /// ```rust - /// let x = 1.65f32; - /// assert!(x == x.trunc() + x.fract()) - /// ``` - #[inline] - fn fract(self) -> f32 { self - self.trunc() } - #[inline] fn max(self, other: f32) -> f32 { unsafe { cmath::fmaxf(self, other) } @@ -231,43 +107,6 @@ impl Float for 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 { consts::SQRT2 } - - /// 1.0 / sqrt(2.0) - #[inline] - fn frac_1_sqrt2() -> f32 { consts::FRAC_1_SQRT2 } - - #[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) } @@ -278,46 +117,6 @@ impl Float for f32 { unsafe { cmath::hypotf(self, other) } } - /// Archimedes' constant - #[inline] - fn pi() -> f32 { consts::PI } - - /// 2.0 * pi - #[inline] - fn two_pi() -> f32 { consts::PI_2 } - - /// pi / 2.0 - #[inline] - fn frac_pi_2() -> f32 { consts::FRAC_PI_2 } - - /// pi / 3.0 - #[inline] - fn frac_pi_3() -> f32 { consts::FRAC_PI_3 } - - /// pi / 4.0 - #[inline] - fn frac_pi_4() -> f32 { consts::FRAC_PI_4 } - - /// pi / 6.0 - #[inline] - fn frac_pi_6() -> f32 { consts::FRAC_PI_6 } - - /// pi / 8.0 - #[inline] - fn frac_pi_8() -> f32 { consts::FRAC_PI_8 } - - /// 1 .0/ pi - #[inline] - fn frac_1_pi() -> f32 { consts::FRAC_1_PI } - - /// 2.0 / pi - #[inline] - fn frac_2_pi() -> f32 { consts::FRAC_2_PI } - - /// 2.0 / sqrt(pi) - #[inline] - fn frac_2_sqrtpi() -> f32 { consts::FRAC_2_SQRTPI } - #[inline] fn sin(self) -> f32 { unsafe { intrinsics::sinf32(self) } @@ -359,38 +158,6 @@ impl Float for f32 { (self.sin(), self.cos()) } - /// Euler's number - #[inline] - fn e() -> f32 { consts::E } - - /// log2(e) - #[inline] - fn log2_e() -> f32 { consts::LOG2_E } - - /// log10(e) - #[inline] - fn log10_e() -> f32 { consts::LOG10_E } - - /// ln(2.0) - #[inline] - fn ln_2() -> f32 { consts::LN_2 } - - /// ln(10.0) - #[inline] - fn ln_10() -> f32 { consts::LN_10 } - - /// Returns the exponential of the number - #[inline] - fn exp(self) -> f32 { - unsafe { intrinsics::expf32(self) } - } - - /// Returns 2 raised to the power of the number - #[inline] - fn exp2(self) -> 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] @@ -398,28 +165,6 @@ impl Float for f32 { unsafe { cmath::expm1f(self) } } - /// Returns the natural logarithm of the number - #[inline] - fn ln(self) -> f32 { - unsafe { intrinsics::logf32(self) } - } - - /// Returns the logarithm of the number with respect to an arbitrary base - #[inline] - fn log(self, base: f32) -> f32 { self.ln() / base.ln() } - - /// Returns the base 2 logarithm of the number - #[inline] - fn log2(self) -> f32 { - unsafe { intrinsics::log2f32(self) } - } - - /// Returns the base 10 logarithm of the number - #[inline] - fn log10(self) -> 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] @@ -486,17 +231,6 @@ impl Float for f32 { fn atanh(self) -> f32 { 0.5 * ((2.0 * self) / (1.0 - self)).ln_1p() } - - /// Converts to degrees, assuming the number is in radians - #[inline] - fn to_degrees(self) -> f32 { self * (180.0f32 / Float::pi()) } - - /// Converts to radians, assuming the number is in degrees - #[inline] - fn to_radians(self) -> f32 { - let value: f32 = Float::pi(); - self * (value / 180.0f32) - } } // diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index c18ea5caba6..41aeb27362e 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -15,11 +15,8 @@ use prelude::*; use from_str::FromStr; -use intrinsics; -use libc::{c_int}; -use mem; -use num::{FPCategory, FPNaN, FPInfinite , FPZero, FPSubnormal, FPNormal}; -use num::{strconv}; +use libc::c_int; +use num::strconv; use num; pub use core::f64::{RADIX, MANTISSA_DIGITS, DIGITS, EPSILON, MIN_VALUE}; @@ -77,82 +74,7 @@ mod cmath { } } -impl Float for f64 { - #[inline] - fn nan() -> f64 { NAN } - - #[inline] - fn infinity() -> f64 { INFINITY } - - #[inline] - fn neg_infinity() -> f64 { NEG_INFINITY } - - #[inline] - fn neg_zero() -> f64 { -0.0 } - - /// Returns `true` if the number is NaN - #[inline] - fn is_nan(self) -> bool { self != self } - - /// Returns `true` if the number is infinite - #[inline] - fn is_infinite(self) -> bool { - self == Float::infinity() || self == Float::neg_infinity() - } - - /// Returns `true` if the number is neither infinite or NaN - #[inline] - fn is_finite(self) -> bool { - !(self.is_nan() || self.is_infinite()) - } - - /// Returns `true` if the number is neither zero, infinite, subnormal or NaN - #[inline] - fn is_normal(self) -> bool { - 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. - fn classify(self) -> FPCategory { - static EXP_MASK: u64 = 0x7ff0000000000000; - static MAN_MASK: u64 = 0x000fffffffffffff; - - let bits: u64 = unsafe { mem::transmute(self) }; - match (bits & MAN_MASK, bits & EXP_MASK) { - (0, 0) => FPZero, - (_, 0) => FPSubnormal, - (0, EXP_MASK) => FPInfinite, - (_, EXP_MASK) => FPNaN, - _ => FPNormal, - } - } - - #[inline] - fn mantissa_digits(_: Option<f64>) -> uint { MANTISSA_DIGITS } - - #[inline] - fn digits(_: Option<f64>) -> uint { DIGITS } - - #[inline] - fn epsilon() -> f64 { EPSILON } - - #[inline] - fn min_exp(_: Option<f64>) -> int { MIN_EXP } - - #[inline] - fn max_exp(_: Option<f64>) -> int { MAX_EXP } - - #[inline] - fn min_10_exp(_: Option<f64>) -> int { MIN_10_EXP } - - #[inline] - fn max_10_exp(_: Option<f64>) -> int { MAX_10_EXP } - - #[inline] - fn min_pos_value(_: Option<f64>) -> f64 { MIN_POS_VALUE } - +impl FloatMath for f64 { /// Constructs a floating point number by multiplying `x` by 2 raised to the /// power of `exp` #[inline] @@ -174,21 +96,6 @@ impl Float for f64 { } } - /// Returns the mantissa, exponent and sign as integers. - fn integer_decode(self) -> (u64, i16, i8) { - let bits: u64 = unsafe { mem::transmute(self) }; - let sign: i8 = if bits >> 63 == 0 { 1 } else { -1 }; - let mut exponent: i16 = ((bits >> 52) & 0x7ff) as i16; - let mantissa = if exponent == 0 { - (bits & 0xfffffffffffff) << 1 - } else { - (bits & 0xfffffffffffff) | 0x10000000000000 - }; - // Exponent bias + mantissa shift - exponent -= 1023 + 52; - (mantissa, exponent, sign) - } - /// Returns the next representable floating-point value in the direction of /// `other`. #[inline] @@ -196,39 +103,6 @@ impl Float for f64 { unsafe { cmath::nextafter(self, other) } } - /// Round half-way cases toward `NEG_INFINITY` - #[inline] - fn floor(self) -> f64 { - unsafe { intrinsics::floorf64(self) } - } - - /// Round half-way cases toward `INFINITY` - #[inline] - fn ceil(self) -> f64 { - unsafe { intrinsics::ceilf64(self) } - } - - /// Round half-way cases away from `0.0` - #[inline] - fn round(self) -> f64 { - unsafe { intrinsics::roundf64(self) } - } - - /// The integer part of the number (rounds towards `0.0`) - #[inline] - fn trunc(self) -> f64 { - unsafe { intrinsics::truncf64(self) } - } - - /// The fractional part of the number, satisfying: - /// - /// ```rust - /// let x = 1.65f64; - /// assert!(x == x.trunc() + x.fract()) - /// ``` - #[inline] - fn fract(self) -> f64 { self - self.trunc() } - #[inline] fn max(self, other: f64) -> f64 { unsafe { cmath::fmax(self, other) } @@ -239,44 +113,6 @@ impl Float for 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 { consts::SQRT2 } - - /// 1.0 / sqrt(2.0) - #[inline] - fn frac_1_sqrt2() -> f64 { consts::FRAC_1_SQRT2 } - - #[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) } @@ -287,46 +123,6 @@ impl Float for f64 { unsafe { cmath::hypot(self, other) } } - /// Archimedes' constant - #[inline] - fn pi() -> f64 { consts::PI } - - /// 2.0 * pi - #[inline] - fn two_pi() -> f64 { consts::PI_2 } - - /// pi / 2.0 - #[inline] - fn frac_pi_2() -> f64 { consts::FRAC_PI_2 } - - /// pi / 3.0 - #[inline] - fn frac_pi_3() -> f64 { consts::FRAC_PI_3 } - - /// pi / 4.0 - #[inline] - fn frac_pi_4() -> f64 { consts::FRAC_PI_4 } - - /// pi / 6.0 - #[inline] - fn frac_pi_6() -> f64 { consts::FRAC_PI_6 } - - /// pi / 8.0 - #[inline] - fn frac_pi_8() -> f64 { consts::FRAC_PI_8 } - - /// 1.0 / pi - #[inline] - fn frac_1_pi() -> f64 { consts::FRAC_1_PI } - - /// 2.0 / pi - #[inline] - fn frac_2_pi() -> f64 { consts::FRAC_2_PI } - - /// 2.0 / sqrt(pi) - #[inline] - fn frac_2_sqrtpi() -> f64 { consts::FRAC_2_SQRTPI } - #[inline] fn sin(self) -> f64 { unsafe { intrinsics::sinf64(self) } @@ -368,38 +164,6 @@ impl Float for f64 { (self.sin(), self.cos()) } - /// Euler's number - #[inline] - fn e() -> f64 { consts::E } - - /// log2(e) - #[inline] - fn log2_e() -> f64 { consts::LOG2_E } - - /// log10(e) - #[inline] - fn log10_e() -> f64 { consts::LOG10_E } - - /// ln(2.0) - #[inline] - fn ln_2() -> f64 { consts::LN_2 } - - /// ln(10.0) - #[inline] - fn ln_10() -> f64 { consts::LN_10 } - - /// Returns the exponential of the number - #[inline] - fn exp(self) -> f64 { - unsafe { intrinsics::expf64(self) } - } - - /// Returns 2 raised to the power of the number - #[inline] - fn exp2(self) -> 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] @@ -407,28 +171,6 @@ impl Float for f64 { unsafe { cmath::expm1(self) } } - /// Returns the natural logarithm of the number - #[inline] - fn ln(self) -> f64 { - unsafe { intrinsics::logf64(self) } - } - - /// Returns the logarithm of the number with respect to an arbitrary base - #[inline] - fn log(self, base: f64) -> f64 { self.ln() / base.ln() } - - /// Returns the base 2 logarithm of the number - #[inline] - fn log2(self) -> f64 { - unsafe { intrinsics::log2f64(self) } - } - - /// Returns the base 10 logarithm of the number - #[inline] - fn log10(self) -> 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] @@ -495,17 +237,6 @@ impl Float for f64 { fn atanh(self) -> f64 { 0.5 * ((2.0 * self) / (1.0 - self)).ln_1p() } - - /// Converts to degrees, assuming the number is in radians - #[inline] - fn to_degrees(self) -> f64 { self * (180.0f64 / Float::pi()) } - - /// Converts to radians, assuming the number is in degrees - #[inline] - fn to_radians(self) -> f64 { - let value: f64 = Float::pi(); - self * (value / 180.0) - } } // diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index 1efd7cad300..3178fcbd66f 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -30,71 +30,13 @@ pub use core::num::{checked_next_power_of_two}; pub use core::num::{from_int, from_i8, from_i16, from_i32, from_i64}; pub use core::num::{from_uint, from_u8, from_u16, from_u32, from_u64}; pub use core::num::{from_f32, from_f64}; +pub use core::num::{FPCategory, FPNaN, FPInfinite, FPZero, FPSubnormal}; +pub use core::num::{FPNormal, Float}; pub mod strconv; -/// Used for representing the classification of floating point numbers -#[deriving(Eq, Show)] -pub enum FPCategory { - /// "Not a Number", often obtained by dividing by zero - FPNaN, - /// Positive or negative infinity - FPInfinite , - /// Positive or negative zero - FPZero, - /// De-normalized floating point representation (less precise than `FPNormal`) - FPSubnormal, - /// A regular floating point number - FPNormal, -} - -/// Operations on primitive floating point numbers. -// FIXME(#5527): In a future version of Rust, many of these functions will -// become constants. -// -// 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 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. - 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; - - // FIXME (#5527): These should be associated constants - - /// Returns the number of binary digits of mantissa that this type supports. - fn mantissa_digits(unused_self: Option<Self>) -> uint; - /// Returns the number of base-10 digits of precision that this type supports. - fn digits(unused_self: Option<Self>) -> uint; - /// Returns the difference between 1.0 and the smallest representable number larger than 1.0. - 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; - /// Returns the smallest normalized positive number that this type can represent. - fn min_pos_value(unused_self: Option<Self>) -> Self; - +/// Mathematical operations on primitive floating point numbers. +pub trait FloatMath: Float { /// Constructs a floating point number created by multiplying `x` by 2 /// raised to the power of `exp`. fn ldexp(x: Self, exp: int) -> Self; @@ -105,82 +47,22 @@ pub trait Float: Signed + Primitive { /// /// * `0.5 <= abs(x) < 1.0` fn frexp(self) -> (Self, int); - /// 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; - /// 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 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; - /// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`. - fn rsqrt(self) -> Self; /// Take the cubic root of a number. fn cbrt(self) -> Self; /// Calculate the length of the hypotenuse of a right-angle triangle given /// legs of length `x` and `y`. fn hypot(self, other: Self) -> Self; - // FIXME (#5527): These should be associated constants - - /// 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). @@ -206,32 +88,9 @@ 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. - fn log(self, base: Self) -> Self; - /// Returns the base 2 logarithm of the number. - 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; @@ -248,11 +107,6 @@ pub trait Float: Signed + Primitive { fn acosh(self) -> Self; /// Inverse hyperbolic tangent function. fn atanh(self) -> Self; - - /// Convert radians to degrees. - fn to_degrees(self) -> Self; - /// Convert degrees to radians. - fn to_radians(self) -> Self; } /// A generic trait for converting a value to a string with a radix (base) |