status-im
/
nim-stint
mirror of https://github.com/status-im/nim-stint.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

fix comparison

This commit is contained in:
jangko 2023-06-13 20:39:22 +07:00
parent fb797d225e
commit f07f574944
No known key found for this signature in database
GPG Key ID: 31702AE10541E6B9
5 changed files with 58 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
stint/intops.nim
View File

@ -33,10 +33,10 @@ func isNegative*(a: StInt): bool =
a.sign < 0 a.sign < 0
func clearMSB(a: var StInt) = func clearMSB(a: var StInt) =
a.limbs[0] = a.limbs[0] and clearSignMask a.limbs[^1] = a.limbs[^1] and clearSignMask
func setMSB(a: var StInt) = func setMSB(a: var StInt) =
a.limbs[0] = a.limbs[0] or signMask a.limbs[^1] = a.limbs[^1] or signMask
func negate*(a: var StInt) = func negate*(a: var StInt) =
a.imp.bitnot(a.imp) a.imp.bitnot(a.imp)
@ -107,8 +107,8 @@ func `==`*(a, b: StInt): bool =
func `<`*(a, b: StInt): bool = func `<`*(a, b: StInt): bool =
## Unsigned `less than` comparison ## Unsigned `less than` comparison
let let
aSign = a.Sign aSign = a.sign
bSign = b.Sign bSign = b.sign
if aSign >= 0: if aSign >= 0:
if bSign < 0: if bSign < 0:

62
stint/io.nim
View File

