auto merge of #13225 : thestinger/rust/num, r=cmr
The `Float` trait methods will be usable as functions via UFCS, and we came to a consensus to remove duplicate functions like this a long time ago. It does still make sense to keep the duplicate functions when the trait methods are static, unless the decision to leave out the in-scope trait name resolution for static methods changes.
This commit is contained in:
bors
commit
1217cfb9e7
src
doc
librand/distributions
libstd
@ -332,8 +332,6 @@ sense, they're simple: just keep whatever ownership the data already has. For
|
||||
example:
|
||||
|
||||
~~~rust
|
||||
use std::num::sqrt;
|
||||
|
||||
struct Point {
|
||||
x: f32,
|
||||
y: f32,
|
||||
@ -343,7 +341,7 @@ fn compute_distance(p1: &Point, p2: &Point) -> f32 {
|
||||
let x_d = p1.x - p2.x;
|
||||
let y_d = p1.y - p2.y;
|
||||
|
||||
sqrt(x_d * x_d + y_d * y_d)
|
||||
(x_d * x_d + y_d * y_d).sqrt()
|
||||
}
|
||||
|
||||
fn main() {
|
||||
|
||||
@ -826,14 +826,14 @@ Use declarations support a number of convenient shortcuts:
|
||||
An example of `use` declarations:
|
||||
|
||||
~~~~
|
||||
use std::num::sin;
|
||||
use std::iter::range_step;
|
||||
use std::option::{Some, None};
|
||||
|
||||
# fn foo<T>(_: T){}
|
||||
|
||||
fn main() {
|
||||
// Equivalent to 'std::num::sin(1.0);'
|
||||
sin(1.0);
|
||||
// Equivalent to 'std::iter::range_step(0, 10, 2);'
|
||||
range_step(0, 10, 2);
|
||||
|
||||
// Equivalent to 'foo(~[std::option::Some(1.0), std::option::None]);'
|
||||
foo(~[Some(1.0), None]);
|
||||
|
||||
@ -504,13 +504,12 @@ matching in order to bind names to the contents of data types.
|
||||
|
||||
~~~~
|
||||
use std::f64;
|
||||
use std::num::atan;
|
||||
fn angle(vector: (f64, f64)) -> f64 {
|
||||
let pi = f64::consts::PI;
|
||||
match vector {
|
||||
(0.0, y) if y < 0.0 => 1.5 * pi,
|
||||
(0.0, _) => 0.5 * pi,
|
||||
(x, y) => atan(y / x)
|
||||
(x, y) => (y / x).atan()
|
||||
}
|
||||
}
|
||||
~~~~
|
||||
@ -1430,12 +1429,11 @@ bad, but often copies are expensive. So we’d like to define a function
|
||||
that takes the points by pointer. We can use references to do this:
|
||||
|
||||
~~~
|
||||
use std::num::sqrt;
|
||||
# struct Point { x: f64, y: f64 }
|
||||
fn compute_distance(p1: &Point, p2: &Point) -> f64 {
|
||||
let x_d = p1.x - p2.x;
|
||||
let y_d = p1.y - p2.y;
|
||||
sqrt(x_d * x_d + y_d * y_d)
|
||||
(x_d * x_d + y_d * y_d).sqrt()
|
||||
}
|
||||
~~~
|
||||
|
||||
@ -2303,7 +2301,7 @@ impl Shape for Circle {
|
||||
fn new(area: f64) -> Circle { Circle { radius: (area / PI).sqrt() } }
|
||||
}
|
||||
impl Shape for Square {
|
||||
fn new(area: f64) -> Square { Square { length: (area).sqrt() } }
|
||||
fn new(area: f64) -> Square { Square { length: area.sqrt() } }
|
||||
}
|
||||
|
||||
let area = 42.5;
|
||||
|
||||
@ -11,7 +11,6 @@
|
||||
//! The Gamma and derived distributions.
|
||||
|
||||
use std::num::Float;
|
||||
use std::num;
|
||||
use {Rng, Open01};
|
||||
use super::normal::StandardNormal;
|
||||
use super::{IndependentSample, Sample, Exp};
|
||||
@ -114,7 +113,7 @@ impl GammaLargeShape {
|
||||
GammaLargeShape {
|
||||
shape: shape,
|
||||
scale: scale,
|
||||
c: 1. / num::sqrt(9. * d),
|
||||
c: 1. / (9. * d).sqrt(),
|
||||
d: d
|
||||
}
|
||||
}
|
||||
@ -143,7 +142,7 @@ impl IndependentSample<f64> for GammaSmallShape {
|
||||
fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64 {
|
||||
let Open01(u) = rng.gen::<Open01<f64>>();
|
||||
|
||||
self.large_shape.ind_sample(rng) * num::powf(u, self.inv_shape)
|
||||
self.large_shape.ind_sample(rng) * u.powf(&self.inv_shape)
|
||||
}
|
||||
}
|
||||
impl IndependentSample<f64> for GammaLargeShape {
|
||||
@ -160,7 +159,7 @@ impl IndependentSample<f64> for GammaLargeShape {
|
||||
|
||||
let x_sqr = x * x;
|
||||
if u < 1.0 - 0.0331 * x_sqr * x_sqr ||
|
||||
num::ln(u) < 0.5 * x_sqr + self.d * (1.0 - v + num::ln(v)) {
|
||||
u.ln() < 0.5 * x_sqr + self.d * (1.0 - v + v.ln()) {
|
||||
return self.d * v * self.scale
|
||||
}
|
||||
}
|
||||
|
||||
@ -206,8 +206,6 @@ pub mod raw;
|
||||
/* For internal use, not exported */
|
||||
|
||||
mod unicode;
|
||||
#[path = "num/cmath.rs"]
|
||||
mod cmath;
|
||||
|
||||
// FIXME #7809: This shouldn't be pub, and it should be reexported under 'unstable'
|
||||
// but name resolution doesn't work without it being pub.
|
||||
|
||||
@ -1,151 +0,0 @@
|
||||
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
#![allow(missing_doc)]
|
||||
#![allow(dead_code)]
|
||||
|
||||
//! Bindings for the C math library (for basic mathematic functions)
|
||||
|
||||
// Function names are almost identical to C's libmath, a few have been
|
||||
// renamed, grep for "rename:"
|
||||
|
||||
pub mod c_double {
|
||||
use libc::{c_double, c_int};
|
||||
|
||||
#[link_name = "m"]
|
||||
extern {
|
||||
// Alphabetically sorted by link_name
|
||||
|
||||
pub fn acos(n: c_double) -> c_double;
|
||||
pub fn asin(n: c_double) -> c_double;
|
||||
pub fn atan(n: c_double) -> c_double;
|
||||
pub fn atan2(a: c_double, b: c_double) -> c_double;
|
||||
pub fn cbrt(n: c_double) -> c_double;
|
||||
pub fn cosh(n: c_double) -> c_double;
|
||||
pub fn erf(n: c_double) -> c_double;
|
||||
pub fn erfc(n: c_double) -> c_double;
|
||||
// rename: for consistency with underscore usage elsewhere
|
||||
#[link_name="expm1"]
|
||||
pub fn exp_m1(n: c_double) -> c_double;
|
||||
// rename: for clarity and consistency with add/sub/mul/div
|
||||
#[link_name="fdim"]
|
||||
pub fn abs_sub(a: c_double, b: c_double) -> c_double;
|
||||
#[link_name="fmax"]
|
||||
pub fn fmax(a: c_double, b: c_double) -> c_double;
|
||||
#[link_name="fmin"]
|
||||
pub fn fmin(a: c_double, b: c_double) -> c_double;
|
||||
#[link_name="nextafter"]
|
||||
pub fn next_after(x: c_double, y: c_double) -> c_double;
|
||||
pub fn frexp(n: c_double, value: &mut c_int) -> c_double;
|
||||
pub fn hypot(x: c_double, y: c_double) -> c_double;
|
||||
pub fn ldexp(x: c_double, n: c_int) -> c_double;
|
||||
#[cfg(unix)]
|
||||
#[link_name="lgamma_r"]
|
||||
pub fn lgamma(n: c_double, sign: &mut c_int) -> c_double;
|
||||
#[cfg(windows)]
|
||||
#[link_name="__lgamma_r"]
|
||||
pub fn lgamma(n: c_double, sign: &mut c_int) -> c_double;
|
||||
// renamed: "logb" /often/ is confused for log2 by beginners
|
||||
#[link_name="logb"]
|
||||
pub fn log_radix(n: c_double) -> c_double;
|
||||
// renamed: to be consitent with log as ln
|
||||
#[link_name="log1p"]
|
||||
pub fn ln_1p(n: c_double) -> c_double;
|
||||
#[link_name="ilogb"]
|
||||
pub fn ilog_radix(n: c_double) -> c_int;
|
||||
pub fn modf(n: c_double, iptr: &mut c_double) -> c_double;
|
||||
// rename: for consistency with logradix
|
||||
#[link_name="scalbn"]
|
||||
pub fn ldexp_radix(n: c_double, i: c_int) -> c_double;
|
||||
pub fn sinh(n: c_double) -> c_double;
|
||||
pub fn tan(n: c_double) -> c_double;
|
||||
pub fn tanh(n: c_double) -> c_double;
|
||||
pub fn tgamma(n: c_double) -> c_double;
|
||||
|
||||
// These are commonly only available for doubles
|
||||
|
||||
pub fn j0(n: c_double) -> c_double;
|
||||
pub fn j1(n: c_double) -> c_double;
|
||||
pub fn jn(i: c_int, n: c_double) -> c_double;
|
||||
|
||||
pub fn y0(n: c_double) -> c_double;
|
||||
pub fn y1(n: c_double) -> c_double;
|
||||
pub fn yn(i: c_int, n: c_double) -> c_double;
|
||||
}
|
||||
}
|
||||
|
||||
pub mod c_float {
|
||||
use libc::{c_float, c_int};
|
||||
|
||||
#[link_name = "m"]
|
||||
extern {
|
||||
// Alphabetically sorted by link_name
|
||||
|
||||
#[link_name="acosf"]
|
||||
pub fn acos(n: c_float) -> c_float;
|
||||
#[link_name="asinf"]
|
||||
pub fn asin(n: c_float) -> c_float;
|
||||
#[link_name="atanf"]
|
||||
pub fn atan(n: c_float) -> c_float;
|
||||
#[link_name="atan2f"]
|
||||
pub fn atan2(a: c_float, b: c_float) -> c_float;
|
||||
#[link_name="cbrtf"]
|
||||
pub fn cbrt(n: c_float) -> c_float;
|
||||
#[link_name="coshf"]
|
||||
pub fn cosh(n: c_float) -> c_float;
|
||||
#[link_name="erff"]
|
||||
pub fn erf(n: c_float) -> c_float;
|
||||
#[link_name="erfcf"]
|
||||
pub fn erfc(n: c_float) -> c_float;
|
||||
#[link_name="expm1f"]
|
||||
pub fn exp_m1(n: c_float) -> c_float;
|
||||
#[link_name="fdimf"]
|
||||
pub fn abs_sub(a: c_float, b: c_float) -> c_float;
|
||||
#[link_name="frexpf"]
|
||||
pub fn frexp(n: c_float, value: &mut c_int) -> c_float;
|
||||
#[link_name="fmaxf"]
|
||||
pub fn fmax(a: c_float, b: c_float) -> c_float;
|
||||
#[link_name="fminf"]
|
||||
pub fn fmin(a: c_float, b: c_float) -> c_float;
|
||||
#[link_name="nextafterf"]
|
||||
pub fn next_after(x: c_float, y: c_float) -> c_float;
|
||||
#[link_name="hypotf"]
|
||||
pub fn hypot(x: c_float, y: c_float) -> c_float;
|
||||
#[link_name="ldexpf"]
|
||||
pub fn ldexp(x: c_float, n: c_int) -> c_float;
|
||||
|
||||
#[cfg(unix)]
|
||||
#[link_name="lgammaf_r"]
|
||||
pub fn lgamma(n: c_float, sign: &mut c_int) -> c_float;
|
||||
|
||||
#[cfg(windows)]
|
||||
#[link_name="__lgammaf_r"]
|
||||
pub fn lgamma(n: c_float, sign: &mut c_int) -> c_float;
|
||||
|
||||
#[link_name="logbf"]
|
||||
pub fn log_radix(n: c_float) -> c_float;
|
||||
#[link_name="log1pf"]
|
||||
pub fn ln_1p(n: c_float) -> c_float;
|
||||
#[link_name="ilogbf"]
|
||||
pub fn ilog_radix(n: c_float) -> c_int;
|
||||
#[link_name="modff"]
|
||||
pub fn modf(n: c_float, iptr: &mut c_float) -> c_float;
|
||||
#[link_name="scalbnf"]
|
||||
pub fn ldexp_radix(n: c_float, i: c_int) -> c_float;
|
||||
#[link_name="sinhf"]
|
||||
pub fn sinh(n: c_float) -> c_float;
|
||||
#[link_name="tanf"]
|
||||
pub fn tan(n: c_float) -> c_float;
|
||||
#[link_name="tanhf"]
|
||||
pub fn tanh(n: c_float) -> c_float;
|
||||
#[link_name="tgammaf"]
|
||||
pub fn tgamma(n: c_float) -> c_float;
|
||||
}
|
||||
}
|
||||
@ -14,7 +14,6 @@
|
||||
|
||||
use prelude::*;
|
||||
|
||||
use cmath;
|
||||
use default::Default;
|
||||
use from_str::FromStr;
|
||||
use libc::{c_float, c_int};
|
||||
@ -23,6 +22,46 @@ use num::{Zero, One, Bounded, strconv};
|
||||
use num;
|
||||
use intrinsics;
|
||||
|
||||
#[allow(dead_code)]
|
||||
mod cmath {
|
||||
use libc::{c_float, c_int};
|
||||
|
||||
#[link_name = "m"]
|
||||
extern {
|
||||
pub fn acosf(n: c_float) -> c_float;
|
||||
pub fn asinf(n: c_float) -> c_float;
|
||||
pub fn atanf(n: c_float) -> c_float;
|
||||
pub fn atan2f(a: c_float, b: c_float) -> c_float;
|
||||
pub fn cbrtf(n: c_float) -> c_float;
|
||||
pub fn coshf(n: c_float) -> c_float;
|
||||
pub fn erff(n: c_float) -> c_float;
|
||||
pub fn erfcf(n: c_float) -> c_float;
|
||||
pub fn expm1f(n: c_float) -> c_float;
|
||||
pub fn fdimf(a: c_float, b: c_float) -> c_float;
|
||||
pub fn frexpf(n: c_float, value: &mut c_int) -> c_float;
|
||||
pub fn fmaxf(a: c_float, b: c_float) -> c_float;
|
||||
pub fn fminf(a: c_float, b: c_float) -> c_float;
|
||||
pub fn nextafterf(x: c_float, y: c_float) -> c_float;
|
||||
pub fn hypotf(x: c_float, y: c_float) -> c_float;
|
||||
pub fn ldexpf(x: c_float, n: c_int) -> c_float;
|
||||
pub fn logbf(n: c_float) -> c_float;
|
||||
pub fn log1pf(n: c_float) -> c_float;
|
||||
pub fn ilogbf(n: c_float) -> c_int;
|
||||
pub fn modff(n: c_float, iptr: &mut c_float) -> c_float;
|
||||
pub fn sinhf(n: c_float) -> c_float;
|
||||
pub fn tanf(n: c_float) -> c_float;
|
||||
pub fn tanhf(n: c_float) -> c_float;
|
||||
pub fn tgammaf(n: c_float) -> c_float;
|
||||
|
||||
#[cfg(unix)]
|
||||
pub fn lgammaf_r(n: c_float, sign: &mut c_int) -> c_float;
|
||||
|
||||
#[cfg(windows)]
|
||||
#[link_name="__lgammaf_r"]
|
||||
pub fn lgammaf_r(n: c_float, sign: &mut c_int) -> c_float;
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! delegate(
|
||||
(
|
||||
$(
|
||||
@ -66,29 +105,22 @@ delegate!(
|
||||
fn nearbyint(n: f32) -> f32 = intrinsics::nearbyintf32,
|
||||
fn round(n: f32) -> f32 = intrinsics::roundf32,
|
||||
|
||||
// cmath
|
||||
fn acos(n: c_float) -> c_float = cmath::c_float::acos,
|
||||
fn asin(n: c_float) -> c_float = cmath::c_float::asin,
|
||||
fn atan(n: c_float) -> c_float = cmath::c_float::atan,
|
||||
fn atan2(a: c_float, b: c_float) -> c_float = cmath::c_float::atan2,
|
||||
fn cbrt(n: c_float) -> c_float = cmath::c_float::cbrt,
|
||||
fn cosh(n: c_float) -> c_float = cmath::c_float::cosh,
|
||||
// fn erf(n: c_float) -> c_float = cmath::c_float::erf,
|
||||
// fn erfc(n: c_float) -> c_float = cmath::c_float::erfc,
|
||||
fn exp_m1(n: c_float) -> c_float = cmath::c_float::exp_m1,
|
||||
fn abs_sub(a: c_float, b: c_float) -> c_float = cmath::c_float::abs_sub,
|
||||
fn next_after(x: c_float, y: c_float) -> c_float = cmath::c_float::next_after,
|
||||
fn frexp(n: c_float, value: &mut c_int) -> c_float = cmath::c_float::frexp,
|
||||
fn hypot(x: c_float, y: c_float) -> c_float = cmath::c_float::hypot,
|
||||
fn ldexp(x: c_float, n: c_int) -> c_float = cmath::c_float::ldexp,
|
||||
// fn log_radix(n: c_float) -> c_float = cmath::c_float::log_radix,
|
||||
fn ln_1p(n: c_float) -> c_float = cmath::c_float::ln_1p,
|
||||
// fn ilog_radix(n: c_float) -> c_int = cmath::c_float::ilog_radix,
|
||||
// fn modf(n: c_float, iptr: &mut c_float) -> c_float = cmath::c_float::modf,
|
||||
// fn ldexp_radix(n: c_float, i: c_int) -> c_float = cmath::c_float::ldexp_radix,
|
||||
fn sinh(n: c_float) -> c_float = cmath::c_float::sinh,
|
||||
fn tan(n: c_float) -> c_float = cmath::c_float::tan,
|
||||
fn tanh(n: c_float) -> c_float = cmath::c_float::tanh
|
||||
fn acos(n: c_float) -> c_float = cmath::acosf,
|
||||
fn asin(n: c_float) -> c_float = cmath::asinf,
|
||||
fn atan(n: c_float) -> c_float = cmath::atanf,
|
||||
fn atan2(a: c_float, b: c_float) -> c_float = cmath::atan2f,
|
||||
fn cbrt(n: c_float) -> c_float = cmath::cbrtf,
|
||||
fn cosh(n: c_float) -> c_float = cmath::coshf,
|
||||
fn exp_m1(n: c_float) -> c_float = cmath::expm1f,
|
||||
fn abs_sub(a: c_float, b: c_float) -> c_float = cmath::fdimf,
|
||||
fn next_after(x: c_float, y: c_float) -> c_float = cmath::nextafterf,
|
||||
fn frexp(n: c_float, value: &mut c_int) -> c_float = cmath::frexpf,
|
||||
fn hypot(x: c_float, y: c_float) -> c_float = cmath::hypotf,
|
||||
fn ldexp(x: c_float, n: c_int) -> c_float = cmath::ldexpf,
|
||||
fn ln_1p(n: c_float) -> c_float = cmath::log1pf,
|
||||
fn sinh(n: c_float) -> c_float = cmath::sinhf,
|
||||
fn tan(n: c_float) -> c_float = cmath::tanf,
|
||||
fn tanh(n: c_float) -> c_float = cmath::tanhf
|
||||
)
|
||||
|
||||
// FIXME(#11621): These constants should be deprecated once CTFE is implemented
|
||||
@ -308,12 +340,12 @@ impl Primitive for f32 {}
|
||||
impl Float for f32 {
|
||||
#[inline]
|
||||
fn max(self, other: f32) -> f32 {
|
||||
unsafe { cmath::c_float::fmax(self, other) }
|
||||
unsafe { cmath::fmaxf(self, other) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn min(self, other: f32) -> f32 {
|
||||
unsafe { cmath::c_float::fmin(self, other) }
|
||||
unsafe { cmath::fminf(self, other) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
|
||||
@ -14,7 +14,6 @@
|
||||
|
||||
use prelude::*;
|
||||
|
||||
use cmath;
|
||||
use default::Default;
|
||||
use from_str::FromStr;
|
||||
use libc::{c_double, c_int};
|
||||
@ -23,6 +22,56 @@ use num::{Zero, One, Bounded, strconv};
|
||||
use num;
|
||||
use intrinsics;
|
||||
|
||||
#[allow(dead_code)]
|
||||
mod cmath {
|
||||
use libc::{c_double, c_int};
|
||||
|
||||
#[link_name = "m"]
|
||||
extern {
|
||||
pub fn acos(n: c_double) -> c_double;
|
||||
pub fn asin(n: c_double) -> c_double;
|
||||
pub fn atan(n: c_double) -> c_double;
|
||||
pub fn atan2(a: c_double, b: c_double) -> c_double;
|
||||
pub fn cbrt(n: c_double) -> c_double;
|
||||
pub fn cosh(n: c_double) -> c_double;
|
||||
pub fn erf(n: c_double) -> c_double;
|
||||
pub fn erfc(n: c_double) -> c_double;
|
||||
pub fn expm1(n: c_double) -> c_double;
|
||||
pub fn fdim(a: c_double, b: c_double) -> c_double;
|
||||
pub fn fmax(a: c_double, b: c_double) -> c_double;
|
||||
pub fn fmin(a: c_double, b: c_double) -> c_double;
|
||||
pub fn nextafter(x: c_double, y: c_double) -> c_double;
|
||||
pub fn frexp(n: c_double, value: &mut c_int) -> c_double;
|
||||
pub fn hypot(x: c_double, y: c_double) -> c_double;
|
||||
pub fn ldexp(x: c_double, n: c_int) -> c_double;
|
||||
pub fn logb(n: c_double) -> c_double;
|
||||
pub fn log1p(n: c_double) -> c_double;
|
||||
pub fn ilogb(n: c_double) -> c_int;
|
||||
pub fn modf(n: c_double, iptr: &mut c_double) -> c_double;
|
||||
pub fn sinh(n: c_double) -> c_double;
|
||||
pub fn tan(n: c_double) -> c_double;
|
||||
pub fn tanh(n: c_double) -> c_double;
|
||||
pub fn tgamma(n: c_double) -> c_double;
|
||||
|
||||
// These are commonly only available for doubles
|
||||
|
||||
pub fn j0(n: c_double) -> c_double;
|
||||
pub fn j1(n: c_double) -> c_double;
|
||||
pub fn jn(i: c_int, n: c_double) -> c_double;
|
||||
|
||||
pub fn y0(n: c_double) -> c_double;
|
||||
pub fn y1(n: c_double) -> c_double;
|
||||
pub fn yn(i: c_int, n: c_double) -> c_double;
|
||||
|
||||
#[cfg(unix)]
|
||||
pub fn lgamma_r(n: c_double, sign: &mut c_int) -> c_double;
|
||||
#[cfg(windows)]
|
||||
#[link_name="__lgamma_r"]
|
||||
pub fn lgamma_r(n: c_double, sign: &mut c_int) -> c_double;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
macro_rules! delegate(
|
||||
(
|
||||
$(
|
||||
@ -66,29 +115,22 @@ delegate!(
|
||||
fn nearbyint(n: f64) -> f64 = intrinsics::nearbyintf64,
|
||||
fn round(n: f64) -> f64 = intrinsics::roundf64,
|
||||
|
||||
// cmath
|
||||
fn acos(n: c_double) -> c_double = cmath::c_double::acos,
|
||||
fn asin(n: c_double) -> c_double = cmath::c_double::asin,
|
||||
fn atan(n: c_double) -> c_double = cmath::c_double::atan,
|
||||
fn atan2(a: c_double, b: c_double) -> c_double = cmath::c_double::atan2,
|
||||
fn cbrt(n: c_double) -> c_double = cmath::c_double::cbrt,
|
||||
fn cosh(n: c_double) -> c_double = cmath::c_double::cosh,
|
||||
// fn erf(n: c_double) -> c_double = cmath::c_double::erf,
|
||||
// fn erfc(n: c_double) -> c_double = cmath::c_double::erfc,
|
||||
fn exp_m1(n: c_double) -> c_double = cmath::c_double::exp_m1,
|
||||
fn abs_sub(a: c_double, b: c_double) -> c_double = cmath::c_double::abs_sub,
|
||||
fn next_after(x: c_double, y: c_double) -> c_double = cmath::c_double::next_after,
|
||||
fn frexp(n: c_double, value: &mut c_int) -> c_double = cmath::c_double::frexp,
|
||||
fn hypot(x: c_double, y: c_double) -> c_double = cmath::c_double::hypot,
|
||||
fn ldexp(x: c_double, n: c_int) -> c_double = cmath::c_double::ldexp,
|
||||
// fn log_radix(n: c_double) -> c_double = cmath::c_double::log_radix,
|
||||
fn ln_1p(n: c_double) -> c_double = cmath::c_double::ln_1p,
|
||||
// fn ilog_radix(n: c_double) -> c_int = cmath::c_double::ilog_radix,
|
||||
// fn modf(n: c_double, iptr: &mut c_double) -> c_double = cmath::c_double::modf,
|
||||
// fn ldexp_radix(n: c_double, i: c_int) -> c_double = cmath::c_double::ldexp_radix,
|
||||
fn sinh(n: c_double) -> c_double = cmath::c_double::sinh,
|
||||
fn tan(n: c_double) -> c_double = cmath::c_double::tan,
|
||||
fn tanh(n: c_double) -> c_double = cmath::c_double::tanh
|
||||
fn acos(n: c_double) -> c_double = cmath::acos,
|
||||
fn asin(n: c_double) -> c_double = cmath::asin,
|
||||
fn atan(n: c_double) -> c_double = cmath::atan,
|
||||
fn atan2(a: c_double, b: c_double) -> c_double = cmath::atan2,
|
||||
fn cbrt(n: c_double) -> c_double = cmath::cbrt,
|
||||
fn cosh(n: c_double) -> c_double = cmath::cosh,
|
||||
fn exp_m1(n: c_double) -> c_double = cmath::expm1,
|
||||
fn abs_sub(a: c_double, b: c_double) -> c_double = cmath::fdim,
|
||||
fn next_after(x: c_double, y: c_double) -> c_double = cmath::nextafter,
|
||||
fn frexp(n: c_double, value: &mut c_int) -> c_double = cmath::frexp,
|
||||
fn hypot(x: c_double, y: c_double) -> c_double = cmath::hypot,
|
||||
fn ldexp(x: c_double, n: c_int) -> c_double = cmath::ldexp,
|
||||
fn ln_1p(n: c_double) -> c_double = cmath::log1p,
|
||||
fn sinh(n: c_double) -> c_double = cmath::sinh,
|
||||
fn tan(n: c_double) -> c_double = cmath::tan,
|
||||
fn tanh(n: c_double) -> c_double = cmath::tanh
|
||||
)
|
||||
|
||||
// FIXME (#1433): obtain these in a different way
|
||||
@ -307,12 +349,12 @@ impl Primitive for f64 {}
|
||||
impl Float for f64 {
|
||||
#[inline]
|
||||
fn max(self, other: f64) -> f64 {
|
||||
unsafe { cmath::c_double::fmax(self, other) }
|
||||
unsafe { cmath::fmax(self, other) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn min(self, other: f64) -> f64 {
|
||||
unsafe { cmath::c_double::fmin(self, other) }
|
||||
unsafe { cmath::fmin(self, other) }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
|
||||
@ -553,79 +553,6 @@ pub trait Float: Signed + Round + Primitive {
|
||||
fn to_radians(&self) -> Self;
|
||||
}
|
||||
|
||||
/// Returns the exponential of the number, minus `1`, `exp(n) - 1`, in a way
|
||||
/// that is accurate even if the number is close to zero.
|
||||
#[inline(always)] pub fn exp_m1<T: Float>(value: T) -> T { value.exp_m1() }
|
||||
/// Returns the natural logarithm of the number plus `1`, `ln(n + 1)`, more
|
||||
/// accurately than if the operations were performed separately.
|
||||
#[inline(always)] pub fn ln_1p<T: Float>(value: T) -> T { value.ln_1p() }
|
||||
/// Fused multiply-add. Computes `(a * b) + c` with only one rounding error.
|
||||
///
|
||||
/// This produces a more accurate result with better performance (on some
|
||||
/// architectures) than a separate multiplication operation followed by an add.
|
||||
#[inline(always)] pub fn mul_add<T: Float>(a: T, b: T, c: T) -> T { a.mul_add(b, c) }
|
||||
|
||||
/// Raise a number to a power.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// use std::num;
|
||||
///
|
||||
/// let sixteen: f64 = num::powf(2.0, 4.0);
|
||||
/// assert_eq!(sixteen, 16.0);
|
||||
/// ```
|
||||
#[inline(always)] pub fn powf<T: Float>(value: T, n: T) -> T { value.powf(&n) }
|
||||
/// Take the square root of a number.
|
||||
#[inline(always)] pub fn sqrt<T: Float>(value: T) -> T { value.sqrt() }
|
||||
/// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`.
|
||||
#[inline(always)] pub fn rsqrt<T: Float>(value: T) -> T { value.rsqrt() }
|
||||
/// Take the cubic root of a number.
|
||||
#[inline(always)] pub fn cbrt<T: Float>(value: T) -> T { value.cbrt() }
|
||||
/// Calculate the length of the hypotenuse of a right-angle triangle given legs
|
||||
/// of length `x` and `y`.
|
||||
#[inline(always)] pub fn hypot<T: Float>(x: T, y: T) -> T { x.hypot(&y) }
|
||||
/// Sine function.
|
||||
#[inline(always)] pub fn sin<T: Float>(value: T) -> T { value.sin() }
|
||||
/// Cosine function.
|
||||
#[inline(always)] pub fn cos<T: Float>(value: T) -> T { value.cos() }
|
||||
/// Tangent function.
|
||||
#[inline(always)] pub fn tan<T: Float>(value: T) -> T { value.tan() }
|
||||
/// Compute the arcsine of the number.
|
||||
#[inline(always)] pub fn asin<T: Float>(value: T) -> T { value.asin() }
|
||||
/// Compute the arccosine of the number.
|
||||
#[inline(always)] pub fn acos<T: Float>(value: T) -> T { value.acos() }
|
||||
/// Compute the arctangent of the number.
|
||||
#[inline(always)] pub fn atan<T: Float>(value: T) -> T { value.atan() }
|
||||
/// Compute the arctangent with 2 arguments.
|
||||
#[inline(always)] pub fn atan2<T: Float>(x: T, y: T) -> T { x.atan2(&y) }
|
||||
/// Simultaneously computes the sine and cosine of the number.
|
||||
#[inline(always)] pub fn sin_cos<T: Float>(value: T) -> (T, T) { value.sin_cos() }
|
||||
/// Returns `e^(value)`, (the exponential function).
|
||||
#[inline(always)] pub fn exp<T: Float>(value: T) -> T { value.exp() }
|
||||
/// Returns 2 raised to the power of the number, `2^(value)`.
|
||||
#[inline(always)] pub fn exp2<T: Float>(value: T) -> T { value.exp2() }
|
||||
/// Returns the natural logarithm of the number.
|
||||
#[inline(always)] pub fn ln<T: Float>(value: T) -> T { value.ln() }
|
||||
/// Returns the logarithm of the number with respect to an arbitrary base.
|
||||
#[inline(always)] pub fn log<T: Float>(value: T, base: T) -> T { value.log(&base) }
|
||||
/// Returns the base 2 logarithm of the number.
|
||||
#[inline(always)] pub fn log2<T: Float>(value: T) -> T { value.log2() }
|
||||
/// Returns the base 10 logarithm of the number.
|
||||
#[inline(always)] pub fn log10<T: Float>(value: T) -> T { value.log10() }
|
||||
/// Hyperbolic sine function.
|
||||
#[inline(always)] pub fn sinh<T: Float>(value: T) -> T { value.sinh() }
|
||||
/// Hyperbolic cosine function.
|
||||
#[inline(always)] pub fn cosh<T: Float>(value: T) -> T { value.cosh() }
|
||||
/// Hyperbolic tangent function.
|
||||
#[inline(always)] pub fn tanh<T: Float>(value: T) -> T { value.tanh() }
|
||||
/// Inverse hyperbolic sine function.
|
||||
#[inline(always)] pub fn asinh<T: Float>(value: T) -> T { value.asinh() }
|
||||
/// Inverse hyperbolic cosine function.
|
||||
#[inline(always)] pub fn acosh<T: Float>(value: T) -> T { value.acosh() }
|
||||
/// Inverse hyperbolic tangent function.
|
||||
#[inline(always)] pub fn atanh<T: Float>(value: T) -> T { value.atanh() }
|
||||
|
||||
/// A generic trait for converting a value to a number.
|
||||
pub trait ToPrimitive {
|
||||
/// Converts the value of `self` to an `int`.
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user