Subversion Repositories openrisc

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Binary to decimal floating point conversion.
// Algorithm:
//   1) store mantissa in multiprecision decimal
//   2) shift decimal by exponent
//   3) read digits out & format

package strconv

import "math"

// TODO: move elsewhere?
type floatInfo struct {
        mantbits uint
        expbits  uint
        bias     int
}

var float32info = floatInfo{23, 8, -127}
var float64info = floatInfo{52, 11, -1023}

// FormatFloat converts the floating-point number f to a string,
// according to the format fmt and precision prec.  It rounds the
// result assuming that the original was obtained from a floating-point
// value of bitSize bits (32 for float32, 64 for float64).
//
// The format fmt is one of
// 'b' (-ddddp±ddd, a binary exponent),
// 'e' (-d.dddde±dd, a decimal exponent),
// 'E' (-d.ddddE±dd, a decimal exponent),
// 'f' (-ddd.dddd, no exponent),
// 'g' ('e' for large exponents, 'f' otherwise), or
// 'G' ('E' for large exponents, 'f' otherwise).
//
// The precision prec controls the number of digits
// (excluding the exponent) printed by the 'e', 'E', 'f', 'g', and 'G' formats.
// For 'e', 'E', and 'f' it is the number of digits after the decimal point.
// For 'g' and 'G' it is the total number of digits.
// The special precision -1 uses the smallest number of digits
// necessary such that ParseFloat will return f exactly.
func FormatFloat(f float64, fmt byte, prec, bitSize int) string {
        return string(genericFtoa(make([]byte, 0, max(prec+4, 24)), f, fmt, prec, bitSize))
}

// AppendFloat appends the string form of the floating-point number f,
// as generated by FormatFloat, to dst and returns the extended buffer.
func AppendFloat(dst []byte, f float64, fmt byte, prec int, bitSize int) []byte {
        return genericFtoa(dst, f, fmt, prec, bitSize)
}

func genericFtoa(dst []byte, val float64, fmt byte, prec, bitSize int) []byte {
        var bits uint64
        var flt *floatInfo
        switch bitSize {
        case 32:
                bits = uint64(math.Float32bits(float32(val)))
                flt = &float32info
        case 64:
                bits = math.Float64bits(val)
                flt = &float64info
        default:
                panic("strconv: illegal AppendFloat/FormatFloat bitSize")
        }

        neg := bits>>(flt.expbits+flt.mantbits) != 0
        exp := int(bits>>flt.mantbits) & (1<<flt.expbits - 1)
        mant := bits & (uint64(1)<<flt.mantbits - 1)

        switch exp {
        case 1<<flt.expbits - 1:
                // Inf, NaN
                var s string
                switch {
                case mant != 0:
                        s = "NaN"
                case neg:
                        s = "-Inf"
                default:
                        s = "+Inf"
                }
                return append(dst, s...)

        case 0:
                // denormalized
                exp++

        default:
                // add implicit top bit
                mant |= uint64(1) << flt.mantbits
        }
        exp += flt.bias

        // Pick off easy binary format.
        if fmt == 'b' {
                return fmtB(dst, neg, mant, exp, flt)
        }

        // Negative precision means "only as much as needed to be exact."
        shortest := prec < 0

        d := new(decimal)
        if shortest {
                ok := false
                if optimize && bitSize == 64 {
                        // Try Grisu3 algorithm.
                        f := new(extFloat)
                        lower, upper := f.AssignComputeBounds(val)
                        ok = f.ShortestDecimal(d, &lower, &upper)
                }
                if !ok {
                        // Create exact decimal representation.
                        // The shift is exp - flt.mantbits because mant is a 1-bit integer
                        // followed by a flt.mantbits fraction, and we are treating it as
                        // a 1+flt.mantbits-bit integer.
                        d.Assign(mant)
                        d.Shift(exp - int(flt.mantbits))
                        roundShortest(d, mant, exp, flt)
                }
                // Precision for shortest representation mode.
                if prec < 0 {
                        switch fmt {
                        case 'e', 'E':
                                prec = d.nd - 1
                        case 'f':
                                prec = max(d.nd-d.dp, 0)
                        case 'g', 'G':
                                prec = d.nd
                        }
                }
        } else {
                // Create exact decimal representation.
                d.Assign(mant)
                d.Shift(exp - int(flt.mantbits))
                // Round appropriately.
                switch fmt {
                case 'e', 'E':
                        d.Round(prec + 1)
                case 'f':
                        d.Round(d.dp + prec)
                case 'g', 'G':
                        if prec == 0 {
                                prec = 1
                        }
                        d.Round(prec)
                }
        }

        switch fmt {
        case 'e', 'E':
                return fmtE(dst, neg, d, prec, fmt)
        case 'f':
                return fmtF(dst, neg, d, prec)
        case 'g', 'G':
                // trailing fractional zeros in 'e' form will be trimmed.
                eprec := prec
                if eprec > d.nd && d.nd >= d.dp {
                        eprec = d.nd
                }
                // %e is used if the exponent from the conversion
                // is less than -4 or greater than or equal to the precision.
                // if precision was the shortest possible, use precision 6 for this decision.
                if shortest {
                        eprec = 6
                }
                exp := d.dp - 1
                if exp < -4 || exp >= eprec {
                        if prec > d.nd {
                                prec = d.nd
                        }
                        return fmtE(dst, neg, d, prec-1, fmt+'e'-'g')
                }
                if prec > d.dp {
                        prec = d.nd
                }
                return fmtF(dst, neg, d, max(prec-d.dp, 0))
        }

        // unknown format
        return append(dst, '%', fmt)
}

