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

166
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, "FF", "FFF", 16)
chkLT(chk, "FFFF", "FFF", 16)
chkLT(chk, "0", "F", 32)
chkLT(chk, "F", "FF", 32)
chkLT(chk, "FF", "FFF", 32)
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)
#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)