15098664129

Committed 18 May 2025 06:08PM UTC coverage: 88.263% (+0.3%) from 88.0%

Build # 15098664129

Build Type

push

github

Committed by

jimxl

Commit Message

实现了 hash 类

Coverage Stats

205 of 231 new or added lines in 2 files covered. (88.74%)

2 existing lines in 1 file now uncovered.

925 of 1048 relevant lines covered (88.26%)

17.43 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.35

/integer.go

// Package goby 提供了一个类似 Ruby 的整数实现
package goby

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

// RInteger 实现了类似 Ruby 的整数功能
type RInteger struct {
        BaseObject
        value int
}

// NewRInteger 创建一个新的整数对象
func NewRInteger(value int) RInteger {
        return RInteger{
                BaseObject: NewBaseObject("Integer"),
                value:      value,
        }
}

// ToString 返回整数的字符串表示
func (i RInteger) ToString() string {
        return strconv.Itoa(i.value)
}

// Equal 比较两个整数是否相等
func (i RInteger) Equal(other Object) bool {
        if otherInt, ok := other.(RInteger); ok {
                return i.value == otherInt.value
        }
        return false
}

// Value 返回整数的底层值
func (i RInteger) Value() int {
        return i.value
}

// Add 返回两个整数的和
func (i RInteger) Add(other RInteger) RInteger {
        return NewRInteger(i.value + other.value)
}

// Sub 返回两个整数的差
func (i RInteger) Sub(other RInteger) RInteger {
        return NewRInteger(i.value - other.value)
}

// Mul 返回两个整数的积
func (i RInteger) Mul(other RInteger) RInteger {
        return NewRInteger(i.value * other.value)
}

// Div 返回两个整数的商
func (i RInteger) Div(other RInteger) RInteger {
        if other.value == 0 {
                panic("除数不能为零")
        }
        return NewRInteger(i.value / other.value)
}

// Mod 返回两个整数的余数
func (i RInteger) Mod(other RInteger) RInteger {
        if other.value == 0 {
                panic("除数不能为零")
        }
        return NewRInteger(i.value % other.value)
}

// Modulo 返回两个整数的余数（Mod 的别名）
func (i RInteger) Modulo(other RInteger) RInteger {
        return i.Mod(other)
}

// Pow 返回整数的指定次幂
func (i RInteger) Pow(exponent RInteger) RInteger {
        return NewRInteger(int(math.Pow(float64(i.value), float64(exponent.value))))
}

// BitAnd 返回两个整数的按位与结果
func (i RInteger) BitAnd(other RInteger) RInteger {
        return NewRInteger(i.value & other.value)
}

// BitOr 返回两个整数的按位或结果
func (i RInteger) BitOr(other RInteger) RInteger {
        return NewRInteger(i.value | other.value)
}

// BitXor 返回两个整数的按位异或结果
func (i RInteger) BitXor(other RInteger) RInteger {
        return NewRInteger(i.value ^ other.value)
}

// BitNot 返回整数的按位取反结果
func (i RInteger) BitNot() RInteger {
        return NewRInteger(^i.value)
}

// LeftShift 返回整数左移指定位数的结果
func (i RInteger) LeftShift(count RInteger) RInteger {
        return NewRInteger(i.value << uint(count.value))
}

// RightShift 返回整数右移指定位数的结果
func (i RInteger) RightShift(count RInteger) RInteger {
        return NewRInteger(i.value >> uint(count.value))
}

// BitAt 返回整数指定位置的值
func (i RInteger) BitAt(pos RInteger) RInteger {
        if pos.value < 0 {
                return NewRInteger(0)
        }

        bit := (i.value >> uint(pos.value)) & 1
        return NewRInteger(bit)
}

// AllBits 检查是否所有指定的位都是1
func (i RInteger) AllBits(mask RInteger) bool {
        return (i.value & mask.value) == mask.value
}

