summaryrefslogtreecommitdiff
path: root/vendor/github.com/pquerna/ffjson/fflib/v1/internal
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/pquerna/ffjson/fflib/v1/internal')
-rw-r--r--vendor/github.com/pquerna/ffjson/fflib/v1/internal/atof.go936
-rw-r--r--vendor/github.com/pquerna/ffjson/fflib/v1/internal/atoi.go213
-rw-r--r--vendor/github.com/pquerna/ffjson/fflib/v1/internal/extfloat.go668
-rw-r--r--vendor/github.com/pquerna/ffjson/fflib/v1/internal/ftoa.go475
4 files changed, 0 insertions, 2292 deletions
diff --git a/vendor/github.com/pquerna/ffjson/fflib/v1/internal/atof.go b/vendor/github.com/pquerna/ffjson/fflib/v1/internal/atof.go
deleted file mode 100644
index 46c1289ec..000000000
--- a/vendor/github.com/pquerna/ffjson/fflib/v1/internal/atof.go
+++ /dev/null
@@ -1,936 +0,0 @@
-/**
- * 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
-}
diff --git a/vendor/github.com/pquerna/ffjson/fflib/v1/internal/atoi.go b/vendor/github.com/pquerna/ffjson/fflib/v1/internal/atoi.go
deleted file mode 100644
index 06eb2ec29..000000000
--- a/vendor/github.com/pquerna/ffjson/fflib/v1/internal/atoi.go
+++ /dev/null
@@ -1,213 +0,0 @@
-/**
- * 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/atoi.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
-
-import (
- "errors"
- "strconv"
-)
-
-// ErrRange indicates that a value is out of range for the target type.
-var ErrRange = errors.New("value out of range")
-
-// ErrSyntax indicates that a value does not have the right syntax for the target type.
-var ErrSyntax = errors.New("invalid syntax")
-
-// A NumError records a failed conversion.
-type NumError struct {
- Func string // the failing function (ParseBool, ParseInt, ParseUint, ParseFloat)
- Num string // the input
- Err error // the reason the conversion failed (ErrRange, ErrSyntax)
-}
-
-func (e *NumError) Error() string {
- return "strconv." + e.Func + ": " + "parsing " + strconv.Quote(e.Num) + ": " + e.Err.Error()
-}
-
-func syntaxError(fn, str string) *NumError {
- return &NumError{fn, str, ErrSyntax}
-}
-
-func rangeError(fn, str string) *NumError {
- return &NumError{fn, str, ErrRange}
-}
-
-const intSize = 32 << uint(^uint(0)>>63)
-
-// IntSize is the size in bits of an int or uint value.
-const IntSize = intSize
-
-// Return the first number n such that n*base >= 1<<64.
-func cutoff64(base int) uint64 {
- if base < 2 {
- return 0
- }
- return (1<<64-1)/uint64(base) + 1
-}
-
-// ParseUint is like ParseInt but for unsigned numbers, and oeprating on []byte
-func ParseUint(s []byte, base int, bitSize int) (n uint64, err error) {
- var cutoff, maxVal uint64
-
- if bitSize == 0 {
- bitSize = int(IntSize)
- }
-
- s0 := s
- switch {
- case len(s) < 1:
- err = ErrSyntax
- goto Error
-
- case 2 <= base && base <= 36:
- // valid base; nothing to do
-
- case base == 0:
- // Look for octal, hex prefix.
- switch {
- case s[0] == '0' && len(s) > 1 && (s[1] == 'x' || s[1] == 'X'):
- base = 16
- s = s[2:]
- if len(s) < 1 {
- err = ErrSyntax
- goto Error
- }
- case s[0] == '0':
- base = 8
- default:
- base = 10
- }
-
- default:
- err = errors.New("invalid base " + strconv.Itoa(base))
- goto Error
- }
-
- n = 0
- cutoff = cutoff64(base)
- maxVal = 1<<uint(bitSize) - 1
-
- for i := 0; i < len(s); i++ {
- var v byte
- d := s[i]
- switch {
- case '0' <= d && d <= '9':
- v = d - '0'
- case 'a' <= d && d <= 'z':
- v = d - 'a' + 10
- case 'A' <= d && d <= 'Z':
- v = d - 'A' + 10
- default:
- n = 0
- err = ErrSyntax
- goto Error
- }
- if int(v) >= base {
- n = 0
- err = ErrSyntax
- goto Error
- }
-
- if n >= cutoff {
- // n*base overflows
- n = 1<<64 - 1
- err = ErrRange
- goto Error
- }
- n *= uint64(base)
-
- n1 := n + uint64(v)
- if n1 < n || n1 > maxVal {
- // n+v overflows
- n = 1<<64 - 1
- err = ErrRange
- goto Error
- }
- n = n1
- }
-
- return n, nil
-
-Error:
- return n, &NumError{"ParseUint", string(s0), err}
-}
-
-// ParseInt interprets a string s in the given base (2 to 36) and
-// returns the corresponding value i. If base == 0, the base is
-// implied by the string's prefix: base 16 for "0x", base 8 for
-// "0", and base 10 otherwise.
-//
-// The bitSize argument specifies the integer type
-// that the result must fit into. Bit sizes 0, 8, 16, 32, and 64
-// correspond to int, int8, int16, int32, and int64.
-//
-// The errors that ParseInt returns have concrete type *NumError
-// and include err.Num = s. If s is empty or contains invalid
-// digits, err.Err = ErrSyntax and the returned value is 0;
-// if the value corresponding to s cannot be represented by a
-// signed integer of the given size, err.Err = ErrRange and the
-// returned value is the maximum magnitude integer of the
-// appropriate bitSize and sign.
-func ParseInt(s []byte, base int, bitSize int) (i int64, err error) {
- const fnParseInt = "ParseInt"
-
- if bitSize == 0 {
- bitSize = int(IntSize)
- }
-
- // Empty string bad.
- if len(s) == 0 {
- return 0, syntaxError(fnParseInt, string(s))
- }
-
- // Pick off leading sign.
- s0 := s
- neg := false
- if s[0] == '+' {
- s = s[1:]
- } else if s[0] == '-' {
- neg = true
- s = s[1:]
- }
-
- // Convert unsigned and check range.
- var un uint64
- un, err = ParseUint(s, base, bitSize)
- if err != nil && err.(*NumError).Err != ErrRange {
- err.(*NumError).Func = fnParseInt
- err.(*NumError).Num = string(s0)
- return 0, err
- }
- cutoff := uint64(1 << uint(bitSize-1))
- if !neg && un >= cutoff {
- return int64(cutoff - 1), rangeError(fnParseInt, string(s0))
- }
- if neg && un > cutoff {
- return -int64(cutoff), rangeError(fnParseInt, string(s0))
- }
- n := int64(un)
- if neg {
- n = -n
- }
- return n, nil
-}
diff --git a/vendor/github.com/pquerna/ffjson/fflib/v1/internal/extfloat.go b/vendor/github.com/pquerna/ffjson/fflib/v1/internal/extfloat.go
deleted file mode 100644
index ab791085a..000000000
--- a/vendor/github.com/pquerna/ffjson/fflib/v1/internal/extfloat.go
+++ /dev/null
@@ -1,668 +0,0 @@
-// Copyright 2011 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
-
-// An extFloat represents an extended floating-point number, with more
-// precision than a float64. It does not try to save bits: the
-// number represented by the structure is mant*(2^exp), with a negative
-// sign if neg is true.
-type extFloat struct {
- mant uint64
- exp int
- neg bool
-}
-
-// Powers of ten taken from double-conversion library.
-// http://code.google.com/p/double-conversion/
-const (
- firstPowerOfTen = -348
- stepPowerOfTen = 8
-)
-
-var smallPowersOfTen = [...]extFloat{
- {1 << 63, -63, false}, // 1
- {0xa << 60, -60, false}, // 1e1
- {0x64 << 57, -57, false}, // 1e2
- {0x3e8 << 54, -54, false}, // 1e3
- {0x2710 << 50, -50, false}, // 1e4
- {0x186a0 << 47, -47, false}, // 1e5
- {0xf4240 << 44, -44, false}, // 1e6
- {0x989680 << 40, -40, false}, // 1e7
-}
-
-var powersOfTen = [...]extFloat{
- {0xfa8fd5a0081c0288, -1220, false}, // 10^-348
- {0xbaaee17fa23ebf76, -1193, false}, // 10^-340
- {0x8b16fb203055ac76, -1166, false}, // 10^-332
- {0xcf42894a5dce35ea, -1140, false}, // 10^-324
- {0x9a6bb0aa55653b2d, -1113, false}, // 10^-316
- {0xe61acf033d1a45df, -1087, false}, // 10^-308
- {0xab70fe17c79ac6ca, -1060, false}, // 10^-300
- {0xff77b1fcbebcdc4f, -1034, false}, // 10^-292
- {0xbe5691ef416bd60c, -1007, false}, // 10^-284
- {0x8dd01fad907ffc3c, -980, false}, // 10^-276
- {0xd3515c2831559a83, -954, false}, // 10^-268
- {0x9d71ac8fada6c9b5, -927, false}, // 10^-260
- {0xea9c227723ee8bcb, -901, false}, // 10^-252
- {0xaecc49914078536d, -874, false}, // 10^-244
- {0x823c12795db6ce57, -847, false}, // 10^-236
- {0xc21094364dfb5637, -821, false}, // 10^-228
- {0x9096ea6f3848984f, -794, false}, // 10^-220
- {0xd77485cb25823ac7, -768, false}, // 10^-212
- {0xa086cfcd97bf97f4, -741, false}, // 10^-204
- {0xef340a98172aace5, -715, false}, // 10^-196
- {0xb23867fb2a35b28e, -688, false}, // 10^-188
- {0x84c8d4dfd2c63f3b, -661, false}, // 10^-180
- {0xc5dd44271ad3cdba, -635, false}, // 10^-172
- {0x936b9fcebb25c996, -608, false}, // 10^-164
- {0xdbac6c247d62a584, -582, false}, // 10^-156
- {0xa3ab66580d5fdaf6, -555, false}, // 10^-148
- {0xf3e2f893dec3f126, -529, false}, // 10^-140
- {0xb5b5ada8aaff80b8, -502, false}, // 10^-132
- {0x87625f056c7c4a8b, -475, false}, // 10^-124
- {0xc9bcff6034c13053, -449, false}, // 10^-116
- {0x964e858c91ba2655, -422, false}, // 10^-108
- {0xdff9772470297ebd, -396, false}, // 10^-100
- {0xa6dfbd9fb8e5b88f, -369, false}, // 10^-92
- {0xf8a95fcf88747d94, -343, false}, // 10^-84
- {0xb94470938fa89bcf, -316, false}, // 10^-76
- {0x8a08f0f8bf0f156b, -289, false}, // 10^-68
- {0xcdb02555653131b6, -263, false}, // 10^-60
- {0x993fe2c6d07b7fac, -236, false}, // 10^-52
- {0xe45c10c42a2b3b06, -210, false}, // 10^-44
- {0xaa242499697392d3, -183, false}, // 10^-36
- {0xfd87b5f28300ca0e, -157, false}, // 10^-28
- {0xbce5086492111aeb, -130, false}, // 10^-20
- {0x8cbccc096f5088cc, -103, false}, // 10^-12
- {0xd1b71758e219652c, -77, false}, // 10^-4
- {0x9c40000000000000, -50, false}, // 10^4
- {0xe8d4a51000000000, -24, false}, // 10^12
- {0xad78ebc5ac620000, 3, false}, // 10^20
- {0x813f3978f8940984, 30, false}, // 10^28
- {0xc097ce7bc90715b3, 56, false}, // 10^36
- {0x8f7e32ce7bea5c70, 83, false}, // 10^44
- {0xd5d238a4abe98068, 109, false}, // 10^52
- {0x9f4f2726179a2245, 136, false}, // 10^60
- {0xed63a231d4c4fb27, 162, false}, // 10^68
- {0xb0de65388cc8ada8, 189, false}, // 10^76
- {0x83c7088e1aab65db, 216, false}, // 10^84
- {0xc45d1df942711d9a, 242, false}, // 10^92
- {0x924d692ca61be758, 269, false}, // 10^100
- {0xda01ee641a708dea, 295, false}, // 10^108
- {0xa26da3999aef774a, 322, false}, // 10^116
- {0xf209787bb47d6b85, 348, false}, // 10^124
- {0xb454e4a179dd1877, 375, false}, // 10^132
- {0x865b86925b9bc5c2, 402, false}, // 10^140
- {0xc83553c5c8965d3d, 428, false}, // 10^148
- {0x952ab45cfa97a0b3, 455, false}, // 10^156
- {0xde469fbd99a05fe3, 481, false}, // 10^164
- {0xa59bc234db398c25, 508, false}, // 10^172
- {0xf6c69a72a3989f5c, 534, false}, // 10^180
- {0xb7dcbf5354e9bece, 561, false}, // 10^188
- {0x88fcf317f22241e2, 588, false}, // 10^196
- {0xcc20ce9bd35c78a5, 614, false}, // 10^204
- {0x98165af37b2153df, 641, false}, // 10^212
- {0xe2a0b5dc971f303a, 667, false}, // 10^220
- {0xa8d9d1535ce3b396, 694, false}, // 10^228
- {0xfb9b7cd9a4a7443c, 720, false}, // 10^236
- {0xbb764c4ca7a44410, 747, false}, // 10^244
- {0x8bab8eefb6409c1a, 774, false}, // 10^252
- {0xd01fef10a657842c, 800, false}, // 10^260
- {0x9b10a4e5e9913129, 827, false}, // 10^268
- {0xe7109bfba19c0c9d, 853, false}, // 10^276
- {0xac2820d9623bf429, 880, false}, // 10^284
- {0x80444b5e7aa7cf85, 907, false}, // 10^292
- {0xbf21e44003acdd2d, 933, false}, // 10^300
- {0x8e679c2f5e44ff8f, 960, false}, // 10^308
- {0xd433179d9c8cb841, 986, false}, // 10^316
- {0x9e19db92b4e31ba9, 1013, false}, // 10^324
- {0xeb96bf6ebadf77d9, 1039, false}, // 10^332
- {0xaf87023b9bf0ee6b, 1066, false}, // 10^340
-}
-
-// floatBits returns the bits of the float64 that best approximates
-// the extFloat passed as receiver. Overflow is set to true if
-// the resulting float64 is ±Inf.
-func (f *extFloat) floatBits(flt *floatInfo) (bits uint64, overflow bool) {
- f.Normalize()
-
- exp := f.exp + 63
-
- // Exponent too small.
- if exp < flt.bias+1 {
- n := flt.bias + 1 - exp
- f.mant >>= uint(n)
- exp += n
- }
-
- // Extract 1+flt.mantbits bits from the 64-bit mantissa.
- mant := f.mant >> (63 - flt.mantbits)
- if f.mant&(1<<(62-flt.mantbits)) != 0 {
- // Round up.
- mant += 1
- }
-
- // Rounding might have added a bit; shift down.
- if mant == 2<<flt.mantbits {
- mant >>= 1
- exp++
- }
-
- // Infinities.
- if exp-flt.bias >= 1<<flt.expbits-1 {
- // ±Inf
- mant = 0
- exp = 1<<flt.expbits - 1 + flt.bias
- overflow = true
- } else if mant&(1<<flt.mantbits) == 0 {
- // Denormalized?
- exp = flt.bias
- }
- // Assemble bits.
- bits = mant & (uint64(1)<<flt.mantbits - 1)
- bits |= uint64((exp-flt.bias)&(1<<flt.expbits-1)) << flt.mantbits
- if f.neg {
- bits |= 1 << (flt.mantbits + flt.expbits)
- }
- return
-}
-
-// AssignComputeBounds sets f to the floating point value
-// defined by mant, exp and precision given by flt. It returns
-// lower, upper such that any number in the closed interval
-// [lower, upper] is converted back to the same floating point number.
-func (f *extFloat) AssignComputeBounds(mant uint64, exp int, neg bool, flt *floatInfo) (lower, upper extFloat) {
- f.mant = mant
- f.exp = exp - int(flt.mantbits)
- f.neg = neg
- if f.exp <= 0 && mant == (mant>>uint(-f.exp))<<uint(-f.exp) {
- // An exact integer
- f.mant >>= uint(-f.exp)
- f.exp = 0
- return *f, *f
- }
- expBiased := exp - flt.bias
-
- upper = extFloat{mant: 2*f.mant + 1, exp: f.exp - 1, neg: f.neg}
- if mant != 1<<flt.mantbits || expBiased == 1 {
- lower = extFloat{mant: 2*f.mant - 1, exp: f.exp - 1, neg: f.neg}
- } else {
- lower = extFloat{mant: 4*f.mant - 1, exp: f.exp - 2, neg: f.neg}
- }
- return
-}
-
-// Normalize normalizes f so that the highest bit of the mantissa is
-// set, and returns the number by which the mantissa was left-shifted.
-func (f *extFloat) Normalize() (shift uint) {
- mant, exp := f.mant, f.exp
- if mant == 0 {
- return 0
- }
- if mant>>(64-32) == 0 {
- mant <<= 32
- exp -= 32
- }
- if mant>>(64-16) == 0 {
- mant <<= 16
- exp -= 16
- }
- if mant>>(64-8) == 0 {
- mant <<= 8
- exp -= 8
- }
- if mant>>(64-4) == 0 {
- mant <<= 4
- exp -= 4
- }
- if mant>>(64-2) == 0 {
- mant <<= 2
- exp -= 2
- }
- if mant>>(64-1) == 0 {
- mant <<= 1
- exp -= 1
- }
- shift = uint(f.exp - exp)
- f.mant, f.exp = mant, exp
- return
-}
-
-// Multiply sets f to the product f*g: the result is correctly rounded,
-// but not normalized.
-func (f *extFloat) Multiply(g extFloat) {
- fhi, flo := f.mant>>32, uint64(uint32(f.mant))
- ghi, glo := g.mant>>32, uint64(uint32(g.mant))
-
- // Cross products.
- cross1 := fhi * glo
- cross2 := flo * ghi
-
- // f.mant*g.mant is fhi*ghi << 64 + (cross1+cross2) << 32 + flo*glo
- f.mant = fhi*ghi + (cross1 >> 32) + (cross2 >> 32)
- rem := uint64(uint32(cross1)) + uint64(uint32(cross2)) + ((flo * glo) >> 32)
- // Round up.
- rem += (1 << 31)
-
- f.mant += (rem >> 32)
- f.exp = f.exp + g.exp + 64
-}
-
-var uint64pow10 = [...]uint64{
- 1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
- 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
-}
-
-// AssignDecimal sets f to an approximate value mantissa*10^exp. It
-// returns true if the value represented by f is guaranteed to be the
-// best approximation of d after being rounded to a float64 or
-// float32 depending on flt.
-func (f *extFloat) AssignDecimal(mantissa uint64, exp10 int, neg bool, trunc bool, flt *floatInfo) (ok bool) {
- const uint64digits = 19
- const errorscale = 8
- errors := 0 // An upper bound for error, computed in errorscale*ulp.
- if trunc {
- // the decimal number was truncated.
- errors += errorscale / 2
- }
-
- f.mant = mantissa
- f.exp = 0
- f.neg = neg
-
- // Multiply by powers of ten.
- i := (exp10 - firstPowerOfTen) / stepPowerOfTen
- if exp10 < firstPowerOfTen || i >= len(powersOfTen) {
- return false
- }
- adjExp := (exp10 - firstPowerOfTen) % stepPowerOfTen
-
- // We multiply by exp%step
- if adjExp < uint64digits && mantissa < uint64pow10[uint64digits-adjExp] {
- // We can multiply the mantissa exactly.
- f.mant *= uint64pow10[adjExp]
- f.Normalize()
- } else {
- f.Normalize()
- f.Multiply(smallPowersOfTen[adjExp])
- errors += errorscale / 2
- }
-
- // We multiply by 10 to the exp - exp%step.
- f.Multiply(powersOfTen[i])
- if errors > 0 {
- errors += 1
- }
- errors += errorscale / 2
-
- // Normalize
- shift := f.Normalize()
- errors <<= shift
-
- // Now f is a good approximation of the decimal.
- // Check whether the error is too large: that is, if the mantissa
- // is perturbated by the error, the resulting float64 will change.
- // The 64 bits mantissa is 1 + 52 bits for float64 + 11 extra bits.
- //
- // In many cases the approximation will be good enough.
- denormalExp := flt.bias - 63
- var extrabits uint
- if f.exp <= denormalExp {
- // f.mant * 2^f.exp is smaller than 2^(flt.bias+1).
- extrabits = uint(63 - flt.mantbits + 1 + uint(denormalExp-f.exp))
- } else {
- extrabits = uint(63 - flt.mantbits)
- }
-
- halfway := uint64(1) << (extrabits - 1)
- mant_extra := f.mant & (1<<extrabits - 1)
-
- // Do a signed comparison here! If the error estimate could make
- // the mantissa round differently for the conversion to double,
- // then we can't give a definite answer.
- if int64(halfway)-int64(errors) < int64(mant_extra) &&
- int64(mant_extra) < int64(halfway)+int64(errors) {
- return false
- }
- return true
-}
-
-// Frexp10 is an analogue of math.Frexp for decimal powers. It scales
-// f by an approximate power of ten 10^-exp, and returns exp10, so
-// that f*10^exp10 has the same value as the old f, up to an ulp,
-// as well as the index of 10^-exp in the powersOfTen table.
-func (f *extFloat) frexp10() (exp10, index int) {
- // The constants expMin and expMax constrain the final value of the
- // binary exponent of f. We want a small integral part in the result
- // because finding digits of an integer requires divisions, whereas
- // digits of the fractional part can be found by repeatedly multiplying
- // by 10.
- const expMin = -60
- const expMax = -32
- // Find power of ten such that x * 10^n has a binary exponent
- // between expMin and expMax.
- approxExp10 := ((expMin+expMax)/2 - f.exp) * 28 / 93 // log(10)/log(2) is close to 93/28.
- i := (approxExp10 - firstPowerOfTen) / stepPowerOfTen
-Loop:
- for {
- exp := f.exp + powersOfTen[i].exp + 64
- switch {
- case exp < expMin:
- i++
- case exp > expMax:
- i--
- default:
- break Loop
- }
- }
- // Apply the desired decimal shift on f. It will have exponent
- // in the desired range. This is multiplication by 10^-exp10.
- f.Multiply(powersOfTen[i])
-
- return -(firstPowerOfTen + i*stepPowerOfTen), i
-}
-
-// frexp10Many applies a common shift by a power of ten to a, b, c.
-func frexp10Many(a, b, c *extFloat) (exp10 int) {
- exp10, i := c.frexp10()
- a.Multiply(powersOfTen[i])
- b.Multiply(powersOfTen[i])
- return
-}
-
-// FixedDecimal stores in d the first n significant digits
-// of the decimal representation of f. It returns false
-// if it cannot be sure of the answer.
-func (f *extFloat) FixedDecimal(d *decimalSlice, n int) bool {
- if f.mant == 0 {
- d.nd = 0
- d.dp = 0
- d.neg = f.neg
- return true
- }
- if n == 0 {
- panic("strconv: internal error: extFloat.FixedDecimal called with n == 0")
- }
- // Multiply by an appropriate power of ten to have a reasonable
- // number to process.
- f.Normalize()
- exp10, _ := f.frexp10()
-
- shift := uint(-f.exp)
- integer := uint32(f.mant >> shift)
- fraction := f.mant - (uint64(integer) << shift)
- ε := uint64(1) // ε is the uncertainty we have on the mantissa of f.
-
- // Write exactly n digits to d.
- needed := n // how many digits are left to write.
- integerDigits := 0 // the number of decimal digits of integer.
- pow10 := uint64(1) // the power of ten by which f was scaled.
- for i, pow := 0, uint64(1); i < 20; i++ {
- if pow > uint64(integer) {
- integerDigits = i
- break
- }
- pow *= 10
- }
- rest := integer
- if integerDigits > needed {
- // the integral part is already large, trim the last digits.
- pow10 = uint64pow10[integerDigits-needed]
- integer /= uint32(pow10)
- rest -= integer * uint32(pow10)
- } else {
- rest = 0
- }
-
- // Write the digits of integer: the digits of rest are omitted.
- var buf [32]byte
- pos := len(buf)
- for v := integer; v > 0; {
- v1 := v / 10
- v -= 10 * v1
- pos--
- buf[pos] = byte(v + '0')
- v = v1
- }
- for i := pos; i < len(buf); i++ {
- d.d[i-pos] = buf[i]
- }
- nd := len(buf) - pos
- d.nd = nd
- d.dp = integerDigits + exp10
- needed -= nd
-
- if needed > 0 {
- if rest != 0 || pow10 != 1 {
- panic("strconv: internal error, rest != 0 but needed > 0")
- }
- // Emit digits for the fractional part. Each time, 10*fraction
- // fits in a uint64 without overflow.
- for needed > 0 {
- fraction *= 10
- ε *= 10 // the uncertainty scales as we multiply by ten.
- if 2*ε > 1<<shift {
- // the error is so large it could modify which digit to write, abort.
- return false
- }
- digit := fraction >> shift
- d.d[nd] = byte(digit + '0')
- fraction -= digit << shift
- nd++
- needed--
- }
- d.nd = nd
- }
-
- // We have written a truncation of f (a numerator / 10^d.dp). The remaining part
- // can be interpreted as a small number (< 1) to be added to the last digit of the
- // numerator.
- //
- // If rest > 0, the amount is:
- // (rest<<shift | fraction) / (pow10 << shift)
- // fraction being known with a ±ε uncertainty.
- // The fact that n > 0 guarantees that pow10 << shift does not overflow a uint64.
- //
- // If rest = 0, pow10 == 1 and the amount is
- // fraction / (1 << shift)
- // fraction being known with a ±ε uncertainty.
- //
- // We pass this information to the rounding routine for adjustment.
-
- ok := adjustLastDigitFixed(d, uint64(rest)<<shift|fraction, pow10, shift, ε)
- if !ok {
- return false
- }
- // Trim trailing zeros.
- for i := d.nd - 1; i >= 0; i-- {
- if d.d[i] != '0' {
- d.nd = i + 1
- break
- }
- }
- return true
-}
-
-// adjustLastDigitFixed assumes d contains the representation of the integral part
-// of some number, whose fractional part is num / (den << shift). The numerator
-// num is only known up to an uncertainty of size ε, assumed to be less than
-// (den << shift)/2.
-//
-// It will increase the last digit by one to account for correct rounding, typically
-// when the fractional part is greater than 1/2, and will return false if ε is such
-// that no correct answer can be given.
-func adjustLastDigitFixed(d *decimalSlice, num, den uint64, shift uint, ε uint64) bool {
- if num > den<<shift {
- panic("strconv: num > den<<shift in adjustLastDigitFixed")
- }
- if 2*ε > den<<shift {
- panic("strconv: ε > (den<<shift)/2")
- }
- if 2*(num+ε) < den<<shift {
- return true
- }
- if 2*(num-ε) > den<<shift {
- // increment d by 1.
- i := d.nd - 1
- for ; i >= 0; i-- {
- if d.d[i] == '9' {
- d.nd--
- } else {
- break
- }
- }
- if i < 0 {
- d.d[0] = '1'
- d.nd = 1
- d.dp++
- } else {
- d.d[i]++
- }
- return true
- }
- return false
-}
-
-// ShortestDecimal stores in d the shortest decimal representation of f
-// which belongs to the open interval (lower, upper), where f is supposed
-// to lie. It returns false whenever the result is unsure. The implementation
-// uses the Grisu3 algorithm.
-func (f *extFloat) ShortestDecimal(d *decimalSlice, lower, upper *extFloat) bool {
- if f.mant == 0 {
- d.nd = 0
- d.dp = 0
- d.neg = f.neg
- return true
- }
- if f.exp == 0 && *lower == *f && *lower == *upper {
- // an exact integer.
- var buf [24]byte
- n := len(buf) - 1
- for v := f.mant; v > 0; {
- v1 := v / 10
- v -= 10 * v1
- buf[n] = byte(v + '0')
- n--
- v = v1
- }
- nd := len(buf) - n - 1
- for i := 0; i < nd; i++ {
- d.d[i] = buf[n+1+i]
- }
- d.nd, d.dp = nd, nd
- for d.nd > 0 && d.d[d.nd-1] == '0' {
- d.nd--
- }
- if d.nd == 0 {
- d.dp = 0
- }
- d.neg = f.neg
- return true
- }
- upper.Normalize()
- // Uniformize exponents.
- if f.exp > upper.exp {
- f.mant <<= uint(f.exp - upper.exp)
- f.exp = upper.exp
- }
- if lower.exp > upper.exp {
- lower.mant <<= uint(lower.exp - upper.exp)
- lower.exp = upper.exp
- }
-
- exp10 := frexp10Many(lower, f, upper)
- // Take a safety margin due to rounding in frexp10Many, but we lose precision.
- upper.mant++
- lower.mant--
-
- // The shortest representation of f is either rounded up or down, but
- // in any case, it is a truncation of upper.
- shift := uint(-upper.exp)
- integer := uint32(upper.mant >> shift)
- fraction := upper.mant - (uint64(integer) << shift)
-
- // How far we can go down from upper until the result is wrong.
- allowance := upper.mant - lower.mant
- // How far we should go to get a very precise result.
- targetDiff := upper.mant - f.mant
-
- // Count integral digits: there are at most 10.
- var integerDigits int
- for i, pow := 0, uint64(1); i < 20; i++ {
- if pow > uint64(integer) {
- integerDigits = i
- break
- }
- pow *= 10
- }
- for i := 0; i < integerDigits; i++ {
- pow := uint64pow10[integerDigits-i-1]
- digit := integer / uint32(pow)
- d.d[i] = byte(digit + '0')
- integer -= digit * uint32(pow)
- // evaluate whether we should stop.
- if currentDiff := uint64(integer)<<shift + fraction; currentDiff < allowance {
- d.nd = i + 1
- d.dp = integerDigits + exp10
- d.neg = f.neg
- // Sometimes allowance is so large the last digit might need to be
- // decremented to get closer to f.
- return adjustLastDigit(d, currentDiff, targetDiff, allowance, pow<<shift, 2)
- }
- }
- d.nd = integerDigits
- d.dp = d.nd + exp10
- d.neg = f.neg
-
- // Compute digits of the fractional part. At each step fraction does not
- // overflow. The choice of minExp implies that fraction is less than 2^60.
- var digit int
- multiplier := uint64(1)
- for {
- fraction *= 10
- multiplier *= 10
- digit = int(fraction >> shift)
- d.d[d.nd] = byte(digit + '0')
- d.nd++
- fraction -= uint64(digit) << shift
- if fraction < allowance*multiplier {
- // We are in the admissible range. Note that if allowance is about to
- // overflow, that is, allowance > 2^64/10, the condition is automatically
- // true due to the limited range of fraction.
- return adjustLastDigit(d,
- fraction, targetDiff*multiplier, allowance*multiplier,
- 1<<shift, multiplier*2)
- }
- }
-}
-
-// adjustLastDigit modifies d = x-currentDiff*ε, to get closest to
-// d = x-targetDiff*ε, without becoming smaller than x-maxDiff*ε.
-// It assumes that a decimal digit is worth ulpDecimal*ε, and that
-// all data is known with a error estimate of ulpBinary*ε.
-func adjustLastDigit(d *decimalSlice, currentDiff, targetDiff, maxDiff, ulpDecimal, ulpBinary uint64) bool {
- if ulpDecimal < 2*ulpBinary {
- // Approximation is too wide.
- return false
- }
- for currentDiff+ulpDecimal/2+ulpBinary < targetDiff {
- d.d[d.nd-1]--
- currentDiff += ulpDecimal
- }
- if currentDiff+ulpDecimal <= targetDiff+ulpDecimal/2+ulpBinary {
- // we have two choices, and don't know what to do.
- return false
- }
- if currentDiff < ulpBinary || currentDiff > maxDiff-ulpBinary {
- // we went too far
- return false
- }
- if d.nd == 1 && d.d[0] == '0' {
- // the number has actually reached zero.
- d.nd = 0
- d.dp = 0
- }
- return true
-}
diff --git a/vendor/github.com/pquerna/ffjson/fflib/v1/internal/ftoa.go b/vendor/github.com/pquerna/ffjson/fflib/v1/internal/ftoa.go
deleted file mode 100644
index 253f83b45..000000000
--- a/vendor/github.com/pquerna/ffjson/fflib/v1/internal/ftoa.go
+++ /dev/null
@@ -1,475 +0,0 @@
-// 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.
-
-// Binary to decimal floating point conversion.
-// Algorithm:
-// 1) store mantissa in multiprecision decimal
-// 2) shift decimal by exponent
-// 3) read digits out & format
-
-package internal
-
-import "math"
-
-// TODO: move elsewhere?
-type floatInfo struct {
- mantbits uint
- expbits uint
- bias int
-}
-
-var float32info = floatInfo{23, 8, -127}
-var float64info = floatInfo{52, 11, -1023}
-
-// FormatFloat converts the floating-point number f to a string,
-// according to the format fmt and precision prec. It rounds the
-// result assuming that the original was obtained from a floating-point
-// value of bitSize bits (32 for float32, 64 for float64).
-//
-// The format fmt is one of
-// 'b' (-ddddp±ddd, a binary exponent),
-// 'e' (-d.dddde±dd, a decimal exponent),
-// 'E' (-d.ddddE±dd, a decimal exponent),
-// 'f' (-ddd.dddd, no exponent),
-// 'g' ('e' for large exponents, 'f' otherwise), or
-// 'G' ('E' for large exponents, 'f' otherwise).
-//
-// The precision prec controls the number of digits
-// (excluding the exponent) printed by the 'e', 'E', 'f', 'g', and 'G' formats.
-// For 'e', 'E', and 'f' it is the number of digits after the decimal point.
-// For 'g' and 'G' it is the total number of digits.
-// The special precision -1 uses the smallest number of digits
-// necessary such that ParseFloat will return f exactly.
-func formatFloat(f float64, fmt byte, prec, bitSize int) string {
- return string(genericFtoa(make([]byte, 0, max(prec+4, 24)), f, fmt, prec, bitSize))
-}
-
-// AppendFloat appends the string form of the floating-point number f,
-// as generated by FormatFloat, to dst and returns the extended buffer.
-func appendFloat(dst []byte, f float64, fmt byte, prec int, bitSize int) []byte {
- return genericFtoa(dst, f, fmt, prec, bitSize)
-}
-
-func genericFtoa(dst []byte, val float64, fmt byte, prec, bitSize int) []byte {
- var bits uint64
- var flt *floatInfo
- switch bitSize {
- case 32:
- bits = uint64(math.Float32bits(float32(val)))
- flt = &float32info
- case 64:
- bits = math.Float64bits(val)
- flt = &float64info
- default:
- panic("strconv: illegal AppendFloat/FormatFloat bitSize")
- }
-
- neg := bits>>(flt.expbits+flt.mantbits) != 0
- exp := int(bits>>flt.mantbits) & (1<<flt.expbits - 1)
- mant := bits & (uint64(1)<<flt.mantbits - 1)
-
- switch exp {
- case 1<<flt.expbits - 1:
- // Inf, NaN
- var s string
- switch {
- case mant != 0:
- s = "NaN"
- case neg:
- s = "-Inf"
- default:
- s = "+Inf"
- }
- return append(dst, s...)
-
- case 0:
- // denormalized
- exp++
-
- default:
- // add implicit top bit
- mant |= uint64(1) << flt.mantbits
- }
- exp += flt.bias
-
- // Pick off easy binary format.
- if fmt == 'b' {
- return fmtB(dst, neg, mant, exp, flt)
- }
-
- if !optimize {
- return bigFtoa(dst, prec, fmt, neg, mant, exp, flt)
- }
-
- var digs decimalSlice
- ok := false
- // Negative precision means "only as much as needed to be exact."
- shortest := prec < 0
- if shortest {
- // Try Grisu3 algorithm.
- f := new(extFloat)
- lower, upper := f.AssignComputeBounds(mant, exp, neg, flt)
- var buf [32]byte
- digs.d = buf[:]
- ok = f.ShortestDecimal(&digs, &lower, &upper)
- if !ok {
- return bigFtoa(dst, prec, fmt, neg, mant, exp, flt)
- }
- // Precision for shortest representation mode.
- switch fmt {
- case 'e', 'E':
- prec = digs.nd - 1
- case 'f':
- prec = max(digs.nd-digs.dp, 0)
- case 'g', 'G':
- prec = digs.nd
- }
- } else if fmt != 'f' {
- // Fixed number of digits.
- digits := prec
- switch fmt {
- case 'e', 'E':
- digits++
- case 'g', 'G':
- if prec == 0 {
- prec = 1
- }
- digits = prec
- }
- if digits <= 15 {
- // try fast algorithm when the number of digits is reasonable.
- var buf [24]byte
- digs.d = buf[:]
- f := extFloat{mant, exp - int(flt.mantbits), neg}
- ok = f.FixedDecimal(&digs, digits)
- }
- }
- if !ok {
- return bigFtoa(dst, prec, fmt, neg, mant, exp, flt)
- }
- return formatDigits(dst, shortest, neg, digs, prec, fmt)
-}
-
-// bigFtoa uses multiprecision computations to format a float.
-func bigFtoa(dst []byte, prec int, fmt byte, neg bool, mant uint64, exp int, flt *floatInfo) []byte {
- d := new(decimal)
- d.Assign(mant)
- d.Shift(exp - int(flt.mantbits))
- var digs decimalSlice
- shortest := prec < 0
- if shortest {
- roundShortest(d, mant, exp, flt)
- digs = decimalSlice{d: d.d[:], nd: d.nd, dp: d.dp}
- // Precision for shortest representation mode.
- switch fmt {
- case 'e', 'E':
- prec = digs.nd - 1
- case 'f':
- prec = max(digs.nd-digs.dp, 0)
- case 'g', 'G':
- prec = digs.nd
- }
- } else {
- // Round appropriately.
- switch fmt {
- case 'e', 'E':
- d.Round(prec + 1)
- case 'f':
- d.Round(d.dp + prec)
- case 'g', 'G':
- if prec == 0 {
- prec = 1
- }
- d.Round(prec)
- }
- digs = decimalSlice{d: d.d[:], nd: d.nd, dp: d.dp}
- }
- return formatDigits(dst, shortest, neg, digs, prec, fmt)
-}
-
-func formatDigits(dst []byte, shortest bool, neg bool, digs decimalSlice, prec int, fmt byte) []byte {
- switch fmt {
- case 'e', 'E':
- return fmtE(dst, neg, digs, prec, fmt)
- case 'f':
- return fmtF(dst, neg, digs, prec)
- case 'g', 'G':
- // trailing fractional zeros in 'e' form will be trimmed.
- eprec := prec
- if eprec > digs.nd && digs.nd >= digs.dp {
- eprec = digs.nd
- }
- // %e is used if the exponent from the conversion
- // is less than -4 or greater than or equal to the precision.
- // if precision was the shortest possible, use precision 6 for this decision.
- if shortest {
- eprec = 6
- }
- exp := digs.dp - 1
- if exp < -4 || exp >= eprec {
- if prec > digs.nd {
- prec = digs.nd
- }
- return fmtE(dst, neg, digs, prec-1, fmt+'e'-'g')
- }
- if prec > digs.dp {
- prec = digs.nd
- }
- return fmtF(dst, neg, digs, max(prec-digs.dp, 0))
- }
-
- // unknown format
- return append(dst, '%', fmt)
-}
-
-// Round d (= mant * 2^exp) to the shortest number of digits
-// that will let the original floating point value be precisely
-// reconstructed. Size is original floating point size (64 or 32).
-func roundShortest(d *decimal, mant uint64, exp int, flt *floatInfo) {
- // If mantissa is zero, the number is zero; stop now.
- if mant == 0 {
- d.nd = 0
- return
- }
-
- // Compute upper and lower such that any decimal number
- // between upper and lower (possibly inclusive)
- // will round to the original floating point number.
-
- // We may see at once that the number is already shortest.
- //
- // Suppose d is not denormal, so that 2^exp <= d < 10^dp.
- // The closest shorter number is at least 10^(dp-nd) away.
- // The lower/upper bounds computed below are at distance
- // at most 2^(exp-mantbits).
- //
- // So the number is already shortest if 10^(dp-nd) > 2^(exp-mantbits),
- // or equivalently log2(10)*(dp-nd) > exp-mantbits.
- // It is true if 332/100*(dp-nd) >= exp-mantbits (log2(10) > 3.32).
- minexp := flt.bias + 1 // minimum possible exponent
- if exp > minexp && 332*(d.dp-d.nd) >= 100*(exp-int(flt.mantbits)) {
- // The number is already shortest.
- return
- }
-
- // d = mant << (exp - mantbits)
- // Next highest floating point number is mant+1 << exp-mantbits.
- // Our upper bound is halfway between, mant*2+1 << exp-mantbits-1.
- upper := new(decimal)
- upper.Assign(mant*2 + 1)
- upper.Shift(exp - int(flt.mantbits) - 1)
-
- // d = mant << (exp - mantbits)
- // Next lowest floating point number is mant-1 << exp-mantbits,
- // unless mant-1 drops the significant bit and exp is not the minimum exp,
- // in which case the next lowest is mant*2-1 << exp-mantbits-1.
- // Either way, call it mantlo << explo-mantbits.
- // Our lower bound is halfway between, mantlo*2+1 << explo-mantbits-1.
- var mantlo uint64
- var explo int
- if mant > 1<<flt.mantbits || exp == minexp {
- mantlo = mant - 1
- explo = exp
- } else {
- mantlo = mant*2 - 1
- explo = exp - 1
- }
- lower := new(decimal)
- lower.Assign(mantlo*2 + 1)
- lower.Shift(explo - int(flt.mantbits) - 1)
-
- // The upper and lower bounds are possible outputs only if
- // the original mantissa is even, so that IEEE round-to-even
- // would round to the original mantissa and not the neighbors.
- inclusive := mant%2 == 0
-
- // Now we can figure out the minimum number of digits required.
- // Walk along until d has distinguished itself from upper and lower.
- for i := 0; i < d.nd; i++ {
- var l, m, u byte // lower, middle, upper digits
- if i < lower.nd {
- l = lower.d[i]
- } else {
- l = '0'
- }
- m = d.d[i]
- if i < upper.nd {
- u = upper.d[i]
- } else {
- u = '0'
- }
-
- // Okay to round down (truncate) if lower has a different digit
- // or if lower is inclusive and is exactly the result of rounding down.
- okdown := l != m || (inclusive && l == m && i+1 == lower.nd)
-
- // Okay to round up if upper has a different digit and
- // either upper is inclusive or upper is bigger than the result of rounding up.
- okup := m != u && (inclusive || m+1 < u || i+1 < upper.nd)
-
- // If it's okay to do either, then round to the nearest one.
- // If it's okay to do only one, do it.
- switch {
- case okdown && okup:
- d.Round(i + 1)
- return
- case okdown:
- d.RoundDown(i + 1)
- return
- case okup:
- d.RoundUp(i + 1)
- return
- }
- }
-}
-
-type decimalSlice struct {
- d []byte
- nd, dp int
- neg bool
-}
-
-// %e: -d.ddddde±dd
-func fmtE(dst []byte, neg bool, d decimalSlice, prec int, fmt byte) []byte {
- // sign
- if neg {
- dst = append(dst, '-')
- }
-
- // first digit
- ch := byte('0')
- if d.nd != 0 {
- ch = d.d[0]
- }
- dst = append(dst, ch)
-
- // .moredigits
- if prec > 0 {
- dst = append(dst, '.')
- i := 1
- m := d.nd + prec + 1 - max(d.nd, prec+1)
- for i < m {
- dst = append(dst, d.d[i])
- i++
- }
- for i <= prec {
- dst = append(dst, '0')
- i++
- }
- }
-
- // e±
- dst = append(dst, fmt)
- exp := d.dp - 1
- if d.nd == 0 { // special case: 0 has exponent 0
- exp = 0
- }
- if exp < 0 {
- ch = '-'
- exp = -exp
- } else {
- ch = '+'
- }
- dst = append(dst, ch)
-
- // dddd
- var buf [3]byte
- i := len(buf)
- for exp >= 10 {
- i--
- buf[i] = byte(exp%10 + '0')
- exp /= 10
- }
- // exp < 10
- i--
- buf[i] = byte(exp + '0')
-
- switch i {
- case 0:
- dst = append(dst, buf[0], buf[1], buf[2])
- case 1:
- dst = append(dst, buf[1], buf[2])
- case 2:
- // leading zeroes
- dst = append(dst, '0', buf[2])
- }
- return dst
-}
-
-// %f: -ddddddd.ddddd
-func fmtF(dst []byte, neg bool, d decimalSlice, prec int) []byte {
- // sign
- if neg {
- dst = append(dst, '-')
- }
-
- // integer, padded with zeros as needed.
- if d.dp > 0 {
- var i int
- for i = 0; i < d.dp && i < d.nd; i++ {
- dst = append(dst, d.d[i])
- }
- for ; i < d.dp; i++ {
- dst = append(dst, '0')
- }
- } else {
- dst = append(dst, '0')
- }
-
- // fraction
- if prec > 0 {
- dst = append(dst, '.')
- for i := 0; i < prec; i++ {
- ch := byte('0')
- if j := d.dp + i; 0 <= j && j < d.nd {
- ch = d.d[j]
- }
- dst = append(dst, ch)
- }
- }
-
- return dst
-}
-
-// %b: -ddddddddp+ddd
-func fmtB(dst []byte, neg bool, mant uint64, exp int, flt *floatInfo) []byte {
- var buf [50]byte
- w := len(buf)
- exp -= int(flt.mantbits)
- esign := byte('+')
- if exp < 0 {
- esign = '-'
- exp = -exp
- }
- n := 0
- for exp > 0 || n < 1 {
- n++
- w--
- buf[w] = byte(exp%10 + '0')
- exp /= 10
- }
- w--
- buf[w] = esign
- w--
- buf[w] = 'p'
- n = 0
- for mant > 0 || n < 1 {
- n++
- w--
- buf[w] = byte(mant%10 + '0')
- mant /= 10
- }
- if neg {
- w--
- buf[w] = '-'
- }
- return append(dst, buf[w:]...)
-}
-
-func max(a, b int) int {
- if a > b {
- return a
- }
- return b
-}