1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! Integer and floating-point number formatting
13 // FIXME: #6220 Implement floating point formatting
15 use container::Container;
17 use iter::{Iterator, DoubleEndedIterator};
18 use num::{Int, cast, zero};
19 use option::{Some, None};
20 use slice::{ImmutableVector, MutableVector};
22 /// A type that represents a specific radix
24 /// The number of digits.
27 /// A radix-specific prefix string.
28 fn prefix(&self) -> &'static str { "" }
30 /// Converts an integer to corresponding radix digit.
31 fn digit(&self, x: u8) -> u8;
33 /// Format an integer using the radix using a formatter.
34 fn fmt_int<T: Int>(&self, mut x: T, f: &mut fmt::Formatter) -> fmt::Result {
35 // The radix can be as low as 2, so we need a buffer of at least 64
36 // characters for a base 2 number.
37 let mut buf = [0u8, ..64];
38 let base = cast(self.base()).unwrap();
39 let mut curr = buf.len();
40 let is_positive = x >= zero();
42 // Accumulate each digit of the number from the least significant
43 // to the most significant figure.
44 for byte in buf.mut_iter().rev() {
45 let n = x % base; // Get the current place value.
46 x = x / base; // Deaccumulate the number.
47 *byte = self.digit(cast(n).unwrap()); // Store the digit in the buffer.
49 if x == zero() { break; } // No more digits left to accumulate.
52 // Do the same as above, but accounting for two's complement.
53 for byte in buf.mut_iter().rev() {
54 let n = -(x % base); // Get the current place value.
55 x = x / base; // Deaccumulate the number.
56 *byte = self.digit(cast(n).unwrap()); // Store the digit in the buffer.
58 if x == zero() { break; } // No more digits left to accumulate.
61 f.pad_integral(is_positive, self.prefix(), buf.slice_from(curr))
65 /// A binary (base 2) radix
66 #[deriving(Clone, Eq)]
69 /// An octal (base 8) radix
70 #[deriving(Clone, Eq)]
73 /// A decimal (base 10) radix
74 #[deriving(Clone, Eq)]
77 /// A hexidecimal (base 16) radix, formatted with lower-case characters
78 #[deriving(Clone, Eq)]
81 /// A hexidecimal (base 16) radix, formatted with upper-case characters
82 #[deriving(Clone, Eq)]
86 ($T:ident, $base:expr, $prefix:expr, $($x:pat => $conv:expr),+) => {
87 impl GenericRadix for $T {
88 fn base(&self) -> u8 { $base }
89 fn prefix(&self) -> &'static str { $prefix }
90 fn digit(&self, x: u8) -> u8 {
93 x => fail!("number not in the range 0..{}: {}", self.base() - 1, x),
100 radix!(Binary, 2, "0b", x @ 0 .. 2 => '0' as u8 + x)
101 radix!(Octal, 8, "0o", x @ 0 .. 7 => '0' as u8 + x)
102 radix!(Decimal, 10, "", x @ 0 .. 9 => '0' as u8 + x)
103 radix!(LowerHex, 16, "0x", x @ 0 .. 9 => '0' as u8 + x,
104 x @ 10 ..15 => 'a' as u8 + (x - 10))
105 radix!(UpperHex, 16, "0x", x @ 0 .. 9 => '0' as u8 + x,
106 x @ 10 ..15 => 'A' as u8 + (x - 10))
108 /// A radix with in the range of `2..36`.
109 #[deriving(Clone, Eq)]
115 fn new(base: u8) -> Radix {
116 assert!(2 <= base && base <= 36, "the base must be in the range of 0..36: {}", base);
121 impl GenericRadix for Radix {
122 fn base(&self) -> u8 { self.base }
123 fn digit(&self, x: u8) -> u8 {
125 x @ 0 ..9 => '0' as u8 + x,
126 x if x < self.base() => 'a' as u8 + (x - 10),
127 x => fail!("number not in the range 0..{}: {}", self.base() - 1, x),
132 /// A helper type for formatting radixes.
133 pub struct RadixFmt<T, R>(T, R);
135 /// Constructs a radix formatter in the range of `2..36`.
140 /// use std::fmt::radix;
141 /// assert_eq!(format!("{}", radix(55, 36)), "1j".to_owned());
143 pub fn radix<T>(x: T, base: u8) -> RadixFmt<T, Radix> {
144 RadixFmt(x, Radix::new(base))
147 macro_rules! radix_fmt {
148 ($T:ty as $U:ty, $fmt:ident) => {
149 impl fmt::Show for RadixFmt<$T, Radix> {
150 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
151 match *self { RadixFmt(ref x, radix) => radix.$fmt(*x as $U, f) }
156 macro_rules! int_base {
157 ($Trait:ident for $T:ident as $U:ident -> $Radix:ident) => {
158 impl fmt::$Trait for $T {
159 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
160 $Radix.fmt_int(*self as $U, f)
165 macro_rules! integer {
166 ($Int:ident, $Uint:ident) => {
167 int_base!(Show for $Int as $Int -> Decimal)
168 int_base!(Signed for $Int as $Int -> Decimal)
169 int_base!(Binary for $Int as $Uint -> Binary)
170 int_base!(Octal for $Int as $Uint -> Octal)
171 int_base!(LowerHex for $Int as $Uint -> LowerHex)
172 int_base!(UpperHex for $Int as $Uint -> UpperHex)
173 radix_fmt!($Int as $Uint, fmt_int)
175 int_base!(Show for $Uint as $Uint -> Decimal)
176 int_base!(Unsigned for $Uint as $Uint -> Decimal)
177 int_base!(Binary for $Uint as $Uint -> Binary)
178 int_base!(Octal for $Uint as $Uint -> Octal)
179 int_base!(LowerHex for $Uint as $Uint -> LowerHex)
180 int_base!(UpperHex for $Uint as $Uint -> UpperHex)
181 radix_fmt!($Uint as $Uint, fmt_int)
193 use super::{Binary, Octal, Decimal, LowerHex, UpperHex};
194 use super::{GenericRadix, Radix};
198 fn test_radix_base() {
199 assert_eq!(Binary.base(), 2);
200 assert_eq!(Octal.base(), 8);
201 assert_eq!(Decimal.base(), 10);
202 assert_eq!(LowerHex.base(), 16);
203 assert_eq!(UpperHex.base(), 16);
204 assert_eq!(Radix { base: 36 }.base(), 36);
208 fn test_radix_prefix() {
209 assert_eq!(Binary.prefix(), "0b");
210 assert_eq!(Octal.prefix(), "0o");
211 assert_eq!(Decimal.prefix(), "");
212 assert_eq!(LowerHex.prefix(), "0x");
213 assert_eq!(UpperHex.prefix(), "0x");
214 assert_eq!(Radix { base: 36 }.prefix(), "");
218 fn test_radix_digit() {
219 assert_eq!(Binary.digit(0), '0' as u8);
220 assert_eq!(Binary.digit(2), '2' as u8);
221 assert_eq!(Octal.digit(0), '0' as u8);
222 assert_eq!(Octal.digit(7), '7' as u8);
223 assert_eq!(Decimal.digit(0), '0' as u8);
224 assert_eq!(Decimal.digit(9), '9' as u8);
225 assert_eq!(LowerHex.digit(0), '0' as u8);
226 assert_eq!(LowerHex.digit(10), 'a' as u8);
227 assert_eq!(LowerHex.digit(15), 'f' as u8);
228 assert_eq!(UpperHex.digit(0), '0' as u8);
229 assert_eq!(UpperHex.digit(10), 'A' as u8);
230 assert_eq!(UpperHex.digit(15), 'F' as u8);
231 assert_eq!(Radix { base: 36 }.digit(0), '0' as u8);
232 assert_eq!(Radix { base: 36 }.digit(15), 'f' as u8);
233 assert_eq!(Radix { base: 36 }.digit(35), 'z' as u8);
238 fn test_hex_radix_digit_overflow() {
239 let _ = LowerHex.digit(16);
243 fn test_format_int() {
244 // Formatting integers should select the right implementation based off
245 // the type of the argument. Also, hex/octal/binary should be defined
246 // for integers, but they shouldn't emit the negative sign.
247 assert_eq!(format!("{}", 1i), "1".to_owned());
248 assert_eq!(format!("{}", 1i8), "1".to_owned());
249 assert_eq!(format!("{}", 1i16), "1".to_owned());
250 assert_eq!(format!("{}", 1i32), "1".to_owned());
251 assert_eq!(format!("{}", 1i64), "1".to_owned());
252 assert_eq!(format!("{:d}", -1i), "-1".to_owned());
253 assert_eq!(format!("{:d}", -1i8), "-1".to_owned());
254 assert_eq!(format!("{:d}", -1i16), "-1".to_owned());
255 assert_eq!(format!("{:d}", -1i32), "-1".to_owned());
256 assert_eq!(format!("{:d}", -1i64), "-1".to_owned());
257 assert_eq!(format!("{:t}", 1i), "1".to_owned());
258 assert_eq!(format!("{:t}", 1i8), "1".to_owned());
259 assert_eq!(format!("{:t}", 1i16), "1".to_owned());
260 assert_eq!(format!("{:t}", 1i32), "1".to_owned());
261 assert_eq!(format!("{:t}", 1i64), "1".to_owned());
262 assert_eq!(format!("{:x}", 1i), "1".to_owned());
263 assert_eq!(format!("{:x}", 1i8), "1".to_owned());
264 assert_eq!(format!("{:x}", 1i16), "1".to_owned());
265 assert_eq!(format!("{:x}", 1i32), "1".to_owned());
266 assert_eq!(format!("{:x}", 1i64), "1".to_owned());
267 assert_eq!(format!("{:X}", 1i), "1".to_owned());
268 assert_eq!(format!("{:X}", 1i8), "1".to_owned());
269 assert_eq!(format!("{:X}", 1i16), "1".to_owned());
270 assert_eq!(format!("{:X}", 1i32), "1".to_owned());
271 assert_eq!(format!("{:X}", 1i64), "1".to_owned());
272 assert_eq!(format!("{:o}", 1i), "1".to_owned());
273 assert_eq!(format!("{:o}", 1i8), "1".to_owned());
274 assert_eq!(format!("{:o}", 1i16), "1".to_owned());
275 assert_eq!(format!("{:o}", 1i32), "1".to_owned());
276 assert_eq!(format!("{:o}", 1i64), "1".to_owned());
278 assert_eq!(format!("{}", 1u), "1".to_owned());
279 assert_eq!(format!("{}", 1u8), "1".to_owned());
280 assert_eq!(format!("{}", 1u16), "1".to_owned());
281 assert_eq!(format!("{}", 1u32), "1".to_owned());
282 assert_eq!(format!("{}", 1u64), "1".to_owned());
283 assert_eq!(format!("{:u}", 1u), "1".to_owned());
284 assert_eq!(format!("{:u}", 1u8), "1".to_owned());
285 assert_eq!(format!("{:u}", 1u16), "1".to_owned());
286 assert_eq!(format!("{:u}", 1u32), "1".to_owned());
287 assert_eq!(format!("{:u}", 1u64), "1".to_owned());
288 assert_eq!(format!("{:t}", 1u), "1".to_owned());
289 assert_eq!(format!("{:t}", 1u8), "1".to_owned());
290 assert_eq!(format!("{:t}", 1u16), "1".to_owned());
291 assert_eq!(format!("{:t}", 1u32), "1".to_owned());
292 assert_eq!(format!("{:t}", 1u64), "1".to_owned());
293 assert_eq!(format!("{:x}", 1u), "1".to_owned());
294 assert_eq!(format!("{:x}", 1u8), "1".to_owned());
295 assert_eq!(format!("{:x}", 1u16), "1".to_owned());
296 assert_eq!(format!("{:x}", 1u32), "1".to_owned());
297 assert_eq!(format!("{:x}", 1u64), "1".to_owned());
298 assert_eq!(format!("{:X}", 1u), "1".to_owned());
299 assert_eq!(format!("{:X}", 1u8), "1".to_owned());
300 assert_eq!(format!("{:X}", 1u16), "1".to_owned());
301 assert_eq!(format!("{:X}", 1u32), "1".to_owned());
302 assert_eq!(format!("{:X}", 1u64), "1".to_owned());
303 assert_eq!(format!("{:o}", 1u), "1".to_owned());
304 assert_eq!(format!("{:o}", 1u8), "1".to_owned());
305 assert_eq!(format!("{:o}", 1u16), "1".to_owned());
306 assert_eq!(format!("{:o}", 1u32), "1".to_owned());
307 assert_eq!(format!("{:o}", 1u64), "1".to_owned());
309 // Test a larger number
310 assert_eq!(format!("{:t}", 55), "110111".to_owned());
311 assert_eq!(format!("{:o}", 55), "67".to_owned());
312 assert_eq!(format!("{:d}", 55), "55".to_owned());
313 assert_eq!(format!("{:x}", 55), "37".to_owned());
314 assert_eq!(format!("{:X}", 55), "37".to_owned());
318 fn test_format_int_zero() {
319 assert_eq!(format!("{}", 0i), "0".to_owned());
320 assert_eq!(format!("{:d}", 0i), "0".to_owned());
321 assert_eq!(format!("{:t}", 0i), "0".to_owned());
322 assert_eq!(format!("{:o}", 0i), "0".to_owned());
323 assert_eq!(format!("{:x}", 0i), "0".to_owned());
324 assert_eq!(format!("{:X}", 0i), "0".to_owned());
326 assert_eq!(format!("{}", 0u), "0".to_owned());
327 assert_eq!(format!("{:u}", 0u), "0".to_owned());
328 assert_eq!(format!("{:t}", 0u), "0".to_owned());
329 assert_eq!(format!("{:o}", 0u), "0".to_owned());
330 assert_eq!(format!("{:x}", 0u), "0".to_owned());
331 assert_eq!(format!("{:X}", 0u), "0".to_owned());
335 fn test_format_int_flags() {
336 assert_eq!(format!("{:3d}", 1), " 1".to_owned());
337 assert_eq!(format!("{:>3d}", 1), " 1".to_owned());
338 assert_eq!(format!("{:>+3d}", 1), " +1".to_owned());
339 assert_eq!(format!("{:<3d}", 1), "1 ".to_owned());
340 assert_eq!(format!("{:#d}", 1), "1".to_owned());
341 assert_eq!(format!("{:#x}", 10), "0xa".to_owned());
342 assert_eq!(format!("{:#X}", 10), "0xA".to_owned());
343 assert_eq!(format!("{:#5x}", 10), " 0xa".to_owned());
344 assert_eq!(format!("{:#o}", 10), "0o12".to_owned());
345 assert_eq!(format!("{:08x}", 10), "0000000a".to_owned());
346 assert_eq!(format!("{:8x}", 10), " a".to_owned());
347 assert_eq!(format!("{:<8x}", 10), "a ".to_owned());
348 assert_eq!(format!("{:>8x}", 10), " a".to_owned());
349 assert_eq!(format!("{:#08x}", 10), "0x00000a".to_owned());
350 assert_eq!(format!("{:08d}", -10), "-0000010".to_owned());
351 assert_eq!(format!("{:x}", -1u8), "ff".to_owned());
352 assert_eq!(format!("{:X}", -1u8), "FF".to_owned());
353 assert_eq!(format!("{:t}", -1u8), "11111111".to_owned());
354 assert_eq!(format!("{:o}", -1u8), "377".to_owned());
355 assert_eq!(format!("{:#x}", -1u8), "0xff".to_owned());
356 assert_eq!(format!("{:#X}", -1u8), "0xFF".to_owned());
357 assert_eq!(format!("{:#t}", -1u8), "0b11111111".to_owned());
358 assert_eq!(format!("{:#o}", -1u8), "0o377".to_owned());
362 fn test_format_int_sign_padding() {
363 assert_eq!(format!("{:+5d}", 1), " +1".to_owned());
364 assert_eq!(format!("{:+5d}", -1), " -1".to_owned());
365 assert_eq!(format!("{:05d}", 1), "00001".to_owned());
366 assert_eq!(format!("{:05d}", -1), "-0001".to_owned());
367 assert_eq!(format!("{:+05d}", 1), "+0001".to_owned());
368 assert_eq!(format!("{:+05d}", -1), "-0001".to_owned());
372 fn test_format_int_twos_complement() {
373 use {i8, i16, i32, i64};
374 assert_eq!(format!("{}", i8::MIN), "-128".to_owned());
375 assert_eq!(format!("{}", i16::MIN), "-32768".to_owned());
376 assert_eq!(format!("{}", i32::MIN), "-2147483648".to_owned());
377 assert_eq!(format!("{}", i64::MIN), "-9223372036854775808".to_owned());
381 fn test_format_radix() {
382 assert_eq!(format!("{:04}", radix(3, 2)), "0011".to_owned());
383 assert_eq!(format!("{}", radix(55, 36)), "1j".to_owned());
388 fn test_radix_base_too_large() {
389 let _ = radix(55, 37);
398 use super::test::Bencher;
400 use rand::{XorShiftRng, Rng};
403 fn format_bin(b: &mut Bencher) {
404 let mut rng = XorShiftRng::new().unwrap();
405 b.iter(|| { format!("{:t}", rng.gen::<uint>()); })
409 fn format_oct(b: &mut Bencher) {
410 let mut rng = XorShiftRng::new().unwrap();
411 b.iter(|| { format!("{:o}", rng.gen::<uint>()); })
415 fn format_dec(b: &mut Bencher) {
416 let mut rng = XorShiftRng::new().unwrap();
417 b.iter(|| { format!("{:u}", rng.gen::<uint>()); })
421 fn format_hex(b: &mut Bencher) {
422 let mut rng = XorShiftRng::new().unwrap();
423 b.iter(|| { format!("{:x}", rng.gen::<uint>()); })
427 fn format_base_36(b: &mut Bencher) {
428 let mut rng = XorShiftRng::new().unwrap();
429 b.iter(|| { format!("{}", radix(rng.gen::<uint>(), 36)); })
434 use super::test::Bencher;
436 use rand::{XorShiftRng, Rng};
439 fn format_bin(b: &mut Bencher) {
440 let mut rng = XorShiftRng::new().unwrap();
441 b.iter(|| { format!("{:t}", rng.gen::<int>()); })
445 fn format_oct(b: &mut Bencher) {
446 let mut rng = XorShiftRng::new().unwrap();
447 b.iter(|| { format!("{:o}", rng.gen::<int>()); })
451 fn format_dec(b: &mut Bencher) {
452 let mut rng = XorShiftRng::new().unwrap();
453 b.iter(|| { format!("{:d}", rng.gen::<int>()); })
457 fn format_hex(b: &mut Bencher) {
458 let mut rng = XorShiftRng::new().unwrap();
459 b.iter(|| { format!("{:x}", rng.gen::<int>()); })
463 fn format_base_36(b: &mut Bencher) {
464 let mut rng = XorShiftRng::new().unwrap();
465 b.iter(|| { format!("{}", radix(rng.gen::<int>(), 36)); })