Source file src/strconv/ftoaryu.go

Documentation: strconv

		 1  // Copyright 2021 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 (
		 8  	"math/bits"
		 9  )
		10  
		11  // binary to decimal conversion using the Ryū algorithm.
		12  //
		13  // See Ulf Adams, "Ryū: Fast Float-to-String Conversion" (doi:10.1145/3192366.3192369)
		14  //
		15  // Fixed precision formatting is a variant of the original paper's
		16  // algorithm, where a single multiplication by 10^k is required,
		17  // sharing the same rounding guarantees.
		18  
		19  // ryuFtoaFixed32 formats mant*(2^exp) with prec decimal digits.
		20  func ryuFtoaFixed32(d *decimalSlice, mant uint32, exp int, prec int) {
		21  	if prec < 0 {
		22  		panic("ryuFtoaFixed32 called with negative prec")
		23  	}
		24  	if prec > 9 {
		25  		panic("ryuFtoaFixed32 called with prec > 9")
		26  	}
		27  	// Zero input.
		28  	if mant == 0 {
		29  		d.nd, d.dp = 0, 0
		30  		return
		31  	}
		32  	// Renormalize to a 25-bit mantissa.
		33  	e2 := exp
		34  	if b := bits.Len32(mant); b < 25 {
		35  		mant <<= uint(25 - b)
		36  		e2 += int(b) - 25
		37  	}
		38  	// Choose an exponent such that rounded mant*(2^e2)*(10^q) has
		39  	// at least prec decimal digits, i.e
		40  	//		 mant*(2^e2)*(10^q) >= 10^(prec-1)
		41  	// Because mant >= 2^24, it is enough to choose:
		42  	//		 2^(e2+24) >= 10^(-q+prec-1)
		43  	// or q = -mulByLog2Log10(e2+24) + prec - 1
		44  	q := -mulByLog2Log10(e2+24) + prec - 1
		45  
		46  	// Now compute mant*(2^e2)*(10^q).
		47  	// Is it an exact computation?
		48  	// Only small positive powers of 10 are exact (5^28 has 66 bits).
		49  	exact := q <= 27 && q >= 0
		50  
		51  	di, dexp2, d0 := mult64bitPow10(mant, e2, q)
		52  	if dexp2 >= 0 {
		53  		panic("not enough significant bits after mult64bitPow10")
		54  	}
		55  	// As a special case, computation might still be exact, if exponent
		56  	// was negative and if it amounts to computing an exact division.
		57  	// In that case, we ignore all lower bits.
		58  	// Note that division by 10^11 cannot be exact as 5^11 has 26 bits.
		59  	if q < 0 && q >= -10 && divisibleByPower5(uint64(mant), -q) {
		60  		exact = true
		61  		d0 = true
		62  	}
		63  	// Remove extra lower bits and keep rounding info.
		64  	extra := uint(-dexp2)
		65  	extraMask := uint32(1<<extra - 1)
		66  
		67  	di, dfrac := di>>extra, di&extraMask
		68  	roundUp := false
		69  	if exact {
		70  		// If we computed an exact product, d + 1/2
		71  		// should round to d+1 if 'd' is odd.
		72  		roundUp = dfrac > 1<<(extra-1) ||
		73  			(dfrac == 1<<(extra-1) && !d0) ||
		74  			(dfrac == 1<<(extra-1) && d0 && di&1 == 1)
		75  	} else {
		76  		// otherwise, d+1/2 always rounds up because
		77  		// we truncated below.
		78  		roundUp = dfrac>>(extra-1) == 1
		79  	}
		80  	if dfrac != 0 {
		81  		d0 = false
		82  	}
		83  	// Proceed to the requested number of digits
		84  	formatDecimal(d, uint64(di), !d0, roundUp, prec)
		85  	// Adjust exponent
		86  	d.dp -= q
		87  }
		88  
		89  // ryuFtoaFixed64 formats mant*(2^exp) with prec decimal digits.
		90  func ryuFtoaFixed64(d *decimalSlice, mant uint64, exp int, prec int) {
		91  	if prec > 18 {
		92  		panic("ryuFtoaFixed64 called with prec > 18")
		93  	}
		94  	// Zero input.
		95  	if mant == 0 {
		96  		d.nd, d.dp = 0, 0
		97  		return
		98  	}
		99  	// Renormalize to a 55-bit mantissa.
	 100  	e2 := exp
	 101  	if b := bits.Len64(mant); b < 55 {
	 102  		mant = mant << uint(55-b)
	 103  		e2 += int(b) - 55
	 104  	}
	 105  	// Choose an exponent such that rounded mant*(2^e2)*(10^q) has
	 106  	// at least prec decimal digits, i.e
	 107  	//		 mant*(2^e2)*(10^q) >= 10^(prec-1)
	 108  	// Because mant >= 2^54, it is enough to choose:
	 109  	//		 2^(e2+54) >= 10^(-q+prec-1)
	 110  	// or q = -mulByLog2Log10(e2+54) + prec - 1
	 111  	//
	 112  	// The minimal required exponent is -mulByLog2Log10(1025)+18 = -291
	 113  	// The maximal required exponent is mulByLog2Log10(1074)+18 = 342
	 114  	q := -mulByLog2Log10(e2+54) + prec - 1
	 115  
	 116  	// Now compute mant*(2^e2)*(10^q).
	 117  	// Is it an exact computation?
	 118  	// Only small positive powers of 10 are exact (5^55 has 128 bits).
	 119  	exact := q <= 55 && q >= 0
	 120  
	 121  	di, dexp2, d0 := mult128bitPow10(mant, e2, q)
	 122  	if dexp2 >= 0 {
	 123  		panic("not enough significant bits after mult128bitPow10")
	 124  	}
	 125  	// As a special case, computation might still be exact, if exponent
	 126  	// was negative and if it amounts to computing an exact division.
	 127  	// In that case, we ignore all lower bits.
	 128  	// Note that division by 10^23 cannot be exact as 5^23 has 54 bits.
	 129  	if q < 0 && q >= -22 && divisibleByPower5(mant, -q) {
	 130  		exact = true
	 131  		d0 = true
	 132  	}
	 133  	// Remove extra lower bits and keep rounding info.
	 134  	extra := uint(-dexp2)
	 135  	extraMask := uint64(1<<extra - 1)
	 136  
	 137  	di, dfrac := di>>extra, di&extraMask
	 138  	roundUp := false
	 139  	if exact {
	 140  		// If we computed an exact product, d + 1/2
	 141  		// should round to d+1 if 'd' is odd.
	 142  		roundUp = dfrac > 1<<(extra-1) ||
	 143  			(dfrac == 1<<(extra-1) && !d0) ||
	 144  			(dfrac == 1<<(extra-1) && d0 && di&1 == 1)
	 145  	} else {
	 146  		// otherwise, d+1/2 always rounds up because
	 147  		// we truncated below.
	 148  		roundUp = dfrac>>(extra-1) == 1
	 149  	}
	 150  	if dfrac != 0 {
	 151  		d0 = false
	 152  	}
	 153  	// Proceed to the requested number of digits
	 154  	formatDecimal(d, di, !d0, roundUp, prec)
	 155  	// Adjust exponent
	 156  	d.dp -= q
	 157  }
	 158  
	 159  var uint64pow10 = [...]uint64{
	 160  	1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
	 161  	1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
	 162  }
	 163  
	 164  // formatDecimal fills d with at most prec decimal digits
	 165  // of mantissa m. The boolean trunc indicates whether m
	 166  // is truncated compared to the original number being formatted.
	 167  func formatDecimal(d *decimalSlice, m uint64, trunc bool, roundUp bool, prec int) {
	 168  	max := uint64pow10[prec]
	 169  	trimmed := 0
	 170  	for m >= max {
	 171  		a, b := m/10, m%10
	 172  		m = a
	 173  		trimmed++
	 174  		if b > 5 {
	 175  			roundUp = true
	 176  		} else if b < 5 {
	 177  			roundUp = false
	 178  		} else { // b == 5
	 179  			// round up if there are trailing digits,
	 180  			// or if the new value of m is odd (round-to-even convention)
	 181  			roundUp = trunc || m&1 == 1
	 182  		}
	 183  		if b != 0 {
	 184  			trunc = true
	 185  		}
	 186  	}
	 187  	if roundUp {
	 188  		m++
	 189  	}
	 190  	if m >= max {
	 191  		// Happens if di was originally 99999....xx
	 192  		m /= 10
	 193  		trimmed++
	 194  	}
	 195  	// render digits (similar to formatBits)
	 196  	n := uint(prec)
	 197  	d.nd = int(prec)
	 198  	v := m
	 199  	for v >= 100 {
	 200  		var v1, v2 uint64
	 201  		if v>>32 == 0 {
	 202  			v1, v2 = uint64(uint32(v)/100), uint64(uint32(v)%100)
	 203  		} else {
	 204  			v1, v2 = v/100, v%100
	 205  		}
	 206  		n -= 2
	 207  		d.d[n+1] = smallsString[2*v2+1]
	 208  		d.d[n+0] = smallsString[2*v2+0]
	 209  		v = v1
	 210  	}
	 211  	if v > 0 {
	 212  		n--
	 213  		d.d[n] = smallsString[2*v+1]
	 214  	}
	 215  	if v >= 10 {
	 216  		n--
	 217  		d.d[n] = smallsString[2*v]
	 218  	}
	 219  	for d.d[d.nd-1] == '0' {
	 220  		d.nd--
	 221  		trimmed++
	 222  	}
	 223  	d.dp = d.nd + trimmed
	 224  }
	 225  
	 226  // ryuFtoaShortest formats mant*2^exp with prec decimal digits.
	 227  func ryuFtoaShortest(d *decimalSlice, mant uint64, exp int, flt *floatInfo) {
	 228  	if mant == 0 {
	 229  		d.nd, d.dp = 0, 0
	 230  		return
	 231  	}
	 232  	// If input is an exact integer with fewer bits than the mantissa,
	 233  	// the previous and next integer are not admissible representations.
	 234  	if exp <= 0 && bits.TrailingZeros64(mant) >= -exp {
	 235  		mant >>= uint(-exp)
	 236  		ryuDigits(d, mant, mant, mant, true, false)
	 237  		return
	 238  	}
	 239  	ml, mc, mu, e2 := computeBounds(mant, exp, flt)
	 240  	if e2 == 0 {
	 241  		ryuDigits(d, ml, mc, mu, true, false)
	 242  		return
	 243  	}
	 244  	// Find 10^q *larger* than 2^-e2
	 245  	q := mulByLog2Log10(-e2) + 1
	 246  
	 247  	// We are going to multiply by 10^q using 128-bit arithmetic.
	 248  	// The exponent is the same for all 3 numbers.
	 249  	var dl, dc, du uint64
	 250  	var dl0, dc0, du0 bool
	 251  	if flt == &float32info {
	 252  		var dl32, dc32, du32 uint32
	 253  		dl32, _, dl0 = mult64bitPow10(uint32(ml), e2, q)
	 254  		dc32, _, dc0 = mult64bitPow10(uint32(mc), e2, q)
	 255  		du32, e2, du0 = mult64bitPow10(uint32(mu), e2, q)
	 256  		dl, dc, du = uint64(dl32), uint64(dc32), uint64(du32)
	 257  	} else {
	 258  		dl, _, dl0 = mult128bitPow10(ml, e2, q)
	 259  		dc, _, dc0 = mult128bitPow10(mc, e2, q)
	 260  		du, e2, du0 = mult128bitPow10(mu, e2, q)
	 261  	}
	 262  	if e2 >= 0 {
	 263  		panic("not enough significant bits after mult128bitPow10")
	 264  	}
	 265  	// Is it an exact computation?
	 266  	if q > 55 {
	 267  		// Large positive powers of ten are not exact
	 268  		dl0, dc0, du0 = false, false, false
	 269  	}
	 270  	if q < 0 && q >= -24 {
	 271  		// Division by a power of ten may be exact.
	 272  		// (note that 5^25 is a 59-bit number so division by 5^25 is never exact).
	 273  		if divisibleByPower5(ml, -q) {
	 274  			dl0 = true
	 275  		}
	 276  		if divisibleByPower5(mc, -q) {
	 277  			dc0 = true
	 278  		}
	 279  		if divisibleByPower5(mu, -q) {
	 280  			du0 = true
	 281  		}
	 282  	}
	 283  	// Express the results (dl, dc, du)*2^e2 as integers.
	 284  	// Extra bits must be removed and rounding hints computed.
	 285  	extra := uint(-e2)
	 286  	extraMask := uint64(1<<extra - 1)
	 287  	// Now compute the floored, integral base 10 mantissas.
	 288  	dl, fracl := dl>>extra, dl&extraMask
	 289  	dc, fracc := dc>>extra, dc&extraMask
	 290  	du, fracu := du>>extra, du&extraMask
	 291  	// Is it allowed to use 'du' as a result?
	 292  	// It is always allowed when it is truncated, but also
	 293  	// if it is exact and the original binary mantissa is even
	 294  	// When disallowed, we can substract 1.
	 295  	uok := !du0 || fracu > 0
	 296  	if du0 && fracu == 0 {
	 297  		uok = mant&1 == 0
	 298  	}
	 299  	if !uok {
	 300  		du--
	 301  	}
	 302  	// Is 'dc' the correctly rounded base 10 mantissa?
	 303  	// The correct rounding might be dc+1
	 304  	cup := false // don't round up.
	 305  	if dc0 {
	 306  		// If we computed an exact product, the half integer
	 307  		// should round to next (even) integer if 'dc' is odd.
	 308  		cup = fracc > 1<<(extra-1) ||
	 309  			(fracc == 1<<(extra-1) && dc&1 == 1)
	 310  	} else {
	 311  		// otherwise, the result is a lower truncation of the ideal
	 312  		// result.
	 313  		cup = fracc>>(extra-1) == 1
	 314  	}
	 315  	// Is 'dl' an allowed representation?
	 316  	// Only if it is an exact value, and if the original binary mantissa
	 317  	// was even.
	 318  	lok := dl0 && fracl == 0 && (mant&1 == 0)
	 319  	if !lok {
	 320  		dl++
	 321  	}
	 322  	// We need to remember whether the trimmed digits of 'dc' are zero.
	 323  	c0 := dc0 && fracc == 0
	 324  	// render digits
	 325  	ryuDigits(d, dl, dc, du, c0, cup)
	 326  	d.dp -= q
	 327  }
	 328  
	 329  // mulByLog2Log10 returns math.Floor(x * log(2)/log(10)) for an integer x in
	 330  // the range -1600 <= x && x <= +1600.
	 331  //
	 332  // The range restriction lets us work in faster integer arithmetic instead of
	 333  // slower floating point arithmetic. Correctness is verified by unit tests.
	 334  func mulByLog2Log10(x int) int {
	 335  	// log(2)/log(10) ≈ 0.30102999566 ≈ 78913 / 2^18
	 336  	return (x * 78913) >> 18
	 337  }
	 338  
	 339  // mulByLog10Log2 returns math.Floor(x * log(10)/log(2)) for an integer x in
	 340  // the range -500 <= x && x <= +500.
	 341  //
	 342  // The range restriction lets us work in faster integer arithmetic instead of
	 343  // slower floating point arithmetic. Correctness is verified by unit tests.
	 344  func mulByLog10Log2(x int) int {
	 345  	// log(10)/log(2) ≈ 3.32192809489 ≈ 108853 / 2^15
	 346  	return (x * 108853) >> 15
	 347  }
	 348  
	 349  // computeBounds returns a floating-point vector (l, c, u)×2^e2
	 350  // where the mantissas are 55-bit (or 26-bit) integers, describing the interval
	 351  // represented by the input float64 or float32.
	 352  func computeBounds(mant uint64, exp int, flt *floatInfo) (lower, central, upper uint64, e2 int) {
	 353  	if mant != 1<<flt.mantbits || exp == flt.bias+1-int(flt.mantbits) {
	 354  		// regular case (or denormals)
	 355  		lower, central, upper = 2*mant-1, 2*mant, 2*mant+1
	 356  		e2 = exp - 1
	 357  		return
	 358  	} else {
	 359  		// border of an exponent
	 360  		lower, central, upper = 4*mant-1, 4*mant, 4*mant+2
	 361  		e2 = exp - 2
	 362  		return
	 363  	}
	 364  }
	 365  
	 366  func ryuDigits(d *decimalSlice, lower, central, upper uint64,
	 367  	c0, cup bool) {
	 368  	lhi, llo := divmod1e9(lower)
	 369  	chi, clo := divmod1e9(central)
	 370  	uhi, ulo := divmod1e9(upper)
	 371  	if uhi == 0 {
	 372  		// only low digits (for denormals)
	 373  		ryuDigits32(d, llo, clo, ulo, c0, cup, 8)
	 374  	} else if lhi < uhi {
	 375  		// truncate 9 digits at once.
	 376  		if llo != 0 {
	 377  			lhi++
	 378  		}
	 379  		c0 = c0 && clo == 0
	 380  		cup = (clo > 5e8) || (clo == 5e8 && cup)
	 381  		ryuDigits32(d, lhi, chi, uhi, c0, cup, 8)
	 382  		d.dp += 9
	 383  	} else {
	 384  		d.nd = 0
	 385  		// emit high part
	 386  		n := uint(9)
	 387  		for v := chi; v > 0; {
	 388  			v1, v2 := v/10, v%10
	 389  			v = v1
	 390  			n--
	 391  			d.d[n] = byte(v2 + '0')
	 392  		}
	 393  		d.d = d.d[n:]
	 394  		d.nd = int(9 - n)
	 395  		// emit low part
	 396  		ryuDigits32(d, llo, clo, ulo,
	 397  			c0, cup, d.nd+8)
	 398  	}
	 399  	// trim trailing zeros
	 400  	for d.nd > 0 && d.d[d.nd-1] == '0' {
	 401  		d.nd--
	 402  	}
	 403  	// trim initial zeros
	 404  	for d.nd > 0 && d.d[0] == '0' {
	 405  		d.nd--
	 406  		d.dp--
	 407  		d.d = d.d[1:]
	 408  	}
	 409  }
	 410  
	 411  // ryuDigits32 emits decimal digits for a number less than 1e9.
	 412  func ryuDigits32(d *decimalSlice, lower, central, upper uint32,
	 413  	c0, cup bool, endindex int) {
	 414  	if upper == 0 {
	 415  		d.dp = endindex + 1
	 416  		return
	 417  	}
	 418  	trimmed := 0
	 419  	// Remember last trimmed digit to check for round-up.
	 420  	// c0 will be used to remember zeroness of following digits.
	 421  	cNextDigit := 0
	 422  	for upper > 0 {
	 423  		// Repeatedly compute:
	 424  		// l = Ceil(lower / 10^k)
	 425  		// c = Round(central / 10^k)
	 426  		// u = Floor(upper / 10^k)
	 427  		// and stop when c goes out of the (l, u) interval.
	 428  		l := (lower + 9) / 10
	 429  		c, cdigit := central/10, central%10
	 430  		u := upper / 10
	 431  		if l > u {
	 432  			// don't trim the last digit as it is forbidden to go below l
	 433  			// other, trim and exit now.
	 434  			break
	 435  		}
	 436  		// Check that we didn't cross the lower boundary.
	 437  		// The case where l < u but c == l-1 is essentially impossible,
	 438  		// but may happen if:
	 439  		//		lower	 = ..11
	 440  		//		central = ..19
	 441  		//		upper	 = ..31
	 442  		// and means that 'central' is very close but less than
	 443  		// an integer ending with many zeros, and usually
	 444  		// the "round-up" logic hides the problem.
	 445  		if l == c+1 && c < u {
	 446  			c++
	 447  			cdigit = 0
	 448  			cup = false
	 449  		}
	 450  		trimmed++
	 451  		// Remember trimmed digits of c
	 452  		c0 = c0 && cNextDigit == 0
	 453  		cNextDigit = int(cdigit)
	 454  		lower, central, upper = l, c, u
	 455  	}
	 456  	// should we round up?
	 457  	if trimmed > 0 {
	 458  		cup = cNextDigit > 5 ||
	 459  			(cNextDigit == 5 && !c0) ||
	 460  			(cNextDigit == 5 && c0 && central&1 == 1)
	 461  	}
	 462  	if central < upper && cup {
	 463  		central++
	 464  	}
	 465  	// We know where the number ends, fill directly
	 466  	endindex -= trimmed
	 467  	v := central
	 468  	n := endindex
	 469  	for n > d.nd {
	 470  		v1, v2 := v/100, v%100
	 471  		d.d[n] = smallsString[2*v2+1]
	 472  		d.d[n-1] = smallsString[2*v2+0]
	 473  		n -= 2
	 474  		v = v1
	 475  	}
	 476  	if n == d.nd {
	 477  		d.d[n] = byte(v + '0')
	 478  	}
	 479  	d.nd = endindex + 1
	 480  	d.dp = d.nd + trimmed
	 481  }
	 482  
	 483  // mult64bitPow10 takes a floating-point input with a 25-bit
	 484  // mantissa and multiplies it with 10^q. The resulting mantissa
	 485  // is m*P >> 57 where P is a 64-bit element of the detailedPowersOfTen tables.
	 486  // It is typically 31 or 32-bit wide.
	 487  // The returned boolean is true if all trimmed bits were zero.
	 488  //
	 489  // That is:
	 490  //		 m*2^e2 * round(10^q) = resM * 2^resE + ε
	 491  //		 exact = ε == 0
	 492  func mult64bitPow10(m uint32, e2, q int) (resM uint32, resE int, exact bool) {
	 493  	if q == 0 {
	 494  		// P == 1<<63
	 495  		return m << 6, e2 - 6, true
	 496  	}
	 497  	if q < detailedPowersOfTenMinExp10 || detailedPowersOfTenMaxExp10 < q {
	 498  		// This never happens due to the range of float32/float64 exponent
	 499  		panic("mult64bitPow10: power of 10 is out of range")
	 500  	}
	 501  	pow := detailedPowersOfTen[q-detailedPowersOfTenMinExp10][1]
	 502  	if q < 0 {
	 503  		// Inverse powers of ten must be rounded up.
	 504  		pow += 1
	 505  	}
	 506  	hi, lo := bits.Mul64(uint64(m), pow)
	 507  	e2 += mulByLog10Log2(q) - 63 + 57
	 508  	return uint32(hi<<7 | lo>>57), e2, lo<<7 == 0
	 509  }
	 510  
	 511  // mult128bitPow10 takes a floating-point input with a 55-bit
	 512  // mantissa and multiplies it with 10^q. The resulting mantissa
	 513  // is m*P >> 119 where P is a 128-bit element of the detailedPowersOfTen tables.
	 514  // It is typically 63 or 64-bit wide.
	 515  // The returned boolean is true is all trimmed bits were zero.
	 516  //
	 517  // That is:
	 518  //		 m*2^e2 * round(10^q) = resM * 2^resE + ε
	 519  //		 exact = ε == 0
	 520  func mult128bitPow10(m uint64, e2, q int) (resM uint64, resE int, exact bool) {
	 521  	if q == 0 {
	 522  		// P == 1<<127
	 523  		return m << 8, e2 - 8, true
	 524  	}
	 525  	if q < detailedPowersOfTenMinExp10 || detailedPowersOfTenMaxExp10 < q {
	 526  		// This never happens due to the range of float32/float64 exponent
	 527  		panic("mult128bitPow10: power of 10 is out of range")
	 528  	}
	 529  	pow := detailedPowersOfTen[q-detailedPowersOfTenMinExp10]
	 530  	if q < 0 {
	 531  		// Inverse powers of ten must be rounded up.
	 532  		pow[0] += 1
	 533  	}
	 534  	e2 += mulByLog10Log2(q) - 127 + 119
	 535  
	 536  	// long multiplication
	 537  	l1, l0 := bits.Mul64(m, pow[0])
	 538  	h1, h0 := bits.Mul64(m, pow[1])
	 539  	mid, carry := bits.Add64(l1, h0, 0)
	 540  	h1 += carry
	 541  	return h1<<9 | mid>>55, e2, mid<<9 == 0 && l0 == 0
	 542  }
	 543  
	 544  func divisibleByPower5(m uint64, k int) bool {
	 545  	if m == 0 {
	 546  		return true
	 547  	}
	 548  	for i := 0; i < k; i++ {
	 549  		if m%5 != 0 {
	 550  			return false
	 551  		}
	 552  		m /= 5
	 553  	}
	 554  	return true
	 555  }
	 556  
	 557  // divmod1e9 computes quotient and remainder of division by 1e9,
	 558  // avoiding runtime uint64 division on 32-bit platforms.
	 559  func divmod1e9(x uint64) (uint32, uint32) {
	 560  	if !host32bit {
	 561  		return uint32(x / 1e9), uint32(x % 1e9)
	 562  	}
	 563  	// Use the same sequence of operations as the amd64 compiler.
	 564  	hi, _ := bits.Mul64(x>>1, 0x89705f4136b4a598) // binary digits of 1e-9
	 565  	q := hi >> 28
	 566  	return uint32(q), uint32(x - q*1e9)
	 567  }
	 568  

View as plain text