// Round d (= mant * 2^exp) to the shortest number of digits
// that will let the original floating point value be precisely
// reconstructed.  Size is original floating point size (64 or 32).
func roundShortest(d *decimal, mant uint64, exp int, flt *floatInfo) {
        // If mantissa is zero, the number is zero; stop now.
        if mant == 0 {
                d.nd = 0
                return
        }

        // Compute upper and lower such that any decimal number
        // between upper and lower (possibly inclusive)
        // will round to the original floating point number.

        // We may see at once that the number is already shortest.
        //
        // Suppose d is not denormal, so that 2^exp <= d < 10^dp.
        // The closest shorter number is at least 10^(dp-nd) away.
        // The lower/upper bounds computed below are at distance
        // at most 2^(exp-mantbits).
        //
        // So the number is already shortest if 10^(dp-nd) > 2^(exp-mantbits),
        // or equivalently log2(10)*(dp-nd) > exp-mantbits.
        // It is true if 332/100*(dp-nd) >= exp-mantbits (log2(10) > 3.32).
        minexp := flt.bias + 1 // minimum possible exponent
        if exp > minexp && 332*(d.dp-d.nd) >= 100*(exp-int(flt.mantbits)) {
                // The number is already shortest.
                return
        }

        // d = mant << (exp - mantbits)
        // Next highest floating point number is mant+1 << exp-mantbits.
        // Our upper bound is halfway inbetween, mant*2+1 << exp-mantbits-1.
        upper := new(decimal)
        upper.Assign(mant*2 + 1)
        upper.Shift(exp - int(flt.mantbits) - 1)

        // d = mant << (exp - mantbits)
        // Next lowest floating point number is mant-1 << exp-mantbits,
        // unless mant-1 drops the significant bit and exp is not the minimum exp,
        // in which case the next lowest is mant*2-1 << exp-mantbits-1.
        // Either way, call it mantlo << explo-mantbits.
        // Our lower bound is halfway inbetween, mantlo*2+1 << explo-mantbits-1.
        var mantlo uint64
        var explo int
        if mant > 1<<flt.mantbits || exp == minexp {
                mantlo = mant - 1
                explo = exp
        } else {
                mantlo = mant*2 - 1
                explo = exp - 1
        }
        lower := new(decimal)
        lower.Assign(mantlo*2 + 1)
        lower.Shift(explo - int(flt.mantbits) - 1)

        // The upper and lower bounds are possible outputs only if
        // the original mantissa is even, so that IEEE round-to-even
        // would round to the original mantissa and not the neighbors.
        inclusive := mant%2 == 0

        // Now we can figure out the minimum number of digits required.
        // Walk along until d has distinguished itself from upper and lower.
        for i := 0; i < d.nd; i++ {
                var l, m, u byte // lower, middle, upper digits
                if i < lower.nd {
                        l = lower.d[i]
                } else {
                        l = '0'
                }
                m = d.d[i]
                if i < upper.nd {
                        u = upper.d[i]
                } else {
                        u = '0'
                }

                // Okay to round down (truncate) if lower has a different digit
                // or if lower is inclusive and is exactly the result of rounding down.
                okdown := l != m || (inclusive && l == m && i+1 == lower.nd)

                // Okay to round up if upper has a different digit and
                // either upper is inclusive or upper is bigger than the result of rounding up.
                okup := m != u && (inclusive || m+1 < u || i+1 < upper.nd)

                // If it's okay to do either, then round to the nearest one.
                // If it's okay to do only one, do it.
                switch {
                case okdown && okup:
                        d.Round(i + 1)
                        return
                case okdown:
                        d.RoundDown(i + 1)
                        return
                case okup:
                        d.RoundUp(i + 1)
                        return
                }
        }
}

