library/std/src/f64.rs

   1 //! Constants specific to the `f64` double-precision floating point type.
   2 //!
   3 //! *[See also the `f64` primitive type](primitive@f64).*
   4 //!
   5 //! Mathematically significant numbers are provided in the `consts` sub-module.
   6 //!
   7 //! For the constants defined directly in this module
   8 //! (as distinct from those defined in the `consts` sub-module),
   9 //! new code should instead use the associated constants
  10 //! defined directly on the `f64` type.
  11
  12 #![stable(feature = "rust1", since = "1.0.0")]
  13 #![allow(missing_docs)]
  14
  15 #[cfg(test)]
  16 mod tests;
  17
  18 #[cfg(not(test))]
  19 use crate::intrinsics;
  20 #[cfg(not(test))]
  21 use crate::sys::cmath;
  22
  23 #[stable(feature = "rust1", since = "1.0.0")]
  24 #[allow(deprecated, deprecated_in_future)]
  25 pub use core::f64::{
  26     consts, DIGITS, EPSILON, INFINITY, MANTISSA_DIGITS, MAX, MAX_10_EXP, MAX_EXP, MIN, MIN_10_EXP,
  27     MIN_EXP, MIN_POSITIVE, NAN, NEG_INFINITY, RADIX,
  28 };
  29
  30 #[cfg(not(test))]
  31 #[lang = "f64_runtime"]
  32 impl f64 {
  33     /// Returns the largest integer less than or equal to a number.
  34     ///
  35     /// # Examples
  36     ///
  37     /// ```
  38     /// let f = 3.7_f64;
  39     /// let g = 3.0_f64;
  40     /// let h = -3.7_f64;
  41     ///
  42     /// assert_eq!(f.floor(), 3.0);
  43     /// assert_eq!(g.floor(), 3.0);
  44     /// assert_eq!(h.floor(), -4.0);
  45     /// ```
  46     #[must_use = "method returns a new number and does not mutate the original value"]
  47     #[stable(feature = "rust1", since = "1.0.0")]
  48     #[inline]
  49     pub fn floor(self) -> f64 {
  50         unsafe { intrinsics::floorf64(self) }
  51     }
  52
  53     /// Returns the smallest integer greater than or equal to a number.
  54     ///
  55     /// # Examples
  56     ///
  57     /// ```
  58     /// let f = 3.01_f64;
  59     /// let g = 4.0_f64;
  60     ///
  61     /// assert_eq!(f.ceil(), 4.0);
  62     /// assert_eq!(g.ceil(), 4.0);
  63     /// ```
  64     #[must_use = "method returns a new number and does not mutate the original value"]
  65     #[stable(feature = "rust1", since = "1.0.0")]
  66     #[inline]
  67     pub fn ceil(self) -> f64 {
  68         unsafe { intrinsics::ceilf64(self) }
  69     }
  70
  71     /// Returns the nearest integer to a number. Round half-way cases away from
  72     /// `0.0`.
  73     ///
  74     /// # Examples
  75     ///
  76     /// ```
  77     /// let f = 3.3_f64;
  78     /// let g = -3.3_f64;
  79     ///
  80     /// assert_eq!(f.round(), 3.0);
  81     /// assert_eq!(g.round(), -3.0);
  82     /// ```
  83     #[must_use = "method returns a new number and does not mutate the original value"]
  84     #[stable(feature = "rust1", since = "1.0.0")]
  85     #[inline]
  86     pub fn round(self) -> f64 {
  87         unsafe { intrinsics::roundf64(self) }
  88     }
  89
  90     /// Returns the integer part of a number.
  91     ///
  92     /// # Examples
  93     ///
  94     /// ```
  95     /// let f = 3.7_f64;
  96     /// let g = 3.0_f64;
  97     /// let h = -3.7_f64;
  98     ///
  99     /// assert_eq!(f.trunc(), 3.0);
 100     /// assert_eq!(g.trunc(), 3.0);
 101     /// assert_eq!(h.trunc(), -3.0);
 102     /// ```
 103     #[must_use = "method returns a new number and does not mutate the original value"]
 104     #[stable(feature = "rust1", since = "1.0.0")]
 105     #[inline]
 106     pub fn trunc(self) -> f64 {
 107         unsafe { intrinsics::truncf64(self) }
 108     }
 109
 110     /// Returns the fractional part of a number.
 111     ///
 112     /// # Examples
 113     ///
 114     /// ```
 115     /// let x = 3.6_f64;
 116     /// let y = -3.6_f64;
 117     /// let abs_difference_x = (x.fract() - 0.6).abs();
 118     /// let abs_difference_y = (y.fract() - (-0.6)).abs();
 119     ///
 120     /// assert!(abs_difference_x < 1e-10);
 121     /// assert!(abs_difference_y < 1e-10);
 122     /// ```
 123     #[must_use = "method returns a new number and does not mutate the original value"]
 124     #[stable(feature = "rust1", since = "1.0.0")]
 125     #[inline]
 126     pub fn fract(self) -> f64 {
 127         self - self.trunc()
 128     }
 129
 130     /// Computes the absolute value of `self`. Returns `NAN` if the
 131     /// number is `NAN`.
 132     ///
 133     /// # Examples
 134     ///
 135     /// ```
 136     /// let x = 3.5_f64;
 137     /// let y = -3.5_f64;
 138     ///
 139     /// let abs_difference_x = (x.abs() - x).abs();
 140     /// let abs_difference_y = (y.abs() - (-y)).abs();
 141     ///
 142     /// assert!(abs_difference_x < 1e-10);
 143     /// assert!(abs_difference_y < 1e-10);
 144     ///
 145     /// assert!(f64::NAN.abs().is_nan());
 146     /// ```
 147     #[must_use = "method returns a new number and does not mutate the original value"]
 148     #[stable(feature = "rust1", since = "1.0.0")]
 149     #[inline]
 150     pub fn abs(self) -> f64 {
 151         unsafe { intrinsics::fabsf64(self) }
 152     }
 153
 154     /// Returns a number that represents the sign of `self`.
 155     ///
 156     /// - `1.0` if the number is positive, `+0.0` or `INFINITY`
 157     /// - `-1.0` if the number is negative, `-0.0` or `NEG_INFINITY`
 158     /// - `NAN` if the number is `NAN`
 159     ///
 160     /// # Examples
 161     ///
 162     /// ```
 163     /// let f = 3.5_f64;
 164     ///
 165     /// assert_eq!(f.signum(), 1.0);
 166     /// assert_eq!(f64::NEG_INFINITY.signum(), -1.0);
 167     ///
 168     /// assert!(f64::NAN.signum().is_nan());
 169     /// ```
 170     #[must_use = "method returns a new number and does not mutate the original value"]
 171     #[stable(feature = "rust1", since = "1.0.0")]
 172     #[inline]
 173     pub fn signum(self) -> f64 {
 174         if self.is_nan() { Self::NAN } else { 1.0_f64.copysign(self) }
 175     }
 176
 177     /// Returns a number composed of the magnitude of `self` and the sign of
 178     /// `sign`.
 179     ///
 180     /// Equal to `self` if the sign of `self` and `sign` are the same, otherwise
 181     /// equal to `-self`. If `self` is a `NAN`, then a `NAN` with the sign of
 182     /// `sign` is returned.
 183     ///
 184     /// # Examples
 185     ///
 186     /// ```
 187     /// let f = 3.5_f64;
 188     ///
 189     /// assert_eq!(f.copysign(0.42), 3.5_f64);
 190     /// assert_eq!(f.copysign(-0.42), -3.5_f64);
 191     /// assert_eq!((-f).copysign(0.42), 3.5_f64);
 192     /// assert_eq!((-f).copysign(-0.42), -3.5_f64);
 193     ///
 194     /// assert!(f64::NAN.copysign(1.0).is_nan());
 195     /// ```
 196     #[must_use = "method returns a new number and does not mutate the original value"]
 197     #[stable(feature = "copysign", since = "1.35.0")]
 198     #[inline]
 199     pub fn copysign(self, sign: f64) -> f64 {
 200         unsafe { intrinsics::copysignf64(self, sign) }
 201     }
 202
 203     /// Fused multiply-add. Computes `(self * a) + b` with only one rounding
 204     /// error, yielding a more accurate result than an unfused multiply-add.
 205     ///
 206     /// Using `mul_add` *may* be more performant than an unfused multiply-add if
 207     /// the target architecture has a dedicated `fma` CPU instruction. However,
 208     /// this is not always true, and will be heavily dependant on designing
 209     /// algorithms with specific target hardware in mind.
 210     ///
 211     /// # Examples
 212     ///
 213     /// ```
 214     /// let m = 10.0_f64;
 215     /// let x = 4.0_f64;
 216     /// let b = 60.0_f64;
 217     ///
 218     /// // 100.0
 219     /// let abs_difference = (m.mul_add(x, b) - ((m * x) + b)).abs();
 220     ///
 221     /// assert!(abs_difference < 1e-10);
 222     /// ```
 223     #[must_use = "method returns a new number and does not mutate the original value"]
 224     #[stable(feature = "rust1", since = "1.0.0")]
 225     #[inline]
 226     pub fn mul_add(self, a: f64, b: f64) -> f64 {
 227         unsafe { intrinsics::fmaf64(self, a, b) }
 228     }
 229
 230     /// Calculates Euclidean division, the matching method for `rem_euclid`.
 231     ///
 232     /// This computes the integer `n` such that
 233     /// `self = n * rhs + self.rem_euclid(rhs)`.
 234     /// In other words, the result is `self / rhs` rounded to the integer `n`
 235     /// such that `self >= n * rhs`.
 236     ///
 237     /// # Examples
 238     ///
 239     /// ```
 240     /// let a: f64 = 7.0;
 241     /// let b = 4.0;
 242     /// assert_eq!(a.div_euclid(b), 1.0); // 7.0 > 4.0 * 1.0
 243     /// assert_eq!((-a).div_euclid(b), -2.0); // -7.0 >= 4.0 * -2.0
 244     /// assert_eq!(a.div_euclid(-b), -1.0); // 7.0 >= -4.0 * -1.0
 245     /// assert_eq!((-a).div_euclid(-b), 2.0); // -7.0 >= -4.0 * 2.0
 246     /// ```
 247     #[must_use = "method returns a new number and does not mutate the original value"]
 248     #[inline]
 249     #[stable(feature = "euclidean_division", since = "1.38.0")]
 250     pub fn div_euclid(self, rhs: f64) -> f64 {
 251         let q = (self / rhs).trunc();
 252         if self % rhs < 0.0 {
 253             return if rhs > 0.0 { q - 1.0 } else { q + 1.0 };
 254         }
 255         q
 256     }
 257
 258     /// Calculates the least nonnegative remainder of `self (mod rhs)`.
 259     ///
 260     /// In particular, the return value `r` satisfies `0.0 <= r < rhs.abs()` in
 261     /// most cases. However, due to a floating point round-off error it can
 262     /// result in `r == rhs.abs()`, violating the mathematical definition, if
 263     /// `self` is much smaller than `rhs.abs()` in magnitude and `self < 0.0`.
 264     /// This result is not an element of the function's codomain, but it is the
 265     /// closest floating point number in the real numbers and thus fulfills the
 266     /// property `self == self.div_euclid(rhs) * rhs + self.rem_euclid(rhs)`
 267     /// approximatively.
 268     ///
 269     /// # Examples
 270     ///
 271     /// ```
 272     /// let a: f64 = 7.0;
 273     /// let b = 4.0;
 274     /// assert_eq!(a.rem_euclid(b), 3.0);
 275     /// assert_eq!((-a).rem_euclid(b), 1.0);
 276     /// assert_eq!(a.rem_euclid(-b), 3.0);
 277     /// assert_eq!((-a).rem_euclid(-b), 1.0);
 278     /// // limitation due to round-off error
 279     /// assert!((-f64::EPSILON).rem_euclid(3.0) != 0.0);
 280     /// ```
 281     #[must_use = "method returns a new number and does not mutate the original value"]
 282     #[inline]
 283     #[stable(feature = "euclidean_division", since = "1.38.0")]
 284     pub fn rem_euclid(self, rhs: f64) -> f64 {
 285         let r = self % rhs;
 286         if r < 0.0 { r + rhs.abs() } else { r }
 287     }
 288
 289     /// Raises a number to an integer power.
 290     ///
 291     /// Using this function is generally faster than using `powf`
 292     ///
 293     /// # Examples
 294     ///
 295     /// ```
 296     /// let x = 2.0_f64;
 297     /// let abs_difference = (x.powi(2) - (x * x)).abs();
 298     ///
 299     /// assert!(abs_difference < 1e-10);
 300     /// ```
 301     #[must_use = "method returns a new number and does not mutate the original value"]
 302     #[stable(feature = "rust1", since = "1.0.0")]
 303     #[inline]
 304     pub fn powi(self, n: i32) -> f64 {
 305         unsafe { intrinsics::powif64(self, n) }
 306     }
 307
 308     /// Raises a number to a floating point power.
 309     ///
 310     /// # Examples
 311     ///
 312     /// ```
 313     /// let x = 2.0_f64;
 314     /// let abs_difference = (x.powf(2.0) - (x * x)).abs();
 315     ///
 316     /// assert!(abs_difference < 1e-10);
 317     /// ```
 318     #[must_use = "method returns a new number and does not mutate the original value"]
 319     #[stable(feature = "rust1", since = "1.0.0")]
 320     #[inline]
 321     pub fn powf(self, n: f64) -> f64 {
 322         unsafe { intrinsics::powf64(self, n) }
 323     }
 324
 325     /// Returns the square root of a number.
 326     ///
 327     /// Returns NaN if `self` is a negative number.
 328     ///
 329     /// # Examples
 330     ///
 331     /// ```
 332     /// let positive = 4.0_f64;
 333     /// let negative = -4.0_f64;
 334     ///
 335     /// let abs_difference = (positive.sqrt() - 2.0).abs();
 336     ///
 337     /// assert!(abs_difference < 1e-10);
 338     /// assert!(negative.sqrt().is_nan());
 339     /// ```
 340     #[must_use = "method returns a new number and does not mutate the original value"]
 341     #[stable(feature = "rust1", since = "1.0.0")]
 342     #[inline]
 343     pub fn sqrt(self) -> f64 {
 344         unsafe { intrinsics::sqrtf64(self) }
 345     }
 346
 347     /// Returns `e^(self)`, (the exponential function).
 348     ///
 349     /// # Examples
 350     ///
 351     /// ```
 352     /// let one = 1.0_f64;
 353     /// // e^1
 354     /// let e = one.exp();
 355     ///
 356     /// // ln(e) - 1 == 0
 357     /// let abs_difference = (e.ln() - 1.0).abs();
 358     ///
 359     /// assert!(abs_difference < 1e-10);
 360     /// ```
 361     #[must_use = "method returns a new number and does not mutate the original value"]
 362     #[stable(feature = "rust1", since = "1.0.0")]
 363     #[inline]
 364     pub fn exp(self) -> f64 {
 365         unsafe { intrinsics::expf64(self) }
 366     }
 367
 368     /// Returns `2^(self)`.
 369     ///
 370     /// # Examples
 371     ///
 372     /// ```
 373     /// let f = 2.0_f64;
 374     ///
 375     /// // 2^2 - 4 == 0
 376     /// let abs_difference = (f.exp2() - 4.0).abs();
 377     ///
 378     /// assert!(abs_difference < 1e-10);
 379     /// ```
 380     #[must_use = "method returns a new number and does not mutate the original value"]
 381     #[stable(feature = "rust1", since = "1.0.0")]
 382     #[inline]
 383     pub fn exp2(self) -> f64 {
 384         unsafe { intrinsics::exp2f64(self) }
 385     }
 386
 387     /// Returns the natural logarithm of the number.
 388     ///
 389     /// # Examples
 390     ///
 391     /// ```
 392     /// let one = 1.0_f64;
 393     /// // e^1
 394     /// let e = one.exp();
 395     ///
 396     /// // ln(e) - 1 == 0
 397     /// let abs_difference = (e.ln() - 1.0).abs();
 398     ///
 399     /// assert!(abs_difference < 1e-10);
 400     /// ```
 401     #[must_use = "method returns a new number and does not mutate the original value"]
 402     #[stable(feature = "rust1", since = "1.0.0")]
 403     #[inline]
 404     pub fn ln(self) -> f64 {
 405         self.log_wrapper(|n| unsafe { intrinsics::logf64(n) })
 406     }
 407
 408     /// Returns the logarithm of the number with respect to an arbitrary base.
 409     ///
 410     /// The result may not be correctly rounded owing to implementation details;
 411     /// `self.log2()` can produce more accurate results for base 2, and
 412     /// `self.log10()` can produce more accurate results for base 10.
 413     ///
 414     /// # Examples
 415     ///
 416     /// ```
 417     /// let twenty_five = 25.0_f64;
 418     ///
 419     /// // log5(25) - 2 == 0
 420     /// let abs_difference = (twenty_five.log(5.0) - 2.0).abs();
 421     ///
 422     /// assert!(abs_difference < 1e-10);
 423     /// ```
 424     #[must_use = "method returns a new number and does not mutate the original value"]
 425     #[stable(feature = "rust1", since = "1.0.0")]
 426     #[inline]
 427     pub fn log(self, base: f64) -> f64 {
 428         self.ln() / base.ln()
 429     }
 430
 431     /// Returns the base 2 logarithm of the number.
 432     ///
 433     /// # Examples
 434     ///
 435     /// ```
 436     /// let four = 4.0_f64;
 437     ///
 438     /// // log2(4) - 2 == 0
 439     /// let abs_difference = (four.log2() - 2.0).abs();
 440     ///
 441     /// assert!(abs_difference < 1e-10);
 442     /// ```
 443     #[must_use = "method returns a new number and does not mutate the original value"]
 444     #[stable(feature = "rust1", since = "1.0.0")]
 445     #[inline]
 446     pub fn log2(self) -> f64 {
 447         self.log_wrapper(|n| {
 448             #[cfg(target_os = "android")]
 449             return crate::sys::android::log2f64(n);
 450             #[cfg(not(target_os = "android"))]
 451             return unsafe { intrinsics::log2f64(n) };
 452         })
 453     }
 454
 455     /// Returns the base 10 logarithm of the number.
 456     ///
 457     /// # Examples
 458     ///
 459     /// ```
 460     /// let hundred = 100.0_f64;
 461     ///
 462     /// // log10(100) - 2 == 0
 463     /// let abs_difference = (hundred.log10() - 2.0).abs();
 464     ///
 465     /// assert!(abs_difference < 1e-10);
 466     /// ```
 467     #[must_use = "method returns a new number and does not mutate the original value"]
 468     #[stable(feature = "rust1", since = "1.0.0")]
 469     #[inline]
 470     pub fn log10(self) -> f64 {
 471         self.log_wrapper(|n| unsafe { intrinsics::log10f64(n) })
 472     }
 473
 474     /// The positive difference of two numbers.
 475     ///
 476     /// * If `self <= other`: `0:0`
 477     /// * Else: `self - other`
 478     ///
 479     /// # Examples
 480     ///
 481     /// ```
 482     /// let x = 3.0_f64;
 483     /// let y = -3.0_f64;
 484     ///
 485     /// let abs_difference_x = (x.abs_sub(1.0) - 2.0).abs();
 486     /// let abs_difference_y = (y.abs_sub(1.0) - 0.0).abs();
 487     ///
 488     /// assert!(abs_difference_x < 1e-10);
 489     /// assert!(abs_difference_y < 1e-10);
 490     /// ```
 491     #[must_use = "method returns a new number and does not mutate the original value"]
 492     #[stable(feature = "rust1", since = "1.0.0")]
 493     #[inline]
 494     #[rustc_deprecated(
 495         since = "1.10.0",
 496         reason = "you probably meant `(self - other).abs()`: \
 497                   this operation is `(self - other).max(0.0)` \
 498                   except that `abs_sub` also propagates NaNs (also \
 499                   known as `fdim` in C). If you truly need the positive \
 500                   difference, consider using that expression or the C function \
 501                   `fdim`, depending on how you wish to handle NaN (please consider \
 502                   filing an issue describing your use-case too)."
 503     )]
 504     pub fn abs_sub(self, other: f64) -> f64 {
 505         unsafe { cmath::fdim(self, other) }
 506     }
 507
 508     /// Returns the cube root of a number.
 509     ///
 510     /// # Examples
 511     ///
 512     /// ```
 513     /// let x = 8.0_f64;
 514     ///
 515     /// // x^(1/3) - 2 == 0
 516     /// let abs_difference = (x.cbrt() - 2.0).abs();
 517     ///
 518     /// assert!(abs_difference < 1e-10);
 519     /// ```
 520     #[must_use = "method returns a new number and does not mutate the original value"]
 521     #[stable(feature = "rust1", since = "1.0.0")]
 522     #[inline]
 523     pub fn cbrt(self) -> f64 {
 524         unsafe { cmath::cbrt(self) }
 525     }
 526
 527     /// Calculates the length of the hypotenuse of a right-angle triangle given
 528     /// legs of length `x` and `y`.
 529     ///
 530     /// # Examples
 531     ///
 532     /// ```
 533     /// let x = 2.0_f64;
 534     /// let y = 3.0_f64;
 535     ///
 536     /// // sqrt(x^2 + y^2)
 537     /// let abs_difference = (x.hypot(y) - (x.powi(2) + y.powi(2)).sqrt()).abs();
 538     ///
 539     /// assert!(abs_difference < 1e-10);
 540     /// ```
 541     #[must_use = "method returns a new number and does not mutate the original value"]
 542     #[stable(feature = "rust1", since = "1.0.0")]
 543     #[inline]
 544     pub fn hypot(self, other: f64) -> f64 {
 545         unsafe { cmath::hypot(self, other) }
 546     }
 547
 548     /// Computes the sine of a number (in radians).
 549     ///
 550     /// # Examples
 551     ///
 552     /// ```
 553     /// let x = std::f64::consts::FRAC_PI_2;
 554     ///
 555     /// let abs_difference = (x.sin() - 1.0).abs();
 556     ///
 557     /// assert!(abs_difference < 1e-10);
 558     /// ```
 559     #[must_use = "method returns a new number and does not mutate the original value"]
 560     #[stable(feature = "rust1", since = "1.0.0")]
 561     #[inline]
 562     pub fn sin(self) -> f64 {
 563         unsafe { intrinsics::sinf64(self) }
 564     }
 565
 566     /// Computes the cosine of a number (in radians).
 567     ///
 568     /// # Examples
 569     ///
 570     /// ```
 571     /// let x = 2.0 * std::f64::consts::PI;
 572     ///
 573     /// let abs_difference = (x.cos() - 1.0).abs();
 574     ///
 575     /// assert!(abs_difference < 1e-10);
 576     /// ```
 577     #[must_use = "method returns a new number and does not mutate the original value"]
 578     #[stable(feature = "rust1", since = "1.0.0")]
 579     #[inline]
 580     pub fn cos(self) -> f64 {
 581         unsafe { intrinsics::cosf64(self) }
 582     }
 583
 584     /// Computes the tangent of a number (in radians).
 585     ///
 586     /// # Examples
 587     ///
 588     /// ```
 589     /// let x = std::f64::consts::FRAC_PI_4;
 590     /// let abs_difference = (x.tan() - 1.0).abs();
 591     ///
 592     /// assert!(abs_difference < 1e-14);
 593     /// ```
 594     #[must_use = "method returns a new number and does not mutate the original value"]
 595     #[stable(feature = "rust1", since = "1.0.0")]
 596     #[inline]
 597     pub fn tan(self) -> f64 {
 598         unsafe { cmath::tan(self) }
 599     }
 600
 601     /// Computes the arcsine of a number. Return value is in radians in
 602     /// the range [-pi/2, pi/2] or NaN if the number is outside the range
 603     /// [-1, 1].
 604     ///
 605     /// # Examples
 606     ///
 607     /// ```
 608     /// let f = std::f64::consts::FRAC_PI_2;
 609     ///
 610     /// // asin(sin(pi/2))
 611     /// let abs_difference = (f.sin().asin() - std::f64::consts::FRAC_PI_2).abs();
 612     ///
 613     /// assert!(abs_difference < 1e-10);
 614     /// ```
 615     #[must_use = "method returns a new number and does not mutate the original value"]
 616     #[stable(feature = "rust1", since = "1.0.0")]
 617     #[inline]
 618     pub fn asin(self) -> f64 {
 619         unsafe { cmath::asin(self) }
 620     }
 621
 622     /// Computes the arccosine of a number. Return value is in radians in
 623     /// the range [0, pi] or NaN if the number is outside the range
 624     /// [-1, 1].
 625     ///
 626     /// # Examples
 627     ///
 628     /// ```
 629     /// let f = std::f64::consts::FRAC_PI_4;
 630     ///
 631     /// // acos(cos(pi/4))
 632     /// let abs_difference = (f.cos().acos() - std::f64::consts::FRAC_PI_4).abs();
 633     ///
 634     /// assert!(abs_difference < 1e-10);
 635     /// ```
 636     #[must_use = "method returns a new number and does not mutate the original value"]
 637     #[stable(feature = "rust1", since = "1.0.0")]
 638     #[inline]
 639     pub fn acos(self) -> f64 {
 640         unsafe { cmath::acos(self) }
 641     }
 642
 643     /// Computes the arctangent of a number. Return value is in radians in the
 644     /// range [-pi/2, pi/2];
 645     ///
 646     /// # Examples
 647     ///
 648     /// ```
 649     /// let f = 1.0_f64;
 650     ///
 651     /// // atan(tan(1))
 652     /// let abs_difference = (f.tan().atan() - 1.0).abs();
 653     ///
 654     /// assert!(abs_difference < 1e-10);
 655     /// ```
 656     #[must_use = "method returns a new number and does not mutate the original value"]
 657     #[stable(feature = "rust1", since = "1.0.0")]
 658     #[inline]
 659     pub fn atan(self) -> f64 {
 660         unsafe { cmath::atan(self) }
 661     }
 662
 663     /// Computes the four quadrant arctangent of `self` (`y`) and `other` (`x`) in radians.
 664     ///
 665     /// * `x = 0`, `y = 0`: `0`
 666     /// * `x >= 0`: `arctan(y/x)` -> `[-pi/2, pi/2]`
 667     /// * `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]`
 668     /// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
 669     ///
 670     /// # Examples
 671     ///
 672     /// ```
 673     /// // Positive angles measured counter-clockwise
 674     /// // from positive x axis
 675     /// // -pi/4 radians (45 deg clockwise)
 676     /// let x1 = 3.0_f64;
 677     /// let y1 = -3.0_f64;
 678     ///
 679     /// // 3pi/4 radians (135 deg counter-clockwise)
 680     /// let x2 = -3.0_f64;
 681     /// let y2 = 3.0_f64;
 682     ///
 683     /// let abs_difference_1 = (y1.atan2(x1) - (-std::f64::consts::FRAC_PI_4)).abs();
 684     /// let abs_difference_2 = (y2.atan2(x2) - (3.0 * std::f64::consts::FRAC_PI_4)).abs();
 685     ///
 686     /// assert!(abs_difference_1 < 1e-10);
 687     /// assert!(abs_difference_2 < 1e-10);
 688     /// ```
 689     #[must_use = "method returns a new number and does not mutate the original value"]
 690     #[stable(feature = "rust1", since = "1.0.0")]
 691     #[inline]
 692     pub fn atan2(self, other: f64) -> f64 {
 693         unsafe { cmath::atan2(self, other) }
 694     }
 695
 696     /// Simultaneously computes the sine and cosine of the number, `x`. Returns
 697     /// `(sin(x), cos(x))`.
 698     ///
 699     /// # Examples
 700     ///
 701     /// ```
 702     /// let x = std::f64::consts::FRAC_PI_4;
 703     /// let f = x.sin_cos();
 704     ///
 705     /// let abs_difference_0 = (f.0 - x.sin()).abs();
 706     /// let abs_difference_1 = (f.1 - x.cos()).abs();
 707     ///
 708     /// assert!(abs_difference_0 < 1e-10);
 709     /// assert!(abs_difference_1 < 1e-10);
 710     /// ```
 711     #[stable(feature = "rust1", since = "1.0.0")]
 712     #[inline]
 713     pub fn sin_cos(self) -> (f64, f64) {
 714         (self.sin(), self.cos())
 715     }
 716
 717     /// Returns `e^(self) - 1` in a way that is accurate even if the
 718     /// number is close to zero.
 719     ///
 720     /// # Examples
 721     ///
 722     /// ```
 723     /// let x = 1e-16_f64;
 724     ///
 725     /// // for very small x, e^x is approximately 1 + x + x^2 / 2
 726     /// let approx = x + x * x / 2.0;
 727     /// let abs_difference = (x.exp_m1() - approx).abs();
 728     ///
 729     /// assert!(abs_difference < 1e-20);
 730     /// ```
 731     #[must_use = "method returns a new number and does not mutate the original value"]
 732     #[stable(feature = "rust1", since = "1.0.0")]
 733     #[inline]
 734     pub fn exp_m1(self) -> f64 {
 735         unsafe { cmath::expm1(self) }
 736     }
 737
 738     /// Returns `ln(1+n)` (natural logarithm) more accurately than if
 739     /// the operations were performed separately.
 740     ///
 741     /// # Examples
 742     ///
 743     /// ```
 744     /// let x = 1e-16_f64;
 745     ///
 746     /// // for very small x, ln(1 + x) is approximately x - x^2 / 2
 747     /// let approx = x - x * x / 2.0;
 748     /// let abs_difference = (x.ln_1p() - approx).abs();
 749     ///
 750     /// assert!(abs_difference < 1e-20);
 751     /// ```
 752     #[must_use = "method returns a new number and does not mutate the original value"]
 753     #[stable(feature = "rust1", since = "1.0.0")]
 754     #[inline]
 755     pub fn ln_1p(self) -> f64 {
 756         unsafe { cmath::log1p(self) }
 757     }
 758
 759     /// Hyperbolic sine function.
 760     ///
 761     /// # Examples
 762     ///
 763     /// ```
 764     /// let e = std::f64::consts::E;
 765     /// let x = 1.0_f64;
 766     ///
 767     /// let f = x.sinh();
 768     /// // Solving sinh() at 1 gives `(e^2-1)/(2e)`
 769     /// let g = ((e * e) - 1.0) / (2.0 * e);
 770     /// let abs_difference = (f - g).abs();
 771     ///
 772     /// assert!(abs_difference < 1e-10);
 773     /// ```
 774     #[must_use = "method returns a new number and does not mutate the original value"]
 775     #[stable(feature = "rust1", since = "1.0.0")]
 776     #[inline]
 777     pub fn sinh(self) -> f64 {
 778         unsafe { cmath::sinh(self) }
 779     }
 780
 781     /// Hyperbolic cosine function.
 782     ///
 783     /// # Examples
 784     ///
 785     /// ```
 786     /// let e = std::f64::consts::E;
 787     /// let x = 1.0_f64;
 788     /// let f = x.cosh();
 789     /// // Solving cosh() at 1 gives this result
 790     /// let g = ((e * e) + 1.0) / (2.0 * e);
 791     /// let abs_difference = (f - g).abs();
 792     ///
 793     /// // Same result
 794     /// assert!(abs_difference < 1.0e-10);
 795     /// ```
 796     #[must_use = "method returns a new number and does not mutate the original value"]
 797     #[stable(feature = "rust1", since = "1.0.0")]
 798     #[inline]
 799     pub fn cosh(self) -> f64 {
 800         unsafe { cmath::cosh(self) }
 801     }
 802
 803     /// Hyperbolic tangent function.
 804     ///
 805     /// # Examples
 806     ///
 807     /// ```
 808     /// let e = std::f64::consts::E;
 809     /// let x = 1.0_f64;
 810     ///
 811     /// let f = x.tanh();
 812     /// // Solving tanh() at 1 gives `(1 - e^(-2))/(1 + e^(-2))`
 813     /// let g = (1.0 - e.powi(-2)) / (1.0 + e.powi(-2));
 814     /// let abs_difference = (f - g).abs();
 815     ///
 816     /// assert!(abs_difference < 1.0e-10);
 817     /// ```
 818     #[must_use = "method returns a new number and does not mutate the original value"]
 819     #[stable(feature = "rust1", since = "1.0.0")]
 820     #[inline]
 821     pub fn tanh(self) -> f64 {
 822         unsafe { cmath::tanh(self) }
 823     }
 824
 825     /// Inverse hyperbolic sine function.
 826     ///
 827     /// # Examples
 828     ///
 829     /// ```
 830     /// let x = 1.0_f64;
 831     /// let f = x.sinh().asinh();
 832     ///
 833     /// let abs_difference = (f - x).abs();
 834     ///
 835     /// assert!(abs_difference < 1.0e-10);
 836     /// ```
 837     #[must_use = "method returns a new number and does not mutate the original value"]
 838     #[stable(feature = "rust1", since = "1.0.0")]
 839     #[inline]
 840     pub fn asinh(self) -> f64 {
 841         (self.abs() + ((self * self) + 1.0).sqrt()).ln().copysign(self)
 842     }
 843
 844     /// Inverse hyperbolic cosine function.
 845     ///
 846     /// # Examples
 847     ///
 848     /// ```
 849     /// let x = 1.0_f64;
 850     /// let f = x.cosh().acosh();
 851     ///
 852     /// let abs_difference = (f - x).abs();
 853     ///
 854     /// assert!(abs_difference < 1.0e-10);
 855     /// ```
 856     #[must_use = "method returns a new number and does not mutate the original value"]
 857     #[stable(feature = "rust1", since = "1.0.0")]
 858     #[inline]
 859     pub fn acosh(self) -> f64 {
 860         if self < 1.0 { Self::NAN } else { (self + ((self * self) - 1.0).sqrt()).ln() }
 861     }
 862
 863     /// Inverse hyperbolic tangent function.
 864     ///
 865     /// # Examples
 866     ///
 867     /// ```
 868     /// let e = std::f64::consts::E;
 869     /// let f = e.tanh().atanh();
 870     ///
 871     /// let abs_difference = (f - e).abs();
 872     ///
 873     /// assert!(abs_difference < 1.0e-10);
 874     /// ```
 875     #[must_use = "method returns a new number and does not mutate the original value"]
 876     #[stable(feature = "rust1", since = "1.0.0")]
 877     #[inline]
 878     pub fn atanh(self) -> f64 {
 879         0.5 * ((2.0 * self) / (1.0 - self)).ln_1p()
 880     }
 881
 882     /// Linear interpolation between `start` and `end`.
 883     ///
 884     /// This enables linear interpolation between `start` and `end`, where start is represented by
 885     /// `self == 0.0` and `end` is represented by `self == 1.0`. This is the basis of all
 886     /// "transition", "easing", or "step" functions; if you change `self` from 0.0 to 1.0
 887     /// at a given rate, the result will change from `start` to `end` at a similar rate.
 888     ///
 889     /// Values below 0.0 or above 1.0 are allowed, allowing you to extrapolate values outside the
 890     /// range from `start` to `end`. This also is useful for transition functions which might
 891     /// move slightly past the end or start for a desired effect. Mathematically, the values
 892     /// returned are equivalent to `start + self * (end - start)`, although we make a few specific
 893     /// guarantees that are useful specifically to linear interpolation.
 894     ///
 895     /// These guarantees are:
 896     ///
 897     /// * If `start` and `end` are [finite], the value at 0.0 is always `start` and the
 898     ///   value at 1.0 is always `end`. (exactness)
 899     /// * If `start` and `end` are [finite], the values will always move in the direction from
 900     ///   `start` to `end` (monotonicity)
 901     /// * If `self` is [finite] and `start == end`, the value at any point will always be
 902     ///   `start == end`. (consistency)
 903     ///
 904     /// [finite]: #method.is_finite
 905     #[must_use = "method returns a new number and does not mutate the original value"]
 906     #[unstable(feature = "float_interpolation", issue = "86269")]
 907     pub fn lerp(self, start: f64, end: f64) -> f64 {
 908         // consistent
 909         if start == end {
 910             start
 911
 912         // exact/monotonic
 913         } else {
 914             self.mul_add(end, (-self).mul_add(start, start))
 915         }
 916     }
 917
 918     // Solaris/Illumos requires a wrapper around log, log2, and log10 functions
 919     // because of their non-standard behavior (e.g., log(-n) returns -Inf instead
 920     // of expected NaN).
 921     fn log_wrapper<F: Fn(f64) -> f64>(self, log_fn: F) -> f64 {
 922         if !cfg!(any(target_os = "solaris", target_os = "illumos")) {
 923             log_fn(self)
 924         } else if self.is_finite() {
 925             if self > 0.0 {
 926                 log_fn(self)
 927             } else if self == 0.0 {
 928                 Self::NEG_INFINITY // log(0) = -Inf
 929             } else {
 930                 Self::NAN // log(-n) = NaN
 931             }
 932         } else if self.is_nan() {
 933             self // log(NaN) = NaN
 934         } else if self > 0.0 {
 935             self // log(Inf) = Inf
 936         } else {
 937             Self::NAN // log(-Inf) = NaN
 938         }
 939     }
 940 }