feat(p/int256): int256

examples/gno.land/p/demo/int256/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Trịnh Đức Bảo Linh(Kevin)
+
+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.

examples/gno.land/p/demo/int256/README.md

@@ -0,0 +1,6 @@
+# Fixed size signed 256-bit math library
+
+1. This is a library specialized at replacing the big.Int library for math based on signed 256-bit types.
+2. It uses [uint256](https://github.com/gnolang/gno/tree/master/examples/gno.land/p/demo/uint256) as the underlying type.
+
+ported from [mempooler/int256](https://github.com/mempooler/int256)

examples/gno.land/p/demo/int256/absolute.gno

@@ -0,0 +1,20 @@
+package int256
+
+import (
+	"gno.land/p/demo/uint256"
+)
+
+// Abs returns |z|
+func (z *Int) Abs() *uint256.Uint {
+	return z.abs.Clone()
+}
+
+// AbsGt returns true if |z| > x, where x is a uint256
+func (z *Int) AbsGt(x *uint256.Uint) bool {
+	return z.abs.Gt(x)
+}
+
+// AbsLt returns true if |z| < x, where x is a uint256
+func (z *Int) AbsLt(x *uint256.Uint) bool {
+	return z.abs.Lt(x)
+}

examples/gno.land/p/demo/int256/absolute_test.gno

@@ -0,0 +1,105 @@
+package int256
+
+import (
+	"testing"
+
+	"gno.land/p/demo/uint256"
+)
+
+func TestAbs(t *testing.T) {
+	tests := []struct {
+		x, want string
+	}{
+		{"0", "0"},
+		{"1", "1"},
+		{"-1", "1"},
+		{"-2", "2"},
+		{"-115792089237316195423570985008687907853269984665640564039457584007913129639935", "115792089237316195423570985008687907853269984665640564039457584007913129639935"},
+	}
+
+	for _, tc := range tests {
+		x, err := FromDecimal(tc.x)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+
+		got := x.Abs()
+
+		if got.ToString() != tc.want {
+			t.Errorf("Abs(%s) = %v, want %v", tc.x, got.ToString(), tc.want)
+		}
+	}
+}
+
+func TestAbsGt(t *testing.T) {
+	tests := []struct {
+		x, y, want string
+	}{
+		{"0", "0", "false"},
+		{"1", "0", "true"},
+		{"-1", "0", "true"},
+		{"-1", "1", "false"},
+		{"-2", "1", "true"},
+		{"-115792089237316195423570985008687907853269984665640564039457584007913129639935", "0", "true"},
+		{"-115792089237316195423570985008687907853269984665640564039457584007913129639935", "1", "true"},
+		{"-115792089237316195423570985008687907853269984665640564039457584007913129639935", "115792089237316195423570985008687907853269984665640564039457584007913129639935", "false"},
+	}
+
+	for _, tc := range tests {
+		x, err := FromDecimal(tc.x)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+
+		y, err := uint256.FromDecimal(tc.y)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+
+		got := x.AbsGt(y)
+
+		if got != (tc.want == "true") {
+			t.Errorf("AbsGt(%s, %s) = %v, want %v", tc.x, tc.y, got, tc.want)
+		}
+	}
+}
+
+func TestAbsLt(t *testing.T) {
+	tests := []struct {
+		x, y, want string
+	}{
+		{"0", "0", "false"},
+		{"1", "0", "false"},
+		{"-1", "0", "false"},
+		{"-1", "1", "false"},
+		{"-2", "1", "false"},
+		{"-5", "10", "true"},
+		{"31330", "31337", "true"},
+		{"-115792089237316195423570985008687907853269984665640564039457584007913129639935", "0", "false"},
+		{"-115792089237316195423570985008687907853269984665640564039457584007913129639935", "1", "false"},
+		{"-115792089237316195423570985008687907853269984665640564039457584007913129639935", "115792089237316195423570985008687907853269984665640564039457584007913129639935", "false"},
+	}
+
+	for _, tc := range tests {
+		x, err := FromDecimal(tc.x)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+
+		y, err := uint256.FromDecimal(tc.y)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+
+		got := x.AbsLt(y)
+
+		if got != (tc.want == "true") {
+			t.Errorf("AbsLt(%s, %s) = %v, want %v", tc.x, tc.y, got, tc.want)
+		}
+	}
+}

examples/gno.land/p/demo/int256/arithmetic.gno

@@ -0,0 +1,198 @@
+package int256
+
+import (
+	"gno.land/p/demo/uint256"
+)
+
+func (z *Int) Add(x, y *Int) *Int {
+	z.initiateAbs()
+
+	neg := x.neg
+
+	if x.neg == y.neg {
+		// x + y == x + y
+		// (-x) + (-y) == -(x + y)
+		z.abs = z.abs.Add(x.abs, y.abs)
+	} else {
+		// x + (-y) == x - y == -(y - x)
+		// (-x) + y == y - x == -(x - y)
+		if x.abs.Cmp(y.abs) >= 0 {
+			z.abs = z.abs.Sub(x.abs, y.abs)
+		} else {
+			neg = !neg
+			z.abs = z.abs.Sub(y.abs, x.abs)
+		}
+	}
+	z.neg = neg // 0 has no sign
+	return z
+}
+
+// AddUint256 set z to the sum x + y, where y is a uint256, and returns z
+func (z *Int) AddUint256(x *Int, y *uint256.Uint) *Int {
+	if x.neg {
+		if x.abs.Gt(y) {
+			z.abs.Sub(x.abs, y)
+			z.neg = true
+		} else {
+			z.abs.Sub(y, x.abs)
+			z.neg = false
+		}
+	} else {
+		z.abs.Add(x.abs, y)
+		z.neg = false
+	}
+	return z
+}
+
+// Sets z to the sum x + y, where z and x are uint256s and y is an int256.
+func AddDelta(z, x *uint256.Uint, y *Int) {
+	if y.neg {
+		z.Sub(x, y.abs)
+	} else {
+		z.Add(x, y.abs)
+	}
+}
+
+// Sets z to the sum x + y, where z and x are uint256s and y is an int256.
+func AddDeltaOverflow(z, x *uint256.Uint, y *Int) bool {
+	var overflow bool
+	if y.neg {
+		_, overflow = z.SubOverflow(x, y.abs)
+	} else {
+		_, overflow = z.AddOverflow(x, y.abs)
+	}
+	return overflow
+}
+
+// Sub sets z to the difference x-y and returns z.
+func (z *Int) Sub(x, y *Int) *Int {
+	z.initiateAbs()
+
+	neg := x.neg
+	if x.neg != y.neg {
+		// x - (-y) == x + y
+		// (-x) - y == -(x + y)
+		z.abs = z.abs.Add(x.abs, y.abs)
+	} else {
+		// x - y == x - y == -(y - x)
+		// (-x) - (-y) == y - x == -(x - y)
+		if x.abs.Cmp(y.abs) >= 0 {
+			z.abs = z.abs.Sub(x.abs, y.abs)
+		} else {
+			neg = !neg
+			z.abs = z.abs.Sub(y.abs, x.abs)
+		}
+	}
+	z.neg = neg // 0 has no sign
+	return z
+}
+
+// SubUint256 set z to the difference x - y, where y is a uint256, and returns z
+func (z *Int) SubUint256(x *Int, y *uint256.Uint) *Int {
+	if x.neg {
+		z.abs.Add(x.abs, y)
+		z.neg = true
+	} else {
+		if x.abs.Lt(y) {
+			z.abs.Sub(y, x.abs)
+			z.neg = true
+		} else {
+			z.abs.Sub(x.abs, y)
+			z.neg = false
+		}
+	}
+	return z
+}
+
+// Mul sets z to the product x*y and returns z.
+func (z *Int) Mul(x, y *Int) *Int {
+	z.initiateAbs()
+
+	z.abs = z.abs.Mul(x.abs, y.abs)
+	z.neg = x.neg != y.neg // 0 has no sign
+	return z
+}
+
+// MulUint256 sets z to the product x*y, where y is a uint256, and returns z
+func (z *Int) MulUint256(x *Int, y *uint256.Uint) *Int {
+	z.abs.Mul(x.abs, y)
+	if z.abs.IsZero() {
+		z.neg = false
+	} else {
+		z.neg = x.neg
+	}
+	return z
+}
+
+// Div sets z to the quotient x/y for y != 0 and returns z.
+func (z *Int) Div(x, y *Int) *Int {
+	z.initiateAbs()
+
+	z.abs.Div(x.abs, y.abs)
+	if x.neg == y.neg {
+		z.neg = false
+	} else {
+		z.neg = true
+	}
+	return z
+}
+
+// DivUint256 sets z to the quotient x/y, where y is a uint256, and returns z
+// If y == 0, z is set to 0
+func (z *Int) DivUint256(x *Int, y *uint256.Uint) *Int {
+	z.abs.Div(x.abs, y)
+	if z.abs.IsZero() {
+		z.neg = false
+	} else {
+		z.neg = x.neg
+	}
+	return z
+}
+
+// Quo sets z to the quotient x/y for y != 0 and returns z.
+// If y == 0, a division-by-zero run-time panic occurs.
+// OBS: differs from mempooler int256, we need to panic manually if y == 0
+// Quo implements truncated division (like Go); see QuoRem for more details.
+func (z *Int) Quo(x, y *Int) *Int {
+	if y.IsZero() {
+		panic("division by zero")
+	}
+
+	z.initiateAbs()
+
+	z.abs = z.abs.Div(x.abs, y.abs)
+	z.neg = !(z.abs.IsZero()) && x.neg != y.neg // 0 has no sign
+	return z
+}
+
+// Rem sets z to the remainder x%y for y != 0 and returns z.
+// If y == 0, a division-by-zero run-time panic occurs.
+// OBS: differs from mempooler int256, we need to panic manually if y == 0
+// Rem implements truncated modulus (like Go); see QuoRem for more details.
+func (z *Int) Rem(x, y *Int) *Int {
+	if y.IsZero() {
+		panic("division by zero")
+	}
+
+	z.initiateAbs()
+
+	z.abs.Mod(x.abs, y.abs)
+	z.neg = z.abs.Sign() > 0 && x.neg // 0 has no sign
+	return z
+}
+
+// Mod sets z to the modulus x%y for y != 0 and returns z.
+// If y == 0, z is set to 0 (OBS: differs from the big.Int)
+func (z *Int) Mod(x, y *Int) *Int {
+	if x.neg {
+		z.abs.Div(x.abs, y.abs)
+		z.abs.Add(z.abs, one)
+		z.abs.Mul(z.abs, y.abs)
+		z.abs.Sub(z.abs, x.abs)
+		z.abs.Mod(z.abs, y.abs)
+	} else {
+		z.abs.Mod(x.abs, y.abs)
+	}
+	z.neg = false
+	return z
+}