]>
Commit | Line | Data |
---|---|---|
1a4d82fc JJ |
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. | |
4 | // | |
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. | |
10 | ||
ff7c6d11 XL |
11 | //! This module provides constants which are specific to the implementation |
12 | //! of the `f64` floating point data type. | |
13 | //! | |
14 | //! Mathematically significant numbers are provided in the `consts` sub-module. | |
15 | //! | |
16 | //! *[See also the `f64` primitive type](../../std/primitive.f64.html).* | |
1a4d82fc | 17 | |
85aaf69f | 18 | #![stable(feature = "rust1", since = "1.0.0")] |
1a4d82fc | 19 | |
1a4d82fc | 20 | use mem; |
9cc50fc6 | 21 | use num::Float; |
83c7162d XL |
22 | #[cfg(not(stage0))] use num::FpCategory; |
23 | use num::FpCategory as Fp; | |
1a4d82fc | 24 | |
5bcae85e | 25 | /// The radix or base of the internal representation of `f64`. |
c34b1796 AL |
26 | #[stable(feature = "rust1", since = "1.0.0")] |
27 | pub const RADIX: u32 = 2; | |
1a4d82fc | 28 | |
5bcae85e | 29 | /// Number of significant digits in base 2. |
c34b1796 AL |
30 | #[stable(feature = "rust1", since = "1.0.0")] |
31 | pub const MANTISSA_DIGITS: u32 = 53; | |
5bcae85e | 32 | /// Approximate number of significant digits in base 10. |
c34b1796 AL |
33 | #[stable(feature = "rust1", since = "1.0.0")] |
34 | pub const DIGITS: u32 = 15; | |
1a4d82fc | 35 | |
5bcae85e | 36 | /// Difference between `1.0` and the next largest representable number. |
85aaf69f | 37 | #[stable(feature = "rust1", since = "1.0.0")] |
1a4d82fc JJ |
38 | pub const EPSILON: f64 = 2.2204460492503131e-16_f64; |
39 | ||
5bcae85e | 40 | /// Smallest finite `f64` value. |
85aaf69f SL |
41 | #[stable(feature = "rust1", since = "1.0.0")] |
42 | pub const MIN: f64 = -1.7976931348623157e+308_f64; | |
5bcae85e | 43 | /// Smallest positive normal `f64` value. |
85aaf69f SL |
44 | #[stable(feature = "rust1", since = "1.0.0")] |
45 | pub const MIN_POSITIVE: f64 = 2.2250738585072014e-308_f64; | |
5bcae85e | 46 | /// Largest finite `f64` value. |
85aaf69f SL |
47 | #[stable(feature = "rust1", since = "1.0.0")] |
48 | pub const MAX: f64 = 1.7976931348623157e+308_f64; | |
49 | ||
5bcae85e | 50 | /// One greater than the minimum possible normal power of 2 exponent. |
c34b1796 AL |
51 | #[stable(feature = "rust1", since = "1.0.0")] |
52 | pub const MIN_EXP: i32 = -1021; | |
5bcae85e | 53 | /// Maximum possible power of 2 exponent. |
c34b1796 AL |
54 | #[stable(feature = "rust1", since = "1.0.0")] |
55 | pub const MAX_EXP: i32 = 1024; | |
1a4d82fc | 56 | |
5bcae85e | 57 | /// Minimum possible normal power of 10 exponent. |
c34b1796 AL |
58 | #[stable(feature = "rust1", since = "1.0.0")] |
59 | pub const MIN_10_EXP: i32 = -307; | |
5bcae85e | 60 | /// Maximum possible power of 10 exponent. |
c34b1796 AL |
61 | #[stable(feature = "rust1", since = "1.0.0")] |
62 | pub const MAX_10_EXP: i32 = 308; | |
1a4d82fc | 63 | |
5bcae85e | 64 | /// Not a Number (NaN). |
85aaf69f | 65 | #[stable(feature = "rust1", since = "1.0.0")] |
c30ab7b3 | 66 | pub const NAN: f64 = 0.0_f64 / 0.0_f64; |
5bcae85e | 67 | /// Infinity (∞). |
85aaf69f | 68 | #[stable(feature = "rust1", since = "1.0.0")] |
c30ab7b3 | 69 | pub const INFINITY: f64 = 1.0_f64 / 0.0_f64; |
5bcae85e | 70 | /// Negative infinity (-∞). |
85aaf69f | 71 | #[stable(feature = "rust1", since = "1.0.0")] |
c30ab7b3 | 72 | pub const NEG_INFINITY: f64 = -1.0_f64 / 0.0_f64; |
1a4d82fc | 73 | |
b039eaaf | 74 | /// Basic mathematical constants. |
c34b1796 | 75 | #[stable(feature = "rust1", since = "1.0.0")] |
1a4d82fc JJ |
76 | pub mod consts { |
77 | // FIXME: replace with mathematical constants from cmath. | |
78 | ||
5bcae85e | 79 | /// Archimedes' constant (π) |
c34b1796 | 80 | #[stable(feature = "rust1", since = "1.0.0")] |
1a4d82fc JJ |
81 | pub const PI: f64 = 3.14159265358979323846264338327950288_f64; |
82 | ||
5bcae85e | 83 | /// π/2 |
c34b1796 | 84 | #[stable(feature = "rust1", since = "1.0.0")] |
1a4d82fc JJ |
85 | pub const FRAC_PI_2: f64 = 1.57079632679489661923132169163975144_f64; |
86 | ||
5bcae85e | 87 | /// π/3 |
c34b1796 | 88 | #[stable(feature = "rust1", since = "1.0.0")] |
1a4d82fc JJ |
89 | pub const FRAC_PI_3: f64 = 1.04719755119659774615421446109316763_f64; |
90 | ||
5bcae85e | 91 | /// π/4 |
c34b1796 | 92 | #[stable(feature = "rust1", since = "1.0.0")] |
1a4d82fc JJ |
93 | pub const FRAC_PI_4: f64 = 0.785398163397448309615660845819875721_f64; |
94 | ||
5bcae85e | 95 | /// π/6 |
c34b1796 | 96 | #[stable(feature = "rust1", since = "1.0.0")] |
1a4d82fc JJ |
97 | pub const FRAC_PI_6: f64 = 0.52359877559829887307710723054658381_f64; |
98 | ||
5bcae85e | 99 | /// π/8 |
c34b1796 | 100 | #[stable(feature = "rust1", since = "1.0.0")] |
1a4d82fc JJ |
101 | pub const FRAC_PI_8: f64 = 0.39269908169872415480783042290993786_f64; |
102 | ||
5bcae85e | 103 | /// 1/π |
c34b1796 | 104 | #[stable(feature = "rust1", since = "1.0.0")] |
1a4d82fc JJ |
105 | pub const FRAC_1_PI: f64 = 0.318309886183790671537767526745028724_f64; |
106 | ||
5bcae85e | 107 | /// 2/π |
c34b1796 | 108 | #[stable(feature = "rust1", since = "1.0.0")] |
1a4d82fc JJ |
109 | pub const FRAC_2_PI: f64 = 0.636619772367581343075535053490057448_f64; |
110 | ||
5bcae85e | 111 | /// 2/sqrt(π) |
c34b1796 AL |
112 | #[stable(feature = "rust1", since = "1.0.0")] |
113 | pub const FRAC_2_SQRT_PI: f64 = 1.12837916709551257389615890312154517_f64; | |
114 | ||
5bcae85e | 115 | /// sqrt(2) |
c34b1796 AL |
116 | #[stable(feature = "rust1", since = "1.0.0")] |
117 | pub const SQRT_2: f64 = 1.41421356237309504880168872420969808_f64; | |
118 | ||
5bcae85e | 119 | /// 1/sqrt(2) |
c34b1796 AL |
120 | #[stable(feature = "rust1", since = "1.0.0")] |
121 | pub const FRAC_1_SQRT_2: f64 = 0.707106781186547524400844362104849039_f64; | |
122 | ||
5bcae85e | 123 | /// Euler's number (e) |
c34b1796 | 124 | #[stable(feature = "rust1", since = "1.0.0")] |
1a4d82fc JJ |
125 | pub const E: f64 = 2.71828182845904523536028747135266250_f64; |
126 | ||
5bcae85e | 127 | /// log<sub>2</sub>(e) |
c34b1796 | 128 | #[stable(feature = "rust1", since = "1.0.0")] |
1a4d82fc JJ |
129 | pub const LOG2_E: f64 = 1.44269504088896340735992468100189214_f64; |
130 | ||
5bcae85e | 131 | /// log<sub>10</sub>(e) |
c34b1796 | 132 | #[stable(feature = "rust1", since = "1.0.0")] |
1a4d82fc JJ |
133 | pub const LOG10_E: f64 = 0.434294481903251827651128918916605082_f64; |
134 | ||
5bcae85e | 135 | /// ln(2) |
c34b1796 | 136 | #[stable(feature = "rust1", since = "1.0.0")] |
1a4d82fc JJ |
137 | pub const LN_2: f64 = 0.693147180559945309417232121458176568_f64; |
138 | ||
5bcae85e | 139 | /// ln(10) |
c34b1796 | 140 | #[stable(feature = "rust1", since = "1.0.0")] |
1a4d82fc JJ |
141 | pub const LN_10: f64 = 2.30258509299404568401799145468436421_f64; |
142 | } | |
143 | ||
92a42be0 SL |
144 | #[unstable(feature = "core_float", |
145 | reason = "stable interface is via `impl f{32,64}` in later crates", | |
54a0048b | 146 | issue = "32110")] |
1a4d82fc | 147 | impl Float for f64 { |
2c00a5a8 XL |
148 | type Bits = u64; |
149 | ||
1a4d82fc JJ |
150 | /// Returns `true` if the number is NaN. |
151 | #[inline] | |
c30ab7b3 SL |
152 | fn is_nan(self) -> bool { |
153 | self != self | |
154 | } | |
1a4d82fc JJ |
155 | |
156 | /// Returns `true` if the number is infinite. | |
157 | #[inline] | |
158 | fn is_infinite(self) -> bool { | |
3157f602 | 159 | self == INFINITY || self == NEG_INFINITY |
1a4d82fc JJ |
160 | } |
161 | ||
162 | /// Returns `true` if the number is neither infinite or NaN. | |
163 | #[inline] | |
164 | fn is_finite(self) -> bool { | |
165 | !(self.is_nan() || self.is_infinite()) | |
166 | } | |
167 | ||
168 | /// Returns `true` if the number is neither zero, infinite, subnormal or NaN. | |
169 | #[inline] | |
170 | fn is_normal(self) -> bool { | |
171 | self.classify() == Fp::Normal | |
172 | } | |
173 | ||
174 | /// Returns the floating point category of the number. If only one property | |
175 | /// is going to be tested, it is generally faster to use the specific | |
176 | /// predicate instead. | |
177 | fn classify(self) -> Fp { | |
178 | const EXP_MASK: u64 = 0x7ff0000000000000; | |
179 | const MAN_MASK: u64 = 0x000fffffffffffff; | |
180 | ||
2c00a5a8 | 181 | let bits = self.to_bits(); |
1a4d82fc | 182 | match (bits & MAN_MASK, bits & EXP_MASK) { |
c30ab7b3 SL |
183 | (0, 0) => Fp::Zero, |
184 | (_, 0) => Fp::Subnormal, | |
1a4d82fc JJ |
185 | (0, EXP_MASK) => Fp::Infinite, |
186 | (_, EXP_MASK) => Fp::Nan, | |
c30ab7b3 | 187 | _ => Fp::Normal, |
1a4d82fc JJ |
188 | } |
189 | } | |
190 | ||
041b39d2 XL |
191 | /// Returns `true` if and only if `self` has a positive sign, including `+0.0`, `NaN`s with |
192 | /// positive sign bit and positive infinity. | |
1a4d82fc | 193 | #[inline] |
92a42be0 | 194 | fn is_sign_positive(self) -> bool { |
041b39d2 | 195 | !self.is_sign_negative() |
1a4d82fc JJ |
196 | } |
197 | ||
041b39d2 XL |
198 | /// Returns `true` if and only if `self` has a negative sign, including `-0.0`, `NaN`s with |
199 | /// negative sign bit and negative infinity. | |
1a4d82fc | 200 | #[inline] |
92a42be0 | 201 | fn is_sign_negative(self) -> bool { |
2c00a5a8 | 202 | self.to_bits() & 0x8000_0000_0000_0000 != 0 |
1a4d82fc JJ |
203 | } |
204 | ||
1a4d82fc JJ |
205 | /// Returns the reciprocal (multiplicative inverse) of the number. |
206 | #[inline] | |
c30ab7b3 SL |
207 | fn recip(self) -> f64 { |
208 | 1.0 / self | |
209 | } | |
1a4d82fc | 210 | |
1a4d82fc JJ |
211 | /// Converts to degrees, assuming the number is in radians. |
212 | #[inline] | |
c30ab7b3 | 213 | fn to_degrees(self) -> f64 { |
2c00a5a8 XL |
214 | // The division here is correctly rounded with respect to the true |
215 | // value of 180/π. (This differs from f32, where a constant must be | |
216 | // used to ensure a correctly rounded result.) | |
c30ab7b3 SL |
217 | self * (180.0f64 / consts::PI) |
218 | } | |
1a4d82fc JJ |
219 | |
220 | /// Converts to radians, assuming the number is in degrees. | |
221 | #[inline] | |
222 | fn to_radians(self) -> f64 { | |
223 | let value: f64 = consts::PI; | |
224 | self * (value / 180.0) | |
225 | } | |
041b39d2 XL |
226 | |
227 | /// Returns the maximum of the two numbers. | |
228 | #[inline] | |
229 | fn max(self, other: f64) -> f64 { | |
230 | // IEEE754 says: maxNum(x, y) is the canonicalized number y if x < y, x if y < x, the | |
231 | // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it | |
232 | // is either x or y, canonicalized (this means results might differ among implementations). | |
233 | // When either x or y is a signalingNaN, then the result is according to 6.2. | |
234 | // | |
235 | // Since we do not support sNaN in Rust yet, we do not need to handle them. | |
236 | // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by | |
237 | // multiplying by 1.0. Should switch to the `canonicalize` when it works. | |
ff7c6d11 | 238 | (if self.is_nan() || self < other { other } else { self }) * 1.0 |
041b39d2 XL |
239 | } |
240 | ||
241 | /// Returns the minimum of the two numbers. | |
242 | #[inline] | |
243 | fn min(self, other: f64) -> f64 { | |
244 | // IEEE754 says: minNum(x, y) is the canonicalized number x if x < y, y if y < x, the | |
245 | // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it | |
246 | // is either x or y, canonicalized (this means results might differ among implementations). | |
247 | // When either x or y is a signalingNaN, then the result is according to 6.2. | |
248 | // | |
249 | // Since we do not support sNaN in Rust yet, we do not need to handle them. | |
250 | // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by | |
251 | // multiplying by 1.0. Should switch to the `canonicalize` when it works. | |
ff7c6d11 | 252 | (if other.is_nan() || self < other { self } else { other }) * 1.0 |
041b39d2 | 253 | } |
2c00a5a8 XL |
254 | |
255 | /// Raw transmutation to `u64`. | |
256 | #[inline] | |
257 | fn to_bits(self) -> u64 { | |
258 | unsafe { mem::transmute(self) } | |
259 | } | |
260 | ||
261 | /// Raw transmutation from `u64`. | |
262 | #[inline] | |
263 | fn from_bits(v: u64) -> Self { | |
264 | // It turns out the safety issues with sNaN were overblown! Hooray! | |
265 | unsafe { mem::transmute(v) } | |
266 | } | |
1a4d82fc | 267 | } |
83c7162d XL |
268 | |
269 | // FIXME: remove (inline) this macro and the Float trait | |
270 | // when updating to a bootstrap compiler that has the new lang items. | |
271 | #[cfg_attr(stage0, macro_export)] | |
272 | #[unstable(feature = "core_float", issue = "32110")] | |
273 | macro_rules! f64_core_methods { () => { | |
274 | /// Returns `true` if this value is `NaN` and false otherwise. | |
275 | /// | |
276 | /// ``` | |
277 | /// use std::f64; | |
278 | /// | |
279 | /// let nan = f64::NAN; | |
280 | /// let f = 7.0_f64; | |
281 | /// | |
282 | /// assert!(nan.is_nan()); | |
283 | /// assert!(!f.is_nan()); | |
284 | /// ``` | |
285 | #[stable(feature = "rust1", since = "1.0.0")] | |
286 | #[inline] | |
287 | pub fn is_nan(self) -> bool { Float::is_nan(self) } | |
288 | ||
289 | /// Returns `true` if this value is positive infinity or negative infinity and | |
290 | /// false otherwise. | |
291 | /// | |
292 | /// ``` | |
293 | /// use std::f64; | |
294 | /// | |
295 | /// let f = 7.0f64; | |
296 | /// let inf = f64::INFINITY; | |
297 | /// let neg_inf = f64::NEG_INFINITY; | |
298 | /// let nan = f64::NAN; | |
299 | /// | |
300 | /// assert!(!f.is_infinite()); | |
301 | /// assert!(!nan.is_infinite()); | |
302 | /// | |
303 | /// assert!(inf.is_infinite()); | |
304 | /// assert!(neg_inf.is_infinite()); | |
305 | /// ``` | |
306 | #[stable(feature = "rust1", since = "1.0.0")] | |
307 | #[inline] | |
308 | pub fn is_infinite(self) -> bool { Float::is_infinite(self) } | |
309 | ||
310 | /// Returns `true` if this number is neither infinite nor `NaN`. | |
311 | /// | |
312 | /// ``` | |
313 | /// use std::f64; | |
314 | /// | |
315 | /// let f = 7.0f64; | |
316 | /// let inf: f64 = f64::INFINITY; | |
317 | /// let neg_inf: f64 = f64::NEG_INFINITY; | |
318 | /// let nan: f64 = f64::NAN; | |
319 | /// | |
320 | /// assert!(f.is_finite()); | |
321 | /// | |
322 | /// assert!(!nan.is_finite()); | |
323 | /// assert!(!inf.is_finite()); | |
324 | /// assert!(!neg_inf.is_finite()); | |
325 | /// ``` | |
326 | #[stable(feature = "rust1", since = "1.0.0")] | |
327 | #[inline] | |
328 | pub fn is_finite(self) -> bool { Float::is_finite(self) } | |
329 | ||
330 | /// Returns `true` if the number is neither zero, infinite, | |
331 | /// [subnormal][subnormal], or `NaN`. | |
332 | /// | |
333 | /// ``` | |
334 | /// use std::f64; | |
335 | /// | |
336 | /// let min = f64::MIN_POSITIVE; // 2.2250738585072014e-308f64 | |
337 | /// let max = f64::MAX; | |
338 | /// let lower_than_min = 1.0e-308_f64; | |
339 | /// let zero = 0.0f64; | |
340 | /// | |
341 | /// assert!(min.is_normal()); | |
342 | /// assert!(max.is_normal()); | |
343 | /// | |
344 | /// assert!(!zero.is_normal()); | |
345 | /// assert!(!f64::NAN.is_normal()); | |
346 | /// assert!(!f64::INFINITY.is_normal()); | |
347 | /// // Values between `0` and `min` are Subnormal. | |
348 | /// assert!(!lower_than_min.is_normal()); | |
349 | /// ``` | |
350 | /// [subnormal]: https://en.wikipedia.org/wiki/Denormal_number | |
351 | #[stable(feature = "rust1", since = "1.0.0")] | |
352 | #[inline] | |
353 | pub fn is_normal(self) -> bool { Float::is_normal(self) } | |
354 | ||
355 | /// Returns the floating point category of the number. If only one property | |
356 | /// is going to be tested, it is generally faster to use the specific | |
357 | /// predicate instead. | |
358 | /// | |
359 | /// ``` | |
360 | /// use std::num::FpCategory; | |
361 | /// use std::f64; | |
362 | /// | |
363 | /// let num = 12.4_f64; | |
364 | /// let inf = f64::INFINITY; | |
365 | /// | |
366 | /// assert_eq!(num.classify(), FpCategory::Normal); | |
367 | /// assert_eq!(inf.classify(), FpCategory::Infinite); | |
368 | /// ``` | |
369 | #[stable(feature = "rust1", since = "1.0.0")] | |
370 | #[inline] | |
371 | pub fn classify(self) -> FpCategory { Float::classify(self) } | |
372 | ||
373 | /// Returns `true` if and only if `self` has a positive sign, including `+0.0`, `NaN`s with | |
374 | /// positive sign bit and positive infinity. | |
375 | /// | |
376 | /// ``` | |
377 | /// let f = 7.0_f64; | |
378 | /// let g = -7.0_f64; | |
379 | /// | |
380 | /// assert!(f.is_sign_positive()); | |
381 | /// assert!(!g.is_sign_positive()); | |
382 | /// ``` | |
383 | #[stable(feature = "rust1", since = "1.0.0")] | |
384 | #[inline] | |
385 | pub fn is_sign_positive(self) -> bool { Float::is_sign_positive(self) } | |
386 | ||
387 | #[stable(feature = "rust1", since = "1.0.0")] | |
388 | #[rustc_deprecated(since = "1.0.0", reason = "renamed to is_sign_positive")] | |
389 | #[inline] | |
390 | #[doc(hidden)] | |
391 | pub fn is_positive(self) -> bool { Float::is_sign_positive(self) } | |
392 | ||
393 | /// Returns `true` if and only if `self` has a negative sign, including `-0.0`, `NaN`s with | |
394 | /// negative sign bit and negative infinity. | |
395 | /// | |
396 | /// ``` | |
397 | /// let f = 7.0_f64; | |
398 | /// let g = -7.0_f64; | |
399 | /// | |
400 | /// assert!(!f.is_sign_negative()); | |
401 | /// assert!(g.is_sign_negative()); | |
402 | /// ``` | |
403 | #[stable(feature = "rust1", since = "1.0.0")] | |
404 | #[inline] | |
405 | pub fn is_sign_negative(self) -> bool { Float::is_sign_negative(self) } | |
406 | ||
407 | #[stable(feature = "rust1", since = "1.0.0")] | |
408 | #[rustc_deprecated(since = "1.0.0", reason = "renamed to is_sign_negative")] | |
409 | #[inline] | |
410 | #[doc(hidden)] | |
411 | pub fn is_negative(self) -> bool { Float::is_sign_negative(self) } | |
412 | ||
413 | /// Takes the reciprocal (inverse) of a number, `1/x`. | |
414 | /// | |
415 | /// ``` | |
416 | /// let x = 2.0_f64; | |
417 | /// let abs_difference = (x.recip() - (1.0/x)).abs(); | |
418 | /// | |
419 | /// assert!(abs_difference < 1e-10); | |
420 | /// ``` | |
421 | #[stable(feature = "rust1", since = "1.0.0")] | |
422 | #[inline] | |
423 | pub fn recip(self) -> f64 { Float::recip(self) } | |
424 | ||
425 | /// Converts radians to degrees. | |
426 | /// | |
427 | /// ``` | |
428 | /// use std::f64::consts; | |
429 | /// | |
430 | /// let angle = consts::PI; | |
431 | /// | |
432 | /// let abs_difference = (angle.to_degrees() - 180.0).abs(); | |
433 | /// | |
434 | /// assert!(abs_difference < 1e-10); | |
435 | /// ``` | |
436 | #[stable(feature = "rust1", since = "1.0.0")] | |
437 | #[inline] | |
438 | pub fn to_degrees(self) -> f64 { Float::to_degrees(self) } | |
439 | ||
440 | /// Converts degrees to radians. | |
441 | /// | |
442 | /// ``` | |
443 | /// use std::f64::consts; | |
444 | /// | |
445 | /// let angle = 180.0_f64; | |
446 | /// | |
447 | /// let abs_difference = (angle.to_radians() - consts::PI).abs(); | |
448 | /// | |
449 | /// assert!(abs_difference < 1e-10); | |
450 | /// ``` | |
451 | #[stable(feature = "rust1", since = "1.0.0")] | |
452 | #[inline] | |
453 | pub fn to_radians(self) -> f64 { Float::to_radians(self) } | |
454 | ||
455 | /// Returns the maximum of the two numbers. | |
456 | /// | |
457 | /// ``` | |
458 | /// let x = 1.0_f64; | |
459 | /// let y = 2.0_f64; | |
460 | /// | |
461 | /// assert_eq!(x.max(y), y); | |
462 | /// ``` | |
463 | /// | |
464 | /// If one of the arguments is NaN, then the other argument is returned. | |
465 | #[stable(feature = "rust1", since = "1.0.0")] | |
466 | #[inline] | |
467 | pub fn max(self, other: f64) -> f64 { | |
468 | Float::max(self, other) | |
469 | } | |
470 | ||
471 | /// Returns the minimum of the two numbers. | |
472 | /// | |
473 | /// ``` | |
474 | /// let x = 1.0_f64; | |
475 | /// let y = 2.0_f64; | |
476 | /// | |
477 | /// assert_eq!(x.min(y), x); | |
478 | /// ``` | |
479 | /// | |
480 | /// If one of the arguments is NaN, then the other argument is returned. | |
481 | #[stable(feature = "rust1", since = "1.0.0")] | |
482 | #[inline] | |
483 | pub fn min(self, other: f64) -> f64 { | |
484 | Float::min(self, other) | |
485 | } | |
486 | ||
487 | /// Raw transmutation to `u64`. | |
488 | /// | |
489 | /// This is currently identical to `transmute::<f64, u64>(self)` on all platforms. | |
490 | /// | |
491 | /// See `from_bits` for some discussion of the portability of this operation | |
492 | /// (there are almost no issues). | |
493 | /// | |
494 | /// Note that this function is distinct from `as` casting, which attempts to | |
495 | /// preserve the *numeric* value, and not the bitwise value. | |
496 | /// | |
497 | /// # Examples | |
498 | /// | |
499 | /// ``` | |
500 | /// assert!((1f64).to_bits() != 1f64 as u64); // to_bits() is not casting! | |
501 | /// assert_eq!((12.5f64).to_bits(), 0x4029000000000000); | |
502 | /// | |
503 | /// ``` | |
504 | #[stable(feature = "float_bits_conv", since = "1.20.0")] | |
505 | #[inline] | |
506 | pub fn to_bits(self) -> u64 { | |
507 | Float::to_bits(self) | |
508 | } | |
509 | ||
510 | /// Raw transmutation from `u64`. | |
511 | /// | |
512 | /// This is currently identical to `transmute::<u64, f64>(v)` on all platforms. | |
513 | /// It turns out this is incredibly portable, for two reasons: | |
514 | /// | |
515 | /// * Floats and Ints have the same endianness on all supported platforms. | |
516 | /// * IEEE-754 very precisely specifies the bit layout of floats. | |
517 | /// | |
518 | /// However there is one caveat: prior to the 2008 version of IEEE-754, how | |
519 | /// to interpret the NaN signaling bit wasn't actually specified. Most platforms | |
520 | /// (notably x86 and ARM) picked the interpretation that was ultimately | |
521 | /// standardized in 2008, but some didn't (notably MIPS). As a result, all | |
522 | /// signaling NaNs on MIPS are quiet NaNs on x86, and vice-versa. | |
523 | /// | |
524 | /// Rather than trying to preserve signaling-ness cross-platform, this | |
525 | /// implementation favours preserving the exact bits. This means that | |
526 | /// any payloads encoded in NaNs will be preserved even if the result of | |
527 | /// this method is sent over the network from an x86 machine to a MIPS one. | |
528 | /// | |
529 | /// If the results of this method are only manipulated by the same | |
530 | /// architecture that produced them, then there is no portability concern. | |
531 | /// | |
532 | /// If the input isn't NaN, then there is no portability concern. | |
533 | /// | |
534 | /// If you don't care about signalingness (very likely), then there is no | |
535 | /// portability concern. | |
536 | /// | |
537 | /// Note that this function is distinct from `as` casting, which attempts to | |
538 | /// preserve the *numeric* value, and not the bitwise value. | |
539 | /// | |
540 | /// # Examples | |
541 | /// | |
542 | /// ``` | |
543 | /// use std::f64; | |
544 | /// let v = f64::from_bits(0x4029000000000000); | |
545 | /// let difference = (v - 12.5).abs(); | |
546 | /// assert!(difference <= 1e-5); | |
547 | /// ``` | |
548 | #[stable(feature = "float_bits_conv", since = "1.20.0")] | |
549 | #[inline] | |
550 | pub fn from_bits(v: u64) -> Self { | |
551 | Float::from_bits(v) | |
552 | } | |
553 | }} | |
554 | ||
555 | #[lang = "f64"] | |
556 | #[cfg(not(test))] | |
557 | #[cfg(not(stage0))] | |
558 | impl f64 { | |
559 | f64_core_methods!(); | |
560 | } |