Imported Upstream version 1.0.0+dfsg1

[rustc.git] / src / libcore / fmt / float.rs

// Copyright 2013-2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

pub use self::ExponentFormat::*;
pub use self::SignificantDigits::*;

use prelude::*;

use char;
use fmt;
use num::Float;
use num::FpCategory as Fp;
use ops::{Div, Rem, Mul};
use slice;
use str;

/// A flag that specifies whether to use exponential (scientific) notation.
pub enum ExponentFormat {
    /// Do not use exponential notation.
    ExpNone,
    /// Use exponential notation with the exponent having a base of 10 and the
    /// exponent sign being `e` or `E`. For example, 1000 would be printed
    /// 1e3.
    ExpDec
}

/// The number of digits used for emitting the fractional part of a number, if
/// any.
pub enum SignificantDigits {
    /// At most the given number of digits will be printed, truncating any
    /// trailing zeroes.
    DigMax(usize),

    /// Precisely the given number of digits will be printed.
    DigExact(usize)
}

#[doc(hidden)]
pub trait MyFloat: Float + PartialEq + PartialOrd + Div<Output=Self> +
                   Mul<Output=Self> + Rem<Output=Self> + Copy {
    fn from_u32(u: u32) -> Self;
    fn to_i32(&self) -> i32;
}

macro_rules! doit {
    ($($t:ident)*) => ($(impl MyFloat for $t {
        fn from_u32(u: u32) -> $t { u as $t }
        fn to_i32(&self) -> i32 { *self as i32 }
    })*)
}
doit! { f32 f64 }

