Vendor in latest containers/storage
Container/storage has been enhanced to speed up the compiling and loading of json files. This should make make cri-o a little bit faster. Signed-off-by: Daniel J Walsh <dwalsh@redhat.com>
This commit is contained in:
Daniel J Walsh
parent
774d44589c
commit
70b1661e10
36 changed files with 11686 additions and 56 deletions
936
vendor/github.com/pquerna/ffjson/fflib/v1/internal/atof.go
generated
vendored
Normal file
936
vendor/github.com/pquerna/ffjson/fflib/v1/internal/atof.go
generated
vendored
Normal file
|
|
@ -0,0 +1,936 @@
|
|||
/**
|
||||
* Copyright 2014 Paul Querna
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/* Portions of this file are on Go stdlib's strconv/atof.go */
|
||||
|
||||
// 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.
|
||||
|
||||
package internal
|
||||
|
||||
// decimal to binary floating point conversion.
|
||||
// Algorithm:
|
||||
// 1) Store input in multiprecision decimal.
|
||||
// 2) Multiply/divide decimal by powers of two until in range [0.5, 1)
|
||||
// 3) Multiply by 2^precision and round to get mantissa.
|
||||
|
||||
import "math"
|
||||
|
||||
var optimize = true // can change for testing
|
||||
|
||||
func equalIgnoreCase(s1 []byte, s2 []byte) bool {
|
||||
if len(s1) != len(s2) {
|
||||
return false
|
||||
}
|
||||
for i := 0; i < len(s1); i++ {
|
||||
c1 := s1[i]
|
||||
if 'A' <= c1 && c1 <= 'Z' {
|
||||
c1 += 'a' - 'A'
|
||||
}
|
||||
c2 := s2[i]
|
||||
if 'A' <= c2 && c2 <= 'Z' {
|
||||
c2 += 'a' - 'A'
|
||||
}
|
||||
if c1 != c2 {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func special(s []byte) (f float64, ok bool) {
|
||||
if len(s) == 0 {
|
||||
return
|
||||
}
|
||||
switch s[0] {
|
||||
default:
|
||||
return
|
||||
case '+':
|
||||
if equalIgnoreCase(s, []byte("+inf")) || equalIgnoreCase(s, []byte("+infinity")) {
|
||||
return math.Inf(1), true
|
||||
}
|
||||
case '-':
|
||||
if equalIgnoreCase(s, []byte("-inf")) || equalIgnoreCase(s, []byte("-infinity")) {
|
||||
return math.Inf(-1), true
|
||||
}
|
||||
case 'n', 'N':
|
||||
if equalIgnoreCase(s, []byte("nan")) {
|
||||
return math.NaN(), true
|
||||
}
|
||||
case 'i', 'I':
|
||||
if equalIgnoreCase(s, []byte("inf")) || equalIgnoreCase(s, []byte("infinity")) {
|
||||
return math.Inf(1), true
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (b *decimal) set(s []byte) (ok bool) {
|
||||
i := 0
|
||||
b.neg = false
|
||||
b.trunc = false
|
||||
|
||||
// optional sign
|
||||
if i >= len(s) {
|
||||
return
|
||||
}
|
||||
switch {
|
||||
case s[i] == '+':
|
||||
i++
|
||||
case s[i] == '-':
|
||||
b.neg = true
|
||||
i++
|
||||
}
|
||||
|
||||
// digits
|
||||
sawdot := false
|
||||
sawdigits := false
|
||||
for ; i < len(s); i++ {
|
||||
switch {
|
||||
case s[i] == '.':
|
||||
if sawdot {
|
||||
return
|
||||
}
|
||||
sawdot = true
|
||||
b.dp = b.nd
|
||||
continue
|
||||
|
||||
case '0' <= s[i] && s[i] <= '9':
|
||||
sawdigits = true
|
||||
if s[i] == '0' && b.nd == 0 { // ignore leading zeros
|
||||
b.dp--
|
||||
continue
|
||||
}
|
||||
if b.nd < len(b.d) {
|
||||
b.d[b.nd] = s[i]
|
||||
b.nd++
|
||||
} else if s[i] != '0' {
|
||||
b.trunc = true
|
||||
}
|
||||
continue
|
||||
}
|
||||
break
|
||||
}
|
||||
if !sawdigits {
|
||||
return
|
||||
}
|
||||
if !sawdot {
|
||||
b.dp = b.nd
|
||||
}
|
||||
|
||||
// optional exponent moves decimal point.
|
||||
// if we read a very large, very long number,
|
||||
// just be sure to move the decimal point by
|
||||
// a lot (say, 100000). it doesn't matter if it's
|
||||
// not the exact number.
|
||||
if i < len(s) && (s[i] == 'e' || s[i] == 'E') {
|
||||
i++
|
||||
if i >= len(s) {
|
||||
return
|
||||
}
|
||||
esign := 1
|
||||
if s[i] == '+' {
|
||||
i++
|
||||
} else if s[i] == '-' {
|
||||
i++
|
||||
esign = -1
|
||||
}
|
||||
if i >= len(s) || s[i] < '0' || s[i] > '9' {
|
||||
return
|
||||
}
|
||||
e := 0
|
||||
for ; i < len(s) && '0' <= s[i] && s[i] <= '9'; i++ {
|
||||
if e < 10000 {
|
||||
e = e*10 + int(s[i]) - '0'
|
||||
}
|
||||
}
|
||||
b.dp += e * esign
|
||||
}
|
||||
|
||||
if i != len(s) {
|
||||
return
|
||||
}
|
||||
|
||||
ok = true
|
||||
return
|
||||
}
|
||||
|
||||
// readFloat reads a decimal mantissa and exponent from a float
|
||||
// string representation. It sets ok to false if the number could
|
||||
// not fit return types or is invalid.
|
||||
func readFloat(s []byte) (mantissa uint64, exp int, neg, trunc, ok bool) {
|
||||
const uint64digits = 19
|
||||
i := 0
|
||||
|
||||
// optional sign
|
||||
if i >= len(s) {
|
||||
return
|
||||
}
|
||||
switch {
|
||||
case s[i] == '+':
|
||||
i++
|
||||
case s[i] == '-':
|
||||
neg = true
|
||||
i++
|
||||
}
|
||||
|
||||
// digits
|
||||
sawdot := false
|
||||
sawdigits := false
|
||||
nd := 0
|
||||
ndMant := 0
|
||||
dp := 0
|
||||
for ; i < len(s); i++ {
|
||||
switch c := s[i]; true {
|
||||
case c == '.':
|
||||
if sawdot {
|
||||
return
|
||||
}
|
||||
sawdot = true
|
||||
dp = nd
|
||||
continue
|
||||
|
||||
case '0' <= c && c <= '9':
|
||||
sawdigits = true
|
||||
if c == '0' && nd == 0 { // ignore leading zeros
|
||||
dp--
|
||||
continue
|
||||
}
|
||||
nd++
|
||||
if ndMant < uint64digits {
|
||||
mantissa *= 10
|
||||
mantissa += uint64(c - '0')
|
||||
ndMant++
|
||||
} else if s[i] != '0' {
|
||||
trunc = true
|
||||
}
|
||||
continue
|
||||
}
|
||||
break
|
||||
}
|
||||
if !sawdigits {
|
||||
return
|
||||
}
|
||||
if !sawdot {
|
||||
dp = nd
|
||||
}
|
||||
|
||||
// optional exponent moves decimal point.
|
||||
// if we read a very large, very long number,
|
||||
// just be sure to move the decimal point by
|
||||
// a lot (say, 100000). it doesn't matter if it's
|
||||
// not the exact number.
|
||||
if i < len(s) && (s[i] == 'e' || s[i] == 'E') {
|
||||
i++
|
||||
if i >= len(s) {
|
||||
return
|
||||
}
|
||||
esign := 1
|
||||
if s[i] == '+' {
|
||||
i++
|
||||
} else if s[i] == '-' {
|
||||
i++
|
||||
esign = -1
|
||||
}
|
||||
if i >= len(s) || s[i] < '0' || s[i] > '9' {
|
||||
return
|
||||
}
|
||||
e := 0
|
||||
for ; i < len(s) && '0' <= s[i] && s[i] <= '9'; i++ {
|
||||
if e < 10000 {
|
||||
e = e*10 + int(s[i]) - '0'
|
||||
}
|
||||
}
|
||||
dp += e * esign
|
||||
}
|
||||
|
||||
if i != len(s) {
|
||||
return
|
||||
}
|
||||
|
||||
exp = dp - ndMant
|
||||
ok = true
|
||||
return
|
||||
|
||||
}
|
||||
|
||||
// decimal power of ten to binary power of two.
|
||||
var powtab = []int{1, 3, 6, 9, 13, 16, 19, 23, 26}
|
||||
|
||||
func (d *decimal) floatBits(flt *floatInfo) (b uint64, overflow bool) {
|
||||
var exp int
|
||||
var mant uint64
|
||||
|
||||
// Zero is always a special case.
|
||||
if d.nd == 0 {
|
||||
mant = 0
|
||||
exp = flt.bias
|
||||
goto out
|
||||
}
|
||||
|
||||
// Obvious overflow/underflow.
|
||||
// These bounds are for 64-bit floats.
|
||||
// Will have to change if we want to support 80-bit floats in the future.
|
||||
if d.dp > 310 {
|
||||
goto overflow
|
||||
}
|
||||
if d.dp < -330 {
|
||||
// zero
|
||||
mant = 0
|
||||
exp = flt.bias
|
||||
goto out
|
||||
}
|
||||
|
||||
// Scale by powers of two until in range [0.5, 1.0)
|
||||
exp = 0
|
||||
for d.dp > 0 {
|
||||
var n int
|
||||
if d.dp >= len(powtab) {
|
||||
n = 27
|
||||
} else {
|
||||
n = powtab[d.dp]
|
||||
}
|
||||
d.Shift(-n)
|
||||
exp += n
|
||||
}
|
||||
for d.dp < 0 || d.dp == 0 && d.d[0] < '5' {
|
||||
var n int
|
||||
if -d.dp >= len(powtab) {
|
||||
n = 27
|
||||
} else {
|
||||
n = powtab[-d.dp]
|
||||
}
|
||||
d.Shift(n)
|
||||
exp -= n
|
||||
}
|
||||
|
||||
// Our range is [0.5,1) but floating point range is [1,2).
|
||||
exp--
|
||||
|
||||
// Minimum representable exponent is flt.bias+1.
|
||||
// If the exponent is smaller, move it up and
|
||||
// adjust d accordingly.
|
||||
if exp < flt.bias+1 {
|
||||
n := flt.bias + 1 - exp
|
||||
d.Shift(-n)
|
||||
exp += n
|
||||
}
|
||||
|
||||
if exp-flt.bias >= 1<<flt.expbits-1 {
|
||||
goto overflow
|
||||
}
|
||||
|
||||
// Extract 1+flt.mantbits bits.
|
||||
d.Shift(int(1 + flt.mantbits))
|
||||
mant = d.RoundedInteger()
|
||||
|
||||
// Rounding might have added a bit; shift down.
|
||||
if mant == 2<<flt.mantbits {
|
||||
mant >>= 1
|
||||
exp++
|
||||
if exp-flt.bias >= 1<<flt.expbits-1 {
|
||||
goto overflow
|
||||
}
|
||||
}
|
||||
|
||||
// Denormalized?
|
||||
if mant&(1<<flt.mantbits) == 0 {
|
||||
exp = flt.bias
|
||||
}
|
||||
goto out
|
||||
|
||||
overflow:
|
||||
// ±Inf
|
||||
mant = 0
|
||||
exp = 1<<flt.expbits - 1 + flt.bias
|
||||
overflow = true
|
||||
|
||||
out:
|
||||
// Assemble bits.
|
||||
bits := mant & (uint64(1)<<flt.mantbits - 1)
|
||||
bits |= uint64((exp-flt.bias)&(1<<flt.expbits-1)) << flt.mantbits
|
||||
if d.neg {
|
||||
bits |= 1 << flt.mantbits << flt.expbits
|
||||
}
|
||||
return bits, overflow
|
||||
}
|
||||
|
||||
// Exact powers of 10.
|
||||
var float64pow10 = []float64{
|
||||
1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
|
||||
1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
|
||||
1e20, 1e21, 1e22,
|
||||
}
|
||||
var float32pow10 = []float32{1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10}
|
||||
|
||||
// If possible to convert decimal representation to 64-bit float f exactly,
|
||||
// entirely in floating-point math, do so, avoiding the expense of decimalToFloatBits.
|
||||
// Three common cases:
|
||||
// value is exact integer
|
||||
// value is exact integer * exact power of ten
|
||||
// value is exact integer / exact power of ten
|
||||
// These all produce potentially inexact but correctly rounded answers.
|
||||
func atof64exact(mantissa uint64, exp int, neg bool) (f float64, ok bool) {
|
||||
if mantissa>>float64info.mantbits != 0 {
|
||||
return
|
||||
}
|
||||
f = float64(mantissa)
|
||||
if neg {
|
||||
f = -f
|
||||
}
|
||||
switch {
|
||||
case exp == 0:
|
||||
// an integer.
|
||||
return f, true
|
||||
// Exact integers are <= 10^15.
|
||||
// Exact powers of ten are <= 10^22.
|
||||
case exp > 0 && exp <= 15+22: // int * 10^k
|
||||
// If exponent is big but number of digits is not,
|
||||
// can move a few zeros into the integer part.
|
||||
if exp > 22 {
|
||||
f *= float64pow10[exp-22]
|
||||
exp = 22
|
||||
}
|
||||
if f > 1e15 || f < -1e15 {
|
||||
// the exponent was really too large.
|
||||
return
|
||||
}
|
||||
return f * float64pow10[exp], true
|
||||
case exp < 0 && exp >= -22: // int / 10^k
|
||||
return f / float64pow10[-exp], true
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// If possible to compute mantissa*10^exp to 32-bit float f exactly,
|
||||
// entirely in floating-point math, do so, avoiding the machinery above.
|
||||
func atof32exact(mantissa uint64, exp int, neg bool) (f float32, ok bool) {
|
||||
if mantissa>>float32info.mantbits != 0 {
|
||||
return
|
||||
}
|
||||
f = float32(mantissa)
|
||||
if neg {
|
||||
f = -f
|
||||
}
|
||||
switch {
|
||||
case exp == 0:
|
||||
return f, true
|
||||
// Exact integers are <= 10^7.
|
||||
// Exact powers of ten are <= 10^10.
|
||||
case exp > 0 && exp <= 7+10: // int * 10^k
|
||||
// If exponent is big but number of digits is not,
|
||||
// can move a few zeros into the integer part.
|
||||
if exp > 10 {
|
||||
f *= float32pow10[exp-10]
|
||||
exp = 10
|
||||
}
|
||||
if f > 1e7 || f < -1e7 {
|
||||
// the exponent was really too large.
|
||||
return
|
||||
}
|
||||
return f * float32pow10[exp], true
|
||||
case exp < 0 && exp >= -10: // int / 10^k
|
||||
return f / float32pow10[-exp], true
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
const fnParseFloat = "ParseFloat"
|
||||
|
||||
func atof32(s []byte) (f float32, err error) {
|
||||
if val, ok := special(s); ok {
|
||||
return float32(val), nil
|
||||
}
|
||||
|
||||
if optimize {
|
||||
// Parse mantissa and exponent.
|
||||
mantissa, exp, neg, trunc, ok := readFloat(s)
|
||||
if ok {
|
||||
// Try pure floating-point arithmetic conversion.
|
||||
if !trunc {
|
||||
if f, ok := atof32exact(mantissa, exp, neg); ok {
|
||||
return f, nil
|
||||
}
|
||||
}
|
||||
// Try another fast path.
|
||||
ext := new(extFloat)
|
||||
if ok := ext.AssignDecimal(mantissa, exp, neg, trunc, &float32info); ok {
|
||||
b, ovf := ext.floatBits(&float32info)
|
||||
f = math.Float32frombits(uint32(b))
|
||||
if ovf {
|
||||
err = rangeError(fnParseFloat, string(s))
|
||||
}
|
||||
return f, err
|
||||
}
|
||||
}
|
||||
}
|
||||
var d decimal
|
||||
if !d.set(s) {
|
||||
return 0, syntaxError(fnParseFloat, string(s))
|
||||
}
|
||||
b, ovf := d.floatBits(&float32info)
|
||||
f = math.Float32frombits(uint32(b))
|
||||
if ovf {
|
||||
err = rangeError(fnParseFloat, string(s))
|
||||
}
|
||||
return f, err
|
||||
}
|
||||
|
||||
func atof64(s []byte) (f float64, err error) {
|
||||
if val, ok := special(s); ok {
|
||||
return val, nil
|
||||
}
|
||||
|
||||
if optimize {
|
||||
// Parse mantissa and exponent.
|
||||
mantissa, exp, neg, trunc, ok := readFloat(s)
|
||||
if ok {
|
||||
// Try pure floating-point arithmetic conversion.
|
||||
if !trunc {
|
||||
if f, ok := atof64exact(mantissa, exp, neg); ok {
|
||||
return f, nil
|
||||
}
|
||||
}
|
||||
// Try another fast path.
|
||||
ext := new(extFloat)
|
||||
if ok := ext.AssignDecimal(mantissa, exp, neg, trunc, &float64info); ok {
|
||||
b, ovf := ext.floatBits(&float64info)
|
||||
f = math.Float64frombits(b)
|
||||
if ovf {
|
||||
err = rangeError(fnParseFloat, string(s))
|
||||
}
|
||||
return f, err
|
||||
}
|
||||
}
|
||||
}
|
||||
var d decimal
|
||||
if !d.set(s) {
|
||||
return 0, syntaxError(fnParseFloat, string(s))
|
||||
}
|
||||
b, ovf := d.floatBits(&float64info)
|
||||
f = math.Float64frombits(b)
|
||||
if ovf {
|
||||
err = rangeError(fnParseFloat, string(s))
|
||||
}
|
||||
return f, err
|
||||
}
|
||||
|
||||
// ParseFloat converts the string s to a floating-point number
|
||||
// with the precision specified by bitSize: 32 for float32, or 64 for float64.
|
||||
// When bitSize=32, the result still has type float64, but it will be
|
||||
// convertible to float32 without changing its value.
|
||||
//
|
||||
// If s is well-formed and near a valid floating point number,
|
||||
// ParseFloat returns the nearest floating point number rounded
|
||||
// using IEEE754 unbiased rounding.
|
||||
//
|
||||
// The errors that ParseFloat returns have concrete type *NumError
|
||||
// and include err.Num = s.
|
||||
//
|
||||
// If s is not syntactically well-formed, ParseFloat returns err.Err = ErrSyntax.
|
||||
//
|
||||
// If s is syntactically well-formed but is more than 1/2 ULP
|
||||
// away from the largest floating point number of the given size,
|
||||
// ParseFloat returns f = ±Inf, err.Err = ErrRange.
|
||||
func ParseFloat(s []byte, bitSize int) (f float64, err error) {
|
||||
if bitSize == 32 {
|
||||
f1, err1 := atof32(s)
|
||||
return float64(f1), err1
|
||||
}
|
||||
f1, err1 := atof64(s)
|
||||
return f1, err1
|
||||
}
|
||||
|
||||
// oroginal: strconv/decimal.go, but not exported, and needed for PareFloat.
|
||||
|
||||
// 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.
|
||||
|
||||
// Multiprecision decimal numbers.
|
||||
// For floating-point formatting only; not general purpose.
|
||||
// Only operations are assign and (binary) left/right shift.
|
||||
// Can do binary floating point in multiprecision decimal precisely
|
||||
// because 2 divides 10; cannot do decimal floating point
|
||||
// in multiprecision binary precisely.
|
||||
|
||||
type decimal struct {
|
||||
d [800]byte // digits
|
||||
nd int // number of digits used
|
||||
dp int // decimal point
|
||||
neg bool
|
||||
trunc bool // discarded nonzero digits beyond d[:nd]
|
||||
}
|
||||
|
||||
func (a *decimal) String() string {
|
||||
n := 10 + a.nd
|
||||
if a.dp > 0 {
|
||||
n += a.dp
|
||||
}
|
||||
if a.dp < 0 {
|
||||
n += -a.dp
|
||||
}
|
||||
|
||||
buf := make([]byte, n)
|
||||
w := 0
|
||||
switch {
|
||||
case a.nd == 0:
|
||||
return "0"
|
||||
|
||||
case a.dp <= 0:
|
||||
// zeros fill space between decimal point and digits
|
||||
buf[w] = '0'
|
||||
w++
|
||||
buf[w] = '.'
|
||||
w++
|
||||
w += digitZero(buf[w : w+-a.dp])
|
||||
w += copy(buf[w:], a.d[0:a.nd])
|
||||
|
||||
case a.dp < a.nd:
|
||||
// decimal point in middle of digits
|
||||
w += copy(buf[w:], a.d[0:a.dp])
|
||||
buf[w] = '.'
|
||||
w++
|
||||
w += copy(buf[w:], a.d[a.dp:a.nd])
|
||||
|
||||
default:
|
||||
// zeros fill space between digits and decimal point
|
||||
w += copy(buf[w:], a.d[0:a.nd])
|
||||
w += digitZero(buf[w : w+a.dp-a.nd])
|
||||
}
|
||||
return string(buf[0:w])
|
||||
}
|
||||
|
||||
func digitZero(dst []byte) int {
|
||||
for i := range dst {
|
||||
dst[i] = '0'
|
||||
}
|
||||
return len(dst)
|
||||
}
|
||||
|
||||
// trim trailing zeros from number.
|
||||
// (They are meaningless; the decimal point is tracked
|
||||
// independent of the number of digits.)
|
||||
func trim(a *decimal) {
|
||||
for a.nd > 0 && a.d[a.nd-1] == '0' {
|
||||
a.nd--
|
||||
}
|
||||
if a.nd == 0 {
|
||||
a.dp = 0
|
||||
}
|
||||
}
|
||||
|
||||
// Assign v to a.
|
||||
func (a *decimal) Assign(v uint64) {
|
||||
var buf [24]byte
|
||||
|
||||
// Write reversed decimal in buf.
|
||||
n := 0
|
||||
for v > 0 {
|
||||
v1 := v / 10
|
||||
v -= 10 * v1
|
||||
buf[n] = byte(v + '0')
|
||||
n++
|
||||
v = v1
|
||||
}
|
||||
|
||||
// Reverse again to produce forward decimal in a.d.
|
||||
a.nd = 0
|
||||
for n--; n >= 0; n-- {
|
||||
a.d[a.nd] = buf[n]
|
||||
a.nd++
|
||||
}
|
||||
a.dp = a.nd
|
||||
trim(a)
|
||||
}
|
||||
|
||||
// Maximum shift that we can do in one pass without overflow.
|
||||
// Signed int has 31 bits, and we have to be able to accommodate 9<<k.
|
||||
const maxShift = 27
|
||||
|
||||
// Binary shift right (* 2) by k bits. k <= maxShift to avoid overflow.
|
||||
func rightShift(a *decimal, k uint) {
|
||||
r := 0 // read pointer
|
||||
w := 0 // write pointer
|
||||
|
||||
// Pick up enough leading digits to cover first shift.
|
||||
n := 0
|
||||
for ; n>>k == 0; r++ {
|
||||
if r >= a.nd {
|
||||
if n == 0 {
|
||||
// a == 0; shouldn't get here, but handle anyway.
|
||||
a.nd = 0
|
||||
return
|
||||
}
|
||||
for n>>k == 0 {
|
||||
n = n * 10
|
||||
r++
|
||||
}
|
||||
break
|
||||
}
|
||||
c := int(a.d[r])
|
||||
n = n*10 + c - '0'
|
||||
}
|
||||
a.dp -= r - 1
|
||||
|
||||
// Pick up a digit, put down a digit.
|
||||
for ; r < a.nd; r++ {
|
||||
c := int(a.d[r])
|
||||
dig := n >> k
|
||||
n -= dig << k
|
||||
a.d[w] = byte(dig + '0')
|
||||
w++
|
||||
n = n*10 + c - '0'
|
||||
}
|
||||
|
||||
// Put down extra digits.
|
||||
for n > 0 {
|
||||
dig := n >> k
|
||||
n -= dig << k
|
||||
if w < len(a.d) {
|
||||
a.d[w] = byte(dig + '0')
|
||||
w++
|
||||
} else if dig > 0 {
|
||||
a.trunc = true
|
||||
}
|
||||
n = n * 10
|
||||
}
|
||||
|
||||
a.nd = w
|
||||
trim(a)
|
||||
}
|
||||
|
||||
// Cheat sheet for left shift: table indexed by shift count giving
|
||||
// number of new digits that will be introduced by that shift.
|
||||
//
|
||||
// For example, leftcheats[4] = {2, "625"}. That means that
|
||||
// if we are shifting by 4 (multiplying by 16), it will add 2 digits
|
||||
// when the string prefix is "625" through "999", and one fewer digit
|
||||
// if the string prefix is "000" through "624".
|
||||
//
|
||||
// Credit for this trick goes to Ken.
|
||||
|
||||
type leftCheat struct {
|
||||
delta int // number of new digits
|
||||
cutoff string // minus one digit if original < a.
|
||||
}
|
||||
|
||||
var leftcheats = []leftCheat{
|
||||
// Leading digits of 1/2^i = 5^i.
|
||||
// 5^23 is not an exact 64-bit floating point number,
|
||||
// so have to use bc for the math.
|
||||
/*
|
||||
seq 27 | sed 's/^/5^/' | bc |
|
||||
awk 'BEGIN{ print "\tleftCheat{ 0, \"\" }," }
|
||||
{
|
||||
log2 = log(2)/log(10)
|
||||
printf("\tleftCheat{ %d, \"%s\" },\t// * %d\n",
|
||||
int(log2*NR+1), $0, 2**NR)
|
||||
}'
|
||||
*/
|
||||
{0, ""},
|
||||
{1, "5"}, // * 2
|
||||
{1, "25"}, // * 4
|
||||
{1, "125"}, // * 8
|
||||
{2, "625"}, // * 16
|
||||
{2, "3125"}, // * 32
|
||||
{2, "15625"}, // * 64
|
||||
{3, "78125"}, // * 128
|
||||
{3, "390625"}, // * 256
|
||||
{3, "1953125"}, // * 512
|
||||
{4, "9765625"}, // * 1024
|
||||
{4, "48828125"}, // * 2048
|
||||
{4, "244140625"}, // * 4096
|
||||
{4, "1220703125"}, // * 8192
|
||||
{5, "6103515625"}, // * 16384
|
||||
{5, "30517578125"}, // * 32768
|
||||
{5, "152587890625"}, // * 65536
|
||||
{6, "762939453125"}, // * 131072
|
||||
{6, "3814697265625"}, // * 262144
|
||||
{6, "19073486328125"}, // * 524288
|
||||
{7, "95367431640625"}, // * 1048576
|
||||
{7, "476837158203125"}, // * 2097152
|
||||
{7, "2384185791015625"}, // * 4194304
|
||||
{7, "11920928955078125"}, // * 8388608
|
||||
{8, "59604644775390625"}, // * 16777216
|
||||
{8, "298023223876953125"}, // * 33554432
|
||||
{8, "1490116119384765625"}, // * 67108864
|
||||
{9, "7450580596923828125"}, // * 134217728
|
||||
}
|
||||
|
||||
// Is the leading prefix of b lexicographically less than s?
|
||||
func prefixIsLessThan(b []byte, s string) bool {
|
||||
for i := 0; i < len(s); i++ {
|
||||
if i >= len(b) {
|
||||
return true
|
||||
}
|
||||
if b[i] != s[i] {
|
||||
return b[i] < s[i]
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// Binary shift left (/ 2) by k bits. k <= maxShift to avoid overflow.
|
||||
func leftShift(a *decimal, k uint) {
|
||||
delta := leftcheats[k].delta
|
||||
if prefixIsLessThan(a.d[0:a.nd], leftcheats[k].cutoff) {
|
||||
delta--
|
||||
}
|
||||
|
||||
r := a.nd // read index
|
||||
w := a.nd + delta // write index
|
||||
n := 0
|
||||
|
||||
// Pick up a digit, put down a digit.
|
||||
for r--; r >= 0; r-- {
|
||||
n += (int(a.d[r]) - '0') << k
|
||||
quo := n / 10
|
||||
rem := n - 10*quo
|
||||
w--
|
||||
if w < len(a.d) {
|
||||
a.d[w] = byte(rem + '0')
|
||||
} else if rem != 0 {
|
||||
a.trunc = true
|
||||
}
|
||||
n = quo
|
||||
}
|
||||
|
||||
// Put down extra digits.
|
||||
for n > 0 {
|
||||
quo := n / 10
|
||||
rem := n - 10*quo
|
||||
w--
|
||||
if w < len(a.d) {
|
||||
a.d[w] = byte(rem + '0')
|
||||
} else if rem != 0 {
|
||||
a.trunc = true
|
||||
}
|
||||
n = quo
|
||||
}
|
||||
|
||||
a.nd += delta
|
||||
if a.nd >= len(a.d) {
|
||||
a.nd = len(a.d)
|
||||
}
|
||||
a.dp += delta
|
||||
trim(a)
|
||||
}
|
||||
|
||||
// Binary shift left (k > 0) or right (k < 0).
|
||||
func (a *decimal) Shift(k int) {
|
||||
switch {
|
||||
case a.nd == 0:
|
||||
// nothing to do: a == 0
|
||||
case k > 0:
|
||||
for k > maxShift {
|
||||
leftShift(a, maxShift)
|
||||
k -= maxShift
|
||||
}
|
||||
leftShift(a, uint(k))
|
||||
case k < 0:
|
||||
for k < -maxShift {
|
||||
rightShift(a, maxShift)
|
||||
k += maxShift
|
||||
}
|
||||
rightShift(a, uint(-k))
|
||||
}
|
||||
}
|
||||
|
||||
// If we chop a at nd digits, should we round up?
|
||||
func shouldRoundUp(a *decimal, nd int) bool {
|
||||
if nd < 0 || nd >= a.nd {
|
||||
return false
|
||||
}
|
||||
if a.d[nd] == '5' && nd+1 == a.nd { // exactly halfway - round to even
|
||||
// if we truncated, a little higher than what's recorded - always round up
|
||||
if a.trunc {
|
||||
return true
|
||||
}
|
||||
return nd > 0 && (a.d[nd-1]-'0')%2 != 0
|
||||
}
|
||||
// not halfway - digit tells all
|
||||
return a.d[nd] >= '5'
|
||||
}
|
||||
|
||||
// Round a to nd digits (or fewer).
|
||||
// If nd is zero, it means we're rounding
|
||||
// just to the left of the digits, as in
|
||||
// 0.09 -> 0.1.
|
||||
func (a *decimal) Round(nd int) {
|
||||
if nd < 0 || nd >= a.nd {
|
||||
return
|
||||
}
|
||||
if shouldRoundUp(a, nd) {
|
||||
a.RoundUp(nd)
|
||||
} else {
|
||||
a.RoundDown(nd)
|
||||
}
|
||||
}
|
||||
|
||||
// Round a down to nd digits (or fewer).
|
||||
func (a *decimal) RoundDown(nd int) {
|
||||
if nd < 0 || nd >= a.nd {
|
||||
return
|
||||
}
|
||||
a.nd = nd
|
||||
trim(a)
|
||||
}
|
||||
|
||||
// Round a up to nd digits (or fewer).
|
||||
func (a *decimal) RoundUp(nd int) {
|
||||
if nd < 0 || nd >= a.nd {
|
||||
return
|
||||
}
|
||||
|
||||
// round up
|
||||
for i := nd - 1; i >= 0; i-- {
|
||||
c := a.d[i]
|
||||
if c < '9' { // can stop after this digit
|
||||
a.d[i]++
|
||||
a.nd = i + 1
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
// Number is all 9s.
|
||||
// Change to single 1 with adjusted decimal point.
|
||||
a.d[0] = '1'
|
||||
a.nd = 1
|
||||
a.dp++
|
||||
}
|
||||
|
||||
// Extract integer part, rounded appropriately.
|
||||
// No guarantees about overflow.
|
||||
func (a *decimal) RoundedInteger() uint64 {
|
||||
if a.dp > 20 {
|
||||
return 0xFFFFFFFFFFFFFFFF
|
||||
}
|
||||
var i int
|
||||
n := uint64(0)
|
||||
for i = 0; i < a.dp && i < a.nd; i++ {
|
||||
n = n*10 + uint64(a.d[i]-'0')
|
||||
}
|
||||
for ; i < a.dp; i++ {
|
||||
n *= 10
|
||||
}
|
||||
if shouldRoundUp(a, a.dp) {
|
||||
n++
|
||||
}
|
||||
return n
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue