libgo/go/strconv/extfloat.go

   1 // Copyright 2011 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package strconv
   6
   7 import "math"
   8
   9 // An extFloat represents an extended floating-point number, with more
  10 // precision than a float64. It does not try to save bits: the
  11 // number represented by the structure is mant*(2^exp), with a negative
  12 // sign if neg is true.
  13 type extFloat struct {
  14         mant uint64
  15         exp  int
  16         neg  bool
  17 }
  18
  19 // Powers of ten taken from double-conversion library.
  20 // http://code.google.com/p/double-conversion/
  21 const (
  22         firstPowerOfTen = -348
  23         stepPowerOfTen  = 8
  24 )
  25
  26 var smallPowersOfTen = [...]extFloat{
  27         {1 << 63, -63, false},        // 1
  28         {0xa << 60, -60, false},      // 1e1
  29         {0x64 << 57, -57, false},     // 1e2
  30         {0x3e8 << 54, -54, false},    // 1e3
  31         {0x2710 << 50, -50, false},   // 1e4
  32         {0x186a0 << 47, -47, false},  // 1e5
  33         {0xf4240 << 44, -44, false},  // 1e6
  34         {0x989680 << 40, -40, false}, // 1e7
  35 }
  36
  37 var powersOfTen = [...]extFloat{
  38         {0xfa8fd5a0081c0288, -1220, false}, // 10^-348
  39         {0xbaaee17fa23ebf76, -1193, false}, // 10^-340
  40         {0x8b16fb203055ac76, -1166, false}, // 10^-332
  41         {0xcf42894a5dce35ea, -1140, false}, // 10^-324
  42         {0x9a6bb0aa55653b2d, -1113, false}, // 10^-316
  43         {0xe61acf033d1a45df, -1087, false}, // 10^-308
  44         {0xab70fe17c79ac6ca, -1060, false}, // 10^-300
  45         {0xff77b1fcbebcdc4f, -1034, false}, // 10^-292
  46         {0xbe5691ef416bd60c, -1007, false}, // 10^-284
  47         {0x8dd01fad907ffc3c, -980, false},  // 10^-276
  48         {0xd3515c2831559a83, -954, false},  // 10^-268
  49         {0x9d71ac8fada6c9b5, -927, false},  // 10^-260
  50         {0xea9c227723ee8bcb, -901, false},  // 10^-252
  51         {0xaecc49914078536d, -874, false},  // 10^-244
  52         {0x823c12795db6ce57, -847, false},  // 10^-236
  53         {0xc21094364dfb5637, -821, false},  // 10^-228
  54         {0x9096ea6f3848984f, -794, false},  // 10^-220
  55         {0xd77485cb25823ac7, -768, false},  // 10^-212
  56         {0xa086cfcd97bf97f4, -741, false},  // 10^-204
  57         {0xef340a98172aace5, -715, false},  // 10^-196
  58         {0xb23867fb2a35b28e, -688, false},  // 10^-188
  59         {0x84c8d4dfd2c63f3b, -661, false},  // 10^-180
  60         {0xc5dd44271ad3cdba, -635, false},  // 10^-172
  61         {0x936b9fcebb25c996, -608, false},  // 10^-164
  62         {0xdbac6c247d62a584, -582, false},  // 10^-156
  63         {0xa3ab66580d5fdaf6, -555, false},  // 10^-148
  64         {0xf3e2f893dec3f126, -529, false},  // 10^-140
  65         {0xb5b5ada8aaff80b8, -502, false},  // 10^-132
  66         {0x87625f056c7c4a8b, -475, false},  // 10^-124
  67         {0xc9bcff6034c13053, -449, false},  // 10^-116
  68         {0x964e858c91ba2655, -422, false},  // 10^-108
  69         {0xdff9772470297ebd, -396, false},  // 10^-100
  70         {0xa6dfbd9fb8e5b88f, -369, false},  // 10^-92
  71         {0xf8a95fcf88747d94, -343, false},  // 10^-84
  72         {0xb94470938fa89bcf, -316, false},  // 10^-76
  73         {0x8a08f0f8bf0f156b, -289, false},  // 10^-68
  74         {0xcdb02555653131b6, -263, false},  // 10^-60
  75         {0x993fe2c6d07b7fac, -236, false},  // 10^-52
  76         {0xe45c10c42a2b3b06, -210, false},  // 10^-44
  77         {0xaa242499697392d3, -183, false},  // 10^-36
  78         {0xfd87b5f28300ca0e, -157, false},  // 10^-28
  79         {0xbce5086492111aeb, -130, false},  // 10^-20
  80         {0x8cbccc096f5088cc, -103, false},  // 10^-12
  81         {0xd1b71758e219652c, -77, false},   // 10^-4
  82         {0x9c40000000000000, -50, false},   // 10^4
  83         {0xe8d4a51000000000, -24, false},   // 10^12
  84         {0xad78ebc5ac620000, 3, false},     // 10^20
  85         {0x813f3978f8940984, 30, false},    // 10^28
  86         {0xc097ce7bc90715b3, 56, false},    // 10^36
  87         {0x8f7e32ce7bea5c70, 83, false},    // 10^44
  88         {0xd5d238a4abe98068, 109, false},   // 10^52
  89         {0x9f4f2726179a2245, 136, false},   // 10^60
  90         {0xed63a231d4c4fb27, 162, false},   // 10^68
  91         {0xb0de65388cc8ada8, 189, false},   // 10^76
  92         {0x83c7088e1aab65db, 216, false},   // 10^84
  93         {0xc45d1df942711d9a, 242, false},   // 10^92
  94         {0x924d692ca61be758, 269, false},   // 10^100
  95         {0xda01ee641a708dea, 295, false},   // 10^108
  96         {0xa26da3999aef774a, 322, false},   // 10^116
  97         {0xf209787bb47d6b85, 348, false},   // 10^124
  98         {0xb454e4a179dd1877, 375, false},   // 10^132
  99         {0x865b86925b9bc5c2, 402, false},   // 10^140
 100         {0xc83553c5c8965d3d, 428, false},   // 10^148
 101         {0x952ab45cfa97a0b3, 455, false},   // 10^156
 102         {0xde469fbd99a05fe3, 481, false},   // 10^164
 103         {0xa59bc234db398c25, 508, false},   // 10^172
 104         {0xf6c69a72a3989f5c, 534, false},   // 10^180
 105         {0xb7dcbf5354e9bece, 561, false},   // 10^188
 106         {0x88fcf317f22241e2, 588, false},   // 10^196
 107         {0xcc20ce9bd35c78a5, 614, false},   // 10^204
 108         {0x98165af37b2153df, 641, false},   // 10^212
 109         {0xe2a0b5dc971f303a, 667, false},   // 10^220
 110         {0xa8d9d1535ce3b396, 694, false},   // 10^228
 111         {0xfb9b7cd9a4a7443c, 720, false},   // 10^236
 112         {0xbb764c4ca7a44410, 747, false},   // 10^244
 113         {0x8bab8eefb6409c1a, 774, false},   // 10^252
 114         {0xd01fef10a657842c, 800, false},   // 10^260
 115         {0x9b10a4e5e9913129, 827, false},   // 10^268
 116         {0xe7109bfba19c0c9d, 853, false},   // 10^276
 117         {0xac2820d9623bf429, 880, false},   // 10^284
 118         {0x80444b5e7aa7cf85, 907, false},   // 10^292
 119         {0xbf21e44003acdd2d, 933, false},   // 10^300
 120         {0x8e679c2f5e44ff8f, 960, false},   // 10^308
 121         {0xd433179d9c8cb841, 986, false},   // 10^316
 122         {0x9e19db92b4e31ba9, 1013, false},  // 10^324
 123         {0xeb96bf6ebadf77d9, 1039, false},  // 10^332
 124         {0xaf87023b9bf0ee6b, 1066, false},  // 10^340
 125 }
 126
 127 // floatBits returns the bits of the float64 that best approximates
 128 // the extFloat passed as receiver. Overflow is set to true if
 129 // the resulting float64 is ±Inf.
 130 func (f *extFloat) floatBits() (bits uint64, overflow bool) {
 131         flt := &float64info
 132         f.Normalize()
 133
 134         exp := f.exp + 63
 135
 136         // Exponent too small.
 137         if exp < flt.bias+1 {
 138                 n := flt.bias + 1 - exp
 139                 f.mant >>= uint(n)
 140                 exp += n
 141         }
 142
 143         // Extract 1+flt.mantbits bits.
 144         mant := f.mant >> (63 - flt.mantbits)
 145         if f.mant&(1<<(62-flt.mantbits)) != 0 {
 146                 // Round up.
 147                 mant += 1
 148         }
 149
 150         // Rounding might have added a bit; shift down.
 151         if mant == 2<<flt.mantbits {
 152                 mant >>= 1
 153                 exp++
 154         }
 155
 156         // Infinities.
 157         if exp-flt.bias >= 1<<flt.expbits-1 {
 158                 goto overflow
 159         }
 160
 161         // Denormalized?
 162         if mant&(1<<flt.mantbits) == 0 {
 163                 exp = flt.bias
 164         }
 165         goto out
 166
 167 overflow:
 168         // ±Inf
 169         mant = 0
 170         exp = 1<<flt.expbits - 1 + flt.bias
 171         overflow = true
 172
 173 out:
 174         // Assemble bits.
 175         bits = mant & (uint64(1)<<flt.mantbits - 1)
 176         bits |= uint64((exp-flt.bias)&(1<<flt.expbits-1)) << flt.mantbits
 177         if f.neg {
 178                 bits |= 1 << (flt.mantbits + flt.expbits)
 179         }
 180         return
 181 }
 182
 183 // Assign sets f to the value of x.
 184 func (f *extFloat) Assign(x float64) {
 185         if x < 0 {
 186                 x = -x
 187                 f.neg = true
 188         }
 189         x, f.exp = math.Frexp(x)
 190         f.mant = uint64(x * float64(1<<64))
 191         f.exp -= 64
 192 }
 193
 194 // AssignComputeBounds sets f to the value of x and returns
 195 // lower, upper such that any number in the closed interval
 196 // [lower, upper] is converted back to x.
 197 func (f *extFloat) AssignComputeBounds(x float64) (lower, upper extFloat) {
 198         // Special cases.
 199         bits := math.Float64bits(x)
 200         flt := &float64info
 201         neg := bits>>(flt.expbits+flt.mantbits) != 0
 202         expBiased := int(bits>>flt.mantbits) & (1<<flt.expbits - 1)
 203         mant := bits & (uint64(1)<<flt.mantbits - 1)
 204
 205         if expBiased == 0 {
 206                 // denormalized.
 207                 f.mant = mant
 208                 f.exp = 1 + flt.bias - int(flt.mantbits)
 209         } else {
 210                 f.mant = mant | 1<<flt.mantbits
 211                 f.exp = expBiased + flt.bias - int(flt.mantbits)
 212         }
 213         f.neg = neg
 214
 215         upper = extFloat{mant: 2*f.mant + 1, exp: f.exp - 1, neg: f.neg}
 216         if mant != 0 || expBiased == 1 {
 217                 lower = extFloat{mant: 2*f.mant - 1, exp: f.exp - 1, neg: f.neg}
 218         } else {
 219                 lower = extFloat{mant: 4*f.mant - 1, exp: f.exp - 2, neg: f.neg}
 220         }
 221         return
 222 }
 223
 224 // Normalize normalizes f so that the highest bit of the mantissa is
 225 // set, and returns the number by which the mantissa was left-shifted.
 226 func (f *extFloat) Normalize() uint {
 227         if f.mant == 0 {
 228                 return 0
 229         }
 230         exp_before := f.exp
 231         for f.mant < (1 << 55) {
 232                 f.mant <<= 8
 233                 f.exp -= 8
 234         }
 235         for f.mant < (1 << 63) {
 236                 f.mant <<= 1
 237                 f.exp -= 1
 238         }
 239         return uint(exp_before - f.exp)
 240 }
 241
 242 // Multiply sets f to the product f*g: the result is correctly rounded,
 243 // but not normalized.
 244 func (f *extFloat) Multiply(g extFloat) {
 245         fhi, flo := f.mant>>32, uint64(uint32(f.mant))
 246         ghi, glo := g.mant>>32, uint64(uint32(g.mant))
 247
 248         // Cross products.
 249         cross1 := fhi * glo
 250         cross2 := flo * ghi
 251
 252         // f.mant*g.mant is fhi*ghi << 64 + (cross1+cross2) << 32 + flo*glo
 253         f.mant = fhi*ghi + (cross1 >> 32) + (cross2 >> 32)
 254         rem := uint64(uint32(cross1)) + uint64(uint32(cross2)) + ((flo * glo) >> 32)
 255         // Round up.
 256         rem += (1 << 31)
 257
 258         f.mant += (rem >> 32)
 259         f.exp = f.exp + g.exp + 64
 260 }
 261
 262 var uint64pow10 = [...]uint64{
 263         1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
 264         1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
 265 }
 266
 267 // AssignDecimal sets f to an approximate value of the decimal d. It
 268 // returns true if the value represented by f is guaranteed to be the
 269 // best approximation of d after being rounded to a float64.
 270 func (f *extFloat) AssignDecimal(d *decimal) (ok bool) {
 271         const uint64digits = 19
 272         const errorscale = 8
 273         mant10, digits := d.atou64()
 274         exp10 := d.dp - digits
 275         errors := 0 // An upper bound for error, computed in errorscale*ulp.
 276
 277         if digits < d.nd {
 278                 // the decimal number was truncated.
 279                 errors += errorscale / 2
 280         }
 281
 282         f.mant = mant10
 283         f.exp = 0
 284         f.neg = d.neg
 285
 286         // Multiply by powers of ten.
 287         i := (exp10 - firstPowerOfTen) / stepPowerOfTen
 288         if exp10 < firstPowerOfTen || i >= len(powersOfTen) {
 289                 return false
 290         }
 291         adjExp := (exp10 - firstPowerOfTen) % stepPowerOfTen
 292
 293         // We multiply by exp%step
 294         if digits+adjExp <= uint64digits {
 295                 // We can multiply the mantissa
 296                 f.mant *= uint64(float64pow10[adjExp])
 297                 f.Normalize()
 298         } else {
 299                 f.Normalize()
 300                 f.Multiply(smallPowersOfTen[adjExp])
 301                 errors += errorscale / 2
 302         }
 303
 304         // We multiply by 10 to the exp - exp%step.
 305         f.Multiply(powersOfTen[i])
 306         if errors > 0 {
 307                 errors += 1
 308         }
 309         errors += errorscale / 2
 310
 311         // Normalize
 312         shift := f.Normalize()
 313         errors <<= shift
 314
 315         // Now f is a good approximation of the decimal.
 316         // Check whether the error is too large: that is, if the mantissa
 317         // is perturbated by the error, the resulting float64 will change.
 318         // The 64 bits mantissa is 1 + 52 bits for float64 + 11 extra bits.
 319         //
 320         // In many cases the approximation will be good enough.
 321         const denormalExp = -1023 - 63
 322         flt := &float64info
 323         var extrabits uint
 324         if f.exp <= denormalExp {
 325                 extrabits = uint(63 - flt.mantbits + 1 + uint(denormalExp-f.exp))
 326         } else {
 327                 extrabits = uint(63 - flt.mantbits)
 328         }
 329
 330         halfway := uint64(1) << (extrabits - 1)
 331         mant_extra := f.mant & (1<<extrabits - 1)
 332
 333         // Do a signed comparison here! If the error estimate could make
 334         // the mantissa round differently for the conversion to double,
 335         // then we can't give a definite answer.
 336         if int64(halfway)-int64(errors) < int64(mant_extra) &&
 337                 int64(mant_extra) < int64(halfway)+int64(errors) {
 338                 return false
 339         }
 340         return true
 341 }
 342
 343 // Frexp10 is an analogue of math.Frexp for decimal powers. It scales
 344 // f by an approximate power of ten 10^-exp, and returns exp10, so
 345 // that f*10^exp10 has the same value as the old f, up to an ulp,
 346 // as well as the index of 10^-exp in the powersOfTen table.
 347 // The arguments expMin and expMax constrain the final value of the
 348 // binary exponent of f.
 349 func (f *extFloat) frexp10(expMin, expMax int) (exp10, index int) {
 350         // it is illegal to call this function with a too restrictive exponent range.
 351         if expMax-expMin <= 25 {
 352                 panic("strconv: invalid exponent range")
 353         }
 354         // Find power of ten such that x * 10^n has a binary exponent
 355         // between expMin and expMax
 356         approxExp10 := -(f.exp + 100) * 28 / 93 // log(10)/log(2) is close to 93/28.
 357         i := (approxExp10 - firstPowerOfTen) / stepPowerOfTen
 358 Loop:
 359         for {
 360                 exp := f.exp + powersOfTen[i].exp + 64
 361                 switch {
 362                 case exp < expMin:
 363                         i++
 364                 case exp > expMax:
 365                         i--
 366                 default:
 367                         break Loop
 368                 }
 369         }
 370         // Apply the desired decimal shift on f. It will have exponent
 371         // in the desired range. This is multiplication by 10^-exp10.
 372         f.Multiply(powersOfTen[i])
 373
 374         return -(firstPowerOfTen + i*stepPowerOfTen), i
 375 }
 376
 377 // frexp10Many applies a common shift by a power of ten to a, b, c.
 378 func frexp10Many(expMin, expMax int, a, b, c *extFloat) (exp10 int) {
 379         exp10, i := c.frexp10(expMin, expMax)
 380         a.Multiply(powersOfTen[i])
 381         b.Multiply(powersOfTen[i])
 382         return
 383 }
 384
 385 // ShortestDecimal stores in d the shortest decimal representation of f
 386 // which belongs to the open interval (lower, upper), where f is supposed
 387 // to lie. It returns false whenever the result is unsure. The implementation
 388 // uses the Grisu3 algorithm.
 389 func (f *extFloat) ShortestDecimal(d *decimal, lower, upper *extFloat) bool {
 390         if f.mant == 0 {
 391                 d.d[0] = '0'
 392                 d.nd = 1
 393                 d.dp = 0
 394                 d.neg = f.neg
 395         }
 396         const minExp = -60
 397         const maxExp = -32
 398         upper.Normalize()
 399         // Uniformize exponents.
 400         if f.exp > upper.exp {
 401                 f.mant <<= uint(f.exp - upper.exp)
 402                 f.exp = upper.exp
 403         }
 404         if lower.exp > upper.exp {
 405                 lower.mant <<= uint(lower.exp - upper.exp)
 406                 lower.exp = upper.exp
 407         }
 408
 409         exp10 := frexp10Many(minExp, maxExp, lower, f, upper)
 410         // Take a safety margin due to rounding in frexp10Many, but we lose precision.
 411         upper.mant++
 412         lower.mant--
 413
 414         // The shortest representation of f is either rounded up or down, but
 415         // in any case, it is a truncation of upper.
 416         shift := uint(-upper.exp)
 417         integer := uint32(upper.mant >> shift)
 418         fraction := upper.mant - (uint64(integer) << shift)
 419
 420         // How far we can go down from upper until the result is wrong.
 421         allowance := upper.mant - lower.mant
 422         // How far we should go to get a very precise result.
 423         targetDiff := upper.mant - f.mant
 424
 425         // Count integral digits: there are at most 10.
 426         var integerDigits int
 427         for i, pow := range uint64pow10 {
 428                 if uint64(integer) >= pow {
 429                         integerDigits = i + 1
 430                 }
 431         }
 432         for i := 0; i < integerDigits; i++ {
 433                 pow := uint64pow10[integerDigits-i-1]
 434                 digit := integer / uint32(pow)
 435                 d.d[i] = byte(digit + '0')
 436                 integer -= digit * uint32(pow)
 437                 // evaluate whether we should stop.
 438                 if currentDiff := uint64(integer)<<shift + fraction; currentDiff < allowance {
 439                         d.nd = i + 1
 440                         d.dp = integerDigits + exp10
 441                         d.neg = f.neg
 442                         // Sometimes allowance is so large the last digit might need to be
 443                         // decremented to get closer to f.
 444                         return adjustLastDigit(d, currentDiff, targetDiff, allowance, pow<<shift, 2)
 445                 }
 446         }
 447         d.nd = integerDigits
 448         d.dp = d.nd + exp10
 449         d.neg = f.neg
 450
 451         // Compute digits of the fractional part. At each step fraction does not
 452         // overflow. The choice of minExp implies that fraction is less than 2^60.
 453         var digit int
 454         multiplier := uint64(1)
 455         for {
 456                 fraction *= 10
 457                 multiplier *= 10
 458                 digit = int(fraction >> shift)
 459                 d.d[d.nd] = byte(digit + '0')
 460                 d.nd++
 461                 fraction -= uint64(digit) << shift
 462                 if fraction < allowance*multiplier {
 463                         // We are in the admissible range. Note that if allowance is about to
 464                         // overflow, that is, allowance > 2^64/10, the condition is automatically
 465                         // true due to the limited range of fraction.
 466                         return adjustLastDigit(d,
 467                                 fraction, targetDiff*multiplier, allowance*multiplier,
 468                                 1<<shift, multiplier*2)
 469                 }
 470         }
 471         return false
 472 }
 473
 474 // adjustLastDigit modifies d = x-currentDiff*ε, to get closest to
 475 // d = x-targetDiff*ε, without becoming smaller than x-maxDiff*ε.
 476 // It assumes that a decimal digit is worth ulpDecimal*ε, and that
 477 // all data is known with a error estimate of ulpBinary*ε.
 478 func adjustLastDigit(d *decimal, currentDiff, targetDiff, maxDiff, ulpDecimal, ulpBinary uint64) bool {
 479         if ulpDecimal < 2*ulpBinary {
 480                 // Approximation is too wide.
 481                 return false
 482         }
 483         for currentDiff+ulpDecimal/2+ulpBinary < targetDiff {
 484                 d.d[d.nd-1]--
 485                 currentDiff += ulpDecimal
 486         }
 487         if currentDiff+ulpDecimal <= targetDiff+ulpDecimal/2+ulpBinary {
 488                 // we have two choices, and don't know what to do.
 489                 return false
 490         }
 491         if currentDiff < ulpBinary || currentDiff > maxDiff-ulpBinary {
 492                 // we went too far
 493                 return false
 494         }
 495         if d.nd == 1 && d.d[0] == '0' {
 496                 // the number has actually reached zero.
 497                 d.nd = 0
 498                 d.dp = 0
 499         }
 500         return true
 501 }