// AnyBits 检查是否任何指定的位是1
func (i RInteger) AnyBits(mask RInteger) bool {
        return (i.value & mask.value) != 0
}

// NoBits 检查是否所有指定的位都是0
func (i RInteger) NoBits(mask RInteger) bool {
        return (i.value & mask.value) == 0
}

// BitLength 返回表示此整数的二进制形式的位数
func (i RInteger) BitLength() int {
        if i.value == 0 {
                return 0
        }

        v := uint(i.value)
        if i.value < 0 {
                v = uint(-i.value - 1)
        }

        return bits(v) + 1
}

// bits 计算一个无符号整数的位数
func bits(v uint) int {
        if v == 0 {
                return 0
        }
        n := 0
        for ; v > 0; v >>= 1 {
                n++
        }
        return n - 1
}

// Abs 返回整数的绝对值
func (i RInteger) Abs() RInteger {
        if i.value < 0 {
                return NewRInteger(-i.value)
        }
        return i
}

// Even 检查整数是否为偶数
func (i RInteger) Even() bool {
        return i.value%2 == 0
}

// Odd 检查整数是否为奇数
func (i RInteger) Odd() bool {
        return i.value%2 != 0
}

// Zero 检查整数是否为零
func (i RInteger) Zero() bool {
        return i.value == 0
}

// Positive 检查整数是否为正数
func (i RInteger) Positive() bool {
        return i.value > 0
}

// Negative 检查整数是否为负数
func (i RInteger) Negative() bool {
        return i.value < 0
}

// Gcd 返回两个整数的最大公约数
func (i RInteger) Gcd(other RInteger) RInteger {
        a, b := i.value, other.value
        if a < 0 {
                a = -a
        }
        if b < 0 {
                b = -b
        }

        for b != 0 {
                a, b = b, a%b
        }

        return NewRInteger(a)
}

// Lcm 返回两个整数的最小公倍数
func (i RInteger) Lcm(other RInteger) RInteger {
        if i.value == 0 || other.value == 0 {
                return NewRInteger(0)
        }

        a, b := i.value, other.value
        if a < 0 {
                a = -a
        }
        if b < 0 {
                b = -b
        }

        return NewRInteger((a / i.Gcd(other).value) * b)
}

// GcdLcm 同时返回两个整数的最大公约数和最小公倍数
func (i RInteger) GcdLcm(other RInteger) RArray {
        gcd := i.Gcd(other)
        lcm := i.Lcm(other)

        return NewRArray([]Object{gcd, lcm})
}

// DivMod 同时返回两个整数的商和余数
func (i RInteger) DivMod(other RInteger) RArray {
        if other.value == 0 {
                panic("除数不能为零")
        }

        quotient := i.value / other.value
        remainder := i.value % other.value

        return NewRArray([]Object{
                NewRInteger(quotient),
                NewRInteger(remainder),
        })
}

// CeilDiv 返回两个整数的向上取整除法结果
func (i RInteger) CeilDiv(other RInteger) RInteger {
        if other.value == 0 {
                panic("除数不能为零")
        }

        if (i.value < 0) != (other.value < 0) {
                return NewRInteger(i.value / other.value)
        }

        return NewRInteger((i.value + other.value - 1) / other.value)
}

// Ceil 返回整数的向上取整结果
func (i RInteger) Ceil() RInteger {
        return i
}

// CeilWithPrecision 返回整数指定精度的向上取整结果
func (i RInteger) CeilWithPrecision(digits RInteger) RInteger {
        if digits.value >= 0 {
                return i
        }

        pow := int(math.Pow(10, float64(-digits.value)))
        remainder := i.value % pow

        if remainder > 0 {
                return NewRInteger(i.value + (pow - remainder))
        } else if remainder < 0 {
                return NewRInteger(i.value - remainder)
        }

        return i
}

// Floor 返回整数的向下取整结果
func (i RInteger) Floor() RInteger {
        return i
}

