From 817dec99aafdcf3ea4657128007707f9e8645d16 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Wed, 4 Mar 2015 09:45:19 -0800 Subject: [PATCH] Remove usage of deprecated apis --- src/bigint.rs | 94 ++++++++++++++++++++++++------------------------- src/iter.rs | 4 +-- src/rational.rs | 4 +-- 3 files changed, 51 insertions(+), 51 deletions(-) diff --git a/src/bigint.rs b/src/bigint.rs index 7b79166..7f92a57 100644 --- a/src/bigint.rs +++ b/src/bigint.rs @@ -765,12 +765,12 @@ macro_rules! impl_to_biguint { } } -impl_to_biguint!(isize, FromPrimitive::from_int); +impl_to_biguint!(isize, FromPrimitive::from_isize); impl_to_biguint!(i8, FromPrimitive::from_i8); impl_to_biguint!(i16, FromPrimitive::from_i16); impl_to_biguint!(i32, FromPrimitive::from_i32); impl_to_biguint!(i64, FromPrimitive::from_i64); -impl_to_biguint!(usize, FromPrimitive::from_uint); +impl_to_biguint!(usize, FromPrimitive::from_usize); impl_to_biguint!(u8, FromPrimitive::from_u8); impl_to_biguint!(u16, FromPrimitive::from_u16); impl_to_biguint!(u32, FromPrimitive::from_u32); @@ -790,11 +790,11 @@ fn to_str_radix(me: &BigUint, radix: u32) -> String { let mut m = n.clone(); while m >= divider { let (d, m0) = m.div_mod_floor(÷r); - result.push(m0.to_uint().unwrap() as BigDigit); + result.push(m0.to_usize().unwrap() as BigDigit); m = d; } if !m.is_zero() { - result.push(m.to_uint().unwrap() as BigDigit); + result.push(m.to_usize().unwrap() as BigDigit); } return result; } @@ -839,7 +839,7 @@ impl FromStrRadix for BigUint { loop { let start = cmp::max(end, unit_len) - unit_len; let d = try!(FromStrRadix::from_str_radix(&s[start .. end], radix)); - let d: Option = FromPrimitive::from_uint(d); + let d: Option = FromPrimitive::from_usize(d); match d { Some(d) => { // FIXME(#5992): assignment operator overloads @@ -1516,12 +1516,12 @@ macro_rules! impl_to_bigint { } } -impl_to_bigint!(isize, FromPrimitive::from_int); +impl_to_bigint!(isize, FromPrimitive::from_isize); impl_to_bigint!(i8, FromPrimitive::from_i8); impl_to_bigint!(i16, FromPrimitive::from_i16); impl_to_bigint!(i32, FromPrimitive::from_i32); impl_to_bigint!(i64, FromPrimitive::from_i64); -impl_to_bigint!(usize, FromPrimitive::from_uint); +impl_to_bigint!(usize, FromPrimitive::from_usize); impl_to_bigint!(u8, FromPrimitive::from_u8); impl_to_bigint!(u16, FromPrimitive::from_u16); impl_to_bigint!(u32, FromPrimitive::from_u32); @@ -2474,9 +2474,9 @@ mod biguint_tests { #[test] fn test_gcd() { fn check(a: usize, b: usize, c: usize) { - let big_a: BigUint = FromPrimitive::from_uint(a).unwrap(); - let big_b: BigUint = FromPrimitive::from_uint(b).unwrap(); - let big_c: BigUint = FromPrimitive::from_uint(c).unwrap(); + let big_a: BigUint = FromPrimitive::from_usize(a).unwrap(); + let big_b: BigUint = FromPrimitive::from_usize(b).unwrap(); + let big_c: BigUint = FromPrimitive::from_usize(c).unwrap(); assert_eq!(big_a.gcd(&big_b), big_c); } @@ -2491,9 +2491,9 @@ mod biguint_tests { #[test] fn test_lcm() { fn check(a: usize, b: usize, c: usize) { - let big_a: BigUint = FromPrimitive::from_uint(a).unwrap(); - let big_b: BigUint = FromPrimitive::from_uint(b).unwrap(); - let big_c: BigUint = FromPrimitive::from_uint(c).unwrap(); + let big_a: BigUint = FromPrimitive::from_usize(a).unwrap(); + let big_b: BigUint = FromPrimitive::from_usize(b).unwrap(); + let big_c: BigUint = FromPrimitive::from_usize(c).unwrap(); assert_eq!(big_a.lcm(&big_b), big_c); } @@ -2620,8 +2620,8 @@ mod biguint_tests { let mut f: BigUint = One::one(); for i in range(2, n + 1) { // FIXME(#5992): assignment operator overloads - // f *= FromPrimitive::from_uint(i); - let bu: BigUint = FromPrimitive::from_uint(i).unwrap(); + // f *= FromPrimitive::from_usize(i); + let bu: BigUint = FromPrimitive::from_usize(i).unwrap(); f = f * bu; } return f; @@ -2644,11 +2644,11 @@ mod biguint_tests { #[test] fn test_bits() { assert_eq!(BigUint::new(vec!(0,0,0,0)).bits(), 0); - let n: BigUint = FromPrimitive::from_uint(0).unwrap(); + let n: BigUint = FromPrimitive::from_usize(0).unwrap(); assert_eq!(n.bits(), 0); - let n: BigUint = FromPrimitive::from_uint(1).unwrap(); + let n: BigUint = FromPrimitive::from_usize(1).unwrap(); assert_eq!(n.bits(), 1); - let n: BigUint = FromPrimitive::from_uint(3).unwrap(); + let n: BigUint = FromPrimitive::from_usize(3).unwrap(); assert_eq!(n.bits(), 2); let n: BigUint = FromStrRadix::from_str_radix("4000000000", 16).unwrap(); assert_eq!(n.bits(), 39); @@ -2668,13 +2668,13 @@ mod biguint_tests { let mut rng = thread_rng(); for _ in range(0, 10) { - assert_eq!(rng.gen_bigint_range(&FromPrimitive::from_uint(236).unwrap(), - &FromPrimitive::from_uint(237).unwrap()), - FromPrimitive::from_uint(236).unwrap()); + assert_eq!(rng.gen_bigint_range(&FromPrimitive::from_usize(236).unwrap(), + &FromPrimitive::from_usize(237).unwrap()), + FromPrimitive::from_usize(236).unwrap()); } - let l = FromPrimitive::from_uint(403469000 + 2352).unwrap(); - let u = FromPrimitive::from_uint(403469000 + 3513).unwrap(); + let l = FromPrimitive::from_usize(403469000 + 2352).unwrap(); + let u = FromPrimitive::from_usize(403469000 + 3513).unwrap(); for _ in range(0, 1000) { let n: BigUint = rng.gen_biguint_below(&u); assert!(n < u); @@ -2688,16 +2688,16 @@ mod biguint_tests { #[test] #[should_fail] fn test_zero_rand_range() { - thread_rng().gen_biguint_range(&FromPrimitive::from_uint(54).unwrap(), - &FromPrimitive::from_uint(54).unwrap()); + thread_rng().gen_biguint_range(&FromPrimitive::from_usize(54).unwrap(), + &FromPrimitive::from_usize(54).unwrap()); } #[test] #[should_fail] fn test_negative_rand_range() { let mut rng = thread_rng(); - let l = FromPrimitive::from_uint(2352).unwrap(); - let u = FromPrimitive::from_uint(3513).unwrap(); + let l = FromPrimitive::from_usize(2352).unwrap(); + let u = FromPrimitive::from_usize(3513).unwrap(); // Switching u and l should fail: let _n: BigUint = rng.gen_biguint_range(&u, &l); } @@ -2725,8 +2725,8 @@ mod bigint_tests { #[test] fn test_from_biguint() { fn check(inp_s: Sign, inp_n: usize, ans_s: Sign, ans_n: usize) { - let inp = BigInt::from_biguint(inp_s, FromPrimitive::from_uint(inp_n).unwrap()); - let ans = BigInt { sign: ans_s, data: FromPrimitive::from_uint(ans_n).unwrap()}; + let inp = BigInt::from_biguint(inp_s, FromPrimitive::from_usize(inp_n).unwrap()); + let ans = BigInt { sign: ans_s, data: FromPrimitive::from_usize(ans_n).unwrap()}; assert_eq!(inp, ans); } check(Plus, 1, Plus, 1); @@ -3231,9 +3231,9 @@ mod bigint_tests { #[test] fn test_gcd() { fn check(a: isize, b: isize, c: isize) { - let big_a: BigInt = FromPrimitive::from_int(a).unwrap(); - let big_b: BigInt = FromPrimitive::from_int(b).unwrap(); - let big_c: BigInt = FromPrimitive::from_int(c).unwrap(); + let big_a: BigInt = FromPrimitive::from_isize(a).unwrap(); + let big_b: BigInt = FromPrimitive::from_isize(b).unwrap(); + let big_c: BigInt = FromPrimitive::from_isize(c).unwrap(); assert_eq!(big_a.gcd(&big_b), big_c); } @@ -3251,9 +3251,9 @@ mod bigint_tests { #[test] fn test_lcm() { fn check(a: isize, b: isize, c: isize) { - let big_a: BigInt = FromPrimitive::from_int(a).unwrap(); - let big_b: BigInt = FromPrimitive::from_int(b).unwrap(); - let big_c: BigInt = FromPrimitive::from_int(c).unwrap(); + let big_a: BigInt = FromPrimitive::from_isize(a).unwrap(); + let big_b: BigInt = FromPrimitive::from_isize(b).unwrap(); + let big_c: BigInt = FromPrimitive::from_isize(c).unwrap(); assert_eq!(big_a.lcm(&big_b), big_c); } @@ -3280,7 +3280,7 @@ mod bigint_tests { let zero: BigInt = Zero::zero(); assert_eq!(one.abs_sub(&zero), one); let one: BigInt = One::one(); - let two: BigInt = FromPrimitive::from_int(2).unwrap(); + let two: BigInt = FromPrimitive::from_isize(2).unwrap(); assert_eq!(one.abs_sub(&-&one), two); } @@ -3288,7 +3288,7 @@ mod bigint_tests { fn test_from_str_radix() { fn check(s: &str, ans: Option) { let ans = ans.map(|n| { - let x: BigInt = FromPrimitive::from_int(n).unwrap(); + let x: BigInt = FromPrimitive::from_isize(n).unwrap(); x }); assert_eq!(FromStrRadix::from_str_radix(s, 10).ok(), ans); @@ -3330,9 +3330,9 @@ mod bigint_tests { let mut rng = thread_rng(); for _ in range(0, 10) { - assert_eq!(rng.gen_bigint_range(&FromPrimitive::from_uint(236).unwrap(), - &FromPrimitive::from_uint(237).unwrap()), - FromPrimitive::from_uint(236).unwrap()); + assert_eq!(rng.gen_bigint_range(&FromPrimitive::from_usize(236).unwrap(), + &FromPrimitive::from_usize(237).unwrap()), + FromPrimitive::from_usize(236).unwrap()); } fn check(l: BigInt, u: BigInt) { @@ -3343,8 +3343,8 @@ mod bigint_tests { assert!(n < u); } } - let l: BigInt = FromPrimitive::from_uint(403469000 + 2352).unwrap(); - let u: BigInt = FromPrimitive::from_uint(403469000 + 3513).unwrap(); + let l: BigInt = FromPrimitive::from_usize(403469000 + 2352).unwrap(); + let u: BigInt = FromPrimitive::from_usize(403469000 + 3513).unwrap(); check( l.clone(), u.clone()); check(-l.clone(), u.clone()); check(-u.clone(), -l.clone()); @@ -3353,16 +3353,16 @@ mod bigint_tests { #[test] #[should_fail] fn test_zero_rand_range() { - thread_rng().gen_bigint_range(&FromPrimitive::from_int(54).unwrap(), - &FromPrimitive::from_int(54).unwrap()); + thread_rng().gen_bigint_range(&FromPrimitive::from_isize(54).unwrap(), + &FromPrimitive::from_isize(54).unwrap()); } #[test] #[should_fail] fn test_negative_rand_range() { let mut rng = thread_rng(); - let l = FromPrimitive::from_uint(2352).unwrap(); - let u = FromPrimitive::from_uint(3513).unwrap(); + let l = FromPrimitive::from_usize(2352).unwrap(); + let u = FromPrimitive::from_usize(3513).unwrap(); // Switching u and l should fail: let _n: BigInt = rng.gen_bigint_range(&u, &l); } @@ -3382,7 +3382,7 @@ mod bench { fn factorial(n: usize) -> BigUint { let mut f: BigUint = One::one(); for i in iter::range_inclusive(1, n) { - let bu: BigUint = FromPrimitive::from_uint(i).unwrap(); + let bu: BigUint = FromPrimitive::from_usize(i).unwrap(); f = f * bu; } f diff --git a/src/iter.rs b/src/iter.rs index dd67fc5..41c6aec 100644 --- a/src/iter.rs +++ b/src/iter.rs @@ -70,7 +70,7 @@ impl Iterator for Range Some(a) => { let sz = self.stop.to_i64().map(|b| b.checked_sub(a)); match sz { - Some(Some(bound)) => bound.to_uint(), + Some(Some(bound)) => bound.to_usize(), _ => None, } }, @@ -78,7 +78,7 @@ impl Iterator for Range Some(a) => { let sz = self.stop.to_u64().map(|b| b.checked_sub(a)); match sz { - Some(Some(bound)) => bound.to_uint(), + Some(Some(bound)) => bound.to_usize(), _ => None } }, diff --git a/src/rational.rs b/src/rational.rs index 939306e..9dcbaca 100644 --- a/src/rational.rs +++ b/src/rational.rs @@ -496,8 +496,8 @@ mod test { pub fn to_big(n: Rational) -> BigRational { Ratio::new( - FromPrimitive::from_int(n.numer).unwrap(), - FromPrimitive::from_int(n.denom).unwrap() + FromPrimitive::from_isize(n.numer).unwrap(), + FromPrimitive::from_isize(n.denom).unwrap() ) }