---

yaml
---
r: 109816
b: refs/heads/master
c: 08e95a8
h: refs/heads/master
v: v3

Author: stepancheg

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: e63346b9d8b1a8f38d9a3dbd694cc77b08ffa1e7
+refs/heads/master: 08e95a87b84aad8051ea806c963d089effaf0a7f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: c7fac4471201977fdb1c0c0a26c87287e12dc644
 refs/heads/try: f64fdf524a434f0e5cd0bc91d09c144723f3c90d

trunk/src/doc/guide-pointers.md

@@ -332,6 +332,8 @@ 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,
@@ -341,7 +343,7 @@ fn compute_distance(p1: &Point, p2: &Point) -> f32 {
     let x_d = p1.x - p2.x;
     let y_d = p1.y - p2.y;
 
-    (x_d * x_d + y_d * y_d).sqrt()
+    sqrt(x_d * x_d + y_d * y_d)
 }
 
 fn main() {

trunk/src/doc/rust.md

@@ -826,14 +826,14 @@ Use declarations support a number of convenient shortcuts:
 An example of `use` declarations:
 
 ~~~~
-use std::iter::range_step;
+use std::num::sin;
 use std::option::{Some, None};
 
 # fn foo<T>(_: T){}
 
 fn main() {
-    // Equivalent to 'std::iter::range_step(0, 10, 2);'
-    range_step(0, 10, 2);
+    // Equivalent to 'std::num::sin(1.0);'
+    sin(1.0);
 
     // Equivalent to 'foo(~[std::option::Some(1.0), std::option::None]);'
     foo(~[Some(1.0), None]);

trunk/src/doc/tutorial.md

@@ -504,12 +504,13 @@ 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) => (y / x).atan()
+      (x, y) => atan(y / x)
     }
 }
 ~~~~
@@ -1429,11 +1430,12 @@ 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;
-    (x_d * x_d + y_d * y_d).sqrt()
+    sqrt(x_d * x_d + y_d * y_d)
 }
 ~~~
 
@@ -2301,7 +2303,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;

trunk/src/librand/distributions/gamma.rs

@@ -11,6 +11,7 @@
 //! The Gamma and derived distributions.
 
 use std::num::Float;
+use std::num;
 use {Rng, Open01};
 use super::normal::StandardNormal;
 use super::{IndependentSample, Sample, Exp};
@@ -113,7 +114,7 @@ impl GammaLargeShape {
         GammaLargeShape {
             shape: shape,
             scale: scale,
-            c: 1. / (9. * d).sqrt(),
+            c: 1. / num::sqrt(9. * d),
             d: d
         }
     }
@@ -142,7 +143,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) * u.powf(&self.inv_shape)
+        self.large_shape.ind_sample(rng) * num::powf(u, self.inv_shape)
     }
 }
 impl IndependentSample<f64> for GammaLargeShape {
@@ -159,7 +160,7 @@ impl IndependentSample<f64> for GammaLargeShape {
 
             let x_sqr = x * x;
             if u < 1.0 - 0.0331 * x_sqr * x_sqr ||
-                u.ln() < 0.5 * x_sqr + self.d * (1.0 - v + v.ln()) {
+                num::ln(u) < 0.5 * x_sqr + self.d * (1.0 - v + num::ln(v)) {
                 return self.d * v * self.scale
             }
         }

trunk/src/libstd/lib.rs

@@ -206,6 +206,8 @@ 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.

trunk/src/libstd/num/cmath.rs

@@ -0,0 +1,151 @@
+// 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;
+    }
+}

trunk/src/libstd/num/f32.rs

@@ -14,6 +14,7 @@
 
 use prelude::*;
 
+use cmath;
 use default::Default;
 use from_str::FromStr;
 use libc::{c_float, c_int};
@@ -22,46 +23,6 @@ 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(
     (
         $(
@@ -105,22 +66,29 @@ delegate!(
     fn nearbyint(n: f32) -> f32 = intrinsics::nearbyintf32,
     fn round(n: f32) -> f32 = intrinsics::roundf32,
 
-    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
+    // 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
 )
 
 // FIXME(#11621): These constants should be deprecated once CTFE is implemented
@@ -340,12 +308,12 @@ impl Primitive for f32 {}
 impl Float for f32 {
     #[inline]
     fn max(self, other: f32) -> f32 {
-        unsafe { cmath::fmaxf(self, other) }
+        unsafe { cmath::c_float::fmax(self, other) }
     }
 
     #[inline]
     fn min(self, other: f32) -> f32 {
-        unsafe { cmath::fminf(self, other) }
+        unsafe { cmath::c_float::fmin(self, other) }
     }
 
     #[inline]