// FloorWithPrecision 返回整数指定精度的向下取整结果
func (i RInteger) FloorWithPrecision(digits RInteger) RInteger {
        if digits.value >= 0 {
                return i
        }

        pow := int(math.Pow(10, float64(-digits.value)))
        remainder := i.value % pow

        if remainder > 0 {
                return NewRInteger(i.value - remainder)
        } else if remainder < 0 {
                return NewRInteger(i.value - (remainder + pow))
        }

        return i
}

// Round 返回整数的四舍五入结果
func (i RInteger) Round() RInteger {
        return i
}

// RoundWithPrecision 返回整数指定精度的四舍五入结果
func (i RInteger) RoundWithPrecision(digits RInteger) RInteger {
        if digits.value >= 0 {
                return i
        }

        pow := int(math.Pow(10, float64(-digits.value)))
        half := pow / 2

        remainder := i.value % pow
        if remainder >= half {
                return NewRInteger(i.value + (pow - remainder))
        } else if remainder <= -half {
                return NewRInteger(i.value - (remainder + pow))
        } else if remainder > 0 {
                return NewRInteger(i.value - remainder)
        } else {
                return NewRInteger(i.value - remainder)
        }
}

// Truncate 返回整数的截断结果
func (i RInteger) Truncate() RInteger {
        return i
}

// TruncateWithPrecision 返回整数指定精度的截断结果
func (i RInteger) TruncateWithPrecision(digits RInteger) RInteger {
        if digits.value >= 0 {
                return i
        }

        pow := int(math.Pow(10, float64(-digits.value)))
        remainder := i.value % pow

        return NewRInteger(i.value - remainder)
}

// Succ 返回整数的下一个值
func (i RInteger) Succ() RInteger {
        return NewRInteger(i.value + 1)
}

// Next 返回整数的下一个值（Succ 的别名）
func (i RInteger) Next() RInteger {
        return i.Succ()
}

// Pred 返回整数的前一个值
func (i RInteger) Pred() RInteger {
        return NewRInteger(i.value - 1)
}

// Times 执行指定次数的操作
func (i RInteger) Times(fn func(RInteger)) {
        for j := 0; j < i.value; j++ {
                fn(NewRInteger(j))
        }
}

// UpTo 从当前值递增到指定值
func (i RInteger) UpTo(limit RInteger, fn func(RInteger)) {
        for j := i.value; j <= limit.value; j++ {
                fn(NewRInteger(j))
        }
}

// DownTo 从当前值递减到指定值
func (i RInteger) DownTo(limit RInteger, fn func(RInteger)) {
        for j := i.value; j >= limit.value; j-- {
                fn(NewRInteger(j))
        }
}

// ToRString 将整数转换为字符串
func (i RInteger) ToRString() RString {
        return NewRString(i.ToString())
}

// ToInt 返回整数本身
func (i RInteger) ToInt() RInteger {
        return i
}

// ToInteger 返回整数本身
func (i RInteger) ToInteger() RInteger {
        return i
}

// ToFloat 将整数转换为浮点数
func (i RInteger) ToFloat() float64 {
        return float64(i.value)
}

// ToRational 将整数转换为有理数
func (i RInteger) ToRational() *big.Rat {
        return big.NewRat(int64(i.value), 1)
}

// FDiv 返回两个整数的浮点除法结果
func (i RInteger) FDiv(other RInteger) float64 {
        if other.value == 0 {
                panic("除数不能为零")
        }
        return float64(i.value) / float64(other.value)
}

// ToHex 将整数转换为十六进制字符串
func (i RInteger) ToHex() RString {
        return NewRString(fmt.Sprintf("%x", i.value))
}

// ToOct 将整数转换为八进制字符串
func (i RInteger) ToOct() RString {
        return NewRString(fmt.Sprintf("%o", i.value))
}

// ToBin 将整数转换为二进制字符串
func (i RInteger) ToBin() RString {
        return NewRString(fmt.Sprintf("%b", i.value))
}

