From 8ca5caf4d936e3193c81c7e9cfa1c6a99717b14a Mon Sep 17 00:00:00 2001 From: Daniel Micay Date: Mon, 31 Mar 2014 07:00:26 -0400 Subject: [PATCH 1/2] num: rm wrapping of `Float` methods as functions 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. --- src/doc/guide-pointers.md | 4 +- src/doc/rust.md | 6 +-- src/doc/tutorial.md | 8 ++-- src/librand/distributions/gamma.rs | 7 ++- src/libstd/num/mod.rs | 73 ------------------------------ 5 files changed, 10 insertions(+), 88 deletions(-) diff --git a/src/doc/guide-pointers.md b/src/doc/guide-pointers.md index 19696b42a37..76e3b521957 100644 --- a/src/doc/guide-pointers.md +++ b/src/doc/guide-pointers.md @@ -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() { diff --git a/src/doc/rust.md b/src/doc/rust.md index 359a9c8052b..0f7dda6b7bc 100644 --- a/src/doc/rust.md +++ b/src/doc/rust.md @@ -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){} 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]); diff --git a/src/doc/tutorial.md b/src/doc/tutorial.md index e15145e5f1d..73c0d0b899a 100644 --- a/src/doc/tutorial.md +++ b/src/doc/tutorial.md @@ -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; diff --git a/src/librand/distributions/gamma.rs b/src/librand/distributions/gamma.rs index 029333cd788..a65f4254080 100644 --- a/src/librand/distributions/gamma.rs +++ b/src/librand/distributions/gamma.rs @@ -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 for GammaSmallShape { fn ind_sample(&self, rng: &mut R) -> f64 { let Open01(u) = rng.gen::>(); - 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 for GammaLargeShape { @@ -160,7 +159,7 @@ impl IndependentSample 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 } } diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index feff0e7e6c0..2c628112957 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -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(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(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(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(value: T, n: T) -> T { value.powf(&n) } -/// Take the square root of a number. -#[inline(always)] pub fn sqrt(value: T) -> T { value.sqrt() } -/// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`. -#[inline(always)] pub fn rsqrt(value: T) -> T { value.rsqrt() } -/// Take the cubic root of a number. -#[inline(always)] pub fn cbrt(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(x: T, y: T) -> T { x.hypot(&y) } -/// Sine function. -#[inline(always)] pub fn sin(value: T) -> T { value.sin() } -/// Cosine function. -#[inline(always)] pub fn cos(value: T) -> T { value.cos() } -/// Tangent function. -#[inline(always)] pub fn tan(value: T) -> T { value.tan() } -/// Compute the arcsine of the number. -#[inline(always)] pub fn asin(value: T) -> T { value.asin() } -/// Compute the arccosine of the number. -#[inline(always)] pub fn acos(value: T) -> T { value.acos() } -/// Compute the arctangent of the number. -#[inline(always)] pub fn atan(value: T) -> T { value.atan() } -/// Compute the arctangent with 2 arguments. -#[inline(always)] pub fn atan2(x: T, y: T) -> T { x.atan2(&y) } -/// Simultaneously computes the sine and cosine of the number. -#[inline(always)] pub fn sin_cos(value: T) -> (T, T) { value.sin_cos() } -/// Returns `e^(value)`, (the exponential function). -#[inline(always)] pub fn exp(value: T) -> T { value.exp() } -/// Returns 2 raised to the power of the number, `2^(value)`. -#[inline(always)] pub fn exp2(value: T) -> T { value.exp2() } -/// Returns the natural logarithm of the number. -#[inline(always)] pub fn ln(value: T) -> T { value.ln() } -/// Returns the logarithm of the number with respect to an arbitrary base. -#[inline(always)] pub fn log(value: T, base: T) -> T { value.log(&base) } -/// Returns the base 2 logarithm of the number. -#[inline(always)] pub fn log2(value: T) -> T { value.log2() } -/// Returns the base 10 logarithm of the number. -#[inline(always)] pub fn log10(value: T) -> T { value.log10() } -/// Hyperbolic sine function. -#[inline(always)] pub fn sinh(value: T) -> T { value.sinh() } -/// Hyperbolic cosine function. -#[inline(always)] pub fn cosh(value: T) -> T { value.cosh() } -/// Hyperbolic tangent function. -#[inline(always)] pub fn tanh(value: T) -> T { value.tanh() } -/// Inverse hyperbolic sine function. -#[inline(always)] pub fn asinh(value: T) -> T { value.asinh() } -/// Inverse hyperbolic cosine function. -#[inline(always)] pub fn acosh(value: T) -> T { value.acosh() } -/// Inverse hyperbolic tangent function. -#[inline(always)] pub fn atanh(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`. From 5e12e1b1a49134f578e1778f4a1216221417bc5e Mon Sep 17 00:00:00 2001 From: Daniel Micay Date: Tue, 1 Apr 2014 05:11:23 -0400 Subject: [PATCH 2/2] remove the cmath module This is an implementation detail of the `f32` and `f64` modules and it should not be public. It renames many functions and leaves out any provided by LLVM intrinsics, so it is not a sensible binding to the C standard library's math library and will never be a stable target. This also removes the abuse of link_name so that this can be switched to using automatically generated definitions in the future. This also removes the `scalbn` binding as it is equivalent to `ldexp` when `FLT_RADIX` is 2, which must always be true for Rust. --- src/libstd/lib.rs | 2 - src/libstd/num/cmath.rs | 151 ---------------------------------------- src/libstd/num/f32.rs | 84 +++++++++++++++------- src/libstd/num/f64.rs | 94 ++++++++++++++++++------- 4 files changed, 126 insertions(+), 205 deletions(-) delete mode 100644 src/libstd/num/cmath.rs diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index c130b89b6d4..d98ceaf9832 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -204,8 +204,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. diff --git a/src/libstd/num/cmath.rs b/src/libstd/num/cmath.rs deleted file mode 100644 index 32864f14c96..00000000000 --- a/src/libstd/num/cmath.rs +++ /dev/null @@ -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 or the MIT license -// , 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; - } -} diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index 99484f41de1..6bae0648a57 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -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] diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index 4029e111b08..4defa452b5c 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -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]