blob: b6049c545899330847d96c02f15be8b456cb3124 [file] [log] [blame]
 // 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} // 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), // '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 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) } func genericFtoa(bits uint64, fmt byte, prec int, flt *floatInfo) string { neg := bits>>(flt.expbits+flt.mantbits) != 0 exp := int(bits>>flt.mantbits) & (1< 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< 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 }