// ToBase 将整数转换为指定进制的字符串
func (i RInteger) ToBase(base RInteger) RString {
        if base.value < 2 || base.value > 36 {
                panic("进制必须在2到36之间")
        }
        return NewRString(strconv.FormatInt(int64(i.value), base.value))
}

// Digits 将整数转换为按位数字的数组
func (i RInteger) Digits(base ...int) RArray {
        baseValue := 10
        if len(base) > 0 {
                baseValue = base[0]
                if baseValue < 2 {
                        panic("进制必须大于等于2")
                }
        }

        if i.value == 0 {
                return NewRArray([]Object{NewRInteger(0)})
        }

        n := i.value
        if n < 0 {
                n = -n
        }

        var digits []Object
        for n > 0 {
                digits = append(digits, NewRInteger(n%baseValue))
                n /= baseValue
        }

        return NewRArray(digits)
}

// Chr 返回整数对应的 Unicode 字符
func (i RInteger) Chr() RString {
        return NewRString(string(rune(i.value)))
}

// Ord 返回整数本身
func (i RInteger) Ord() RInteger {
        return i
}

// Size 返回整数的字节表示长度
func (i RInteger) Size() int {
        return strconv.IntSize / 8
}

// Coerce 将另一个对象转换为兼容类型
func (i RInteger) Coerce(other Object) RArray {
        switch v := other.(type) {
        case RInteger:
                return NewRArray([]Object{v, i})
        default:
                if str, ok := other.(RString); ok {
                        val, err := strconv.Atoi(str.ToString())
                        if err == nil {
                                return NewRArray([]Object{NewRInteger(val), i})
                        }
                }
                panic("无法转换为兼容类型")
        }
}

