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

246 lines
8.5 KiB
Nim
Raw Normal View History

Update Stint in header + mention unsigned vs signed int in tests
2018-04-25 19:21:25 +00:00
# Stint
Relicense under dual Apache/MIT
2018-03-02 10:48:08 +00:00
# Copyright 2018 Status Research & Development GmbH
# Licensed under either of
#
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
# * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
#
# at your option. This file may not be copied, modified, or distributed except according to those terms.
[WIP] Add multiplication with Karatsuba algorithm + basic test
2018-02-16 08:22:23 +00:00
cosmetics changes
2019-10-23 02:20:06 +00:00
import ../stint, unittest, test_helpers
[WIP] Add multiplication with Karatsuba algorithm + basic test
2018-02-16 08:22:23 +00:00
fixes operator precedence issue with nim 19.6
2019-10-22 11:07:35 +00:00
template chkDiv(chk: untyped, a, b, c: string, bits: int) =
Enable --styleCheck:usages (#118)
2022-02-24 19:09:53 +00:00
chk (fromHex(StUint[bits], a) div fromHex(StUint[bits], b)) == fromHex(StUint[bits], c)
improve uint muldiv coverage + compile time test
2019-10-22 13:53:24 +00:00
fixes operator precedence issue with nim 19.6
2019-10-22 11:07:35 +00:00
template chkMod(chk: untyped, a, b, c: string, bits: int) =
Enable --styleCheck:usages (#118)
2022-02-24 19:09:53 +00:00
chk (fromHex(StUint[bits], a) mod fromHex(StUint[bits], b)) == fromHex(StUint[bits], c)
fixes operator precedence issue with nim 19.6
2019-10-22 11:07:35 +00:00
template chkDivMod(chk: untyped, a, b, c, d: string, bits: int) =
Enable --styleCheck:usages (#118)
2022-02-24 19:09:53 +00:00
chk divmod(fromHex(StUint[bits], a), fromHex(StUint[bits], b)) == (fromHex(StUint[bits], c), fromHex(StUint[bits], d))
improve uint muldiv coverage + compile time test
2019-10-22 13:53:24 +00:00
Implement exponentiation, test mul, split mul/div tests
2020-09-06 14:27:11 +00:00
template testdivmod(chk, tst: untyped) =
improve uint muldiv coverage + compile time test
2019-10-22 13:53:24 +00:00
tst "operator `div`":
chkDiv(chk, "0", "3", "0", 8)
chkDiv(chk, "1", "3", "0", 8)
chkDiv(chk, "3", "3", "1", 8)
chkDiv(chk, "3", "1", "3", 8)
chkDiv(chk, "FF", "3", "55", 8)
chkDiv(chk, "0", "3", "0", 16)
chkDiv(chk, "1", "3", "0", 16)
chkDiv(chk, "3", "3", "1", 16)
chkDiv(chk, "3", "1", "3", 16)
chkDiv(chk, "FF", "3", "55", 16)
chkDiv(chk, "FFFF", "3", "5555", 16)
chkDiv(chk, "0", "3", "0", 32)
chkDiv(chk, "1", "3", "0", 32)
chkDiv(chk, "3", "3", "1", 32)
chkDiv(chk, "3", "1", "3", 32)
chkDiv(chk, "FF", "3", "55", 32)
chkDiv(chk, "FFFF", "3", "5555", 32)
chkDiv(chk, "FFFFFFFF", "3", "55555555", 32)
chkDiv(chk, "0", "3", "0", 64)
chkDiv(chk, "1", "3", "0", 64)
chkDiv(chk, "3", "3", "1", 64)
chkDiv(chk, "3", "1", "3", 64)
chkDiv(chk, "FF", "3", "55", 64)
chkDiv(chk, "FFFF", "3", "5555", 64)
chkDiv(chk, "FFFFFFFF", "3", "55555555", 64)
chkDiv(chk, "FFFFFFFFFFFFFFFF", "3", "5555555555555555", 64)
chkDiv(chk, "0", "3", "0", 128)
chkDiv(chk, "1", "3", "0", 128)
chkDiv(chk, "3", "3", "1", 128)
chkDiv(chk, "3", "1", "3", 128)
chkDiv(chk, "FF", "3", "55", 128)
chkDiv(chk, "FFFF", "3", "5555", 128)
chkDiv(chk, "FFFFFFFF", "3", "55555555", 128)
chkDiv(chk, "FFFFFFFFFFFFFFFF", "3", "5555555555555555", 128)
chkDiv(chk, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "3", "55555555555555555555555555555555", 128)
tst "operator `mod`":
chkMod(chk, "0", "3", "0", 8)
chkMod(chk, "1", "3", "1", 8)
chkMod(chk, "3", "3", "0", 8)
chkMod(chk, "3", "1", "0", 8)
chkMod(chk, "FF", "3", "0", 8)
chkMod(chk, "FF", "4", "3", 8)
chkMod(chk, "0", "3", "0", 16)
chkMod(chk, "1", "3", "1", 16)
chkMod(chk, "3", "3", "0", 16)
chkMod(chk, "3", "1", "0", 16)
chkMod(chk, "FF", "3", "0", 16)
chkMod(chk, "FF", "4", "3", 16)
chkMod(chk, "FFFF", "3", "0", 16)
chkMod(chk, "FFFF", "4", "3", 16)
chkMod(chk, "FFFF", "17", "8", 16)
chkMod(chk, "0", "3", "0", 32)
chkMod(chk, "1", "3", "1", 32)
chkMod(chk, "3", "3", "0", 32)
chkMod(chk, "3", "1", "0", 32)
chkMod(chk, "FF", "3", "0", 32)
chkMod(chk, "FF", "4", "3", 32)
chkMod(chk, "FFFF", "3", "0", 32)
chkMod(chk, "FFFF", "17", "8", 32)
chkMod(chk, "FFFFFFFF", "3", "0", 32)
chkMod(chk, "FFFFFFFF", "23", "A", 32)
chkMod(chk, "FFFFFFFF", "27", "15", 32)
chkMod(chk, "0", "3", "0", 64)
chkMod(chk, "1", "3", "1", 64)
chkMod(chk, "3", "3", "0", 64)
chkMod(chk, "3", "1", "0", 64)
chkMod(chk, "FF", "3", "0", 64)
chkMod(chk, "FF", "4", "3", 64)
chkMod(chk, "FFFF", "3", "0", 64)
chkMod(chk, "FFFF", "17", "8", 64)
chkMod(chk, "FFFFFFFF", "3", "0", 64)
chkMod(chk, "FFFFFFFF", "23", "A", 64)
chkMod(chk, "FFFFFFFF", "27", "15", 64)
chkMod(chk, "FFFFFFFFFFFFFFFF", "27", "F", 64)
chkMod(chk, "0", "3", "0", 128)
chkMod(chk, "1", "3", "1", 128)
chkMod(chk, "3", "3", "0", 128)
chkMod(chk, "3", "1", "0", 128)
chkMod(chk, "FF", "3", "0", 128)
chkMod(chk, "FF", "4", "3", 128)
chkMod(chk, "FFFF", "3", "0", 128)
chkMod(chk, "FFFF", "17", "8", 128)
chkMod(chk, "FFFFFFFF", "3", "0", 128)
chkMod(chk, "FFFFFFFF", "23", "A", 128)
chkMod(chk, "FFFFFFFF", "27", "15", 128)
chkMod(chk, "FFFFFFFFFFFFFFFF", "27", "F", 128)
chkMod(chk, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "27", "15", 128)
tst "operator `divmod`":
chkDivMod(chk, "0", "3", "0", "0", 8)
chkDivMod(chk, "1", "3", "0", "1", 8)
chkDivMod(chk, "3", "3", "1", "0", 8)
chkDivMod(chk, "3", "1", "3", "0", 8)
chkDivMod(chk, "FF", "3", "55", "0", 8)
chkDivMod(chk, "FF", "4", "3F", "3", 8)
chkDivMod(chk, "0", "3", "0", "0", 16)
chkDivMod(chk, "1", "3", "0", "1", 16)
chkDivMod(chk, "3", "3", "1", "0", 16)
chkDivMod(chk, "3", "1", "3", "0", 16)
chkDivMod(chk, "FF", "3", "55", "0", 16)
chkDivMod(chk, "FF", "4", "3F", "3", 16)
chkDivMod(chk, "FFFF", "3", "5555", "0", 16)
chkDivMod(chk, "FFFF", "4", "3FFF", "3", 16)
chkDivMod(chk, "FFFF", "17", "B21", "8", 16)
chkDivMod(chk, "0", "3", "0", "0", 32)
chkDivMod(chk, "1", "3", "0", "1", 32)
chkDivMod(chk, "3", "3", "1", "0", 32)
chkDivMod(chk, "3", "1", "3", "0", 32)
chkDivMod(chk, "FF", "3", "55", "0", 32)
chkDivMod(chk, "FF", "4", "3F", "3", 32)
chkDivMod(chk, "FFFF", "3", "5555", "0", 32)
chkDivMod(chk, "FFFF", "17", "B21", "8", 32)
chkDivMod(chk, "FFFFFFFF", "3", "55555555", "0", 32)
chkDivMod(chk, "FFFFFFFF", "23", "7507507", "0A", 32)
chkDivMod(chk, "FFFFFFFF", "27", "6906906", "15", 32)
chkDivMod(chk, "0", "3", "0", "0", 64)
chkDivMod(chk, "1", "3", "0", "1", 64)
chkDivMod(chk, "3", "3", "1", "0", 64)
chkDivMod(chk, "3", "1", "3", "0", 64)
chkDivMod(chk, "FF", "3", "55", "0", 64)
chkDivMod(chk, "FF", "4", "3F", "3", 64)
chkDivMod(chk, "FFFF", "3", "5555", "0", 64)
chkDivMod(chk, "FFFF", "17", "B21", "8", 64)
chkDivMod(chk, "FFFFFFFF", "3", "55555555", "0", 64)
chkDivMod(chk, "FFFFFFFF", "23", "7507507", "0A", 64)
chkDivMod(chk, "FFFFFFFF", "27", "6906906", "15", 64)
chkDivMod(chk, "FFFFFFFFFFFFFFFF", "27", "690690690690690", "F", 64)
chkDivMod(chk, "0", "3", "0", "0", 128)
chkDivMod(chk, "1", "3", "0", "1", 128)
chkDivMod(chk, "3", "3", "1", "0", 128)
chkDivMod(chk, "3", "1", "3", "0", 128)
chkDivMod(chk, "FF", "3", "55", "0", 128)
chkDivMod(chk, "FF", "4", "3F", "3", 128)
chkDivMod(chk, "FFFF", "3", "5555", "0", 128)
chkDivMod(chk, "FFFF", "17", "B21", "8", 128)
chkDivMod(chk, "FFFFFFFF", "3", "55555555", "0", 128)
chkDivMod(chk, "FFFFFFFF", "23", "7507507", "0A", 128)
chkDivMod(chk, "FFFFFFFF", "27", "6906906", "15", 128)
chkDivMod(chk, "FFFFFFFFFFFFFFFF", "27", "690690690690690", "F", 128)
chkDivMod(chk, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "27", "6906906906906906906906906906906", "15", 128)
fixes operator precedence issue with nim 19.6
2019-10-22 11:07:35 +00:00
static:
Implement exponentiation, test mul, split mul/div tests
2020-09-06 14:27:11 +00:00
testdivmod(ctCheck, ctTest)
fixes operator precedence issue with nim 19.6
2019-10-22 11:07:35 +00:00
suite "Wider unsigned int muldiv coverage":
Implement exponentiation, test mul, split mul/div tests
2020-09-06 14:27:11 +00:00
testdivmod(check, test)
Add division test + consistent Subtype conversion use
2018-02-17 11:44:51 +00:00
Update Stint in header + mention unsigned vs signed int in tests
2018-04-25 19:21:25 +00:00
suite "Testing unsigned int division and modulo implementation":
Faster division algorithm (#8) * cosmetic changes * fix zero conversion * Div using divided and conquer algorithm. (Compiles but doesn't work) * Passes test with production flag
2018-03-28 15:15:36 +00:00
test "Divmod(100, 13) returns the correct result":
Add division test + consistent Subtype conversion use
2018-02-17 11:44:51 +00:00
Don't use single letter function like u(256)
2018-04-25 11:36:56 +00:00
let a = 100.stuint(64)
let b = 13.stuint(64)
Make bits part of type (#6) * Small reorg of conversion proc * Rework with bits as type. Pass endianess test * tests_comparison compiles and succeed * Fix init with int for mpint_test compilation flag * All tests green :fire:
2018-03-26 09:46:24 +00:00
let qr = divmod(a, b)
Add division test + consistent Subtype conversion use
2018-02-17 11:44:51 +00:00
check: cast[uint64](qr.quot) == 7'u64
check: cast[uint64](qr.rem) == 9'u64
Faster division algorithm (#8) * cosmetic changes * fix zero conversion * Div using divided and conquer algorithm. (Compiles but doesn't work) * Passes test with production flag
2018-03-28 15:15:36 +00:00
uint division - compile and pass the single limb tests
2022-01-22 00:42:54 +00:00
# TODO - no more .lo / .hi
#
# test "Divmod(2^64, 3) returns the correct result":
# let a = 1.stuint(128) shl 64
# let b = 3.stuint(128)
#
# let qr = divmod(a, b)
#
# let q = cast[UintImpl[uint64]](qr.quot)
# let r = cast[UintImpl[uint64]](qr.rem)
#
# check: q.lo == 6148914691236517205'u64
# check: q.hi == 0'u64
# check: r.lo == 1'u64
# check: r.hi == 0'u64
Add bigint serialization (hex and decimal) (#29) * Add serialization for decimal and hex * Fix carry bug in signed add * Add parsing test * Improve highlow for int, remove most_significant_word_mut * make conversion toString compile * Add division corner case test * Remove a buggy division shortcut * Fix decimal string conversion * Fix hex dumping * Fix power of 2 division (what was I thinking?) * Add hexdump test * Move runtime check to compile-time * Fix static assert check * more compile-time asserts * Fix parsing of negative hex numbers, add test_io to the suite * dump default to bigEndian, split toString in Stint and Stuint * Add (failing) tests with big ints conversion * Temporarily remove all the noInit pragma
2018-04-30 11:38:55 +00:00
test "Divmod(1234567891234567890, 10) returns the correct result":
let a = cast[StUint[64]](1234567891234567890'u64)
let b = cast[StUint[64]](10'u64)
let qr = divmod(a, b)
let q = cast[uint64](qr.quot)
let r = cast[uint64](qr.rem)
check: q == 123456789123456789'u64
check: r == 0'u64
Fix #30 - modulo failures (#32) * Add corner cases to test suite * Add failing div2n1n case * Fix test and fix #30 * Add to tests * Fix failing tests due to Nim string change between Apr 27 and Apr 29 (doc: https://github.com/nim-lang/Nim/commit/5237ef4f5280fef8df630f265cc67869d013c0ef)
2018-05-02 15:49:31 +00:00
suite "Testing specific failures highlighted by property-based testing":
test "Modulo: 65696211516342324 mod 174261910798982":
let u = 65696211516342324'u64
let v = 174261910798982'u64
Enable --styleCheck:usages (#118)
2022-02-24 19:09:53 +00:00
let a = cast[StUint[64]](u)
let b = cast[StUint[64]](v)
Fix #30 - modulo failures (#32) * Add corner cases to test suite * Add failing div2n1n case * Fix test and fix #30 * Add to tests * Fix failing tests due to Nim string change between Apr 27 and Apr 29 (doc: https://github.com/nim-lang/Nim/commit/5237ef4f5280fef8df630f265cc67869d013c0ef)
2018-05-02 15:49:31 +00:00
let z = u mod v
let tz = cast[uint64](a mod b)
check: z == tz
test "Modulo: 15080397990160655 mod 600432699691":
let u = 15080397990160655'u64
let v = 600432699691'u64
Enable --styleCheck:usages (#118)
2022-02-24 19:09:53 +00:00
let a = cast[StUint[64]](u)
let b = cast[StUint[64]](v)
Fix #30 - modulo failures (#32) * Add corner cases to test suite * Add failing div2n1n case * Fix test and fix #30 * Add to tests * Fix failing tests due to Nim string change between Apr 27 and Apr 29 (doc: https://github.com/nim-lang/Nim/commit/5237ef4f5280fef8df630f265cc67869d013c0ef)
2018-05-02 15:49:31 +00:00
let z = u mod v
let tz = cast[uint64](a mod b)
check: z == tz