// %e: -d.ddddde±dd
func fmtE(dst []byte, neg bool, d *decimal, prec int, fmt byte) []byte {
        // sign
        if neg {
                dst = append(dst, '-')
        }

        // first digit
        ch := byte('0')
        if d.nd != 0 {
                ch = d.d[0]
        }
        dst = append(dst, ch)

        // .moredigits
        if prec > 0 {
                dst = append(dst, '.')
                for i := 1; i <= prec; i++ {
                        ch = '0'
                        if i < d.nd {
                                ch = d.d[i]
                        }
                        dst = append(dst, ch)
                }
        }

        // e±
        dst = append(dst, fmt)
        exp := d.dp - 1
        if d.nd == 0 { // special case: 0 has exponent 0
                exp = 0
        }
        if exp < 0 {
                ch = '-'
                exp = -exp
        } else {
                ch = '+'
        }
        dst = append(dst, ch)

        // dddd
        var buf [3]byte
        i := len(buf)
        for exp >= 10 {
                i--
                buf[i] = byte(exp%10 + '0')
                exp /= 10
        }
        // exp < 10
        i--
        buf[i] = byte(exp + '0')

        // leading zeroes
        if i > len(buf)-2 {
                i--
                buf[i] = '0'
        }

        return append(dst, buf[i:]...)
}

// %f: -ddddddd.ddddd
func fmtF(dst []byte, neg bool, d *decimal, prec int) []byte {
        // sign
        if neg {
                dst = append(dst, '-')
        }

        // integer, padded with zeros as needed.
        if d.dp > 0 {
                var i int
                for i = 0; i < d.dp && i < d.nd; i++ {
                        dst = append(dst, d.d[i])
                }
                for ; i < d.dp; i++ {
                        dst = append(dst, '0')
                }
        } else {
                dst = append(dst, '0')
        }

        // fraction
        if prec > 0 {
                dst = append(dst, '.')
                for i := 0; i < prec; i++ {
                        ch := byte('0')
                        if j := d.dp + i; 0 <= j && j < d.nd {
                                ch = d.d[j]
                        }
                        dst = append(dst, ch)
                }
        }

        return dst
}

// %b: -ddddddddp+ddd
func fmtB(dst []byte, neg bool, mant uint64, exp int, flt *floatInfo) []byte {
        var buf [50]byte
        w := len(buf)
        exp -= int(flt.mantbits)
        esign := byte('+')
        if exp < 0 {
                esign = '-'
                exp = -exp
        }
        n := 0
        for exp > 0 || n < 1 {
                n++
                w--
                buf[w] = byte(exp%10 + '0')
                exp /= 10
        }
        w--
        buf[w] = esign
        w--
        buf[w] = 'p'
        n = 0
        for mant > 0 || n < 1 {
                n++
                w--
                buf[w] = byte(mant%10 + '0')
                mant /= 10
        }
        if neg {
                w--
                buf[w] = '-'
        }
        return append(dst, buf[w:]...)
}

func max(a, b int) int {
        if a > b {
                return a
        }
        return b
}