1	// Package goby 提供了一个类似 Ruby 的整数实现
2	package goby
3
4	import (
5	"fmt"
6	"math"
7	"math/big"
8	"strconv"
9	)
10
11	// RInteger 实现了类似 Ruby 的整数功能
12	type RInteger struct {
13	BaseObject
14	value int
15	}
16
17	// NewRInteger 创建一个新的整数对象
18	func NewRInteger(value int) RInteger {	548✔
19	return RInteger{	548✔
20	BaseObject: NewBaseObject("Integer"),	548✔
21	value: value,	548✔
22	}	548✔
23	}	548✔
24
25	// ToString 返回整数的字符串表示
26	func (i RInteger) ToString() string {	10✔
27	return strconv.Itoa(i.value)	10✔
28	}	10✔
29
30	// Equal 比较两个整数是否相等
31	func (i RInteger) Equal(other Object) bool {	5✔
32	if otherInt, ok := other.(RInteger); ok {	10✔
33	return i.value == otherInt.value	5✔
34	}	5✔
35	return false	×
36	}
37
38	// Value 返回整数的底层值
39	func (i RInteger) Value() int {	151✔
40	return i.value	151✔
41	}	151✔
42
43	// Add 返回两个整数的和
44	func (i RInteger) Add(other RInteger) RInteger {	3✔
45	return NewRInteger(i.value + other.value)	3✔
46	}	3✔
47
48	// Sub 返回两个整数的差
49	func (i RInteger) Sub(other RInteger) RInteger {	3✔
50	return NewRInteger(i.value - other.value)	3✔
51	}	3✔
52
53	// Mul 返回两个整数的积
54	func (i RInteger) Mul(other RInteger) RInteger {	3✔
55	return NewRInteger(i.value * other.value)	3✔
56	}	3✔
57
58	// Div 返回两个整数的商
59	func (i RInteger) Div(other RInteger) RInteger {	6✔
60	if other.value == 0 {	10✔
61	panic("除数不能为零")	4✔
62	}
63	return NewRInteger(i.value / other.value)	2✔
64	}
65
66	// Mod 返回两个整数的余数
67	func (i RInteger) Mod(other RInteger) RInteger {	6✔
68	if other.value == 0 {	10✔
69	panic("除数不能为零")	4✔
70	}
71	return NewRInteger(i.value % other.value)	2✔
72	}
73
74	// Modulo 返回两个整数的余数（Mod 的别名）
75	func (i RInteger) Modulo(other RInteger) RInteger {	×
76	return i.Mod(other)	×
77	}	×
78
79	// Pow 返回整数的指定次幂
80	func (i RInteger) Pow(exponent RInteger) RInteger {	7✔
81	return NewRInteger(int(math.Pow(float64(i.value), float64(exponent.value))))	7✔
82	}	7✔
83
84	// BitAnd 返回两个整数的按位与结果
85	func (i RInteger) BitAnd(other RInteger) RInteger {	2✔
86	return NewRInteger(i.value & other.value)	2✔
87	}	2✔
88
89	// BitOr 返回两个整数的按位或结果
90	func (i RInteger) BitOr(other RInteger) RInteger {	2✔
91	return NewRInteger(i.value \| other.value)	2✔
92	}	2✔
93
94	// BitXor 返回两个整数的按位异或结果
95	func (i RInteger) BitXor(other RInteger) RInteger {	2✔
96	return NewRInteger(i.value ^ other.value)	2✔
97	}	2✔
98
99	// BitNot 返回整数的按位取反结果
100	func (i RInteger) BitNot() RInteger {	2✔
101	return NewRInteger(^i.value)	2✔
102	}	2✔
103
104	// LeftShift 返回整数左移指定位数的结果
105	func (i RInteger) LeftShift(count RInteger) RInteger {	4✔
106	return NewRInteger(i.value << uint(count.value))	4✔
107	}	4✔
108
109	// RightShift 返回整数右移指定位数的结果
110	func (i RInteger) RightShift(count RInteger) RInteger {	4✔
111	return NewRInteger(i.value >> uint(count.value))	4✔
112	}	4✔
113
114	// BitAt 返回整数指定位置的值
115	func (i RInteger) BitAt(pos RInteger) RInteger {	6✔
116	if pos.value < 0 {	6✔
117	return NewRInteger(0)	×
118	}	×
119
120	bit := (i.value >> uint(pos.value)) & 1	6✔
121	return NewRInteger(bit)	6✔
122	}
123
124	// AllBits 检查是否所有指定的位都是1
125	func (i RInteger) AllBits(mask RInteger) bool {	4✔
126	return (i.value & mask.value) == mask.value	4✔
127	}	4✔
128
129	// AnyBits 检查是否任何指定的位是1
130	func (i RInteger) AnyBits(mask RInteger) bool {	4✔
131	return (i.value & mask.value) != 0	4✔
132	}	4✔
133
134	// NoBits 检查是否所有指定的位都是0
135	func (i RInteger) NoBits(mask RInteger) bool {	4✔
136	return (i.value & mask.value) == 0	4✔
137	}	4✔
138
139	// BitLength 返回表示此整数的二进制形式的位数
140	func (i RInteger) BitLength() int {	6✔
141	if i.value == 0 {	7✔
142	return 0	1✔
143	}	1✔
144
145	v := uint(i.value)	5✔
146	if i.value < 0 {	5✔
147	v = uint(-i.value - 1)	×
148	}	×
149
150	return bits(v) + 1	5✔
151	}
152
153	// bits 计算一个无符号整数的位数
154	func bits(v uint) int {	5✔
155	if v == 0 {	5✔
156	return 0	×
157	}	×
158	n := 0	5✔
159	for ; v > 0; v >>= 1 {	17✔
160	n++	12✔
161	}	12✔
162	return n - 1	5✔
163	}
164
165	// Abs 返回整数的绝对值
166	func (i RInteger) Abs() RInteger {	3✔
167	if i.value < 0 {	4✔
168	return NewRInteger(-i.value)	1✔
169	}	1✔
170	return i	2✔
171	}
172
173	// Even 检查整数是否为偶数
174	func (i RInteger) Even() bool {	3✔
175	return i.value%2 == 0	3✔
176	}	3✔
177
178	// Odd 检查整数是否为奇数
179	func (i RInteger) Odd() bool {	1✔
180	return i.value%2 != 0	1✔
181	}	1✔
182
183	// Zero 检查整数是否为零
184	func (i RInteger) Zero() bool {	3✔
185	return i.value == 0	3✔
186	}	3✔
187
188	// Positive 检查整数是否为正数
189	func (i RInteger) Positive() bool {	3✔
190	return i.value > 0	3✔
191	}	3✔
192
193	// Negative 检查整数是否为负数
194	func (i RInteger) Negative() bool {	2✔
195	return i.value < 0	2✔
196	}	2✔
197
198	// Gcd 返回两个整数的最大公约数
199	func (i RInteger) Gcd(other RInteger) RInteger {	13✔
200	a, b := i.value, other.value	13✔
201	if a < 0 {	14✔
202	a = -a	1✔
203	}	1✔
204	if b < 0 {	13✔
205	b = -b	×
206	}	×
207
208	for b != 0 {	29✔
209	a, b = b, a%b	16✔
210	}	16✔
211
212	return NewRInteger(a)	13✔
213	}
214
215	// Lcm 返回两个整数的最小公倍数
216	func (i RInteger) Lcm(other RInteger) RInteger {	10✔
217	if i.value == 0 \|\| other.value == 0 {	17✔
218	return NewRInteger(0)	7✔
219	}	7✔
220
221	a, b := i.value, other.value	3✔
222	if a < 0 {	3✔
223	a = -a	×
224	}	×
225	if b < 0 {	3✔
226	b = -b	×
227	}	×
228
229	return NewRInteger((a / i.Gcd(other).value) * b)	3✔
230	}
231
232	// GcdLcm 同时返回两个整数的最大公约数和最小公倍数
233	func (i RInteger) GcdLcm(other RInteger) RArray {	4✔
234	gcd := i.Gcd(other)	4✔
235	lcm := i.Lcm(other)	4✔
236		4✔
237	return NewRArray([]Object{gcd, lcm})	4✔
238	}	4✔
239
240	// DivMod 同时返回两个整数的商和余数
241	func (i RInteger) DivMod(other RInteger) RArray {	4✔
242	if other.value == 0 {	6✔
243	panic("除数不能为零")	2✔
244	}
245
246	quotient := i.value / other.value	2✔
247	remainder := i.value % other.value	2✔
248		2✔
249	return NewRArray([]Object{	2✔
250	NewRInteger(quotient),	2✔
251	NewRInteger(remainder),	2✔
252	})	2✔
253	}
254
255	// CeilDiv 返回两个整数的向上取整除法结果
256	func (i RInteger) CeilDiv(other RInteger) RInteger {	5✔
257	if other.value == 0 {	7✔
258	panic("除数不能为零")	2✔
259	}
260
261	if (i.value < 0) != (other.value < 0) {	4✔
262	return NewRInteger(i.value / other.value)	1✔
263	}	1✔
264
265	return NewRInteger((i.value + other.value - 1) / other.value)	2✔
266	}
267
268	// Ceil 返回整数的向上取整结果
269	func (i RInteger) Ceil() RInteger {	2✔
270	return i	2✔
271	}	2✔
272
273	// CeilWithPrecision 返回整数指定精度的向上取整结果
274	func (i RInteger) CeilWithPrecision(digits RInteger) RInteger {	4✔
275	if digits.value >= 0 {	6✔
276	return i	2✔
277	}	2✔
278
279	pow := int(math.Pow(10, float64(-digits.value)))	2✔
280	remainder := i.value % pow	2✔
281		2✔
282	if remainder > 0 {	4✔
283	return NewRInteger(i.value + (pow - remainder))	2✔
284	} else if remainder < 0 {	2✔
285	return NewRInteger(i.value - remainder)	×
286	}	×
287
288	return i	×
289	}
290
291	// Floor 返回整数的向下取整结果
292	func (i RInteger) Floor() RInteger {	2✔
293	return i	2✔
294	}	2✔
295
296	// FloorWithPrecision 返回整数指定精度的向下取整结果
297	func (i RInteger) FloorWithPrecision(digits RInteger) RInteger {	4✔
298	if digits.value >= 0 {	6✔
299	return i	2✔
300	}	2✔
301
302	pow := int(math.Pow(10, float64(-digits.value)))	2✔
303	remainder := i.value % pow	2✔
304		2✔
305	if remainder > 0 {	4✔
306	return NewRInteger(i.value - remainder)	2✔
307	} else if remainder < 0 {	2✔
308	return NewRInteger(i.value - (remainder + pow))	×
309	}	×
310
311	return i	×
312	}
313
314	// Round 返回整数的四舍五入结果
315	func (i RInteger) Round() RInteger {	2✔
316	return i	2✔
317	}	2✔
318
319	// RoundWithPrecision 返回整数指定精度的四舍五入结果
320	func (i RInteger) RoundWithPrecision(digits RInteger) RInteger {	4✔
321	if digits.value >= 0 {	6✔
322	return i	2✔
323	}	2✔
324
325	pow := int(math.Pow(10, float64(-digits.value)))	2✔
326	half := pow / 2	2✔
327		2✔
328	remainder := i.value % pow	2✔
329	if remainder >= half {	3✔
330	return NewRInteger(i.value + (pow - remainder))	1✔
331	} else if remainder <= -half {	2✔
332	return NewRInteger(i.value - (remainder + pow))	×
333	} else if remainder > 0 {	2✔
334	return NewRInteger(i.value - remainder)	1✔
335	} else {	1✔
336	return NewRInteger(i.value - remainder)	×
337	}	×
338	}
339
340	// Truncate 返回整数的截断结果
341	func (i RInteger) Truncate() RInteger {	2✔
342	return i	2✔
343	}	2✔
344
345	// TruncateWithPrecision 返回整数指定精度的截断结果
346	func (i RInteger) TruncateWithPrecision(digits RInteger) RInteger {	4✔
347	if digits.value >= 0 {	6✔
348	return i	2✔
349	}	2✔
350
351	pow := int(math.Pow(10, float64(-digits.value)))	2✔
352	remainder := i.value % pow	2✔
353		2✔
354	return NewRInteger(i.value - remainder)	2✔
355	}
356
357	// Succ 返回整数的下一个值
358	func (i RInteger) Succ() RInteger {	3✔
359	return NewRInteger(i.value + 1)	3✔
360	}	3✔
361
362	// Next 返回整数的下一个值（Succ 的别名）
363	func (i RInteger) Next() RInteger {	1✔
364	return i.Succ()	1✔
365	}	1✔
366
367	// Pred 返回整数的前一个值
368	func (i RInteger) Pred() RInteger {	2✔
369	return NewRInteger(i.value - 1)	2✔
370	}	2✔
371
372	// Times 执行指定次数的操作
373	func (i RInteger) Times(fn func(RInteger)) {	2✔
374	for j := 0; j < i.value; j++ {	7✔
375	fn(NewRInteger(j))	5✔
376	}	5✔
377	}
378
379	// UpTo 从当前值递增到指定值
380	func (i RInteger) UpTo(limit RInteger, fn func(RInteger)) {	2✔
381	for j := i.value; j <= limit.value; j++ {	7✔
382	fn(NewRInteger(j))	5✔
383	}	5✔
384	}
385
386	// DownTo 从当前值递减到指定值
387	func (i RInteger) DownTo(limit RInteger, fn func(RInteger)) {	2✔
388	for j := i.value; j >= limit.value; j-- {	7✔
389	fn(NewRInteger(j))	5✔
390	}	5✔
391	}
392
393	// ToRString 将整数转换为字符串
394	func (i RInteger) ToRString() RString {	1✔
395	return NewRString(i.ToString())	1✔
396	}	1✔
397
398	// ToInt 返回整数本身
399	func (i RInteger) ToInt() RInteger {	1✔
400	return i	1✔
401	}	1✔
402
403	// ToInteger 返回整数本身
404	func (i RInteger) ToInteger() RInteger {	1✔
405	return i	1✔
406	}	1✔
407
408	// ToFloat 将整数转换为浮点数
409	func (i RInteger) ToFloat() float64 {	×
410	return float64(i.value)	×
411	}	×
412
413	// ToRational 将整数转换为有理数
414	func (i RInteger) ToRational() *big.Rat {	×
415	return big.NewRat(int64(i.value), 1)	×
416	}	×
417
418	// FDiv 返回两个整数的浮点除法结果
419	func (i RInteger) FDiv(other RInteger) float64 {	5✔
420	if other.value == 0 {	8✔
421	panic("除数不能为零")	3✔
422	}
423	return float64(i.value) / float64(other.value)	2✔
424	}
425
426	// ToHex 将整数转换为十六进制字符串
427	func (i RInteger) ToHex() RString {	2✔
428	return NewRString(fmt.Sprintf("%x", i.value))	2✔
429	}	2✔
430
431	// ToOct 将整数转换为八进制字符串
432	func (i RInteger) ToOct() RString {	2✔
433	return NewRString(fmt.Sprintf("%o", i.value))	2✔
434	}	2✔
435
436	// ToBin 将整数转换为二进制字符串
437	func (i RInteger) ToBin() RString {	2✔
438	return NewRString(fmt.Sprintf("%b", i.value))	2✔
439	}	2✔
440
441	// ToBase 将整数转换为指定进制的字符串
442	func (i RInteger) ToBase(base RInteger) RString {	4✔
443	if base.value < 2 \|\| base.value > 36 {	5✔
444	panic("进制必须在2到36之间")	1✔
445	}
446	return NewRString(strconv.FormatInt(int64(i.value), base.value))	3✔
447	}
448
449	// Digits 将整数转换为按位数字的数组
450	func (i RInteger) Digits(base ...int) RArray {	2✔
451	baseValue := 10	2✔
452	if len(base) > 0 {	3✔
453	baseValue = base[0]	1✔
454	if baseValue < 2 {	1✔
455	panic("进制必须大于等于2")	×
456	}
457	}
458
459	if i.value == 0 {	2✔
460	return NewRArray([]Object{NewRInteger(0)})	×
461	}	×
462
463	n := i.value	2✔
464	if n < 0 {	2✔
465	n = -n	×
466	}	×
467
468	var digits []Object	2✔
469	for n > 0 {	11✔
470	digits = append(digits, NewRInteger(n%baseValue))	9✔
471	n /= baseValue	9✔
472	}	9✔
473
474	return NewRArray(digits)	2✔
475	}
476
477	// Chr 返回整数对应的 Unicode 字符
478	func (i RInteger) Chr() RString {	2✔
479	return NewRString(string(rune(i.value)))	2✔
480	}	2✔
481
482	// Ord 返回整数本身
483	func (i RInteger) Ord() RInteger {	×
484	return i	×
485	}	×
486
487	// Size 返回整数的字节表示长度
488	func (i RInteger) Size() int {	×
NEW 489	return strconv.IntSize / 8	×
490	}	×
491
492	// Coerce 将另一个对象转换为兼容类型
493	func (i RInteger) Coerce(other Object) RArray {	1✔
494	switch v := other.(type) {	1✔
495	case RInteger:	1✔
496	return NewRArray([]Object{v, i})	1✔
497	default:	×
498	if str, ok := other.(RString); ok {	×
499	val, err := strconv.Atoi(str.ToString())	×
500	if err == nil {	×
501	return NewRArray([]Object{NewRInteger(val), i})	×
502	}	×
503	}
504	panic("无法转换为兼容类型")	×
505	}
506	}

GoLangDream / rgo / 15098664129

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous