1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! Operations and constants for 32-bits floats (`f32` type)
13 #![stable(feature = "rust1", since = "1.0.0")]
18 use num
::FpCategory
as Fp
;
20 /// The radix or base of the internal representation of `f32`.
21 #[stable(feature = "rust1", since = "1.0.0")]
22 pub const RADIX
: u32 = 2;
24 /// Number of significant digits in base 2.
25 #[stable(feature = "rust1", since = "1.0.0")]
26 pub const MANTISSA_DIGITS
: u32 = 24;
27 /// Approximate number of significant digits in base 10.
28 #[stable(feature = "rust1", since = "1.0.0")]
29 pub const DIGITS
: u32 = 6;
31 /// Difference between `1.0` and the next largest representable number.
32 #[stable(feature = "rust1", since = "1.0.0")]
33 pub const EPSILON
: f32 = 1.19209290e-07_f32;
35 /// Smallest finite `f32` value.
36 #[stable(feature = "rust1", since = "1.0.0")]
37 pub const MIN
: f32 = -3.40282347e+38_f32;
38 /// Smallest positive normal `f32` value.
39 #[stable(feature = "rust1", since = "1.0.0")]
40 pub const MIN_POSITIVE
: f32 = 1.17549435e-38_f32;
41 /// Largest finite `f32` value.
42 #[stable(feature = "rust1", since = "1.0.0")]
43 pub const MAX
: f32 = 3.40282347e+38_f32;
45 /// One greater than the minimum possible normal power of 2 exponent.
46 #[stable(feature = "rust1", since = "1.0.0")]
47 pub const MIN_EXP
: i32 = -125;
48 /// Maximum possible power of 2 exponent.
49 #[stable(feature = "rust1", since = "1.0.0")]
50 pub const MAX_EXP
: i32 = 128;
52 /// Minimum possible normal power of 10 exponent.
53 #[stable(feature = "rust1", since = "1.0.0")]
54 pub const MIN_10_EXP
: i32 = -37;
55 /// Maximum possible power of 10 exponent.
56 #[stable(feature = "rust1", since = "1.0.0")]
57 pub const MAX_10_EXP
: i32 = 38;
59 /// Not a Number (NaN).
60 #[stable(feature = "rust1", since = "1.0.0")]
61 pub const NAN
: f32 = 0.0_f32 / 0.0_f32;
63 #[stable(feature = "rust1", since = "1.0.0")]
64 pub const INFINITY
: f32 = 1.0_f32 / 0.0_f32;
65 /// Negative infinity (-∞).
66 #[stable(feature = "rust1", since = "1.0.0")]
67 pub const NEG_INFINITY
: f32 = -1.0_f32 / 0.0_f32;
69 /// Basic mathematical constants.
70 #[stable(feature = "rust1", since = "1.0.0")]
72 // FIXME: replace with mathematical constants from cmath.
74 /// Archimedes' constant (π)
75 #[stable(feature = "rust1", since = "1.0.0")]
76 pub const PI
: f32 = 3.14159265358979323846264338327950288_f32;
79 #[stable(feature = "rust1", since = "1.0.0")]
80 pub const FRAC_PI_2
: f32 = 1.57079632679489661923132169163975144_f32;
83 #[stable(feature = "rust1", since = "1.0.0")]
84 pub const FRAC_PI_3
: f32 = 1.04719755119659774615421446109316763_f32;
87 #[stable(feature = "rust1", since = "1.0.0")]
88 pub const FRAC_PI_4
: f32 = 0.785398163397448309615660845819875721_f32;
91 #[stable(feature = "rust1", since = "1.0.0")]
92 pub const FRAC_PI_6
: f32 = 0.52359877559829887307710723054658381_f32;
95 #[stable(feature = "rust1", since = "1.0.0")]
96 pub const FRAC_PI_8
: f32 = 0.39269908169872415480783042290993786_f32;
99 #[stable(feature = "rust1", since = "1.0.0")]
100 pub const FRAC_1_PI
: f32 = 0.318309886183790671537767526745028724_f32;
103 #[stable(feature = "rust1", since = "1.0.0")]
104 pub const FRAC_2_PI
: f32 = 0.636619772367581343075535053490057448_f32;
107 #[stable(feature = "rust1", since = "1.0.0")]
108 pub const FRAC_2_SQRT_PI
: f32 = 1.12837916709551257389615890312154517_f32;
111 #[stable(feature = "rust1", since = "1.0.0")]
112 pub const SQRT_2
: f32 = 1.41421356237309504880168872420969808_f32;
115 #[stable(feature = "rust1", since = "1.0.0")]
116 pub const FRAC_1_SQRT_2
: f32 = 0.707106781186547524400844362104849039_f32;
118 /// Euler's number (e)
119 #[stable(feature = "rust1", since = "1.0.0")]
120 pub const E
: f32 = 2.71828182845904523536028747135266250_f32;
122 /// log<sub>2</sub>(e)
123 #[stable(feature = "rust1", since = "1.0.0")]
124 pub const LOG2_E
: f32 = 1.44269504088896340735992468100189214_f32;
126 /// log<sub>10</sub>(e)
127 #[stable(feature = "rust1", since = "1.0.0")]
128 pub const LOG10_E
: f32 = 0.434294481903251827651128918916605082_f32;
131 #[stable(feature = "rust1", since = "1.0.0")]
132 pub const LN_2
: f32 = 0.693147180559945309417232121458176568_f32;
135 #[stable(feature = "rust1", since = "1.0.0")]
136 pub const LN_10
: f32 = 2.30258509299404568401799145468436421_f32;
139 #[unstable(feature = "core_float",
140 reason
= "stable interface is via `impl f{32,64}` in later crates",
143 /// Returns `true` if the number is NaN.
145 fn is_nan(self) -> bool
{
149 /// Returns `true` if the number is infinite.
151 fn is_infinite(self) -> bool
{
152 self == INFINITY
|| self == NEG_INFINITY
155 /// Returns `true` if the number is neither infinite or NaN.
157 fn is_finite(self) -> bool
{
158 !(self.is_nan() || self.is_infinite())
161 /// Returns `true` if the number is neither zero, infinite, subnormal or NaN.
163 fn is_normal(self) -> bool
{
164 self.classify() == Fp
::Normal
167 /// Returns the floating point category of the number. If only one property
168 /// is going to be tested, it is generally faster to use the specific
169 /// predicate instead.
170 fn classify(self) -> Fp
{
171 const EXP_MASK
: u32 = 0x7f800000;
172 const MAN_MASK
: u32 = 0x007fffff;
174 let bits
: u32 = unsafe { mem::transmute(self) }
;
175 match (bits
& MAN_MASK
, bits
& EXP_MASK
) {
177 (_
, 0) => Fp
::Subnormal
,
178 (0, EXP_MASK
) => Fp
::Infinite
,
179 (_
, EXP_MASK
) => Fp
::Nan
,
184 /// Computes the absolute value of `self`. Returns `Float::nan()` if the
185 /// number is `Float::nan()`.
187 fn abs(self) -> f32 {
188 unsafe { intrinsics::fabsf32(self) }
191 /// Returns a number that represents the sign of `self`.
193 /// - `1.0` if the number is positive, `+0.0` or `Float::infinity()`
194 /// - `-1.0` if the number is negative, `-0.0` or `Float::neg_infinity()`
195 /// - `Float::nan()` if the number is `Float::nan()`
197 fn signum(self) -> f32 {
201 unsafe { intrinsics::copysignf32(1.0, self) }
205 /// Returns `true` if and only if `self` has a positive sign, including `+0.0`, `NaN`s with
206 /// positive sign bit and positive infinity.
208 fn is_sign_positive(self) -> bool
{
209 !self.is_sign_negative()
212 /// Returns `true` if and only if `self` has a negative sign, including `-0.0`, `NaN`s with
213 /// negative sign bit and negative infinity.
215 fn is_sign_negative(self) -> bool
{
216 // IEEE754 says: isSignMinus(x) is true if and only if x has negative sign. isSignMinus
217 // applies to zeros and NaNs as well.
223 unsafe { F32Bytes { f: self }
.b
& 0x8000_0000 != 0 }
226 /// Returns the reciprocal (multiplicative inverse) of the number.
228 fn recip(self) -> f32 {
233 fn powi(self, n
: i32) -> f32 {
234 unsafe { intrinsics::powif32(self, n) }
237 /// Converts to degrees, assuming the number is in radians.
239 fn to_degrees(self) -> f32 {
240 self * (180.0f32 / consts
::PI
)
243 /// Converts to radians, assuming the number is in degrees.
245 fn to_radians(self) -> f32 {
246 let value
: f32 = consts
::PI
;
247 self * (value
/ 180.0f32)
250 /// Returns the maximum of the two numbers.
252 fn max(self, other
: f32) -> f32 {
253 // IEEE754 says: maxNum(x, y) is the canonicalized number y if x < y, x if y < x, the
254 // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it
255 // is either x or y, canonicalized (this means results might differ among implementations).
256 // When either x or y is a signalingNaN, then the result is according to 6.2.
258 // Since we do not support sNaN in Rust yet, we do not need to handle them.
259 // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by
260 // multiplying by 1.0. Should switch to the `canonicalize` when it works.
261 (if self < other
|| self.is_nan() { other }
else { self }
) * 1.0
264 /// Returns the minimum of the two numbers.
266 fn min(self, other
: f32) -> f32 {
267 // IEEE754 says: minNum(x, y) is the canonicalized number x if x < y, y if y < x, the
268 // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it
269 // is either x or y, canonicalized (this means results might differ among implementations).
270 // When either x or y is a signalingNaN, then the result is according to 6.2.
272 // Since we do not support sNaN in Rust yet, we do not need to handle them.
273 // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by
274 // multiplying by 1.0. Should switch to the `canonicalize` when it works.
275 (if self < other
|| other
.is_nan() { self }
else { other }
) * 1.0