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
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) =
a.limbs[0] = a.limbs[0] or signMask
a.limbs[^1] = a.limbs[^1] or signMask
func negate*(a: var StInt) =
a.imp.bitnot(a.imp)
@ -107,8 +107,8 @@ func `==`*(a, b: StInt): bool =
func `<`*(a, b: StInt): bool =
## Unsigned `less than` comparison
let
aSign = a.Sign
bSign = b.Sign
aSign = a.sign
bSign = b.sign
if aSign >= 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)
nextNonBlank(curr, input)
# 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].
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].
# 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)
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: 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
# # and be much faster
# For conversion we require overflowing operations (for example for negative hex numbers)
const base = radix.int8.stuint(bits)
# # For conversion we require overflowing operations (for example for negative hex numbers)
# const base = radix.int8.StUint(bits)
var
curr = 0 # Current index in the string
isNeg = false
noOverflow: StUint[bits]
# var
# curr = 0 # Current index in the string
# isNeg = false
# no_overflow: StUint[bits]
if input[curr] == '-':
doAssert radix == 10, "Negative numbers are only supported with base 10 input."
isNeg = true
inc curr
else:
skipPrefixes(curr, input, radix)
# if input[curr] == '-':
# doAssert radix == 10, "Negative numbers are only supported with base 10 input."
# isNeg = true
# inc curr
# else:
# skipPrefixes(curr, input, radix)
while curr < input.len:
# TODO: overflow detection
when radix <= 10:
noOverflow = noOverflow * base + input[curr].readDecChar.stuint(bits)
else:
noOverflow = noOverflow * base + input[curr].readHexChar.stuint(bits)
nextNonBlank(curr, input)
# while curr < input.len:
# # TODO: overflow detection
# when radix <= 10:
# 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)
result.imp = noOverflow
if isNeg:
result.negate
func fromHex*(T: typedesc[StUint|StInt], s: string): T {.inline.} =
## 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.
## - if not base 10, they are returned raw in two-complement form.
let isNeg = num.isNegative
if radix == 10 and isNeg:
#if radix == 10 and isNeg:
if isNeg:
"-" & toString(num.neg.imp, radix)
else:
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) =
chk (not fromHex(StInt[bits], a).isEven())
import strutils
template testComparison(chk, tst: untyped) =
tst "operator `LT`":
chkLT(chk, "0", "F", 8)
chkLT(chk, "F", "7F", 8)
chkLT(chk, "FF", "7F", 8)
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)
chk 0.i128 < 1.i128
chk -1.i128 < 1.i128
chk -1.i128 < 0.i128
chk Int128.low < Int128.high
#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`":
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, "F", "FF", 128)
chkNotLT(chk, "FF", "FFF", 128)
@ -115,32 +78,6 @@ template testComparison(chk, tst: untyped) =
chkNotLT(chk, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128)
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, "F", "FF", 128)
chkLTE(chk, "FF", "FFF", 128)
@ -151,28 +88,6 @@ template testComparison(chk, tst: untyped) =
chkLTE(chk, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128)
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, "F", "FF", 128)
chkNotLTE(chk, "FF", "FFF", 128)
@ -182,29 +97,6 @@ template testComparison(chk, tst: untyped) =
chkNotLTE(chk, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128)
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, "F", "F", 128)
chkEQ(chk, "FF", "FF", 128)
@ -213,24 +105,6 @@ template testComparison(chk, tst: untyped) =
chkEQ(chk, "FFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128)
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, "F", "FF", 128)
chkNotEQ(chk, "FF", "FFF", 128)
@ -277,17 +151,9 @@ template testComparison(chk, tst: untyped) =
chkIsNegative(chk, "A600000000000000000000000000000000000000000000000000000000000000", 256)
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", 256)
chkNotIsNegative(chk, "1", 8)
chkNotIsNegative(chk, "2", 16)
chkNotIsNegative(chk, "3", 32)
chkNotIsNegative(chk, "4", 64)
chkNotIsNegative(chk, "5", 128)
chkNotIsNegative(chk, "6", 256)
@ -370,7 +236,7 @@ template testComparison(chk, tst: untyped) =
chkIsOdd(chk, "FFFFF", 32)
chkIsOdd(chk, "FFFFFF", 64)
chkIsOdd(chk, "FFFFFFFFFFFFFFF", 128)
chkIsOdd(chk, "FFFFFFFFFFFFFFFFFF", 256)
chkIsOdd(chk, "FFFFFFFFFFFFFFFFFF", 256)]#
static:
testComparison(ctCheck, ctTest)
@ -382,6 +248,7 @@ proc main() =
suite "Wider signed int comparison coverage":
testComparison(check, test)
#[
suite "Signed int - Testing comparison operators":
let
a = 10'i16.stint(16)
@ -436,5 +303,6 @@ proc main() =
not b.isEven
c.isEven
not c.isOdd
]#
main()

10
tests/test_int_initialization.nim
View File

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