- Kind
- Pure package
- Name
- v0
- Namespace
- onbloc / int256
- Exported functions
- n/a — not supported for pure packages by the node (vm/qfuncs)
- Module
- gno.land/p/onbloc/int256/v0
- gno
- 0.9
int256.gnogno
1package int25623import (4 "errors"56 "gno.land/p/onbloc/uint256/v0"7)8
not supported for pure packages by the node (vm/qfuncs)
Signatures reconstructed verbatim from vm/qfuncs — interface params keep their inline definitions.
9var (
10 int1 = NewInt(1)
11 uint0 = uint256.NewUint(0)
12 uint1 = uint256.NewUint(1)
13)
14
15type Int struct {
16 value uint256.Uint
17}
18
19// New creates and returns a new Int initialized to zero.
20func New() *Int {
21 return &Int{}
22}
23
24// NewInt allocates and returns a new Int set to the value of the provided int64.
25func NewInt(x int64) *Int {
26 return New().SetInt64(x)
27}
28
29// Zero returns a new Int initialized to 0.
30//
31// This function is useful for creating a starting point for calculations or
32// when an explicit zero value is needed.
33func Zero() *Int { return &Int{} }
34
35// One returns a new Int initialized to one.
36//
37// This function is convenient for operations that require a unit value,
38// such as incrementing or serving as an identity element in multiplication.
39func One() *Int {
40 return &Int{
41 value: *uint256.NewUint(1),
42 }
43}
44
45// Sign determines the sign of the Int.
46//
47// It returns -1 for negative numbers, 0 for zero, and +1 for positive numbers.
48func (z *Int) Sign() int {
49 if z == nil || z.IsZero() {
50 return 0
51 }
52 // Right shift the value by 255 bits to check the sign bit.
53 // In two's complement representation, the most significant bit (MSB) is the sign bit.
54 // If the MSB is 0, the number is positive; if it is 1, the number is negative.
55 //
56 // Example:
57 // Original value: 1 0 1 0 ... 0 1 (256 bits)
58 // After Rsh 255: 0 0 0 0 ... 0 1 (1 bit)
59 //
60 // This approach is highly efficient as it avoids the need for comparisons
61 // or arithmetic operations on the full 256-bit number. Instead it reduces
62 // the problem to checking a single bit.
63 //
64 // Additionally, this method will work correctly for all values,
65 // including the minimum possible negative number (which in two's complement
66 // doesn't have a positive counterpart in the same bit range).
67 var temp uint256.Uint
68 if temp.Rsh(&z.value, 255).IsZero() {
69 return 1
70 }
71 return -1
72}
73
74// FromDecimal creates a new Int from a decimal string representation.
75// It handles both positive and negative values.
76//
77// This function is useful for parsing user input or reading numeric data
78// from text-based formats.
79func FromDecimal(s string) (*Int, error) {
80 return New().SetString(s)
81}
82
83// MustFromDecimal is similar to FromDecimal but panics if the input string
84// is not a valid decimal representation.
85func MustFromDecimal(s string) *Int {
86 z, err := FromDecimal(s)
87 if err != nil {
88 panic(err)
89 }
90 return z
91}
92
93// SetString sets the Int to the value represented by the input string.
94// This method supports decimal string representations of integers and handles
95// both positive and negative values.
96func (z *Int) SetString(s string) (*Int, error) {
97 if len(s) == 0 {
98 return nil, errors.New("cannot set int256 from empty string")
99 }
100
101 // Check for negative sign
102 neg := s[0] == '-'
103 if neg || s[0] == '+' {
104 s = s[1:]
105 }
106
107 // Convert string to uint256
108 temp, err := uint256.FromDecimal(s)
109 if err != nil {
110 return nil, err
111 }
112
113 // If negative, negate the uint256 value
114 if neg {
115 temp.Neg(temp)
116 }
117
118 z.value.Set(temp)
119 return z, nil
120}
121
122// FromUint256 sets the Int to the value of the provided Uint256.
123//
124// This method allows for conversion from unsigned 256-bit integers
125// to signed integers.
126func (z *Int) FromUint256(v *uint256.Uint) *Int {
127 z.value.Set(v)
128 return z
129}
130