core: Remove the nearly empty math module

This mod only had two functions, all of whose users have been changed
to use the uint module.

src/fuzzer/fuzzer.rs

@@ -254,9 +254,9 @@ fn check_variants_T<T: copy>(
     let L = vec::len(things);
 
     if L < 100u {
-        under(math::min(L, 20u)) {|i|
+        under(uint::min(L, 20u)) {|i|
             log(error, "Replacing... #" + uint::str(i));
-            under(math::min(L, 30u)) {|j|
+            under(uint::min(L, 30u)) {|j|
                 log(error, "With... " + stringifier(@things[j]));
                 let crate2 = @replacer(crate, i, things[j], cx.mode);
                 // It would be best to test the *crate* for stability, but testing the

src/libcore/core.rc

@@ -34,7 +34,7 @@ export either, option, result, iter;
 export libc, os, ctypes, sys, unsafe, logging;
 export comm, task, future;
 export extfmt;
-export math, bessel;
+export bessel;
 export tuple;
 export to_str;
 
@@ -84,7 +84,6 @@ mod os;
 mod path;
 
 mod ctypes;
-mod math;
 mod cmath;
 mod sys;
 mod unsafe;

src/libcore/math.rs

-#[doc = "
-Generic functions that have been defined for all numeric types
-
-(may very well go away again soon)
-"];
-
-#[doc = "Returns the minimum of two values"]
-pure fn min<T: copy>(x: T, y: T) -> T { if x < y { x } else { y} }
-
-#[doc = "Returns the maximum of two values"]
-pure fn max<T: copy>(x: T, y: T) -> T { if x < y { y } else { x } }
-
-#[test]
-fn test_max_min() {
-    assert max(0, 1) == 1;
-    assert min(0, 1) == 0;
-    assert max(0, -1) == 0;
-    assert min(0, -1) == -1;
-    assert max(0.0, 1.0) == 1.0;
-    assert min(0.0, 1.0) == 0.0;
-}
-
-// FIXME use macros to execute the tests below for all float types
-
-/*
-#[test]
-fn test_trig() {
-    assert sin(0.0) == 0.0;
-    assert sin(-0.0) == 0.0;
-
-    assert float::isNaN(sin(float::infinity));
-    assert float::isNaN(sin(float::neg_infinity));
-
-    assert cos(0.0) == 1.0;
-    assert cos(-0.0) == 1.0;
-    assert float::isNaN(cos(float::infinity));
-    assert float::isNaN(cos(float::neg_infinity));
-
-    assert tan(0.0) == 0.0;
-    assert tan(-0.0) == 0.0;;
-    assert float::isNaN(tan(float::infinity));
-    assert float::isNaN(tan(float::neg_infinity));
-}
-
-#[test]
-fn test_inv_trig() {
-    assert asin(0.0) == 0.0;
-    assert asin(-0.0) == -0.0;
-    assert float::isNaN(asin(1.1));
-    assert float::isNaN(asin(-1.1));
-
-    assert acos(1.0) == 0.0;
-    assert float::isNaN(acos(1.1));
-    assert float::isNaN(acos(-1.1));
-
-    assert atan(0.0) == 0.0;
-    assert atan(-0.0) == 0.0;
-    assert atan(float::infinity) == consts::frac_pi_2;
-    assert atan(float::neg_infinity) == - consts::frac_pi_2;
-
-    assert atan2(0.0, -0.0) == consts::pi;
-    assert atan2(-0.0, -0.0) == -consts::pi;
-
-    assert atan2(0.0, 0.0) == 0.0;
-    assert atan2(-0.0, 0.0) == -0.0;
-
-    assert atan2(0.0, -1.0) == consts::pi;
-    assert atan2(-0.0, -1.0) == -consts::pi;
-
-    assert atan2(0.0, 1.0) == 0.0;
-    assert atan2(-0.0, 1.0) == -0.0;
-
-    assert atan2(1.0, 0.0) == consts::frac_pi_2;
-    assert atan2(1.0, -0.0) == consts::frac_pi_2;
-}
-
-// FIXME (1222): The commented-out tests give different results on windows
-#[test]
-fn test_pow() {
-    assert pow(2.0, 4.0) == 16.0;
-
-    assert pow(0.0, -3.0) == float::infinity;
-    assert pow(-0.0, -3.0) == float::neg_infinity;
-
-    assert pow(0.0, -4.0) == float::infinity;
-    assert pow(-0.0, -4.0) == float::infinity;
-
-    assert pow(0.0, 3.0) == 0.0;
-    assert pow(-0.0, 3.0) == -0.0;
-    assert pow(0.0, 4.0) == 0.0;
-    assert pow(-0.0, 4.0) == 0.0;
-
-    assert pow(-1.0, float::infinity) == 1.0;
-    //assert pow(-1.0, float::neg_infinity) == 1.0;
-
-    assert pow(1.0, 4.0) == 1.0;
-    assert pow(1.0, 0.0) == 1.0;
-    assert pow(1.0, -0.0) == 1.0;
-    //assert pow(1.0, float::NaN) == 1.0;
-    assert pow(1.0, float::infinity) == 1.0;
-    //assert pow(1.0, float::neg_infinity) == 1.0;
-    assert pow(1.0, -3.0) == 1.0;
-    assert pow(1.0, -4.0) == 1.0;
-
-    assert pow(4.0, 0.0) == 1.0;
-    assert pow(0.0, 0.0) == 1.0;
-    assert pow(-0.0, 0.0) == 1.0;
-    //assert pow(float::NaN, 0.0) == 1.0;
-    assert pow(float::infinity, 0.0) == 1.0;
-    assert pow(float::neg_infinity, 0.0) == 1.0;
-    assert pow(-3.0, 0.0) == 1.0;
-    assert pow(-4.0, 0.0) == 1.0;
-
-    assert pow(4.0, -0.0) == 1.0;
-    assert pow(0.0, -0.0) == 1.0;
-    assert pow(-0.0, -0.0) == 1.0;
-    //assert pow(float::NaN, -0.0) == 1.0;
-    assert pow(float::infinity, -0.0) == 1.0;
-    assert pow(float::neg_infinity, -0.0) == 1.0;
-    assert pow(-3.0, -0.0) == 1.0;
-    assert pow(-4.0, -0.0) == 1.0;
-
-    assert float::isNaN(pow(-1.0, -1.5));
-    assert float::isNaN(pow(-1.0, 1.5));
-
-    assert float::isNaN(pow(-1.2, -1.5));
-    assert float::isNaN(pow(-1.2, 1.5));
-
-    assert pow(0.5, float::neg_infinity) == float::infinity;
-    assert pow(-0.5, float::neg_infinity) == float::infinity;
-
-    assert pow(1.5, float::neg_infinity) == 0.0;
-    assert pow(-1.5, float::neg_infinity) == 0.0;
-
-    assert pow(0.5, float::infinity) == 0.0;
-    assert pow(-0.5, float::infinity) == 0.0;
-
-    assert pow(-1.5, float::infinity) == float::infinity;
-    assert pow(1.5, float::infinity) == float::infinity;
-
-    assert pow(float::neg_infinity, -3.0) == -0.0;
-    assert pow(float::neg_infinity, -4.0) == 0.0;
-
-    assert pow(float::neg_infinity, 3.0) == float::neg_infinity;
-    assert pow(float::neg_infinity, 4.0) == float::infinity;
-
-    assert pow(float::infinity, -16.0) == 0.0;
-    assert pow(float::infinity, 16.0) == float::infinity;
-}
-
-// FIXME (1222): The commented-out tests give different results on windows
-#[test]
-fn test_exp_and_mod() {
-    assert exp(0.0) == 1.0;
-    assert exp(-0.0) == 1.0;
-    assert exp(float::neg_infinity) == 0.0;
-    assert exp(float::infinity) == float::infinity;
-
-    let d1: c_int = 1 as c_int;
-    assert frexp(0.0, d1) == 0.0;
-    assert frexp(-0.0, d1) == 0.0;
-    //assert frexp(float::infinity, d1) == float::infinity;
-    //assert frexp(float::neg_infinity, d1) == float::neg_infinity;
-    assert float::isNaN(frexp(float::NaN, d1));
-
-    let d2: float = 1.0;
-    assert modf(float::infinity, d2) == 0.0;
-    assert d2 == float::infinity;
-    assert modf(float::neg_infinity, d2) == -0.0;
-    assert d2 == float::neg_infinity;
-    assert float::isNaN(modf(float::NaN, d2));
-    assert float::isNaN(d2);
-}
-
-#[test]
-fn test_round_and_abs() {
-    assert abs(0.0) == 0.0;
-    assert abs(-0.0) == 0.0;
-    assert abs(float::infinity) == float::infinity;
-    assert abs(float::neg_infinity) == float::infinity;
-
-    assert abs(-2.5) == 2.5;
-    assert abs(2.5) == 2.5;
-
-    assert ceil(0.0) == 0.0;
-    assert ceil(-0.0) == -0.0;
-    assert ceil(float::infinity) == float::infinity;
-    assert ceil(float::neg_infinity) == float::neg_infinity;
-
-    assert ceil(1.9) == 2.0;
-    assert ceil(-1.9) == -1.0;
-
-    assert floor(0.0) == 0.0;
-    assert floor(-0.0) == -0.0;
-    assert floor(float::infinity) == float::infinity;
-    assert floor(float::neg_infinity) == float::neg_infinity;
-
-    assert floor(1.9) == 1.0;
-    assert floor(-1.9) == -2.0;
-
-    assert trunc(0.0) == 0.0;
-    assert trunc(-0.0) == -0.0;
-    assert trunc(float::infinity) == float::infinity;
-    assert trunc(float::neg_infinity) == float::neg_infinity;
-
-    assert trunc(1.5) == 1.0;
-    assert trunc(1.2) == 1.0;
-    assert trunc(1.0) == 1.0;
-    assert trunc(1.9) == 1.0;
-    assert trunc(-1.5) == -1.0;
-    assert trunc(-1.2) == -1.0;
-    assert trunc(-1.0) == -1.0;
-    assert trunc(-1.9) == -1.0;
-
-    assert round(0.0) == 0.0;
-    assert round(-0.0) == -0.0;
-    assert round(float::infinity) == float::infinity;
-    assert round(float::neg_infinity) == float::neg_infinity;
-
-    assert rint(0.0) == 0.0;
-    assert rint(-0.0) == -0.0;
-    assert rint(float::infinity) == float::infinity;
-    assert rint(float::neg_infinity) == float::neg_infinity;
-}
-
-#[test]
-fn test_hyp_trig() {
-    assert sinh(0.0) == 0.0;
-    assert sinh(-0.0) == 0.0;
-    assert sinh(float::infinity) == float::infinity;
-    assert sinh(float::neg_infinity) == float::neg_infinity;
-
-    assert cosh(0.0) == 1.0;
-    assert cosh(-0.0) == 1.0;
-    assert cosh(float::infinity) == float::infinity;
-    assert cosh(float::neg_infinity) == float::infinity;
-
-    assert tanh(0.0) == 0.0;
-    assert tanh(-0.0) == 0.0;
-    assert tanh(float::infinity) == 1.0;
-    assert tanh(float::neg_infinity) == -1.0;
-}
-
-#[test]
-fn test_sqrt() {
-    assert sqrt(9.0) == 3.0;
-    assert sqrt(4.0) == 2.0;
-    assert sqrt(1.0) == 1.0;
-    assert sqrt(0.0) == 0.0;
-}
-
-
-#[test]
-fn test_angle() {
-    fn angle(vec: (float, float)) -> float {
-        alt vec {
-          (0f, y) if y < 0f { 1.5 * consts::pi }
-          (0f, y) { 0.5 * consts::pi }
-          (x, y) { float::atan(y / x) }
-        }
-    }
-    assert angle((1f, 0f)) == 0f;
-    assert angle((1f, 1f)) == 0.25 * consts::pi;
-    assert angle((0f, 1f)) == 0.5 * consts::pi;
-}
-
-
-#[test]
-fn test_log_functions() {
-    assert ln(1.0) == 0.0;
-    assert log2(1.0) == 0.0;
-    assert log10(1.0) == 0.0;
-
-    // FIXME remove round-up due to valgrind weirdness
-    assert ceil(ln(consts::e)) == 1.0; /* ln(e) == 0.999.. under valgrind */
-    assert log2(2.0) == 1.0;
-    assert log10(10.0) == 1.0;
-
-    // FIXME remove round-up due to valgrind weirdness
-    assert ceil(ln(consts::e*consts::e*consts::e*consts::e)) == 4.0;
-    assert log2(256.0) == 8.0;
-    assert log10(1000.0) == 3.0;
-
-    assert ln(0.0) == float::neg_infinity;
-    assert log2(0.0) == float::neg_infinity;
-    assert log10(0.0) == float::neg_infinity;
-
-    assert ln(-0.0) == float::neg_infinity;
-    assert log2(-0.0) == float::neg_infinity;
-    assert log10(-0.0) == float::neg_infinity;
-
-    assert float::isNaN(ln(-1.0));
-    assert float::isNaN(log2(-1.0));
-    assert float::isNaN(log10(-1.0));
-
-    assert ln(float::infinity) == float::infinity;
-    assert log2(float::infinity) == float::infinity;
-    assert log10(float::infinity) == float::infinity;
-
-    assert ln1p(0.0) == 0.0;
-    assert ln1p(-0.0) == 0.0;
-    assert ln1p(-1.0) == float::neg_infinity;
-    assert float::isNaN(ln1p(-2.0f));
-    assert ln1p(float::infinity) == float::infinity;
-}
-
-*/

src/libcore/vec.rs

@@ -912,7 +912,7 @@ mod u8 {
     pure fn cmp(&&a: [u8], &&b: [u8]) -> int unsafe {
         let a_len = len(a);
         let b_len = len(b);
-        let n = math::min(a_len, b_len) as ctypes::size_t;
+        let n = uint::min(a_len, b_len) as ctypes::size_t;
         let r = libc::memcmp(unsafe::to_ptr(a) as *libc::c_void,
                              unsafe::to_ptr(b) as *libc::c_void, n) as int;
 

src/libstd/rope.rs

@@ -1006,7 +1006,7 @@ fn concat2(left: @node, right: @node) -> @node {
                      right   : right,
              char_len: char_len(left) + char_len(right),
                      byte_len: byte_len(left) + byte_len(right),
-             height: math::max(height(left), height(right)) + 1u
+             height: uint::max(height(left), height(right)) + 1u
                     })
     }
 

src/rustc/back/rpath.rs

@@ -129,7 +129,7 @@ fn get_relative_to(abs1: fs::path, abs2: fs::path) -> fs::path {
     assert len1 > 0u;
     assert len2 > 0u;
 
-    let max_common_path = math::min(len1, len2) - 1u;
+    let max_common_path = uint::min(len1, len2) - 1u;
     let start_idx = 0u;
     while start_idx < max_common_path
         && split1[start_idx] == split2[start_idx] {

src/rustc/middle/ty.rs

@@ -1568,7 +1568,7 @@ fn union(cx: @uctxt, set_a: uint, set_b: uint,
             _ { cx.tcx.sess.bug("someone forgot to document an invariant \
                          in union"); }
         };
-        ufind::grow(vb.sets, math::max(set_a, set_b) + 1u);
+        ufind::grow(vb.sets, uint::max(set_a, set_b) + 1u);
         let root_a = ufind::find(vb.sets, set_a);
         let root_b = ufind::find(vb.sets, set_b);
 

src/rustc/util/common.rs

-import math::{max, min};
 import std::map::hashmap;
 import syntax::ast;
 import ast::{ty, pat};

src/rustdoc/unindent_pass.rs

@@ -57,7 +57,7 @@ fn unindent(s: str) -> str {
                     false
                 }
             };
-            math::min(min_indent, spaces)
+            uint::min(min_indent, spaces)
         }
     };