/// Converts a float number to its string representation.
/// This is meant to be a common base implementation for various formatting styles.
/// The number is assumed to be non-negative, callers use `Formatter::pad_integral`
/// to add the right sign, if any.
///
/// # Arguments
///
/// - `num`           - The number to convert (non-negative). Accepts any number that
///                     implements the numeric traits.
/// - `digits`        - The amount of digits to use for emitting the fractional
///                     part, if any. See `SignificantDigits`.
/// - `exp_format`   - Whether or not to use the exponential (scientific) notation.
///                    See `ExponentFormat`.
/// - `exp_capital`   - Whether or not to use a capital letter for the exponent sign, if
///                     exponential notation is desired.
/// - `f`             - A closure to invoke with the string representing the
///                     float.
///
/// # Panics
///
/// - Panics if `num` is negative.
pub fn float_to_str_bytes_common<T: MyFloat, U, F>(
    num: T,
    digits: SignificantDigits,
    exp_format: ExponentFormat,
    exp_upper: bool,
    f: F
) -> U where
    F: FnOnce(&str) -> U,
{
    let _0: T = T::zero();
    let _1: T = T::one();
    let radix: u32 = 10;
    let radix_f = T::from_u32(radix);

    assert!(num.is_nan() || num >= _0, "float_to_str_bytes_common: number is negative");

    match num.classify() {
        Fp::Nan => return f("NaN"),
        Fp::Infinite if num > _0 => {
            return f("inf");
        }
        Fp::Infinite if num < _0 => {
            return f("-inf");
        }
        _ => {}
    }

    // For an f64 the (decimal) exponent is roughly in the range of [-307, 308], so
    // we may have up to that many digits. We err on the side of caution and
    // add 50% extra wiggle room.
    let mut buf = [0; 462];
    let mut end = 0;

    let (num, exp) = match exp_format {
        ExpDec if num != _0 => {
            let exp = num.log10().floor();
            (num / radix_f.powf(exp), exp.to_i32())
        }
        _ => (num, 0)
    };

    // First emit the non-fractional part, looping at least once to make
    // sure at least a `0` gets emitted.
    let mut deccum = num.trunc();
    loop {
        let current_digit = deccum % radix_f;

        // Decrease the deccumulator one digit at a time
        deccum = deccum / radix_f;
        deccum = deccum.trunc();

        let c = char::from_digit(current_digit.to_i32() as u32, radix);
        buf[end] = c.unwrap() as u8;
        end += 1;

        // No more digits to calculate for the non-fractional part -> break
        if deccum == _0 { break; }
    }

    // If limited digits, calculate one digit more for rounding.
    let (limit_digits, digit_count, exact) = match digits {
        DigMax(count)   => (true, count + 1, false),
        DigExact(count) => (true, count + 1, true)
    };

    buf[..end].reverse();

    // Remember start of the fractional digits.
    // Points one beyond end of buf if none get generated,
    // or at the '.' otherwise.
    let start_fractional_digits = end;

    // Now emit the fractional part, if any
    deccum = num.fract();
    if deccum != _0 || (limit_digits && exact && digit_count > 0) {
        buf[end] = b'.';
        end += 1;
        let mut dig = 0;

        // calculate new digits while
        // - there is no limit and there are digits left
        // - or there is a limit, it's not reached yet and
        //   - it's exact
        //   - or it's a maximum, and there are still digits left
        while (!limit_digits && deccum != _0)
           || (limit_digits && dig < digit_count && (
                   exact
                || (!exact && deccum != _0)
              )
        ) {
            // Shift first fractional digit into the integer part
            deccum = deccum * radix_f;

            let current_digit = deccum.trunc();

            let c = char::from_digit(current_digit.to_i32() as u32, radix);
            buf[end] = c.unwrap() as u8;
            end += 1;

            // Decrease the deccumulator one fractional digit at a time
            deccum = deccum.fract();
            dig += 1;
        }

        // If digits are limited, and that limit has been reached,
        // cut off the one extra digit, and depending on its value
        // round the remaining ones.
        if limit_digits && dig == digit_count {
            let ascii2value = |chr: u8| {
                (chr as char).to_digit(radix).unwrap()
            };
            let value2ascii = |val: u32| {
                char::from_digit(val, radix).unwrap() as u8
            };

            let extra_digit = ascii2value(buf[end - 1]);
            end -= 1;
            if extra_digit >= radix / 2 { // -> need to round
                let mut i: isize = end as isize - 1;
                loop {
                    // If reached left end of number, have to
                    // insert additional digit:
                    if i < 0
                    || buf[i as usize] == b'-'
                    || buf[i as usize] == b'+' {
                        for j in ((i + 1) as usize..end).rev() {
                            buf[j + 1] = buf[j];
                        }
                        buf[(i + 1) as usize] = value2ascii(1);
                        end += 1;
                        break;
                    }

                    // Skip the '.'
                    if buf[i as usize] == b'.' { i -= 1; continue; }

                    // Either increment the digit,
                    // or set to 0 if max and carry the 1.
                    let current_digit = ascii2value(buf[i as usize]);
                    if current_digit < (radix - 1) {
                        buf[i as usize] = value2ascii(current_digit+1);
                        break;
                    } else {
                        buf[i as usize] = value2ascii(0);
                        i -= 1;
                    }
                }
            }
        }
    }

    // if number of digits is not exact, remove all trailing '0's up to
    // and including the '.'
    if !exact {
        let buf_max_i = end - 1;

        // index to truncate from
        let mut i = buf_max_i;

        // discover trailing zeros of fractional part
        while i > start_fractional_digits && buf[i] == b'0' {
            i -= 1;
        }

        // Only attempt to truncate digits if buf has fractional digits
        if i >= start_fractional_digits {
            // If buf ends with '.', cut that too.
            if buf[i] == b'.' { i -= 1 }

            // only resize buf if we actually remove digits
            if i < buf_max_i {
                end = i + 1;
            }
        }
    } // If exact and trailing '.', just cut that
    else {
        let max_i = end - 1;
        if buf[max_i] == b'.' {
            end = max_i;
        }
    }

    match exp_format {
        ExpNone => {},
        ExpDec => {
            buf[end] = if exp_upper { b'E' } else { b'e' };
            end += 1;

            struct Filler<'a> {
                buf: &'a mut [u8],
                end: &'a mut usize,
            }

            impl<'a> fmt::Write for Filler<'a> {
                fn write_str(&mut self, s: &str) -> fmt::Result {
                    slice::bytes::copy_memory(s.as_bytes(),
                                              &mut self.buf[(*self.end)..]);
                    *self.end += s.len();
                    Ok(())
                }
            }

            let mut filler = Filler { buf: &mut buf, end: &mut end };
            let _ = fmt::write(&mut filler, format_args!("{:-}", exp));
        }
    }

    f(unsafe { str::from_utf8_unchecked(&buf[..end]) })
}