blob: 55e618881084f22d3d7e328a383a04338cb871d8 [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 } 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); } // 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< d.nd { prec = 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. eprec := prec; if shortest { eprec = 6 } exp := d.dp - 1; if exp < -4 || exp >= eprec { return fmtE(neg, d, prec - 1, fmt + 'e' - 'g'); } 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: Unless exp == minexp, if the number of digits in d // is less than 17, it seems unlikely that it could not 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:len(buf)]); } func max(a, b int) int { if a > b { return a; } return b; }