source: code/trunk/vendor/modernc.org/mathutil/int.go@ 824

// Copyright (c) 2018 The mathutil 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 mathutil // import "modernc.org/mathutil"

import (
        "fmt"
        "math"
        "math/big"
)

var (
        // MaxInt128 represents the maximun Int128 value as big.Int
        MaxInt128 *big.Int
        // MinInt128 represents the minimun Int128 value as big.Int
        MinInt128 *big.Int
        // MaxUint128 represents the maximun Uint128 value as big.Int
        MaxUint128 *big.Int
)

func init() {
        var ok bool
        MaxInt128, ok = big.NewInt(0).SetString("0x7fffffff_ffffffff_ffffffff_ffffffff", 0)
        if !ok {
                panic("internal error")
        }

        MinInt128 = big.NewInt(0).Set(MaxInt128)
        MinInt128.Add(MinInt128, _1)
        MinInt128.Neg(MinInt128)

        MaxUint128, ok = big.NewInt(0).SetString("0xffffffff_ffffffff_ffffffff_ffffffff", 0)
        if !ok {
                panic("internal error")
        }
}

const (
        maxInt128  = 1<<127 - 1
        maxUint128 = 1<<128 - 1
        minInt128  = -maxInt128 - 1
)

// Int128 is an 128 bit signed integer.
type Int128 struct {
        Lo int64 // Bits 63..0.
        Hi int64 // Bits 127..64.
}

// Add returns the sum of x and y and a carry indication.
func (x Int128) Add(y Int128) (r Int128, cy bool) {
        r.Lo = x.Lo + y.Lo
        r.Hi = x.Hi + y.Hi
        if uint64(r.Lo) < uint64(x.Lo) {
                r.Hi++
        }
        return r, (r.Cmp(x) < 0) == (y.Sign() >= 0)
}

// BigInt returns x in the form of a big.Int.
func (x Int128) BigInt() *big.Int {
        r := big.NewInt(x.Hi)
        r.Lsh(r, 64)
        lo := big.NewInt(0)
        lo.SetUint64(uint64(x.Lo))
        return r.Add(r, lo)
}

// Cmp compares x and y and returns:
//
//      -1 if x <  y
//       0 if x == y
//      +1 if x >  y
func (x Int128) Cmp(y Int128) int {
        if x.Hi > y.Hi {
                return 1
        }

        if x.Hi < y.Hi {
                return -1
        }

        if uint64(x.Lo) > uint64(y.Lo) {
                return 1
        }

        if uint64(x.Lo) < uint64(y.Lo) {
                return -1
        }

        return 0
}

// Neg returns -x and an indication that x was not equal to MinInt128.
func (x Int128) Neg() (r Int128, ok bool) {
        if x == (Int128{Hi: math.MinInt64}) {
                return x, false
        }

        x.Lo = ^x.Lo
        x.Hi = ^x.Hi
        r, _ = x.Add(Int128{Lo: 1})
        return r, true
}

// SetBigInt sets x to y, returns x and an error, if any.
func (x *Int128) SetBigInt(y *big.Int) (r Int128, err error) {
        if y.Cmp(MaxInt128) > 0 {
                return *x, fmt.Errorf("%T.SetInt: overflow", x)
        }
        if y.Cmp(MinInt128) < 0 {
                return *x, fmt.Errorf("%T.SetInt: underflow", x)
        }
        neg := y.Sign() < 0
        var z big.Int
        z.Set(y)
        if neg {
                z.Neg(&z)
        }
        r.Lo = z.Int64()
        z.Rsh(&z, 64)
        r.Hi = z.Int64()
        if neg {
                r, _ = r.Neg()
        }
        *x = r
        return r, nil
}

// SetInt64 sets x to y and returns x.
func (x *Int128) SetInt64(y int64) (r Int128) {
        r.Lo = y
        if y >= 0 {
                r.Hi = 0
                *x = r
                return r
        }

        r.Hi = -1
        *x = r
        return r
}

// SetUint64 sets x to y and returns x.
func (x *Int128) SetUint64(y uint64) (r Int128) {
        r = Int128{Lo: int64(y)}
        *x = r
        return r
}

// Sign returns:
//
//      -1 if x <  0
//       0 if x == 0
//      +1 if x >  0
func (x Int128) Sign() int {
        if x.Hi < 0 {
                return -1
        }

        if x.Hi != 0 || x.Lo != 0 {
                return 1
        }

        return 0
}

// String implements fmt.Stringer()
func (x Int128) String() string { return x.BigInt().String() }

// NewInt128FromInt64 return a new Int128 value initialized to n.
func NewInt128FromInt64(n int64) (r Int128) {
        r.Lo = n
        if n < 0 {
                r.Hi = -1
        }
        return r
}

// NewInt128FromUint64 return a new Int128 value initialized to n.
func NewInt128FromUint64(n uint64) (r Int128) { return Int128{Lo: int64(n)} }

// NewInt128FromFloat32 returns a new Int128 value initialized to n. Result is
// not specified in n does not represent a number within the range of Int128
// values.
func NewInt128FromFloat32(n float32) (r Int128) {
        if n >= minInt128 && n <= maxInt128 {
                if n >= math.MinInt64 && n <= math.MaxInt64 {
                        return NewInt128FromInt64(int64(n))
                }

                f := big.NewFloat(float64(n))
                bi, _ := f.Int(nil)
                r.SetBigInt(bi)
        }
        return r
}

// NewInt128FromFloat64 returns a new Int128 value initialized to n. Result is
// not specified in n does not represent a number within the range of Int128
// values.
func NewInt128FromFloat64(n float64) (r Int128) {
        if n >= minInt128 && n <= maxInt128 {
                if n >= math.MinInt64 && n <= math.MaxInt64 {
                        return NewInt128FromInt64(int64(n))
                }

                f := big.NewFloat(n)
                bi, _ := f.Int(nil)
                r.SetBigInt(bi)
        }
        return r
}

// Uint128 is an 128 bit unsigned integer.
type Uint128 struct {
        Lo uint64 // Bits 63..0.
        Hi uint64 // Bits 127..64.
}

// NewUint128FromInt64 return a new Uint128 value initialized to n.
func NewUint128FromInt64(n int64) (r Uint128) {
        r.Lo = uint64(n)
        if n < 0 {
                r.Hi = ^uint64(0)
        }
        return r
}

// NewUint128FromUint64 return a new Uint128 value initialized to n.
func NewUint128FromUint64(n uint64) (r Uint128) { return Uint128{Lo: n} }

// NewUint128FromFloat32 returns a new Uint128 value initialized to n. Result is
// not specified in n does not represent a number within the range of Uint128
// values.
func NewUint128FromFloat32(n float32) (r Uint128) {
        if n >= 0 {
                if n <= math.MaxUint64 {
                        return NewUint128FromUint64(uint64(n))
                }

                f := big.NewFloat(float64(n))
                bi, _ := f.Int(nil)
                r.SetBigInt(bi)
        }
        return r
}

// NewUint128FromFloat64 returns a new Uint128 value initialized to n. Result is
// not specified in n does not represent a number within the range of Uint128
// values.
func NewUint128FromFloat64(n float64) (r Uint128) {
        if n >= 0 && n <= maxUint128 {
                if n <= math.MaxUint64 {
                        return NewUint128FromUint64(uint64(n))
                }

                f := big.NewFloat(n)
                bi, _ := f.Int(nil)
                r.SetBigInt(bi)
        }
        return r
}

// SetBigInt sets x to y, returns x and an error, if any.
func (x *Uint128) SetBigInt(y *big.Int) (r Uint128, err error) {
        if y.Sign() < 0 || y.Cmp(MaxUint128) > 0 {
                return *x, fmt.Errorf("%T.SetInt: overflow", x)
        }

        var z big.Int
        z.Set(y)
        r.Lo = z.Uint64()
        z.Rsh(&z, 64)
        r.Hi = z.Uint64()
        *x = r
        return r, nil
}