src/pkg/strconv/extfloat.go - The Go Programming Language

Golang

Source file src/pkg/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	}