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_comparison.nim

367 lines
10 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.
Add comparison operators + tests + fix shr forward declaration
2018-02-16 16:48:54 +00:00
Corrected package structure
2018-05-08 13:51:55 +00:00
import ../stint, unittest
Add comparison operators + tests + fix shr forward declaration
2018-02-16 16:48:54 +00:00
improve uint comparison coverage + compile time test
2019-10-22 10:44:43 +00:00
template chkLT(chk: untyped, a, b: string, bits: int) =
chk fromHex(Stuint[bits], a) < fromHex(Stuint[bits], b)
template chknotLT(chk: untyped, a, b: string, bits: int) =
fixes operator precedence issue with nim 19.6
2019-10-22 11:07:35 +00:00
chk (not(fromHex(Stuint[bits], b) < fromHex(Stuint[bits], a)))
improve uint comparison coverage + compile time test
2019-10-22 10:44:43 +00:00
template chkLTE(chk: untyped, a, b: string, bits: int) =
chk fromHex(Stuint[bits], a) <= fromHex(Stuint[bits], b)
template chknotLTE(chk: untyped, a, b: string, bits: int) =
fixes operator precedence issue with nim 19.6
2019-10-22 11:07:35 +00:00
chk (not(fromHex(Stuint[bits], b) <= fromHex(Stuint[bits], a)))
improve uint comparison coverage + compile time test
2019-10-22 10:44:43 +00:00
template chkEQ(chk: untyped, a, b: string, bits: int) =
chk fromHex(Stuint[bits], a) == fromHex(Stuint[bits], b)
template chknotEQ(chk: untyped, a, b: string, bits: int) =
fixes operator precedence issue with nim 19.6
2019-10-22 11:07:35 +00:00
chk (not(fromHex(Stuint[bits], a) == fromHex(Stuint[bits], b)))
improve uint comparison coverage + compile time test
2019-10-22 10:44:43 +00:00
template chkisZero(chk: untyped, a: string, bits: int) =
chk fromHex(Stuint[bits], a).isZero()
template chknotisZero(chk: untyped, a: string, bits: int) =
fixes operator precedence issue with nim 19.6
2019-10-22 11:07:35 +00:00
chk (not fromHex(Stuint[bits], a).isZero())
improve uint comparison coverage + compile time test
2019-10-22 10:44:43 +00:00
template chkisOdd(chk: untyped, a: string, bits: int) =
chk fromHex(Stuint[bits], a).isOdd()
template chknotisOdd(chk: untyped, a: string, bits: int) =
chk (not fromHex(Stuint[bits], a).isOdd())
template chkisEven(chk: untyped, a: string, bits: int) =
chk fromHex(Stuint[bits], a).isEven()
template chknotisEven(chk: untyped, a: string, bits: int) =
fixes operator precedence issue with nim 19.6
2019-10-22 11:07:35 +00:00
chk (not fromHex(Stuint[bits], a).isEven())
improve uint comparison coverage + compile time test
2019-10-22 10:44:43 +00:00
template ctTest(name: string, body: untyped) =
body
echo "[OK] compile time ", name
template testComparison(chk, tst: untyped) =
tst "operator `LT`":
chkLT(chk, "0", "F", 8)
chkLT(chk, "F", "FF", 8)
chkLT(chk, "0", "F", 16)
chkLT(chk, "F", "FF", 16)
chkLT(chk, "FF", "FFF", 16)
chkLT(chk, "0", "F", 32)
chkLT(chk, "F", "FF", 32)
chkLT(chk, "FF", "FFF", 32)
chkLT(chk, "FFFF", "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, "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)
tst "operator not `LT`":
chknotLT(chk, "0", "F", 8)
chknotLT(chk, "F", "FF", 8)
chknotLT(chk, "0", "F", 16)
chknotLT(chk, "F", "FF", 16)
chknotLT(chk, "FF", "FFF", 16)
chknotLT(chk, "0", "F", 32)
chknotLT(chk, "F", "FF", 32)
chknotLT(chk, "FF", "FFF", 32)
chknotLT(chk, "FFFF", "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, "0", "F", 128)
chknotLT(chk, "F", "FF", 128)
chknotLT(chk, "FF", "FFF", 128)
chknotLT(chk, "FFFF", "FFFFF", 128)
chknotLT(chk, "FFFFF", "FFFFFFFF", 128)
chknotLT(chk, "FFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128)
tst "operator `LTE`":
chkLTE(chk, "0", "F", 8)
chkLTE(chk, "F", "FF", 8)
chkLTE(chk, "F", "F", 8)
chkLTE(chk, "0", "F", 16)
chkLTE(chk, "F", "FF", 16)
chkLTE(chk, "FF", "FFF", 16)
chkLTE(chk, "FFF", "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, "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, "0", "F", 128)
chkLTE(chk, "F", "FF", 128)
chkLTE(chk, "FF", "FFF", 128)
chkLTE(chk, "FFFF", "FFFFF", 128)
chkLTE(chk, "FFFFF", "FFFFFFFF", 128)
chkLTE(chk, "FFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128)
chkLTE(chk, "FFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128)
tst "operator not `LTE`":
chknotLTE(chk, "0", "F", 8)
chknotLTE(chk, "F", "FF", 8)
chknotLTE(chk, "0", "F", 16)
chknotLTE(chk, "F", "FF", 16)
chknotLTE(chk, "FF", "FFF", 16)
chknotLTE(chk, "0", "F", 32)
chknotLTE(chk, "F", "FF", 32)
chknotLTE(chk, "FF", "FFF", 32)
chknotLTE(chk, "FFFF", "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, "0", "F", 128)
chknotLTE(chk, "F", "FF", 128)
chknotLTE(chk, "FF", "FFF", 128)
chknotLTE(chk, "FFFF", "FFFFF", 128)
chknotLTE(chk, "FFFFF", "FFFFFFFF", 128)
chknotLTE(chk, "FFFFFFFFFFF", "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, "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)
chkEQ(chk, "FFFF", "FFFF", 128)
chkEQ(chk, "FFFFF", "FFFFF", 128)
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", "FFF", 16)
chknotEQ(chk, "0", "F", 32)
chknotEQ(chk, "F", "FF", 32)
chknotEQ(chk, "FF", "FFF", 32)
chknotEQ(chk, "FFFF", "FFFFF", 32)
chknotEQ(chk, "0", "F", 64)
chknotEQ(chk, "F", "FF", 64)
chknotEQ(chk, "FF", "FFF", 64)
chknotEQ(chk, "FFFF", "FFFFF", 64)
chknotEQ(chk, "FFFFF", "FFFFFFFF", 64)
chknotEQ(chk, "0", "F", 128)
chknotEQ(chk, "F", "FF", 128)
chknotEQ(chk, "FF", "FFF", 128)
chknotEQ(chk, "FFFF", "FFFFF", 128)
chknotEQ(chk, "FFFFF", "FFFFFFFF", 128)
chknotEQ(chk, "FFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFF", 128)
tst "operator `isZero`":
chkIsZero(chk, "0", 8)
chkIsZero(chk, "0", 16)
chkIsZero(chk, "0", 32)
chkIsZero(chk, "0", 64)
chkIsZero(chk, "0", 128)
chkIsZero(chk, "0", 256)
tst "operator not `isZero`":
chknotIsZero(chk, "1", 8)
chknotIsZero(chk, "2", 16)
chknotIsZero(chk, "3", 32)
chknotIsZero(chk, "4", 64)
chknotIsZero(chk, "5", 128)
chknotIsZero(chk, "6", 256)
tst "operator `isOdd`":
chkIsOdd(chk, "1", 8)
chkIsOdd(chk, "1", 16)
chkIsOdd(chk, "1", 32)
chkIsOdd(chk, "1", 64)
chkIsOdd(chk, "1", 128)
chkIsOdd(chk, "1", 256)
chkIsOdd(chk, "FF", 8)
chkIsOdd(chk, "FFF", 16)
chkIsOdd(chk, "FFFFF", 32)
chkIsOdd(chk, "FFFFFF", 64)
chkIsOdd(chk, "FFFFFFFFFFFFFFF", 128)
chkIsOdd(chk, "FFFFFFFFFFFFFFFFFF", 256)
tst "operator not `isOdd`":
chkNotIsOdd(chk, "0", 8)
chkNotIsOdd(chk, "0", 16)
chkNotIsOdd(chk, "0", 32)
chkNotIsOdd(chk, "0", 64)
chkNotIsOdd(chk, "0", 128)
chkNotIsOdd(chk, "0", 256)
chkNotIsOdd(chk, "4", 8)
chkNotIsOdd(chk, "4", 16)
chkNotIsOdd(chk, "4", 32)
chkNotIsOdd(chk, "4", 64)
chkNotIsOdd(chk, "4", 128)
chkNotIsOdd(chk, "4", 256)
chkNotIsOdd(chk, "A", 8)
chkNotIsOdd(chk, "AAA", 16)
chkNotIsOdd(chk, "AAAA", 32)
chkNotIsOdd(chk, "FFFFFA", 64)
chkNotIsOdd(chk, "FFFFFFFFFFFFFFA", 128)
chkNotIsOdd(chk, "FFFFFFFFFFFFFFFFFA", 256)
tst "operator `isEven`":
chkNotIsOdd(chk, "0", 8)
chkNotIsOdd(chk, "0", 16)
chkNotIsOdd(chk, "0", 32)
chkNotIsOdd(chk, "0", 64)
chkNotIsOdd(chk, "0", 128)
chkNotIsOdd(chk, "0", 256)
chkNotIsOdd(chk, "4", 8)
chkNotIsOdd(chk, "4", 16)
chkNotIsOdd(chk, "4", 32)
chkNotIsOdd(chk, "4", 64)
chkNotIsOdd(chk, "4", 128)
chkNotIsOdd(chk, "4", 256)
chkNotIsOdd(chk, "A", 8)
chkNotIsOdd(chk, "AAA", 16)
chkNotIsOdd(chk, "AAAA", 32)
chkNotIsOdd(chk, "FFFFFA", 64)
chkNotIsOdd(chk, "FFFFFFFFFFFFFFA", 128)
chkNotIsOdd(chk, "FFFFFFFFFFFFFFFFFA", 256)
tst "operator not `isEven`":
chkIsOdd(chk, "1", 8)
chkIsOdd(chk, "1", 16)
chkIsOdd(chk, "1", 32)
chkIsOdd(chk, "1", 64)
chkIsOdd(chk, "1", 128)
chkIsOdd(chk, "1", 256)
chkIsOdd(chk, "FF", 8)
chkIsOdd(chk, "FFF", 16)
chkIsOdd(chk, "FFFFF", 32)
chkIsOdd(chk, "FFFFFF", 64)
chkIsOdd(chk, "FFFFFFFFFFFFFFF", 128)
chkIsOdd(chk, "FFFFFFFFFFFFFFFFFF", 256)
static:
testComparison(doAssert, ctTest)
suite "Wider unsigned int comparison coverage":
testComparison(check, test)
Update Stint in header + mention unsigned vs signed int in tests
2018-04-25 19:21:25 +00:00
suite "Testing unsigned int comparison operators":
Add comparison operators + tests + fix shr forward declaration
2018-02-16 16:48:54 +00:00
let
Don't use single letter function like u(256)
2018-04-25 11:36:56 +00:00
a = 10'i16.stuint(16)
b = 15'i16.stuint(16)
Add comparison operators + tests + fix shr forward declaration
2018-02-16 16:48:54 +00:00
c = 150'u16
Don't use single letter function like u(256)
2018-04-25 11:36:56 +00:00
d = 4.stuint(128) shl 64
e = 4.stuint(128)
f = 4.stuint(128) shl 65
Add comparison operators + tests + fix shr forward declaration
2018-02-16 16:48:54 +00:00
test "< operator":
[WIP] Division and multiplication optimization (#21) * Clean-up code, part 1 * Managed to get best borrow code for the not inlined substraction #10 * Implement in place substraction in terms of substraction #10 * Another unneed proc removal/temporary step * more cleanup * Upgrade benchmark to Uint256 * Special case when divisor is less than halfSize x2 speed :fire: (still 4x slower than ttmath on Uint256) * Division: special case if dividend can overflow. 10% improvement. * forgot to undo normalization (why did the test pass :??) * 1st part, special cases of fast division * Change bitops, simplify bithacks to detect new fast division cases * 25% speed increase. Within 3x of ttmath * Reimplement multiplication with minimum allocation * Fix call. Now only 2x slower than ttmath * Prepare for optimizing comparison operators * Comparison inlining and optimization. 25% speed increase. 50% slower than ttmath now :fire: * Fix comparison, optimize one() * inline initMpUintImpl for another 20% speed. Only 20% slower than ttmath without ASM
2018-04-21 10:12:05 +00:00
check:
a < b
not (a + b < b)
not (a + a + a < b + b)
Rename the library to Stint (#26)
2018-04-25 10:52:00 +00:00
not (a * b < cast[StUint[16]](c))
[WIP] Division and multiplication optimization (#21) * Clean-up code, part 1 * Managed to get best borrow code for the not inlined substraction #10 * Implement in place substraction in terms of substraction #10 * Another unneed proc removal/temporary step * more cleanup * Upgrade benchmark to Uint256 * Special case when divisor is less than halfSize x2 speed :fire: (still 4x slower than ttmath on Uint256) * Division: special case if dividend can overflow. 10% improvement. * forgot to undo normalization (why did the test pass :??) * 1st part, special cases of fast division * Change bitops, simplify bithacks to detect new fast division cases * 25% speed increase. Within 3x of ttmath * Reimplement multiplication with minimum allocation * Fix call. Now only 2x slower than ttmath * Prepare for optimizing comparison operators * Comparison inlining and optimization. 25% speed increase. 50% slower than ttmath now :fire: * Fix comparison, optimize one() * inline initMpUintImpl for another 20% speed. Only 20% slower than ttmath without ASM
2018-04-21 10:12:05 +00:00
e < d
d < f
Add comparison operators + tests + fix shr forward declaration
2018-02-16 16:48:54 +00:00
test "<= operator":
[WIP] Division and multiplication optimization (#21) * Clean-up code, part 1 * Managed to get best borrow code for the not inlined substraction #10 * Implement in place substraction in terms of substraction #10 * Another unneed proc removal/temporary step * more cleanup * Upgrade benchmark to Uint256 * Special case when divisor is less than halfSize x2 speed :fire: (still 4x slower than ttmath on Uint256) * Division: special case if dividend can overflow. 10% improvement. * forgot to undo normalization (why did the test pass :??) * 1st part, special cases of fast division * Change bitops, simplify bithacks to detect new fast division cases * 25% speed increase. Within 3x of ttmath * Reimplement multiplication with minimum allocation * Fix call. Now only 2x slower than ttmath * Prepare for optimizing comparison operators * Comparison inlining and optimization. 25% speed increase. 50% slower than ttmath now :fire: * Fix comparison, optimize one() * inline initMpUintImpl for another 20% speed. Only 20% slower than ttmath without ASM
2018-04-21 10:12:05 +00:00
check:
a <= b
not (a + b <= b)
a + a + a <= b + b
Rename the library to Stint (#26)
2018-04-25 10:52:00 +00:00
a * b <= cast[StUint[16]](c)
[WIP] Division and multiplication optimization (#21) * Clean-up code, part 1 * Managed to get best borrow code for the not inlined substraction #10 * Implement in place substraction in terms of substraction #10 * Another unneed proc removal/temporary step * more cleanup * Upgrade benchmark to Uint256 * Special case when divisor is less than halfSize x2 speed :fire: (still 4x slower than ttmath on Uint256) * Division: special case if dividend can overflow. 10% improvement. * forgot to undo normalization (why did the test pass :??) * 1st part, special cases of fast division * Change bitops, simplify bithacks to detect new fast division cases * 25% speed increase. Within 3x of ttmath * Reimplement multiplication with minimum allocation * Fix call. Now only 2x slower than ttmath * Prepare for optimizing comparison operators * Comparison inlining and optimization. 25% speed increase. 50% slower than ttmath now :fire: * Fix comparison, optimize one() * inline initMpUintImpl for another 20% speed. Only 20% slower than ttmath without ASM
2018-04-21 10:12:05 +00:00
e <= d
d <= f
Add comparison operators + tests + fix shr forward declaration
2018-02-16 16:48:54 +00:00
test "> operator":
[WIP] Division and multiplication optimization (#21) * Clean-up code, part 1 * Managed to get best borrow code for the not inlined substraction #10 * Implement in place substraction in terms of substraction #10 * Another unneed proc removal/temporary step * more cleanup * Upgrade benchmark to Uint256 * Special case when divisor is less than halfSize x2 speed :fire: (still 4x slower than ttmath on Uint256) * Division: special case if dividend can overflow. 10% improvement. * forgot to undo normalization (why did the test pass :??) * 1st part, special cases of fast division * Change bitops, simplify bithacks to detect new fast division cases * 25% speed increase. Within 3x of ttmath * Reimplement multiplication with minimum allocation * Fix call. Now only 2x slower than ttmath * Prepare for optimizing comparison operators * Comparison inlining and optimization. 25% speed increase. 50% slower than ttmath now :fire: * Fix comparison, optimize one() * inline initMpUintImpl for another 20% speed. Only 20% slower than ttmath without ASM
2018-04-21 10:12:05 +00:00
check:
b > a
not (b > a + b)
not (b + b > a + a + a)
Rename the library to Stint (#26)
2018-04-25 10:52:00 +00:00
not (cast[StUint[16]](c) > a * b)
[WIP] Division and multiplication optimization (#21) * Clean-up code, part 1 * Managed to get best borrow code for the not inlined substraction #10 * Implement in place substraction in terms of substraction #10 * Another unneed proc removal/temporary step * more cleanup * Upgrade benchmark to Uint256 * Special case when divisor is less than halfSize x2 speed :fire: (still 4x slower than ttmath on Uint256) * Division: special case if dividend can overflow. 10% improvement. * forgot to undo normalization (why did the test pass :??) * 1st part, special cases of fast division * Change bitops, simplify bithacks to detect new fast division cases * 25% speed increase. Within 3x of ttmath * Reimplement multiplication with minimum allocation * Fix call. Now only 2x slower than ttmath * Prepare for optimizing comparison operators * Comparison inlining and optimization. 25% speed increase. 50% slower than ttmath now :fire: * Fix comparison, optimize one() * inline initMpUintImpl for another 20% speed. Only 20% slower than ttmath without ASM
2018-04-21 10:12:05 +00:00
d > e
f > d
Add comparison operators + tests + fix shr forward declaration
2018-02-16 16:48:54 +00:00
test ">= operator":
[WIP] Division and multiplication optimization (#21) * Clean-up code, part 1 * Managed to get best borrow code for the not inlined substraction #10 * Implement in place substraction in terms of substraction #10 * Another unneed proc removal/temporary step * more cleanup * Upgrade benchmark to Uint256 * Special case when divisor is less than halfSize x2 speed :fire: (still 4x slower than ttmath on Uint256) * Division: special case if dividend can overflow. 10% improvement. * forgot to undo normalization (why did the test pass :??) * 1st part, special cases of fast division * Change bitops, simplify bithacks to detect new fast division cases * 25% speed increase. Within 3x of ttmath * Reimplement multiplication with minimum allocation * Fix call. Now only 2x slower than ttmath * Prepare for optimizing comparison operators * Comparison inlining and optimization. 25% speed increase. 50% slower than ttmath now :fire: * Fix comparison, optimize one() * inline initMpUintImpl for another 20% speed. Only 20% slower than ttmath without ASM
2018-04-21 10:12:05 +00:00
check:
b >= a
not (b >= a + b)
b + b >= a + a + a
Rename the library to Stint (#26)
2018-04-25 10:52:00 +00:00
cast[StUint[16]](c) >= a * b
[WIP] Division and multiplication optimization (#21) * Clean-up code, part 1 * Managed to get best borrow code for the not inlined substraction #10 * Implement in place substraction in terms of substraction #10 * Another unneed proc removal/temporary step * more cleanup * Upgrade benchmark to Uint256 * Special case when divisor is less than halfSize x2 speed :fire: (still 4x slower than ttmath on Uint256) * Division: special case if dividend can overflow. 10% improvement. * forgot to undo normalization (why did the test pass :??) * 1st part, special cases of fast division * Change bitops, simplify bithacks to detect new fast division cases * 25% speed increase. Within 3x of ttmath * Reimplement multiplication with minimum allocation * Fix call. Now only 2x slower than ttmath * Prepare for optimizing comparison operators * Comparison inlining and optimization. 25% speed increase. 50% slower than ttmath now :fire: * Fix comparison, optimize one() * inline initMpUintImpl for another 20% speed. Only 20% slower than ttmath without ASM
2018-04-21 10:12:05 +00:00
d >= e
f >= d
Modular arithmetic (#47) * Add isEven and isOdd functions * Add modular add, mul, sub pow fixes #18
2018-05-16 08:41:46 +00:00
test "isOdd/isEven":
check:
a.isEven
not a.isOdd
b.isOdd
not b.isEven
c.isEven
not c.isOdd