SignNeg
}
-static DIGIT_E_RADIX: uint = ('e' as uint) - ('a' as uint) + 11;
+static DIGIT_E_RADIX: u32 = ('e' as u32) - ('a' as u32) + 11;
/// Converts a number to its string representation as a byte vector.
/// This is meant to be a common base implementation for all numeric string
/// between digit and exponent sign `'p'`.
pub fn float_to_str_bytes_common<T: Float, U, F>(
num: T,
- radix: uint,
+ radix: u32,
negative_zero: bool,
sign: SignFormat,
digits: SignificantDigits,
deccum = deccum / radix_gen;
deccum = deccum.trunc();
- let c = char::from_digit(current_digit.to_int().unwrap() as uint, radix);
+ let c = char::from_digit(current_digit.to_int().unwrap() as u32, radix);
buf[end] = c.unwrap() as u8;
end += 1;
// See note in first loop.
let current_digit = deccum.trunc().abs();
- let c = char::from_digit(current_digit.to_int().unwrap() as uint,
+ let c = char::from_digit(current_digit.to_int().unwrap() as u32,
radix);
buf[end] = c.unwrap() as u8;
end += 1;
let ascii2value = |chr: u8| {
(chr as char).to_digit(radix).unwrap()
};
- let value2ascii = |val: uint| {
+ let value2ascii = |val: u32| {
char::from_digit(val, radix).unwrap() as u8
};
#[unstable(feature = "core", reason = "needs reevaluation")]
pub trait FromStrRadix {
type Err;
- fn from_str_radix(str: &str, radix: uint) -> Result<Self, Self::Err>;
+ fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::Err>;
}
/// A utility function that just calls FromStrRadix::from_str_radix.
#[unstable(feature = "core", reason = "needs reevaluation")]
-pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: uint)
+pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: u32)
-> Result<T, T::Err> {
FromStrRadix::from_str_radix(str, radix)
}
/// `None` if the string did not represent a valid number.
/// Otherwise, `Some(n)` where `n` is the floating-point number
/// represented by `src`.
- fn from_str_radix(src: &str, radix: uint)
+ fn from_str_radix(src: &str, radix: u32)
-> Result<$T, ParseFloatError> {
use self::FloatErrorKind::*;
use self::ParseFloatError as PFE;
#[stable(feature = "rust1", since = "1.0.0")]
impl FromStrRadix for $T {
type Err = ParseIntError;
- fn from_str_radix(src: &str, radix: uint)
+ fn from_str_radix(src: &str, radix: u32)
-> Result<$T, ParseIntError> {
use self::IntErrorKind::*;
use self::ParseIntError as PIE;
Some((_, c)) => {
match c.to_digit(10) {
Some(i) => {
- cur = cur * 10 + i;
+ cur = cur * 10 + i as usize;
found = true;
self.cur.next();
}
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_string(num: f32) -> String {
let (r, _) = strconv::float_to_str_common(
- num, 10u, true, SignNeg, DigAll, ExpNone, false);
+ num, 10, true, SignNeg, DigAll, ExpNone, false);
r
}
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_hex(num: f32) -> String {
let (r, _) = strconv::float_to_str_common(
- num, 16u, true, SignNeg, DigAll, ExpNone, false);
+ num, 16, true, SignNeg, DigAll, ExpNone, false);
r
}
/// * radix - The base to use
#[inline]
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
-pub fn to_str_radix_special(num: f32, rdx: uint) -> (String, bool) {
+pub fn to_str_radix_special(num: f32, rdx: u32) -> (String, bool) {
strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false)
}
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_exact(num: f32, dig: uint) -> String {
let (r, _) = strconv::float_to_str_common(
- num, 10u, true, SignNeg, DigExact(dig), ExpNone, false);
+ num, 10, true, SignNeg, DigExact(dig), ExpNone, false);
r
}
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_digits(num: f32, dig: uint) -> String {
let (r, _) = strconv::float_to_str_common(
- num, 10u, true, SignNeg, DigMax(dig), ExpNone, false);
+ num, 10, true, SignNeg, DigMax(dig), ExpNone, false);
r
}
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_exp_exact(num: f32, dig: uint, upper: bool) -> String {
let (r, _) = strconv::float_to_str_common(
- num, 10u, true, SignNeg, DigExact(dig), ExpDec, upper);
+ num, 10, true, SignNeg, DigExact(dig), ExpDec, upper);
r
}
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_exp_digits(num: f32, dig: uint, upper: bool) -> String {
let (r, _) = strconv::float_to_str_common(
- num, 10u, true, SignNeg, DigMax(dig), ExpDec, upper);
+ num, 10, true, SignNeg, DigMax(dig), ExpDec, upper);
r
}
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_string(num: f64) -> String {
let (r, _) = strconv::float_to_str_common(
- num, 10u, true, SignNeg, DigAll, ExpNone, false);
+ num, 10, true, SignNeg, DigAll, ExpNone, false);
r
}
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_hex(num: f64) -> String {
let (r, _) = strconv::float_to_str_common(
- num, 16u, true, SignNeg, DigAll, ExpNone, false);
+ num, 16, true, SignNeg, DigAll, ExpNone, false);
r
}
/// * radix - The base to use
#[inline]
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
-pub fn to_str_radix_special(num: f64, rdx: uint) -> (String, bool) {
+pub fn to_str_radix_special(num: f64, rdx: u32) -> (String, bool) {
strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false)
}
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_exact(num: f64, dig: uint) -> String {
let (r, _) = strconv::float_to_str_common(
- num, 10u, true, SignNeg, DigExact(dig), ExpNone, false);
+ num, 10, true, SignNeg, DigExact(dig), ExpNone, false);
r
}
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_digits(num: f64, dig: uint) -> String {
let (r, _) = strconv::float_to_str_common(
- num, 10u, true, SignNeg, DigMax(dig), ExpNone, false);
+ num, 10, true, SignNeg, DigMax(dig), ExpNone, false);
r
}
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_exp_exact(num: f64, dig: uint, upper: bool) -> String {
let (r, _) = strconv::float_to_str_common(
- num, 10u, true, SignNeg, DigExact(dig), ExpDec, upper);
+ num, 10, true, SignNeg, DigExact(dig), ExpDec, upper);
r
}
#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
pub fn to_str_exp_digits(num: f64, dig: uint, upper: bool) -> String {
let (r, _) = strconv::float_to_str_common(
- num, 10u, true, SignNeg, DigMax(dig), ExpDec, upper);
+ num, 10, true, SignNeg, DigMax(dig), ExpDec, upper);
r
}
/// - Panics if `radix` > 25 and `exp_format` is `ExpBin` due to conflict
/// between digit and exponent sign `'p'`.
pub fn float_to_str_bytes_common<T: Float>(
- num: T, radix: uint, negative_zero: bool,
+ num: T, radix: u32, negative_zero: bool,
sign: SignFormat, digits: SignificantDigits, exp_format: ExponentFormat, exp_upper: bool
) -> (Vec<u8>, bool) {
assert!(2 <= radix && radix <= 36);
deccum = deccum / radix_gen;
deccum = deccum.trunc();
- buf.push(char::from_digit(current_digit.to_int().unwrap() as uint, radix)
+ buf.push(char::from_digit(current_digit.to_int().unwrap() as u32, radix)
.unwrap() as u8);
// No more digits to calculate for the non-fractional part -> break
let current_digit = deccum.trunc().abs();
buf.push(char::from_digit(
- current_digit.to_int().unwrap() as uint, radix).unwrap() as u8);
+ current_digit.to_int().unwrap() as u32, radix).unwrap() as u8);
// Decrease the deccumulator one fractional digit at a time
deccum = deccum.fract();
let ascii2value = |chr: u8| {
(chr as char).to_digit(radix).unwrap()
};
- let value2ascii = |val: uint| {
+ let value2ascii = |val: u32| {
char::from_digit(val, radix).unwrap() as u8
};
/// `to_str_bytes_common()`, for details see there.
#[inline]
pub fn float_to_str_common<T: Float>(
- num: T, radix: uint, negative_zero: bool,
+ num: T, radix: u32, negative_zero: bool,
sign: SignFormat, digits: SignificantDigits, exp_format: ExponentFormat, exp_capital: bool
) -> (String, bool) {
let (bytes, special) = float_to_str_bytes_common(num, radix,
// Some constants for from_str_bytes_common's input validation,
// they define minimum radix values for which the character is a valid digit.
-static DIGIT_P_RADIX: uint = ('p' as uint) - ('a' as uint) + 11u;
-static DIGIT_E_RADIX: uint = ('e' as uint) - ('a' as uint) + 11u;
+static DIGIT_P_RADIX: u32 = ('p' as u32) - ('a' as u32) + 11;
+static DIGIT_E_RADIX: u32 = ('e' as u32) - ('a' as u32) + 11;
#[cfg(test)]
mod tests {
/// Scan through any digits (base `radix`) or underscores, and return how
/// many digits there were.
- fn scan_digits(&mut self, radix: usize) -> usize {
+ fn scan_digits(&mut self, radix: u32) -> usize {
let mut len = 0;
loop {
let c = self.curr;
PushParam => {
// params are 1-indexed
stack.push(mparams[match cur.to_digit(10) {
- Some(d) => d - 1,
+ Some(d) => d as usize - 1,
None => return Err("bad param number".to_string())
}].clone());
},
pub fn main() {
// Basic usage
- t!(to_string(1.2345678e-5f64, 10u, true, SignNeg, DigMax(6), ExpDec, false),
+ t!(to_string(1.2345678e-5f64, 10, true, SignNeg, DigMax(6), ExpDec, false),
"1.234568e-5");
// Hexadecimal output
- t!(to_string(7.281738281250e+01f64, 16u, true, SignAll, DigMax(6), ExpBin, false),
+ t!(to_string(7.281738281250e+01f64, 16, true, SignAll, DigMax(6), ExpBin, false),
"+1.2345p+6");
- t!(to_string(-1.777768135071e-02f64, 16u, true, SignAll, DigMax(6), ExpBin, false),
+ t!(to_string(-1.777768135071e-02f64, 16, true, SignAll, DigMax(6), ExpBin, false),
"-1.2345p-6");
// Some denormals
- t!(to_string(4.9406564584124654e-324f64, 10u, true, SignNeg, DigMax(6), ExpBin, false),
+ t!(to_string(4.9406564584124654e-324f64, 10, true, SignNeg, DigMax(6), ExpBin, false),
"1p-1074");
- t!(to_string(2.2250738585072009e-308f64, 10u, true, SignNeg, DigMax(6), ExpBin, false),
+ t!(to_string(2.2250738585072009e-308f64, 10, true, SignNeg, DigMax(6), ExpBin, false),
"1p-1022");
}