---

yaml
---
r: 97845
b: refs/heads/snap-stage3
c: 3830a3b
h: refs/heads/master
i:
  97843: 7c8e4b6
v: v3

Author: flaper87

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: aaf8ba7c51011570e7a6bb350345c23378c4152c
+refs/heads/snap-stage3: 3830a3b4f2559165a89847320d277ef827dd1da9
 refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libextra/json.rs

@@ -688,7 +688,7 @@ impl<T : Iterator<char>> Parser<T> {
             }
         }
 
-        let exp: f64 = num::pow_with_uint(10u, exp);
+        let exp: f64 = num::pow(10u as f64, exp);
         if neg_exp {
             res /= exp;
         } else {

branches/snap-stage3/src/libstd/num/mod.rs

@@ -993,37 +993,6 @@ pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: uint) -> Option<T> {
     FromStrRadix::from_str_radix(str, radix)
 }
 
-/// Calculates a power to a given radix, optimized for uint `pow` and `radix`.
-///
-/// Returns `radix^pow` as `T`.
-///
-/// Note:
-/// Also returns `1` for `0^0`, despite that technically being an
-/// undefined number. The reason for this is twofold:
-/// - If code written to use this function cares about that special case, it's
-///   probably going to catch it before making the call.
-/// - If code written to use this function doesn't care about it, it's
-///   probably assuming that `x^0` always equals `1`.
-///
-pub fn pow_with_uint<T:NumCast+One+Zero+Div<T,T>+Mul<T,T>>(radix: uint, pow: uint) -> T {
-    let _0: T = Zero::zero();
-    let _1: T = One::one();
-
-    if pow   == 0u { return _1; }
-    if radix == 0u { return _0; }
-    let mut my_pow     = pow;
-    let mut total      = _1;
-    let mut multiplier = cast(radix).unwrap();
-    while (my_pow > 0u) {
-        if my_pow % 2u == 1u {
-            total = total * multiplier;
-        }
-        my_pow = my_pow / 2u;
-        multiplier = multiplier * multiplier;
-    }
-    total
-}
-
 impl<T: Zero + 'static> Zero for @T {
     fn zero() -> @T { @Zero::zero() }
     fn is_zero(&self) -> bool { (**self).is_zero() }
@@ -1698,10 +1667,4 @@ mod bench {
         let v = vec::from_fn(1024, |n| n);
         b.iter(|| {v.iter().fold(0, |old, new| num::pow(old, *new));});
     }
-
-    #[bench]
-    fn bench_pow_with_uint_function(b: &mut BenchHarness) {
-        let v = vec::from_fn(1024, |n| n);
-        b.iter(|| {v.iter().fold(0, |old, new| num::pow_with_uint(old, *new));});
-    }
 }

branches/snap-stage3/src/libstd/num/strconv.rs

@@ -20,7 +20,8 @@ use str::{StrSlice};
 use str;
 use vec::{CopyableVector, ImmutableVector, MutableVector};
 use vec::OwnedVector;
-use num::{NumCast, Zero, One, cast, pow_with_uint, Integer};
+use num;
+use num::{NumCast, Zero, One, cast, Integer};
 use num::{Round, Float, FPNaN, FPInfinite, ToPrimitive};
 
 pub enum ExponentFormat {
@@ -648,10 +649,10 @@ pub fn from_str_bytes_common<T:NumCast+Zero+One+Eq+Ord+Div<T,T>+
 
     if exp_found {
         let c = buf[i] as char;
-        let base = match (c, exponent) {
+        let base: T = match (c, exponent) {
             // c is never _ so don't need to handle specially
-            ('e', ExpDec) | ('E', ExpDec) => 10u,
-            ('p', ExpBin) | ('P', ExpBin) => 2u,
+            ('e', ExpDec) | ('E', ExpDec) => cast(10u).unwrap(),
+            ('p', ExpBin) | ('P', ExpBin) => cast(2u).unwrap(),
             _ => return None // char doesn't fit given exponent format
         };
 
@@ -664,9 +665,9 @@ pub fn from_str_bytes_common<T:NumCast+Zero+One+Eq+Ord+Div<T,T>+
         match exp {
             Some(exp_pow) => {
                 multiplier = if exp_pow < 0 {
-                    _1 / pow_with_uint::<T>(base, (-exp_pow.to_int().unwrap()) as uint)
+                    _1 / num::pow(base, (-exp_pow.to_int().unwrap()) as uint)
                 } else {
-                    pow_with_uint::<T>(base, exp_pow.to_int().unwrap() as uint)
+                    num::pow(base, exp_pow.to_int().unwrap() as uint)
                 }
             }
             None => return None // invalid exponent -> invalid number