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 #![cfg_attr(stage0, allow(overflowing_literals))]
15 #![stable(feature = "rust1", since = "1.0.0")]
20 use num
::FpCategory
as Fp
;
22 /// The radix or base of the internal representation of `f32`.
23 #[stable(feature = "rust1", since = "1.0.0")]
24 pub const RADIX
: u32 = 2;
26 /// Number of significant digits in base 2.
27 #[stable(feature = "rust1", since = "1.0.0")]
28 pub const MANTISSA_DIGITS
: u32 = 24;
29 /// Approximate number of significant digits in base 10.
30 #[stable(feature = "rust1", since = "1.0.0")]
31 pub const DIGITS
: u32 = 6;
33 /// Difference between `1.0` and the next largest representable number.
34 #[stable(feature = "rust1", since = "1.0.0")]
35 pub const EPSILON
: f32 = 1.19209290e-07_f32;
37 /// Smallest finite `f32` value.
38 #[stable(feature = "rust1", since = "1.0.0")]
39 pub const MIN
: f32 = -3.40282347e+38_f32;
40 /// Smallest positive normal `f32` value.
41 #[stable(feature = "rust1", since = "1.0.0")]
42 pub const MIN_POSITIVE
: f32 = 1.17549435e-38_f32;
43 /// Largest finite `f32` value.
44 #[stable(feature = "rust1", since = "1.0.0")]
45 pub const MAX
: f32 = 3.40282347e+38_f32;
47 /// One greater than the minimum possible normal power of 2 exponent.
48 #[stable(feature = "rust1", since = "1.0.0")]
49 pub const MIN_EXP
: i32 = -125;
50 /// Maximum possible power of 2 exponent.
51 #[stable(feature = "rust1", since = "1.0.0")]
52 pub const MAX_EXP
: i32 = 128;
54 /// Minimum possible normal power of 10 exponent.
55 #[stable(feature = "rust1", since = "1.0.0")]
56 pub const MIN_10_EXP
: i32 = -37;
57 /// Maximum possible power of 10 exponent.
58 #[stable(feature = "rust1", since = "1.0.0")]
59 pub const MAX_10_EXP
: i32 = 38;
61 /// Not a Number (NaN).
62 #[stable(feature = "rust1", since = "1.0.0")]
63 pub const NAN
: f32 = 0.0_f32 / 0.0_f32;
65 #[stable(feature = "rust1", since = "1.0.0")]
66 pub const INFINITY
: f32 = 1.0_f32 / 0.0_f32;
67 /// Negative infinity (-∞).
68 #[stable(feature = "rust1", since = "1.0.0")]
69 pub const NEG_INFINITY
: f32 = -1.0_f32 / 0.0_f32;
71 /// Basic mathematical constants.
72 #[stable(feature = "rust1", since = "1.0.0")]
74 // FIXME: replace with mathematical constants from cmath.
76 /// Archimedes' constant (π)
77 #[stable(feature = "rust1", since = "1.0.0")]
78 pub const PI
: f32 = 3.14159265358979323846264338327950288_f32;
81 #[stable(feature = "rust1", since = "1.0.0")]
82 pub const FRAC_PI_2
: f32 = 1.57079632679489661923132169163975144_f32;
85 #[stable(feature = "rust1", since = "1.0.0")]
86 pub const FRAC_PI_3
: f32 = 1.04719755119659774615421446109316763_f32;
89 #[stable(feature = "rust1", since = "1.0.0")]
90 pub const FRAC_PI_4
: f32 = 0.785398163397448309615660845819875721_f32;
93 #[stable(feature = "rust1", since = "1.0.0")]
94 pub const FRAC_PI_6
: f32 = 0.52359877559829887307710723054658381_f32;
97 #[stable(feature = "rust1", since = "1.0.0")]
98 pub const FRAC_PI_8
: f32 = 0.39269908169872415480783042290993786_f32;
101 #[stable(feature = "rust1", since = "1.0.0")]
102 pub const FRAC_1_PI
: f32 = 0.318309886183790671537767526745028724_f32;
105 #[stable(feature = "rust1", since = "1.0.0")]
106 pub const FRAC_2_PI
: f32 = 0.636619772367581343075535053490057448_f32;
109 #[stable(feature = "rust1", since = "1.0.0")]
110 pub const FRAC_2_SQRT_PI
: f32 = 1.12837916709551257389615890312154517_f32;
113 #[stable(feature = "rust1", since = "1.0.0")]
114 pub const SQRT_2
: f32 = 1.41421356237309504880168872420969808_f32;
117 #[stable(feature = "rust1", since = "1.0.0")]
118 pub const FRAC_1_SQRT_2
: f32 = 0.707106781186547524400844362104849039_f32;
120 /// Euler's number (e)
121 #[stable(feature = "rust1", since = "1.0.0")]
122 pub const E
: f32 = 2.71828182845904523536028747135266250_f32;
124 /// log<sub>2</sub>(e)
125 #[stable(feature = "rust1", since = "1.0.0")]
126 pub const LOG2_E
: f32 = 1.44269504088896340735992468100189214_f32;
128 /// log<sub>10</sub>(e)
129 #[stable(feature = "rust1", since = "1.0.0")]
130 pub const LOG10_E
: f32 = 0.434294481903251827651128918916605082_f32;
133 #[stable(feature = "rust1", since = "1.0.0")]
134 pub const LN_2
: f32 = 0.693147180559945309417232121458176568_f32;
137 #[stable(feature = "rust1", since = "1.0.0")]
138 pub const LN_10
: f32 = 2.30258509299404568401799145468436421_f32;
141 #[unstable(feature = "core_float",
142 reason
= "stable interface is via `impl f{32,64}` in later crates",
145 /// Returns `true` if the number is NaN.
147 fn is_nan(self) -> bool
{
151 /// Returns `true` if the number is infinite.
153 fn is_infinite(self) -> bool
{
154 self == INFINITY
|| self == NEG_INFINITY
157 /// Returns `true` if the number is neither infinite or NaN.
159 fn is_finite(self) -> bool
{
160 !(self.is_nan() || self.is_infinite())
163 /// Returns `true` if the number is neither zero, infinite, subnormal or NaN.
165 fn is_normal(self) -> bool
{
166 self.classify() == Fp
::Normal
169 /// Returns the floating point category of the number. If only one property
170 /// is going to be tested, it is generally faster to use the specific
171 /// predicate instead.
172 fn classify(self) -> Fp
{
173 const EXP_MASK
: u32 = 0x7f800000;
174 const MAN_MASK
: u32 = 0x007fffff;
176 let bits
: u32 = unsafe { mem::transmute(self) }
;
177 match (bits
& MAN_MASK
, bits
& EXP_MASK
) {
179 (_
, 0) => Fp
::Subnormal
,
180 (0, EXP_MASK
) => Fp
::Infinite
,
181 (_
, EXP_MASK
) => Fp
::Nan
,
186 /// Computes the absolute value of `self`. Returns `Float::nan()` if the
187 /// number is `Float::nan()`.
189 fn abs(self) -> f32 {
190 unsafe { intrinsics::fabsf32(self) }
193 /// Returns a number that represents the sign of `self`.
195 /// - `1.0` if the number is positive, `+0.0` or `Float::infinity()`
196 /// - `-1.0` if the number is negative, `-0.0` or `Float::neg_infinity()`
197 /// - `Float::nan()` if the number is `Float::nan()`
199 fn signum(self) -> f32 {
203 unsafe { intrinsics::copysignf32(1.0, self) }
207 /// Returns `true` if and only if `self` has a positive sign, including `+0.0`, `NaN`s with
208 /// positive sign bit and positive infinity.
210 fn is_sign_positive(self) -> bool
{
211 !self.is_sign_negative()
214 /// Returns `true` if and only if `self` has a negative sign, including `-0.0`, `NaN`s with
215 /// negative sign bit and negative infinity.
217 fn is_sign_negative(self) -> bool
{
218 // IEEE754 says: isSignMinus(x) is true if and only if x has negative sign. isSignMinus
219 // applies to zeros and NaNs as well.
225 unsafe { F32Bytes { f: self }
.b
& 0x8000_0000 != 0 }
228 /// Returns the reciprocal (multiplicative inverse) of the number.
230 fn recip(self) -> f32 {
235 fn powi(self, n
: i32) -> f32 {
236 unsafe { intrinsics::powif32(self, n) }
239 /// Converts to degrees, assuming the number is in radians.
241 fn to_degrees(self) -> f32 {
242 self * (180.0f32 / consts
::PI
)
245 /// Converts to radians, assuming the number is in degrees.
247 fn to_radians(self) -> f32 {
248 let value
: f32 = consts
::PI
;
249 self * (value
/ 180.0f32)
252 /// Returns the maximum of the two numbers.
254 fn max(self, other
: f32) -> f32 {
255 // IEEE754 says: maxNum(x, y) is the canonicalized number y if x < y, x if y < x, the
256 // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it
257 // is either x or y, canonicalized (this means results might differ among implementations).
258 // When either x or y is a signalingNaN, then the result is according to 6.2.
260 // Since we do not support sNaN in Rust yet, we do not need to handle them.
261 // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by
262 // multiplying by 1.0. Should switch to the `canonicalize` when it works.
263 (if self < other
|| self.is_nan() { other }
else { self }
) * 1.0
266 /// Returns the minimum of the two numbers.
268 fn min(self, other
: f32) -> f32 {
269 // IEEE754 says: minNum(x, y) is the canonicalized number x if x < y, y if y < x, the
270 // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it
271 // is either x or y, canonicalized (this means results might differ among implementations).
272 // When either x or y is a signalingNaN, then the result is according to 6.2.
274 // Since we do not support sNaN in Rust yet, we do not need to handle them.
275 // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by
276 // multiplying by 1.0. Should switch to the `canonicalize` when it works.
277 (if self < other
|| other
.is_nan() { self }
else { other }
) * 1.0