Source file
src/strconv/extfloat.go
Documentation: strconv
1
2
3
4
5 package strconv
6
7 import (
8 "math/bits"
9 )
10
11
12
13
14
15 type extFloat struct {
16 mant uint64
17 exp int
18 neg bool
19 }
20
21
22
23 const (
24 firstPowerOfTen = -348
25 stepPowerOfTen = 8
26 )
27
28 var smallPowersOfTen = [...]extFloat{
29 {1 << 63, -63, false},
30 {0xa << 60, -60, false},
31 {0x64 << 57, -57, false},
32 {0x3e8 << 54, -54, false},
33 {0x2710 << 50, -50, false},
34 {0x186a0 << 47, -47, false},
35 {0xf4240 << 44, -44, false},
36 {0x989680 << 40, -40, false},
37 }
38
39 var powersOfTen = [...]extFloat{
40 {0xfa8fd5a0081c0288, -1220, false},
41 {0xbaaee17fa23ebf76, -1193, false},
42 {0x8b16fb203055ac76, -1166, false},
43 {0xcf42894a5dce35ea, -1140, false},
44 {0x9a6bb0aa55653b2d, -1113, false},
45 {0xe61acf033d1a45df, -1087, false},
46 {0xab70fe17c79ac6ca, -1060, false},
47 {0xff77b1fcbebcdc4f, -1034, false},
48 {0xbe5691ef416bd60c, -1007, false},
49 {0x8dd01fad907ffc3c, -980, false},
50 {0xd3515c2831559a83, -954, false},
51 {0x9d71ac8fada6c9b5, -927, false},
52 {0xea9c227723ee8bcb, -901, false},
53 {0xaecc49914078536d, -874, false},
54 {0x823c12795db6ce57, -847, false},
55 {0xc21094364dfb5637, -821, false},
56 {0x9096ea6f3848984f, -794, false},
57 {0xd77485cb25823ac7, -768, false},
58 {0xa086cfcd97bf97f4, -741, false},
59 {0xef340a98172aace5, -715, false},
60 {0xb23867fb2a35b28e, -688, false},
61 {0x84c8d4dfd2c63f3b, -661, false},
62 {0xc5dd44271ad3cdba, -635, false},
63 {0x936b9fcebb25c996, -608, false},
64 {0xdbac6c247d62a584, -582, false},
65 {0xa3ab66580d5fdaf6, -555, false},
66 {0xf3e2f893dec3f126, -529, false},
67 {0xb5b5ada8aaff80b8, -502, false},
68 {0x87625f056c7c4a8b, -475, false},
69 {0xc9bcff6034c13053, -449, false},
70 {0x964e858c91ba2655, -422, false},
71 {0xdff9772470297ebd, -396, false},
72 {0xa6dfbd9fb8e5b88f, -369, false},
73 {0xf8a95fcf88747d94, -343, false},
74 {0xb94470938fa89bcf, -316, false},
75 {0x8a08f0f8bf0f156b, -289, false},
76 {0xcdb02555653131b6, -263, false},
77 {0x993fe2c6d07b7fac, -236, false},
78 {0xe45c10c42a2b3b06, -210, false},
79 {0xaa242499697392d3, -183, false},
80 {0xfd87b5f28300ca0e, -157, false},
81 {0xbce5086492111aeb, -130, false},
82 {0x8cbccc096f5088cc, -103, false},
83 {0xd1b71758e219652c, -77, false},
84 {0x9c40000000000000, -50, false},
85 {0xe8d4a51000000000, -24, false},
86 {0xad78ebc5ac620000, 3, false},
87 {0x813f3978f8940984, 30, false},
88 {0xc097ce7bc90715b3, 56, false},
89 {0x8f7e32ce7bea5c70, 83, false},
90 {0xd5d238a4abe98068, 109, false},
91 {0x9f4f2726179a2245, 136, false},
92 {0xed63a231d4c4fb27, 162, false},
93 {0xb0de65388cc8ada8, 189, false},
94 {0x83c7088e1aab65db, 216, false},
95 {0xc45d1df942711d9a, 242, false},
96 {0x924d692ca61be758, 269, false},
97 {0xda01ee641a708dea, 295, false},
98 {0xa26da3999aef774a, 322, false},
99 {0xf209787bb47d6b85, 348, false},
100 {0xb454e4a179dd1877, 375, false},
101 {0x865b86925b9bc5c2, 402, false},
102 {0xc83553c5c8965d3d, 428, false},
103 {0x952ab45cfa97a0b3, 455, false},
104 {0xde469fbd99a05fe3, 481, false},
105 {0xa59bc234db398c25, 508, false},
106 {0xf6c69a72a3989f5c, 534, false},
107 {0xb7dcbf5354e9bece, 561, false},
108 {0x88fcf317f22241e2, 588, false},
109 {0xcc20ce9bd35c78a5, 614, false},
110 {0x98165af37b2153df, 641, false},
111 {0xe2a0b5dc971f303a, 667, false},
112 {0xa8d9d1535ce3b396, 694, false},
113 {0xfb9b7cd9a4a7443c, 720, false},
114 {0xbb764c4ca7a44410, 747, false},
115 {0x8bab8eefb6409c1a, 774, false},
116 {0xd01fef10a657842c, 800, false},
117 {0x9b10a4e5e9913129, 827, false},
118 {0xe7109bfba19c0c9d, 853, false},
119 {0xac2820d9623bf429, 880, false},
120 {0x80444b5e7aa7cf85, 907, false},
121 {0xbf21e44003acdd2d, 933, false},
122 {0x8e679c2f5e44ff8f, 960, false},
123 {0xd433179d9c8cb841, 986, false},
124 {0x9e19db92b4e31ba9, 1013, false},
125 {0xeb96bf6ebadf77d9, 1039, false},
126 {0xaf87023b9bf0ee6b, 1066, false},
127 }
128
129
130
131
132 func (f *extFloat) floatBits(flt *floatInfo) (bits uint64, overflow bool) {
133 f.Normalize()
134
135 exp := f.exp + 63
136
137
138 if exp < flt.bias+1 {
139 n := flt.bias + 1 - exp
140 f.mant >>= uint(n)
141 exp += n
142 }
143
144
145 mant := f.mant >> (63 - flt.mantbits)
146 if f.mant&(1<<(62-flt.mantbits)) != 0 {
147
148 mant += 1
149 }
150
151
152 if mant == 2<<flt.mantbits {
153 mant >>= 1
154 exp++
155 }
156
157
158 if exp-flt.bias >= 1<<flt.expbits-1 {
159
160 mant = 0
161 exp = 1<<flt.expbits - 1 + flt.bias
162 overflow = true
163 } else if mant&(1<<flt.mantbits) == 0 {
164
165 exp = flt.bias
166 }
167
168 bits = mant & (uint64(1)<<flt.mantbits - 1)
169 bits |= uint64((exp-flt.bias)&(1<<flt.expbits-1)) << flt.mantbits
170 if f.neg {
171 bits |= 1 << (flt.mantbits + flt.expbits)
172 }
173 return
174 }
175
176
177
178
179
180 func (f *extFloat) AssignComputeBounds(mant uint64, exp int, neg bool, flt *floatInfo) (lower, upper extFloat) {
181 f.mant = mant
182 f.exp = exp - int(flt.mantbits)
183 f.neg = neg
184 if f.exp <= 0 && mant == (mant>>uint(-f.exp))<<uint(-f.exp) {
185
186 f.mant >>= uint(-f.exp)
187 f.exp = 0
188 return *f, *f
189 }
190 expBiased := exp - flt.bias
191
192 upper = extFloat{mant: 2*f.mant + 1, exp: f.exp - 1, neg: f.neg}
193 if mant != 1<<flt.mantbits || expBiased == 1 {
194 lower = extFloat{mant: 2*f.mant - 1, exp: f.exp - 1, neg: f.neg}
195 } else {
196 lower = extFloat{mant: 4*f.mant - 1, exp: f.exp - 2, neg: f.neg}
197 }
198 return
199 }
200
201
202
203 func (f *extFloat) Normalize() uint {
204
205 if f.mant == 0 {
206 return 0
207 }
208 shift := bits.LeadingZeros64(f.mant)
209 f.mant <<= uint(shift)
210 f.exp -= shift
211 return uint(shift)
212 }
213
214
215
216 func (f *extFloat) Multiply(g extFloat) {
217 hi, lo := bits.Mul64(f.mant, g.mant)
218
219 f.mant = hi + (lo >> 63)
220 f.exp = f.exp + g.exp + 64
221 }
222
223 var uint64pow10 = [...]uint64{
224 1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
225 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
226 }
227
228
229
230
231
232 func (f *extFloat) AssignDecimal(mantissa uint64, exp10 int, neg bool, trunc bool, flt *floatInfo) (ok bool) {
233 const uint64digits = 19
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255 const errorscale = 8
256
257 errors := 0
258 if trunc {
259
260 errors += errorscale / 2
261 }
262
263 f.mant = mantissa
264 f.exp = 0
265 f.neg = neg
266
267
268 i := (exp10 - firstPowerOfTen) / stepPowerOfTen
269 if exp10 < firstPowerOfTen || i >= len(powersOfTen) {
270 return false
271 }
272 adjExp := (exp10 - firstPowerOfTen) % stepPowerOfTen
273
274
275 if adjExp < uint64digits && mantissa < uint64pow10[uint64digits-adjExp] {
276
277 f.mant *= uint64pow10[adjExp]
278 f.Normalize()
279 } else {
280 f.Normalize()
281 f.Multiply(smallPowersOfTen[adjExp])
282 errors += errorscale / 2
283 }
284
285
286 f.Multiply(powersOfTen[i])
287 if errors > 0 {
288 errors += 1
289 }
290 errors += errorscale / 2
291
292
293 shift := f.Normalize()
294 errors <<= shift
295
296
297
298
299
300
301
302 denormalExp := flt.bias - 63
303 var extrabits uint
304 if f.exp <= denormalExp {
305
306 extrabits = 63 - flt.mantbits + 1 + uint(denormalExp-f.exp)
307 } else {
308 extrabits = 63 - flt.mantbits
309 }
310
311 halfway := uint64(1) << (extrabits - 1)
312 mant_extra := f.mant & (1<<extrabits - 1)
313
314
315
316
317 if int64(halfway)-int64(errors) < int64(mant_extra) &&
318 int64(mant_extra) < int64(halfway)+int64(errors) {
319 return false
320 }
321 return true
322 }
323
324
325
326
327
328 func (f *extFloat) frexp10() (exp10, index int) {
329
330
331
332
333
334 const expMin = -60
335 const expMax = -32
336
337
338 approxExp10 := ((expMin+expMax)/2 - f.exp) * 28 / 93
339 i := (approxExp10 - firstPowerOfTen) / stepPowerOfTen
340 Loop:
341 for {
342 exp := f.exp + powersOfTen[i].exp + 64
343 switch {
344 case exp < expMin:
345 i++
346 case exp > expMax:
347 i--
348 default:
349 break Loop
350 }
351 }
352
353
354 f.Multiply(powersOfTen[i])
355
356 return -(firstPowerOfTen + i*stepPowerOfTen), i
357 }
358
359
360 func frexp10Many(a, b, c *extFloat) (exp10 int) {
361 exp10, i := c.frexp10()
362 a.Multiply(powersOfTen[i])
363 b.Multiply(powersOfTen[i])
364 return
365 }
366
367
368
369
370 func (f *extFloat) FixedDecimal(d *decimalSlice, n int) bool {
371 if f.mant == 0 {
372 d.nd = 0
373 d.dp = 0
374 d.neg = f.neg
375 return true
376 }
377 if n == 0 {
378 panic("strconv: internal error: extFloat.FixedDecimal called with n == 0")
379 }
380
381
382 f.Normalize()
383 exp10, _ := f.frexp10()
384
385 shift := uint(-f.exp)
386 integer := uint32(f.mant >> shift)
387 fraction := f.mant - (uint64(integer) << shift)
388 ε := uint64(1)
389
390
391 needed := n
392 integerDigits := 0
393 pow10 := uint64(1)
394 for i, pow := 0, uint64(1); i < 20; i++ {
395 if pow > uint64(integer) {
396 integerDigits = i
397 break
398 }
399 pow *= 10
400 }
401 rest := integer
402 if integerDigits > needed {
403
404 pow10 = uint64pow10[integerDigits-needed]
405 integer /= uint32(pow10)
406 rest -= integer * uint32(pow10)
407 } else {
408 rest = 0
409 }
410
411
412 var buf [32]byte
413 pos := len(buf)
414 for v := integer; v > 0; {
415 v1 := v / 10
416 v -= 10 * v1
417 pos--
418 buf[pos] = byte(v + '0')
419 v = v1
420 }
421 for i := pos; i < len(buf); i++ {
422 d.d[i-pos] = buf[i]
423 }
424 nd := len(buf) - pos
425 d.nd = nd
426 d.dp = integerDigits + exp10
427 needed -= nd
428
429 if needed > 0 {
430 if rest != 0 || pow10 != 1 {
431 panic("strconv: internal error, rest != 0 but needed > 0")
432 }
433
434
435 for needed > 0 {
436 fraction *= 10
437 ε *= 10
438 if 2*ε > 1<<shift {
439
440 return false
441 }
442 digit := fraction >> shift
443 d.d[nd] = byte(digit + '0')
444 fraction -= digit << shift
445 nd++
446 needed--
447 }
448 d.nd = nd
449 }
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466 ok := adjustLastDigitFixed(d, uint64(rest)<<shift|fraction, pow10, shift, ε)
467 if !ok {
468 return false
469 }
470
471 for i := d.nd - 1; i >= 0; i-- {
472 if d.d[i] != '0' {
473 d.nd = i + 1
474 break
475 }
476 }
477 return true
478 }
479
480
481
482
483
484
485
486
487
488 func adjustLastDigitFixed(d *decimalSlice, num, den uint64, shift uint, ε uint64) bool {
489 if num > den<<shift {
490 panic("strconv: num > den<<shift in adjustLastDigitFixed")
491 }
492 if 2*ε > den<<shift {
493 panic("strconv: ε > (den<<shift)/2")
494 }
495 if 2*(num+ε) < den<<shift {
496 return true
497 }
498 if 2*(num-ε) > den<<shift {
499
500 i := d.nd - 1
501 for ; i >= 0; i-- {
502 if d.d[i] == '9' {
503 d.nd--
504 } else {
505 break
506 }
507 }
508 if i < 0 {
509 d.d[0] = '1'
510 d.nd = 1
511 d.dp++
512 } else {
513 d.d[i]++
514 }
515 return true
516 }
517 return false
518 }
519
520
521
522
523
524 func (f *extFloat) ShortestDecimal(d *decimalSlice, lower, upper *extFloat) bool {
525 if f.mant == 0 {
526 d.nd = 0
527 d.dp = 0
528 d.neg = f.neg
529 return true
530 }
531 if f.exp == 0 && *lower == *f && *lower == *upper {
532
533 var buf [24]byte
534 n := len(buf) - 1
535 for v := f.mant; v > 0; {
536 v1 := v / 10
537 v -= 10 * v1
538 buf[n] = byte(v + '0')
539 n--
540 v = v1
541 }
542 nd := len(buf) - n - 1
543 for i := 0; i < nd; i++ {
544 d.d[i] = buf[n+1+i]
545 }
546 d.nd, d.dp = nd, nd
547 for d.nd > 0 && d.d[d.nd-1] == '0' {
548 d.nd--
549 }
550 if d.nd == 0 {
551 d.dp = 0
552 }
553 d.neg = f.neg
554 return true
555 }
556 upper.Normalize()
557
558 if f.exp > upper.exp {
559 f.mant <<= uint(f.exp - upper.exp)
560 f.exp = upper.exp
561 }
562 if lower.exp > upper.exp {
563 lower.mant <<= uint(lower.exp - upper.exp)
564 lower.exp = upper.exp
565 }
566
567 exp10 := frexp10Many(lower, f, upper)
568
569 upper.mant++
570 lower.mant--
571
572
573
574 shift := uint(-upper.exp)
575 integer := uint32(upper.mant >> shift)
576 fraction := upper.mant - (uint64(integer) << shift)
577
578
579 allowance := upper.mant - lower.mant
580
581 targetDiff := upper.mant - f.mant
582
583
584 var integerDigits int
585 for i, pow := 0, uint64(1); i < 20; i++ {
586 if pow > uint64(integer) {
587 integerDigits = i
588 break
589 }
590 pow *= 10
591 }
592 for i := 0; i < integerDigits; i++ {
593 pow := uint64pow10[integerDigits-i-1]
594 digit := integer / uint32(pow)
595 d.d[i] = byte(digit + '0')
596 integer -= digit * uint32(pow)
597
598 if currentDiff := uint64(integer)<<shift + fraction; currentDiff < allowance {
599 d.nd = i + 1
600 d.dp = integerDigits + exp10
601 d.neg = f.neg
602
603
604 return adjustLastDigit(d, currentDiff, targetDiff, allowance, pow<<shift, 2)
605 }
606 }
607 d.nd = integerDigits
608 d.dp = d.nd + exp10
609 d.neg = f.neg
610
611
612
613 var digit int
614 multiplier := uint64(1)
615 for {
616 fraction *= 10
617 multiplier *= 10
618 digit = int(fraction >> shift)
619 d.d[d.nd] = byte(digit + '0')
620 d.nd++
621 fraction -= uint64(digit) << shift
622 if fraction < allowance*multiplier {
623
624
625
626 return adjustLastDigit(d,
627 fraction, targetDiff*multiplier, allowance*multiplier,
628 1<<shift, multiplier*2)
629 }
630 }
631 }
632
633
634
635
636
637 func adjustLastDigit(d *decimalSlice, currentDiff, targetDiff, maxDiff, ulpDecimal, ulpBinary uint64) bool {
638 if ulpDecimal < 2*ulpBinary {
639
640 return false
641 }
642 for currentDiff+ulpDecimal/2+ulpBinary < targetDiff {
643 d.d[d.nd-1]--
644 currentDiff += ulpDecimal
645 }
646 if currentDiff+ulpDecimal <= targetDiff+ulpDecimal/2+ulpBinary {
647
648 return false
649 }
650 if currentDiff < ulpBinary || currentDiff > maxDiff-ulpBinary {
651
652 return false
653 }
654 if d.nd == 1 && d.d[0] == '0' {
655
656 d.nd = 0
657 d.dp = 0
658 }
659 return true
660 }
661
View as plain text