init server
This commit is contained in:
313
vendor/github.com/ugorji/go/codec/float.go
generated
vendored
Normal file
313
vendor/github.com/ugorji/go/codec/float.go
generated
vendored
Normal file
@@ -0,0 +1,313 @@
|
||||
// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
import "strconv"
|
||||
|
||||
// func parseFloat(b []byte, bitsize int) (f float64, err error) {
|
||||
// if bitsize == 32 {
|
||||
// return parseFloat32(b)
|
||||
// } else {
|
||||
// return parseFloat64(b)
|
||||
// }
|
||||
// }
|
||||
|
||||
func parseFloat32(b []byte) (f float32, err error) {
|
||||
return parseFloat32_custom(b)
|
||||
// return parseFloat32_strconv(b)
|
||||
}
|
||||
|
||||
func parseFloat64(b []byte) (f float64, err error) {
|
||||
return parseFloat64_custom(b)
|
||||
// return parseFloat64_strconv(b)
|
||||
}
|
||||
|
||||
func parseFloat32_strconv(b []byte) (f float32, err error) {
|
||||
f64, err := strconv.ParseFloat(stringView(b), 32)
|
||||
f = float32(f64)
|
||||
return
|
||||
}
|
||||
|
||||
func parseFloat64_strconv(b []byte) (f float64, err error) {
|
||||
return strconv.ParseFloat(stringView(b), 64)
|
||||
}
|
||||
|
||||
// ------ parseFloat custom below --------
|
||||
|
||||
// We assume that a lot of floating point numbers in json files will be
|
||||
// those that are handwritten, and with defined precision (in terms of number
|
||||
// of digits after decimal point), etc.
|
||||
//
|
||||
// We further assume that this ones can be written in exact format.
|
||||
//
|
||||
// strconv.ParseFloat has some unnecessary overhead which we can do without
|
||||
// for the common case:
|
||||
//
|
||||
// - expensive char-by-char check to see if underscores are in right place
|
||||
// - testing for and skipping underscores
|
||||
// - check if the string matches ignorecase +/- inf, +/- infinity, nan
|
||||
// - support for base 16 (0xFFFF...)
|
||||
//
|
||||
// The functions below will try a fast-path for floats which can be decoded
|
||||
// without any loss of precision, meaning they:
|
||||
//
|
||||
// - fits within the significand bits of the 32-bits or 64-bits
|
||||
// - exponent fits within the exponent value
|
||||
// - there is no truncation (any extra numbers are all trailing zeros)
|
||||
//
|
||||
// To figure out what the values are for maxMantDigits, use this idea below:
|
||||
//
|
||||
// 2^23 = 838 8608 (between 10^ 6 and 10^ 7) (significand bits of uint32)
|
||||
// 2^32 = 42 9496 7296 (between 10^ 9 and 10^10) (full uint32)
|
||||
// 2^52 = 4503 5996 2737 0496 (between 10^15 and 10^16) (significand bits of uint64)
|
||||
// 2^64 = 1844 6744 0737 0955 1616 (between 10^19 and 10^20) (full uint64)
|
||||
//
|
||||
// Since we only allow for up to what can comfortably fit into the significand
|
||||
// ignoring the exponent, and we only try to parse iff significand fits into the
|
||||
|
||||
// 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}
|
||||
|
||||
type floatinfo struct {
|
||||
mantbits uint8
|
||||
expbits uint8
|
||||
bias int16
|
||||
|
||||
exactPow10 int8 // Exact powers of ten are <= 10^N (32: 10, 64: 22)
|
||||
exactInts int8 // Exact integers are <= 10^N
|
||||
|
||||
maxMantDigits int8 // 10^19 fits in uint64, while 10^9 fits in uint32
|
||||
}
|
||||
|
||||
var fi32 = floatinfo{23, 8, -127, 10, 7, 9} // maxMantDigits = 9
|
||||
var fi64 = floatinfo{52, 11, -1023, 22, 15, 19} // maxMantDigits = 19
|
||||
|
||||
const fMax64 = 1e15
|
||||
const fMax32 = 1e7
|
||||
|
||||
const fBase = 10
|
||||
|
||||
func parseFloatErr(b []byte) error {
|
||||
return &strconv.NumError{
|
||||
Func: "ParseFloat",
|
||||
Err: strconv.ErrSyntax,
|
||||
Num: string(b),
|
||||
}
|
||||
}
|
||||
|
||||
func parseFloat32_custom(b []byte) (f float32, err error) {
|
||||
mantissa, exp, neg, trunc, bad, ok := readFloat(b, fi32)
|
||||
_ = trunc
|
||||
if bad {
|
||||
return 0, parseFloatErr(b)
|
||||
}
|
||||
if ok {
|
||||
// parseFloatDebug(b, 32, false, exp, trunc, ok)
|
||||
f = float32(mantissa)
|
||||
if neg {
|
||||
f = -f
|
||||
}
|
||||
if exp != 0 {
|
||||
indx := fExpIndx(exp)
|
||||
if exp < 0 { // int / 10^k
|
||||
f /= float32pow10[indx]
|
||||
} else { // exp > 0
|
||||
if exp > fi32.exactPow10 {
|
||||
f *= float32pow10[exp-fi32.exactPow10]
|
||||
if f < -fMax32 || f > fMax32 { // exponent too large - outside range
|
||||
goto FALLBACK
|
||||
}
|
||||
indx = uint8(fi32.exactPow10)
|
||||
}
|
||||
f *= float32pow10[indx]
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
FALLBACK:
|
||||
// parseFloatDebug(b, 32, true, exp, trunc, ok)
|
||||
return parseFloat32_strconv(b)
|
||||
}
|
||||
|
||||
func parseFloat64_custom(b []byte) (f float64, err error) {
|
||||
mantissa, exp, neg, trunc, bad, ok := readFloat(b, fi64)
|
||||
_ = trunc
|
||||
if bad {
|
||||
return 0, parseFloatErr(b)
|
||||
}
|
||||
if ok {
|
||||
f = float64(mantissa)
|
||||
if neg {
|
||||
f = -f
|
||||
}
|
||||
if exp != 0 {
|
||||
indx := fExpIndx(exp)
|
||||
if exp < 0 { // int / 10^k
|
||||
f /= float64pow10[indx]
|
||||
} else { // exp > 0
|
||||
if exp > fi64.exactPow10 {
|
||||
f *= float64pow10[exp-fi64.exactPow10]
|
||||
if f < -fMax64 || f > fMax64 { // exponent too large - outside range
|
||||
goto FALLBACK
|
||||
}
|
||||
indx = uint8(fi64.exactPow10)
|
||||
}
|
||||
f *= float64pow10[indx]
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
FALLBACK:
|
||||
return parseFloat64_strconv(b)
|
||||
}
|
||||
|
||||
func fExpIndx(v int8) uint8 {
|
||||
if v < 0 {
|
||||
return uint8(-v)
|
||||
}
|
||||
return uint8(v)
|
||||
}
|
||||
|
||||
func readFloat(s []byte, y floatinfo) (mantissa uint64, exp int8, neg, trunc, bad, ok bool) {
|
||||
var i uint // make it uint, so that we eliminate bounds checking
|
||||
var slen = uint(len(s))
|
||||
if slen == 0 {
|
||||
bad = true
|
||||
return
|
||||
}
|
||||
switch s[0] {
|
||||
case '+':
|
||||
i++
|
||||
case '-':
|
||||
neg = true
|
||||
i++
|
||||
}
|
||||
|
||||
// we considered punting early if string has length > maxMantDigits, but this doesn't account
|
||||
// for trailing 0's e.g. 700000000000000000000 can be encoded exactly as it is 7e20
|
||||
|
||||
// var sawdot, sawdigits, sawexp bool
|
||||
var sawdot, sawexp bool
|
||||
var nd, ndMant, dp int8
|
||||
L:
|
||||
for ; i < slen; i++ {
|
||||
switch s[i] {
|
||||
case '.':
|
||||
if sawdot {
|
||||
bad = true
|
||||
return
|
||||
}
|
||||
sawdot = true
|
||||
dp = nd
|
||||
case '0':
|
||||
if nd == 0 { // ignore leading zeros
|
||||
dp--
|
||||
continue
|
||||
}
|
||||
nd++
|
||||
if ndMant < y.maxMantDigits {
|
||||
// mantissa = (mantissa << 1) + (mantissa << 3)
|
||||
mantissa *= fBase
|
||||
ndMant++
|
||||
}
|
||||
case '1', '2', '3', '4', '5', '6', '7', '8', '9':
|
||||
// sawdigits = true
|
||||
nd++
|
||||
if ndMant < y.maxMantDigits {
|
||||
// mantissa = (mantissa << 1) + (mantissa << 3) + uint64(s[i]-'0')
|
||||
mantissa = mantissa*fBase + uint64(s[i]-'0')
|
||||
// mantissa *= fBase
|
||||
// mantissa += uint64(s[i] - '0')
|
||||
ndMant++
|
||||
} else {
|
||||
trunc = true
|
||||
return // break L
|
||||
}
|
||||
case 'e', 'E':
|
||||
sawexp = true
|
||||
break L
|
||||
default:
|
||||
bad = true
|
||||
return
|
||||
}
|
||||
}
|
||||
// if !sawdigits {
|
||||
// bad = true
|
||||
// return
|
||||
// }
|
||||
if !sawdot {
|
||||
dp = nd
|
||||
}
|
||||
|
||||
if sawexp {
|
||||
i++
|
||||
if i < slen {
|
||||
var eneg bool
|
||||
if s[i] == '+' {
|
||||
i++
|
||||
} else if s[i] == '-' {
|
||||
i++
|
||||
eneg = true
|
||||
}
|
||||
if i < slen {
|
||||
// for exact match, exponent is 1 or 2 digits (float64: -22 to 37, float32: -1 to 17).
|
||||
// exit quick if exponent is more than 2 digits.
|
||||
if i+2 < slen {
|
||||
return
|
||||
}
|
||||
|
||||
var e int8
|
||||
|
||||
if s[i] < '0' || s[i] > '9' {
|
||||
bad = true
|
||||
return
|
||||
}
|
||||
e = e*fBase + int8(s[i]-'0') // (e << 1) + (e << 3) + int8(s[i]-'0')
|
||||
i++
|
||||
|
||||
if i < slen {
|
||||
if s[i] < '0' || s[i] > '9' {
|
||||
bad = true
|
||||
return
|
||||
}
|
||||
e = e*fBase + int8(s[i]-'0') // (e << 1) + (e << 3) + int8(s[i]-'0')
|
||||
i++
|
||||
}
|
||||
|
||||
if eneg {
|
||||
dp -= e
|
||||
} else {
|
||||
dp += e
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if mantissa != 0 {
|
||||
if mantissa>>y.mantbits != 0 {
|
||||
return
|
||||
}
|
||||
exp = dp - ndMant
|
||||
if exp < -y.exactPow10 || exp > y.exactInts+y.exactPow10 { // cannot handle it
|
||||
return
|
||||
}
|
||||
}
|
||||
ok = true // && !trunc // if trunc=true, we return early (so here trunc=false)
|
||||
return
|
||||
}
|
||||
|
||||
// fMul10ShiftU64
|
||||
|
||||
// func parseFloatDebug(b []byte, bitsize int, strconv bool, exp int8, trunc, ok bool) {
|
||||
// if strconv {
|
||||
// xdebugf("parseFloat%d: delegating: %s, exp: %d, trunc: %v, ok: %v", bitsize, b, exp, trunc, ok)
|
||||
// } else {
|
||||
// xdebug2f("parseFloat%d: attempting: %s, exp: %d, trunc: %v, ok: %v", bitsize, b, exp, trunc, ok)
|
||||
// }
|
||||
// }
|
||||
Reference in New Issue
Block a user