• Home
•  
• Go Resources
• Installing Go
•  
• Selected Documents
• Tutorial
• Effective Go
• FAQ
• Language Design FAQ
• Programming FAQ
•  
• References
• Language Specification
• Package documentation
• Command documentation
• Source files
•  
• Help & Community
• Go Blog
• Go Nuts mailing list
• #go-nuts on irc.freenode.net
• @go_nuts on Twitter
• gocoding YouTube Channel
• Issue tracker
• Go Wiki
•  
• Go Dashboard
• Build Status
• External Packages
• Benchmarks
•  
•  
• Go code search
•  
• Last update
• Fri Jul 30 00:00:57 PDT 2010
• release.2010-07-14

Source file src/pkg/strconv/ftoa.go

// 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}

func floatsize() int {
    // Figure out whether float is float32 or float64.
    // 1e-35 is representable in both, but 1e-70
    // is too small for a float32.
    var f float = 1e-35
    if f*f == 0 {
        return 32
    }
    return 64
}

// Floatsize gives the size of the float type, either 32 or 64.
var FloatSize = floatsize()

// Ftoa32 converts the 32-bit floating-point number f to a string,
// according to the format fmt and precision prec.
//
// The format fmt is one of
// 'b' (-ddddp±ddd, a binary exponent),
// 'e' (-d.dddde±dd, a decimal exponent),
// 'f' (-ddd.dddd, no exponent), or
// 'g' ('e' for large exponents, 'f' otherwise).
//
// The precision prec controls the number of digits
// (excluding the exponent) printed by the 'e', 'f', and 'g' formats.
// For 'e' and 'f' it is the number of digits after the decimal point.
// For 'g' it is the total number of digits.
// The special precision -1 uses the smallest number of digits
// necessary such that Atof32 will return f exactly.
//
// Ftoa32(f) is not the same as Ftoa64(float32(f)),
// because correct rounding and the number of digits
// needed to identify f depend on the precision of the representation.
func Ftoa32(f float32, fmt byte, prec int) string {
    return genericFtoa(uint64(math.Float32bits(f)), fmt, prec, &float32info)
}

// Ftoa64 is like Ftoa32 but converts a 64-bit floating-point number.
func Ftoa64(f float64, fmt byte, prec int) string {
    return genericFtoa(math.Float64bits(f), fmt, prec, &float64info)
}

// FtoaN converts the 64-bit floating-point number f to a string,
// according to the format fmt and precision prec, but it rounds the
// result assuming that it was obtained from a floating-point value
// of n bits (32 or 64).
func FtoaN(f float64, fmt byte, prec int, n int) string {
    if n == 32 {
        return Ftoa32(float32(f), fmt, prec)
    }
    return Ftoa64(f, fmt, prec)
}

// Ftoa behaves as Ftoa32 or Ftoa64, depending on the size of the float type.
func Ftoa(f float, fmt byte, prec int) string {
    if FloatSize == 32 {
        return Ftoa32(float32(f), fmt, prec)
    }
    return Ftoa64(float64(f), fmt, prec)
}

func genericFtoa(bits uint64, fmt byte, prec int, flt *floatInfo) string {
    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
        if mant != 0 {
            return "NaN"
        }
        if neg {
            return "-Inf"
        }
        return "+Inf"

    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(neg, mant, exp, flt)
    }

    // 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 := newDecimal(mant).Shift(exp - int(flt.mantbits))

    // Round appropriately.
    // Negative precision means "only as much as needed to be exact."
    shortest := false
    if prec < 0 {
        shortest = true
        roundShortest(d, mant, exp, flt)
        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 {
        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(neg, d, prec, fmt)
    case 'f':
        return fmtF(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(neg, d, prec-1, fmt+'e'-'g')
        }
        if prec > d.dp {
            prec = d.nd
        }
        return fmtF(neg, d, max(prec-d.dp, 0))
    }

    return "%" + string(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
    }

    // TODO(rsc): Unless exp == minexp, if the number of digits in d
    // is less than 17, it seems likely that it would be
    // the shortest possible number already.  So maybe we can
    // bail out without doing the extra multiprecision math here.

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

    // 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 := newDecimal(mant*2 + 1).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.
    minexp := flt.bias + 1 // minimum possible exponent
    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 := newDecimal(mantlo*2 + 1).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 || 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(neg bool, d *decimal, prec int, fmt byte) string {
    buf := make([]byte, 3+max(prec, 0)+30) // "-0." + prec digits + exp
    w := 0                                 // write index

    // sign
    if neg {
        buf[w] = '-'
        w++
    }

    // first digit
    if d.nd == 0 {
        buf[w] = '0'
    } else {
        buf[w] = d.d[0]
    }
    w++

    // .moredigits
    if prec > 0 {
        buf[w] = '.'
        w++
        for i := 0; i < prec; i++ {
            if 1+i < d.nd {
                buf[w] = d.d[1+i]
            } else {
                buf[w] = '0'
            }
            w++
        }
    }

    // e±
    buf[w] = fmt
    w++
    exp := d.dp - 1
    if d.nd == 0 { // special case: 0 has exponent 0
        exp = 0
    }
    if exp < 0 {
        buf[w] = '-'
        exp = -exp
    } else {
        buf[w] = '+'
    }
    w++

    // dddd
    // count digits
    n := 0
    for e := exp; e > 0; e /= 10 {
        n++
    }
    // leading zeros
    for i := n; i < 2; i++ {
        buf[w] = '0'
        w++
    }
    // digits
    w += n
    n = 0
    for e := exp; e > 0; e /= 10 {
        n++
        buf[w-n] = byte(e%10 + '0')
    }

    return string(buf[0:w])
}

// %f: -ddddddd.ddddd
func fmtF(neg bool, d *decimal, prec int) string {
    buf := make([]byte, 1+max(d.dp, 1)+1+max(prec, 0))
    w := 0

    // sign
    if neg {
        buf[w] = '-'
        w++
    }

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

    // fraction
    if prec > 0 {
        buf[w] = '.'
        w++
        for i := 0; i < prec; i++ {
            if d.dp+i < 0 || d.dp+i >= d.nd {
                buf[w] = '0'
            } else {
                buf[w] = d.d[d.dp+i]
            }
            w++
        }
    }

    return string(buf[0:w])
}

// %b: -ddddddddp+ddd
func fmtB(neg bool, mant uint64, exp int, flt *floatInfo) string {
    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 string(buf[w:])
}

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

Except as noted, this content is licensed under Creative Commons Attribution 3.0.