diff options
Diffstat (limited to 'vendor/modernc.org/libc/int128.go')
| -rw-r--r-- | vendor/modernc.org/libc/int128.go | 331 |
1 files changed, 331 insertions, 0 deletions
diff --git a/vendor/modernc.org/libc/int128.go b/vendor/modernc.org/libc/int128.go new file mode 100644 index 00000000..7995f084 --- /dev/null +++ b/vendor/modernc.org/libc/int128.go @@ -0,0 +1,331 @@ +// Copyright 2020 The Libc Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Some code is copied and adjusted from +// https://github.com/lukechampine/uint128, the original LICENSE file +// reproduced below in full as of 2021-01-19: + +/* +The MIT License (MIT) + +Copyright (c) 2019 Luke Champine + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +package libc // import "modernc.org/libc" + +import ( + mbits "math/bits" + + "modernc.org/mathutil" +) + +type Int128 mathutil.Int128 + +var ( + int128Minus1 = Int128{-1, -1} + int128Plus1 = Int128{Lo: 1} +) + +func Int128FromFloat32(n float32) Int128 { return Int128(mathutil.NewInt128FromFloat32(n)) } +func Int128FromFloat64(n float64) Int128 { return Int128(mathutil.NewInt128FromFloat64(n)) } +func Int128FromInt16(n int16) Int128 { return Int128(mathutil.NewInt128FromInt64(int64(n))) } +func Int128FromInt32(n int32) Int128 { return Int128(mathutil.NewInt128FromInt64(int64(n))) } +func Int128FromInt64(n int64) Int128 { return Int128(mathutil.NewInt128FromInt64(int64(n))) } +func Int128FromInt8(n int8) Int128 { return Int128(mathutil.NewInt128FromInt64(int64(n))) } +func Int128FromUint16(n uint16) Int128 { return Int128(mathutil.NewInt128FromInt64(int64(n))) } +func Int128FromUint32(n uint32) Int128 { return Int128(mathutil.NewInt128FromInt64(int64(n))) } +func Int128FromUint64(n uint64) Int128 { return Int128(mathutil.NewInt128FromUint64(n)) } +func Int128FromUint8(n uint8) Int128 { return Int128(mathutil.NewInt128FromInt64(int64(n))) } +func Int128FromUint128(n Uint128) Int128 { return Int128{Lo: int64(n.Lo), Hi: int64(n.Hi)} } + +func (n *Int128) LValueDec() { *n = n.Add(int128Minus1) } +func (n *Int128) LValueInc() { *n = n.Add(int128Plus1) } +func (n *Int128) LValueShl(c int32) { *n = n.Shl(c) } +func (n *Int128) LValueShr(c int32) { *n = n.Shr(c) } +func (n Int128) And(v Int128) Int128 { return Int128{n.Lo & v.Lo, n.Hi & v.Hi} } +func (n Int128) Cmp(y Int128) int { return mathutil.Int128(n).Cmp(mathutil.Int128(y)) } +func (n Int128) Int16() int16 { return int16(n.Lo) } +func (n Int128) Int32() int32 { return int32(n.Lo) } +func (n Int128) Int64() int64 { return int64(n.Lo) } +func (n Int128) Int8() int8 { return int8(n.Lo) } +func (n Int128) Or(v Int128) Int128 { return Int128{n.Lo | v.Lo, n.Hi | v.Hi} } +func (n Int128) Uint128() (r Uint128) { return Uint128{uint64(n.Lo), uint64(n.Hi)} } +func (n Int128) Uint16() uint16 { return uint16(n.Lo) } +func (n Int128) Uint32() uint32 { return uint32(n.Lo) } +func (n Int128) Uint64() uint64 { return uint64(n.Lo) } +func (n Int128) Uint8() uint8 { return uint8(n.Lo) } +func (n Int128) Xor(v Int128) Int128 { return Int128{n.Lo ^ v.Lo, n.Hi ^ v.Hi} } + +func (n Int128) Neg() Int128 { + n.Lo ^= -1 + n.Hi ^= -1 + return n.Add(int128Plus1) +} + +func (n Int128) Float32() float32 { + switch n.Hi { + case 0: + return float32(uint64(n.Lo)) + case -1: + return -float32(uint64(n.Lo)) + } + + if n.Hi < 0 { + n = n.Neg() + return -float32(n.Hi)*(1<<64) + float32(uint64(n.Lo)) + } + + return -float32(n.Hi)*(1<<64) + float32(uint64(n.Lo)) +} + +func (n Int128) Float64() float64 { + switch n.Hi { + case 0: + return float64(uint64(n.Lo)) + case -1: + return -float64(uint64(n.Lo)) + } + + if n.Hi < 0 { + n = n.Neg() + return -float64(n.Hi)*(1<<64) + float64(uint64(n.Lo)) + } + + return float64(n.Hi)*(1<<64) + float64(uint64(n.Lo)) +} + +func (n Int128) Add(m Int128) (r Int128) { + r.Lo = n.Lo + m.Lo + r.Hi = n.Hi + m.Hi + if uint64(r.Lo) < uint64(n.Lo) { + r.Hi++ + } + return r +} + +func (n Int128) Mul(m Int128) Int128 { + hi, lo := mbits.Mul64(uint64(n.Lo), uint64(m.Lo)) + _, p1 := mbits.Mul64(uint64(n.Hi), uint64(m.Lo)) + _, p3 := mbits.Mul64(uint64(n.Lo), uint64(m.Hi)) + hi, _ = mbits.Add64(hi, p1, 0) + hi, _ = mbits.Add64(hi, p3, 0) + return Int128{int64(lo), int64(hi)} +} + +func (n Int128) Shl(c int32) (r Int128) { + if c > 64 { + r.Lo = 0 + r.Hi = n.Lo << (c - 64) + } else { + r.Lo = n.Lo << c + r.Hi = n.Hi<<c | n.Lo>>(64-c) + } + return r +} + +func (n Int128) Shr(c int32) (r Int128) { + if c > 64 { + r.Lo = n.Hi >> (c - 64) + switch { + case n.Hi < 0: + r.Hi = -1 + default: + r.Hi = 0 + } + } else { + r.Lo = n.Lo>>c | n.Hi<<(64-c) + r.Hi = n.Hi >> c + } + return r +} + +type Uint128 mathutil.Uint128 + +func Uint128FromFloat32(n float32) Uint128 { return Uint128(mathutil.NewUint128FromFloat32(n)) } +func Uint128FromFloat64(n float64) Uint128 { return Uint128(mathutil.NewUint128FromFloat64(n)) } +func Uint128FromInt128(n Int128) Uint128 { return Uint128{Lo: uint64(n.Lo), Hi: uint64(n.Hi)} } +func Uint128FromInt16(n int16) Uint128 { return Uint128FromInt64(int64(n)) } +func Uint128FromInt32(n int32) Uint128 { return Uint128FromInt64(int64(n)) } +func Uint128FromInt8(n int8) Uint128 { return Uint128FromInt64(int64(n)) } +func Uint128FromUint16(n uint16) Uint128 { return Uint128{Lo: uint64(n)} } +func Uint128FromUint32(n uint32) Uint128 { return Uint128{Lo: uint64(n)} } +func Uint128FromUint64(n uint64) Uint128 { return Uint128{Lo: n} } +func Uint128FromUint8(n uint8) Uint128 { return Uint128{Lo: uint64(n)} } + +func Uint128FromInt64(n int64) (r Uint128) { + r.Lo = uint64(n) + if n < 0 { + r.Hi = ^uint64(0) + } + return r +} + +func (n *Uint128) LValueShl(c int32) { *n = n.Shl(c) } +func (n *Uint128) LValueShr(c int32) { *n = n.Shr(c) } +func (n Uint128) And(m Uint128) Uint128 { return Uint128{n.Lo & m.Lo, n.Hi & m.Hi} } +func (n Uint128) Int128() Int128 { return Int128{int64(n.Lo), int64(n.Hi)} } +func (n Uint128) Int16() int16 { return int16(n.Lo) } +func (n Uint128) Int32() int32 { return int32(n.Lo) } +func (n Uint128) Int64() int64 { return int64(n.Lo) } +func (n Uint128) Int8() int8 { return int8(n.Lo) } +func (n Uint128) Or(m Uint128) Uint128 { return Uint128{n.Lo | m.Lo, n.Hi | m.Hi} } +func (n Uint128) Uint16() uint16 { return uint16(n.Lo) } +func (n Uint128) Uint32() uint32 { return uint32(n.Lo) } +func (n Uint128) Uint64() uint64 { return n.Lo } +func (n Uint128) Uint8() uint8 { return uint8(n.Lo) } +func (n Uint128) Xor(m Uint128) Uint128 { return Uint128{n.Lo ^ m.Lo, n.Hi ^ m.Hi} } + +func (n Uint128) Add(m Uint128) (r Uint128) { + var carry uint64 + r.Lo, carry = mbits.Add64(n.Lo, m.Lo, 0) + r.Hi, _ = mbits.Add64(n.Hi, m.Hi, carry) + return r +} + +func (n Uint128) Mul(m Uint128) Uint128 { + hi, lo := mbits.Mul64(n.Lo, m.Lo) + _, p1 := mbits.Mul64(n.Hi, m.Lo) + _, p3 := mbits.Mul64(n.Lo, m.Hi) + hi, _ = mbits.Add64(hi, p1, 0) + hi, _ = mbits.Add64(hi, p3, 0) + return Uint128{lo, hi} +} + +func (n Uint128) Shr(c int32) (r Uint128) { + if c > 64 { + r.Lo = n.Hi >> (c - 64) + r.Hi = 0 + } else { + r.Lo = n.Lo>>c | n.Hi<<(64-c) + r.Hi = n.Hi >> c + } + return r +} + +func (n Uint128) mulOvf(m Uint128) (_ Uint128, ovf bool) { + hi, lo := mbits.Mul64(n.Lo, m.Lo) + p0, p1 := mbits.Mul64(n.Hi, m.Lo) + p2, p3 := mbits.Mul64(n.Lo, m.Hi) + hi, c0 := mbits.Add64(hi, p1, 0) + hi, c1 := mbits.Add64(hi, p3, 0) + ovf = p0 != 0 || p2 != 0 || c0 != 0 || c1 != 0 + return Uint128{lo, hi}, ovf +} + +func (n Uint128) quoRem(m Uint128) (q, r Uint128) { + if m.Hi == 0 { + var r64 uint64 + q, r64 = n.quoRem64(m.Lo) + r = Uint128FromUint64(r64) + } else { + // generate a "trial quotient," guaranteed to be within 1 of the actual + // quotient, then adjust. + nz := mbits.LeadingZeros64(m.Hi) + v1 := m.Shl(int32(nz)) + u1 := n.Shr(1) + tq, _ := mbits.Div64(u1.Hi, u1.Lo, v1.Hi) + tq >>= 63 - nz + if tq != 0 { + tq-- + } + q = Uint128FromUint64(tq) + // calculate remainder using trial quotient, then adjust if remainder is + // greater than divisor + r = n.Sub(m.mul64(tq)) + if r.Cmp(m) >= 0 { + q = q.add64(1) + r = r.Sub(m) + } + } + return +} + +func (n Uint128) quoRem64(m uint64) (q Uint128, r uint64) { + if n.Hi < m { + q.Lo, r = mbits.Div64(n.Hi, n.Lo, m) + } else { + q.Hi, r = mbits.Div64(0, n.Hi, m) + q.Lo, r = mbits.Div64(r, n.Lo, m) + } + return +} + +func (n Uint128) Div(m Uint128) (r Uint128) { + r, _ = n.quoRem(m) + return r +} + +func (n Uint128) Shl(c int32) (r Uint128) { + if c > 64 { + r.Lo = 0 + r.Hi = n.Lo << (c - 64) + } else { + r.Lo = n.Lo << c + r.Hi = n.Hi<<c | n.Lo>>(64-c) + } + return +} + +func (n Uint128) Sub(m Uint128) Uint128 { + lo, borrow := mbits.Sub64(n.Lo, m.Lo, 0) + hi, _ := mbits.Sub64(n.Hi, m.Hi, borrow) + return Uint128{lo, hi} +} + +func (n Uint128) mul64(m uint64) Uint128 { + hi, lo := mbits.Mul64(n.Lo, m) + _, p1 := mbits.Mul64(n.Hi, m) + hi, _ = mbits.Add64(hi, p1, 0) + return Uint128{lo, hi} +} + +func (n Uint128) Cmp(m Uint128) int { + if n == m { + return 0 + } else if n.Hi < m.Hi || (n.Hi == m.Hi && n.Lo < m.Lo) { + return -1 + } else { + return 1 + } +} + +func (n Uint128) add64(m uint64) Uint128 { + lo, carry := mbits.Add64(n.Lo, m, 0) + hi, _ := mbits.Add64(n.Hi, 0, carry) + return Uint128{lo, hi} +} + +func (n Uint128) Float32() float32 { + if n.Hi == 0 { + return float32(uint64(n.Lo)) + } + + return float32(n.Hi)*(1<<64) + float32(uint64(n.Lo)) +} + +func (n Uint128) Float64() float64 { + if n.Hi == 0 { + return float64(uint64(n.Lo)) + } + + return float64(n.Hi)*(1<<64) + float64(uint64(n.Lo)) +} |