@ -224,43 +224,40 @@ func parse*[bits: static[int]](input: string, T: typedesc[StUint[bits]], radix:
result = result * base + input[curr].readHexChar.stuint(bits) result = result * base + input[curr].readHexChar.stuint(bits)
nextNonBlank(curr, input) nextNonBlank(curr, input)
# func parse*[bits: static[int]](input: string, T: typedesc[Stint[bits]], radix: static[int8] = 10): T = func parse*[bits: static[int]](input: string, T: typedesc[StInt[bits]], radix: static[int8] = 10): T =
# ## Parse a string and store the result in a Stint[bits] or StUint[bits]. ## Parse a string and store the result in a Stint[bits] or StUint[bits].
# static: doAssert (radix >= 2) and radix <= 16, "Only base from 2..16 are supported" static: doAssert (radix >= 2) and radix <= 16, "Only base from 2..16 are supported"
# # TODO: use static[range[2 .. 16]], not supported at the moment (2018-04-26) # TODO: use static[range[2 .. 16]], not supported at the moment (2018-04-26)
# TODO: we can special case hex result/input as an array of bytes
# and be much faster
# # TODO: we can special case hex result/input as an array of bytes # For conversion we require overflowing operations (for example for negative hex numbers)
# # and be much faster const base = radix.int8.stuint(bits)
# # For conversion we require overflowing operations (for example for negative hex numbers) var
# const base = radix.int8.StUint(bits) curr = 0 # Current index in the string
isNeg = false
noOverflow: StUint[bits]
# var if input[curr] == '-':
# curr = 0 # Current index in the string doAssert radix == 10, "Negative numbers are only supported with base 10 input."
# isNeg = false isNeg = true
# no_overflow: StUint[bits] inc curr
else:
skipPrefixes(curr, input, radix)
# if input[curr] == '-': while curr < input.len:
# doAssert radix == 10, "Negative numbers are only supported with base 10 input." # TODO: overflow detection
# isNeg = true when radix <= 10:
# inc curr noOverflow = noOverflow * base + input[curr].readDecChar.stuint(bits)
# else: else:
# skipPrefixes(curr, input, radix) noOverflow = noOverflow * base + input[curr].readHexChar.stuint(bits)
nextNonBlank(curr, input)
# while curr < input.len: result.imp = noOverflow
# # TODO: overflow detection if isNeg:
# when radix <= 10: result.negate
# no_overflow = no_overflow * base + input[curr].readDecChar.StUint(bits)
# else:
# no_overflow = no_overflow * base + input[curr].readHexChar.StUint(bits)
# nextNonBlank(curr, input)
# # TODO: we can't create the lowest int this way
# if isNeg:
# result = -convert[T](no_overflow)
# else:
# result = convert[T](no_overflow)
func fromHex*(T: typedesc[StUint|StInt], s: string): T {.inline.} = func fromHex*(T: typedesc[StUint|StInt], s: string): T {.inline.} =
## Convert an hex string to the corresponding unsigned integer ## Convert an hex string to the corresponding unsigned integer
@ -302,7 +299,8 @@ func toString*[bits: static[int]](num: StInt[bits], radix: static[int8] = 10): s
## - they are prefixed with "-" for base 10. ## - they are prefixed with "-" for base 10.
## - if not base 10, they are returned raw in two-complement form. ## - if not base 10, they are returned raw in two-complement form.
let isNeg = num.isNegative let isNeg = num.isNegative
if radix == 10 and isNeg: #if radix == 10 and isNeg:
if isNeg:
"-" & toString(num.neg.imp, radix) "-" & toString(num.neg.imp, radix)
else: else:
toString(num.imp, radix) toString(num.imp, radix)

5
tests/test_int_boundchecks.nim
View File

@ -1,5 +0,0 @@
import ../stint, unittest
suite "int boundchecks":
test "to be implemented":
discard

168
tests/test_int_comparison.nim
View File

@ -51,61 +51,24 @@ template chkIsEven(chk: untyped, a: string, bits: int) =
template chkNotIsEven(chk: untyped, a: string, bits: int) = template chkNotIsEven(chk: untyped, a: string, bits: int) =
chk (not fromHex(StInt[bits], a).isEven()) chk (not fromHex(StInt[bits], a).isEven())
import strutils
template testComparison(chk, tst: untyped) = template testComparison(chk, tst: untyped) =
tst "operator `LT`": tst "operator `LT`":
chkLT(chk, "0", "F", 8) chk 0.i128 < 1.i128
chkLT(chk, "F", "7F", 8) chk -1.i128 < 1.i128
chkLT(chk, "FF", "7F", 8) chk -1.i128 < 0.i128
chk Int128.low < Int128.high
chkLT(chk, "0", "F", 16)
chkLT(chk, "F", "FF", 16) #chkLT(chk, "0", "F", 128)
chkLT(chk, "FF", "FFF", 16) #chkLT(chk, "F", "FF", 128)
chkLT(chk, "FFFF", "FFF", 16) #chkLT(chk, "FF", "FFF", 128)
#chkLT(chk, "FFFF", "FFFFF", 128)
chkLT(chk, "0", "F", 32) #chkLT(chk, "FFFFF", "FFFFFFFF", 128)
chkLT(chk, "F", "FF", 32) #chkLT(chk, "FFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128)
chkLT(chk, "FF", "FFF", 32) #chkLT(chk, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128)
chkLT(chk, "FFFF", "FFFFF", 32) #[
chkLT(chk, "FFFFFFFF", "FFFFF", 32)
chkLT(chk, "0", "F", 64)
chkLT(chk, "F", "FF", 64)
chkLT(chk, "FF", "FFF", 64)
chkLT(chk, "FFFF", "FFFFF", 64)
chkLT(chk, "FFFFF", "FFFFFFFF", 64)
chkLT(chk, "FFFFFFFFFFFFFFFF", "FFFFFFFF", 64)
chkLT(chk, "0", "F", 128)
chkLT(chk, "F", "FF", 128)
chkLT(chk, "FF", "FFF", 128)
chkLT(chk, "FFFF", "FFFFF", 128)
chkLT(chk, "FFFFF", "FFFFFFFF", 128)
chkLT(chk, "FFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128)
chkLT(chk, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128)
tst "operator not `LT`": tst "operator not `LT`":
chkNotLT(chk, "0", "F", 8)
chkNotLT(chk, "F", "7F", 8)
chkNotLT(chk, "FF", "7F", 8)
chkNotLT(chk, "0", "F", 16)
chkNotLT(chk, "F", "FF", 16)
chkNotLT(chk, "FF", "FFF", 16)
chkNotLT(chk, "FFFF", "FFF", 16)
chkNotLT(chk, "0", "F", 32)
chkNotLT(chk, "F", "FF", 32)
chkNotLT(chk, "FF", "FFF", 32)
chkNotLT(chk, "FFFF", "FFFFF", 32)
chkNotLT(chk, "FFFFFFFF", "FFFFF", 32)
chkNotLT(chk, "0", "F", 64)
chkNotLT(chk, "F", "FF", 64)
chkNotLT(chk, "FF", "FFF", 64)
chkNotLT(chk, "FFFF", "FFFFF", 64)
chkNotLT(chk, "FFFFF", "FFFFFFFF", 64)
chkNotLT(chk, "FFFFFFFFFFFFFFFF", "FFFFFFFF", 64)
chkNotLT(chk, "0", "F", 128) chkNotLT(chk, "0", "F", 128)
chkNotLT(chk, "F", "FF", 128) chkNotLT(chk, "F", "FF", 128)
chkNotLT(chk, "FF", "FFF", 128) chkNotLT(chk, "FF", "FFF", 128)
@ -115,32 +78,6 @@ template testComparison(chk, tst: untyped) =
chkNotLT(chk, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128) chkNotLT(chk, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128)
tst "operator `LTE`": tst "operator `LTE`":
chkLTE(chk, "0", "F", 8)
chkLTE(chk, "F", "7F", 8)
chkLTE(chk, "F", "F", 8)
chkLTE(chk, "FF", "7F", 8)
chkLTE(chk, "0", "F", 16)
chkLTE(chk, "F", "FF", 16)
chkLTE(chk, "FF", "FFF", 16)
chkLTE(chk, "FFF", "FFF", 16)
chkLTE(chk, "FFFF", "FFF", 16)
chkLTE(chk, "0", "F", 32)
chkLTE(chk, "F", "FF", 32)
chkLTE(chk, "FF", "FFF", 32)
chkLTE(chk, "FFFF", "FFFFF", 32)
chkLTE(chk, "FFFFF", "FFFFF", 32)
chkLTE(chk, "FFFFFFFF", "FFFFF", 32)
chkLTE(chk, "0", "F", 64)
chkLTE(chk, "F", "FF", 64)
chkLTE(chk, "FF", "FFF", 64)
chkLTE(chk, "FFFF", "FFFFF", 64)
chkLTE(chk, "FFFFF", "FFFFFFFF", 64)
chkLTE(chk, "FFFFFFFF", "FFFFFFFF", 64)
chkLTE(chk, "FFFFFFFFFFFFFFFF", "FFFFFFFF", 64)
chkLTE(chk, "0", "F", 128) chkLTE(chk, "0", "F", 128)
chkLTE(chk, "F", "FF", 128) chkLTE(chk, "F", "FF", 128)
chkLTE(chk, "FF", "FFF", 128) chkLTE(chk, "FF", "FFF", 128)
@ -151,28 +88,6 @@ template testComparison(chk, tst: untyped) =
chkLTE(chk, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128) chkLTE(chk, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128)
tst "operator not `LTE`": tst "operator not `LTE`":
chkNotLTE(chk, "0", "F", 8)
chkNotLTE(chk, "F", "7F", 8)
chkNotLTE(chk, "FF", "7F", 8)
chkNotLTE(chk, "0", "F", 16)
chkNotLTE(chk, "F", "FF", 16)
chkNotLTE(chk, "FF", "FFF", 16)
chkNotLTE(chk, "FFFF", "FFF", 16)
chkNotLTE(chk, "0", "F", 32)
chkNotLTE(chk, "F", "FF", 32)
chkNotLTE(chk, "FF", "FFF", 32)
chkNotLTE(chk, "FFFF", "FFFFF", 32)
chkNotLTE(chk, "FFFFFFFF", "FFFFF", 32)
chkNotLTE(chk, "0", "F", 64)
chkNotLTE(chk, "F", "FF", 64)
chkNotLTE(chk, "FF", "FFF", 64)
chkNotLTE(chk, "FFFF", "FFFFF", 64)
chkNotLTE(chk, "FFFFF", "FFFFFFFF", 64)
chkNotLTE(chk, "FFFFFFFFFFFFFFFF", "FFFFFFFF", 64)
chkNotLTE(chk, "0", "F", 128) chkNotLTE(chk, "0", "F", 128)
chkNotLTE(chk, "F", "FF", 128) chkNotLTE(chk, "F", "FF", 128)
chkNotLTE(chk, "FF", "FFF", 128) chkNotLTE(chk, "FF", "FFF", 128)
@ -182,29 +97,6 @@ template testComparison(chk, tst: untyped) =
chkNotLTE(chk, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128) chkNotLTE(chk, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128)
tst "operator `EQ`": tst "operator `EQ`":
chkEQ(chk, "0", "0", 8)
chkEQ(chk, "FF", "FF", 8)
chkEQ(chk, "F", "F", 8)
chkEQ(chk, "0", "0", 16)
chkEQ(chk, "F", "F", 16)
chkEQ(chk, "FF", "FF", 16)
chkEQ(chk, "FFF", "FFF", 16)
chkEQ(chk, "FFFF", "FFFF", 16)
chkEQ(chk, "0", "0", 32)
chkEQ(chk, "F", "F", 32)
chkEQ(chk, "FF", "FF", 32)
chkEQ(chk, "FFFF", "FFFF", 32)
chkEQ(chk, "FFFFF", "FFFFF", 32)
chkEQ(chk, "0", "0", 64)
chkEQ(chk, "F", "F", 64)
chkEQ(chk, "FF", "FF", 64)
chkEQ(chk, "FFFF", "FFFF", 64)
chkEQ(chk, "FFFFF", "FFFFF", 64)
chkEQ(chk, "FFFFFFFF", "FFFFFFFF", 64)
chkEQ(chk, "0", "0", 128) chkEQ(chk, "0", "0", 128)
chkEQ(chk, "F", "F", 128) chkEQ(chk, "F", "F", 128)
chkEQ(chk, "FF", "FF", 128) chkEQ(chk, "FF", "FF", 128)
@ -213,24 +105,6 @@ template testComparison(chk, tst: untyped) =
chkEQ(chk, "FFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128) chkEQ(chk, "FFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128)
tst "operator not `EQ`": tst "operator not `EQ`":
chkNotEQ(chk, "0", "F", 8)
chkNotEQ(chk, "F", "FF", 8)
chkNotEQ(chk, "0", "F", 16)
chkNotEQ(chk, "F", "FF", 16)
chkNotEQ(chk, "FF", "FFA", 16)
chkNotEQ(chk, "0", "F", 32)
chkNotEQ(chk, "F", "FF", 32)
chkNotEQ(chk, "FF", "FFF", 32)
chkNotEQ(chk, "FFFF", "FAFFF", 32)
chkNotEQ(chk, "0", "F", 64)
chkNotEQ(chk, "F", "FF", 64)
chkNotEQ(chk, "FF", "FFF", 64)
chkNotEQ(chk, "FFFF", "FFFFF", 64)
chkNotEQ(chk, "FFFFF", "FAFFFFFFF", 64)
chkNotEQ(chk, "0", "F", 128) chkNotEQ(chk, "0", "F", 128)
chkNotEQ(chk, "F", "FF", 128) chkNotEQ(chk, "F", "FF", 128)
chkNotEQ(chk, "FF", "FFF", 128) chkNotEQ(chk, "FF", "FFF", 128)
@ -277,17 +151,9 @@ template testComparison(chk, tst: untyped) =
chkIsNegative(chk, "A600000000000000000000000000000000000000000000000000000000000000", 256) chkIsNegative(chk, "A600000000000000000000000000000000000000000000000000000000000000", 256)
tst "operator not `isNegative`": tst "operator not `isNegative`":
chkNotIsNegative(chk, "0", 8)
chkNotIsNegative(chk, "0", 16)
chkNotIsNegative(chk, "0", 32)
chkNotIsNegative(chk, "0", 64)
chkNotIsNegative(chk, "0", 128) chkNotIsNegative(chk, "0", 128)
chkNotIsNegative(chk, "0", 256) chkNotIsNegative(chk, "0", 256)
chkNotIsNegative(chk, "1", 8)
chkNotIsNegative(chk, "2", 16)
chkNotIsNegative(chk, "3", 32)
chkNotIsNegative(chk, "4", 64)
chkNotIsNegative(chk, "5", 128) chkNotIsNegative(chk, "5", 128)
chkNotIsNegative(chk, "6", 256) chkNotIsNegative(chk, "6", 256)
@ -370,7 +236,7 @@ template testComparison(chk, tst: untyped) =
chkIsOdd(chk, "FFFFF", 32) chkIsOdd(chk, "FFFFF", 32)
chkIsOdd(chk, "FFFFFF", 64) chkIsOdd(chk, "FFFFFF", 64)
chkIsOdd(chk, "FFFFFFFFFFFFFFF", 128) chkIsOdd(chk, "FFFFFFFFFFFFFFF", 128)
chkIsOdd(chk, "FFFFFFFFFFFFFFFFFF", 256) chkIsOdd(chk, "FFFFFFFFFFFFFFFFFF", 256)]#
static: static:
testComparison(ctCheck, ctTest) testComparison(ctCheck, ctTest)
@ -382,6 +248,7 @@ proc main() =
suite "Wider signed int comparison coverage": suite "Wider signed int comparison coverage":
testComparison(check, test) testComparison(check, test)
#[
suite "Signed int - Testing comparison operators": suite "Signed int - Testing comparison operators":
let let
a = 10'i16.stint(16) a = 10'i16.stint(16)
@ -436,5 +303,6 @@ proc main() =
not b.isEven not b.isEven
c.isEven c.isEven
not c.isOdd not c.isOdd
]#
main() main()

10
tests/test_int_initialization.nim
View File

@ -42,16 +42,18 @@ template testInitialization(chk, tst: untyped) =
tst "hi lo": tst "hi lo":
let x = Int128.high let x = Int128.high
var z = UInt128.high var z = UInt128.high
z.clearBit(0) z.clearBit(10)
debugEcho x.toHex
debugEcho z.toHex
chk x.imp == z chk x.imp == z
let xx = Int128.low let xx = Int128.low
var zz = UInt128.low var zz = UInt128.low
zz.setBit(0) zz.setBit(z.bits - 1)
chk xx.imp == zz chk xx.imp == zz
static: #static:
testInitialization(ctCheck, ctTest) # testInitialization(ctCheck, ctTest)
suite "Signed integer initialization": suite "Signed integer initialization":
testInitialization(check, test) testInitialization(check, test)