mirror of
https://github.com/nim-lang/Nim.git
synced 2025-12-28 17:04:41 +00:00
0a9a90d991
* Improve documentation for bitops Use func Use let in runnableExamples * Remove unnecessary tests Fix #7587
350 lines
12 KiB
Nim
350 lines
12 KiB
Nim
discard """
|
|
nimout: "OK"
|
|
output: '''
|
|
OK
|
|
'''
|
|
"""
|
|
import bitops
|
|
|
|
proc main() =
|
|
const U8 = 0b0011_0010'u8
|
|
const I8 = 0b0011_0010'i8
|
|
const U16 = 0b00100111_00101000'u16
|
|
const I16 = 0b00100111_00101000'i16
|
|
const U32 = 0b11010101_10011100_11011010_01010000'u32
|
|
const I32 = 0b11010101_10011100_11011010_01010000'i32
|
|
const U64A = 0b01000100_00111111_01111100_10001010_10011001_01001000_01111010_00010001'u64
|
|
const I64A = 0b01000100_00111111_01111100_10001010_10011001_01001000_01111010_00010001'i64
|
|
const U64B = 0b00110010_11011101_10001111_00101000_00000000_00000000_00000000_00000000'u64
|
|
const I64B = 0b00110010_11011101_10001111_00101000_00000000_00000000_00000000_00000000'i64
|
|
const U64C = 0b00101010_11110101_10001111_00101000_00000100_00000000_00000100_00000000'u64
|
|
const I64C = 0b00101010_11110101_10001111_00101000_00000100_00000000_00000100_00000000'i64
|
|
|
|
doAssert (U8 and U8) == bitand(U8,U8)
|
|
doAssert (I8 and I8) == bitand(I8,I8)
|
|
doAssert (U16 and U16) == bitand(U16,U16)
|
|
doAssert (I16 and I16) == bitand(I16,I16)
|
|
doAssert (U32 and U32) == bitand(U32,U32)
|
|
doAssert (I32 and I32) == bitand(I32,I32)
|
|
doAssert (U64A and U64B) == bitand(U64A,U64B)
|
|
doAssert (I64A and I64B) == bitand(I64A,I64B)
|
|
doAssert (U64A and U64B and U64C) == bitand(U64A,U64B,U64C)
|
|
doAssert (I64A and I64B and I64C) == bitand(I64A,I64B,I64C)
|
|
|
|
doAssert (U8 or U8) == bitor(U8,U8)
|
|
doAssert (I8 or I8) == bitor(I8,I8)
|
|
doAssert (U16 or U16) == bitor(U16,U16)
|
|
doAssert (I16 or I16) == bitor(I16,I16)
|
|
doAssert (U32 or U32) == bitor(U32,U32)
|
|
doAssert (I32 or I32) == bitor(I32,I32)
|
|
doAssert (U64A or U64B) == bitor(U64A,U64B)
|
|
doAssert (I64A or I64B) == bitor(I64A,I64B)
|
|
doAssert (U64A or U64B or U64C) == bitor(U64A,U64B,U64C)
|
|
doAssert (I64A or I64B or I64C) == bitor(I64A,I64B,I64C)
|
|
|
|
doAssert (U8 xor U8) == bitxor(U8,U8)
|
|
doAssert (I8 xor I8) == bitxor(I8,I8)
|
|
doAssert (U16 xor U16) == bitxor(U16,U16)
|
|
doAssert (I16 xor I16) == bitxor(I16,I16)
|
|
doAssert (U32 xor U32) == bitxor(U32,U32)
|
|
doAssert (I32 xor I32) == bitxor(I32,I32)
|
|
doAssert (U64A xor U64B) == bitxor(U64A,U64B)
|
|
doAssert (I64A xor I64B) == bitxor(I64A,I64B)
|
|
doAssert (U64A xor U64B xor U64C) == bitxor(U64A,U64B,U64C)
|
|
doAssert (I64A xor I64B xor I64C) == bitxor(I64A,I64B,I64C)
|
|
|
|
doAssert not(U8) == bitnot(U8)
|
|
doAssert not(I8) == bitnot(I8)
|
|
doAssert not(U16) == bitnot(U16)
|
|
doAssert not(I16) == bitnot(I16)
|
|
doAssert not(U32) == bitnot(U32)
|
|
doAssert not(I32) == bitnot(I32)
|
|
doAssert not(U64A) == bitnot(U64A)
|
|
doAssert not(I64A) == bitnot(I64A)
|
|
|
|
doAssert U64A.fastLog2 == 62
|
|
doAssert I64A.fastLog2 == 62
|
|
doAssert U64A.countLeadingZeroBits == 1
|
|
doAssert I64A.countLeadingZeroBits == 1
|
|
doAssert U64A.countTrailingZeroBits == 0
|
|
doAssert I64A.countTrailingZeroBits == 0
|
|
doAssert U64A.firstSetBit == 1
|
|
doAssert I64A.firstSetBit == 1
|
|
doAssert U64A.parityBits == 1
|
|
doAssert I64A.parityBits == 1
|
|
doAssert U64A.countSetBits == 29
|
|
doAssert I64A.countSetBits == 29
|
|
doAssert U64A.rotateLeftBits(37) == 0b00101001_00001111_01000010_00101000_10000111_11101111_10010001_01010011'u64
|
|
doAssert U64A.rotateRightBits(37) == 0b01010100_11001010_01000011_11010000_10001010_00100001_11111011_11100100'u64
|
|
|
|
doAssert U64B.firstSetBit == 36
|
|
doAssert I64B.firstSetBit == 36
|
|
|
|
doAssert U32.fastLog2 == 31
|
|
doAssert I32.fastLog2 == 31
|
|
doAssert U32.countLeadingZeroBits == 0
|
|
doAssert I32.countLeadingZeroBits == 0
|
|
doAssert U32.countTrailingZeroBits == 4
|
|
doAssert I32.countTrailingZeroBits == 4
|
|
doAssert U32.firstSetBit == 5
|
|
doAssert I32.firstSetBit == 5
|
|
doAssert U32.parityBits == 0
|
|
doAssert I32.parityBits == 0
|
|
doAssert U32.countSetBits == 16
|
|
doAssert I32.countSetBits == 16
|
|
doAssert U32.rotateLeftBits(21) == 0b01001010_00011010_10110011_10011011'u32
|
|
doAssert U32.rotateRightBits(21) == 0b11100110_11010010_10000110_10101100'u32
|
|
|
|
doAssert U16.fastLog2 == 13
|
|
doAssert I16.fastLog2 == 13
|
|
doAssert U16.countLeadingZeroBits == 2
|
|
doAssert I16.countLeadingZeroBits == 2
|
|
doAssert U16.countTrailingZeroBits == 3
|
|
doAssert I16.countTrailingZeroBits == 3
|
|
doAssert U16.firstSetBit == 4
|
|
doAssert I16.firstSetBit == 4
|
|
doAssert U16.parityBits == 0
|
|
doAssert I16.parityBits == 0
|
|
doAssert U16.countSetBits == 6
|
|
doAssert I16.countSetBits == 6
|
|
doAssert U16.rotateLeftBits(12) == 0b10000010_01110010'u16
|
|
doAssert U16.rotateRightBits(12) == 0b01110010_10000010'u16
|
|
|
|
doAssert U8.fastLog2 == 5
|
|
doAssert I8.fastLog2 == 5
|
|
doAssert U8.countLeadingZeroBits == 2
|
|
doAssert I8.countLeadingZeroBits == 2
|
|
doAssert U8.countTrailingZeroBits == 1
|
|
doAssert I8.countTrailingZeroBits == 1
|
|
doAssert U8.firstSetBit == 2
|
|
doAssert I8.firstSetBit == 2
|
|
doAssert U8.parityBits == 1
|
|
doAssert I8.parityBits == 1
|
|
doAssert U8.countSetBits == 3
|
|
doAssert I8.countSetBits == 3
|
|
doAssert U8.rotateLeftBits(3) == 0b10010001'u8
|
|
doAssert U8.rotateRightBits(3) == 0b0100_0110'u8
|
|
|
|
template test_undefined_impl(ffunc: untyped; expected: int; is_static: bool) =
|
|
doAssert ffunc(0'u8) == expected
|
|
doAssert ffunc(0'i8) == expected
|
|
doAssert ffunc(0'u16) == expected
|
|
doAssert ffunc(0'i16) == expected
|
|
doAssert ffunc(0'u32) == expected
|
|
doAssert ffunc(0'i32) == expected
|
|
doAssert ffunc(0'u64) == expected
|
|
doAssert ffunc(0'i64) == expected
|
|
|
|
template test_undefined(ffunc: untyped; expected: int) =
|
|
test_undefined_impl(ffunc, expected, false)
|
|
static:
|
|
test_undefined_impl(ffunc, expected, true)
|
|
|
|
when defined(noUndefinedBitOpts):
|
|
# check for undefined behavior with zero.
|
|
test_undefined(countSetBits, 0)
|
|
test_undefined(parityBits, 0)
|
|
test_undefined(firstSetBit, 0)
|
|
test_undefined(countLeadingZeroBits, 0)
|
|
test_undefined(countTrailingZeroBits, 0)
|
|
test_undefined(fastLog2, -1)
|
|
|
|
# check for undefined behavior with rotate by zero.
|
|
doAssert U8.rotateLeftBits(0) == U8
|
|
doAssert U8.rotateRightBits(0) == U8
|
|
doAssert U16.rotateLeftBits(0) == U16
|
|
doAssert U16.rotateRightBits(0) == U16
|
|
doAssert U32.rotateLeftBits(0) == U32
|
|
doAssert U32.rotateRightBits(0) == U32
|
|
doAssert U64A.rotateLeftBits(0) == U64A
|
|
doAssert U64A.rotateRightBits(0) == U64A
|
|
|
|
# check for undefined behavior with rotate by integer width.
|
|
doAssert U8.rotateLeftBits(8) == U8
|
|
doAssert U8.rotateRightBits(8) == U8
|
|
doAssert U16.rotateLeftBits(16) == U16
|
|
doAssert U16.rotateRightBits(16) == U16
|
|
doAssert U32.rotateLeftBits(32) == U32
|
|
doAssert U32.rotateRightBits(32) == U32
|
|
doAssert U64A.rotateLeftBits(64) == U64A
|
|
doAssert U64A.rotateRightBits(64) == U64A
|
|
|
|
block:
|
|
# basic mask operations (mutating)
|
|
var v: uint8
|
|
v.setMask(0b1100_0000)
|
|
v.setMask(0b0000_1100)
|
|
doAssert v == 0b1100_1100
|
|
v.flipMask(0b0101_0101)
|
|
doAssert v == 0b1001_1001
|
|
v.clearMask(0b1000_1000)
|
|
doAssert v == 0b0001_0001
|
|
v.clearMask(0b0001_0001)
|
|
doAssert v == 0b0000_0000
|
|
v.setMask(0b0001_1110)
|
|
doAssert v == 0b0001_1110
|
|
v.mask(0b0101_0100)
|
|
doAssert v == 0b0001_0100
|
|
block:
|
|
# basic mask operations (non-mutating)
|
|
let v = 0b1100_0000'u8
|
|
doAssert v.masked(0b0000_1100) == 0b0000_0000
|
|
doAssert v.masked(0b1000_1100) == 0b1000_0000
|
|
doAssert v.setMasked(0b0000_1100) == 0b1100_1100
|
|
doAssert v.setMasked(0b1000_1110) == 0b1100_1110
|
|
doAssert v.flipMasked(0b1100_1000) == 0b0000_1000
|
|
doAssert v.flipMasked(0b0000_1100) == 0b1100_1100
|
|
let t = 0b1100_0110'u8
|
|
doAssert t.clearMasked(0b0100_1100) == 0b1000_0010
|
|
doAssert t.clearMasked(0b1100_0000) == 0b0000_0110
|
|
block:
|
|
# basic bitslice opeartions
|
|
let a = 0b1111_1011'u8
|
|
doAssert a.bitsliced(0 .. 3) == 0b1011
|
|
doAssert a.bitsliced(2 .. 3) == 0b10
|
|
doAssert a.bitsliced(4 .. 7) == 0b1111
|
|
|
|
# same thing, but with exclusive ranges.
|
|
doAssert a.bitsliced(0 ..< 4) == 0b1011
|
|
doAssert a.bitsliced(2 ..< 4) == 0b10
|
|
doAssert a.bitsliced(4 ..< 8) == 0b1111
|
|
|
|
# mutating
|
|
var b = 0b1111_1011'u8
|
|
b.bitslice(1 .. 3)
|
|
doAssert b == 0b101
|
|
|
|
# loop test:
|
|
let c = 0b1111_1111'u8
|
|
for i in 0 .. 7:
|
|
doAssert c.bitsliced(i .. 7) == c shr i
|
|
block:
|
|
# bitslice versions of mask operations (mutating)
|
|
var a = 0b1100_1100'u8
|
|
let b = toMask[uint8](2 .. 3)
|
|
a.mask(b)
|
|
doAssert a == 0b0000_1100
|
|
a.setMask(4 .. 7)
|
|
doAssert a == 0b1111_1100
|
|
a.flipMask(1 .. 3)
|
|
doAssert a == 0b1111_0010
|
|
a.flipMask(2 .. 4)
|
|
doAssert a == 0b1110_1110
|
|
a.clearMask(2 .. 4)
|
|
doAssert a == 0b1110_0010
|
|
a.mask(0 .. 3)
|
|
doAssert a == 0b0000_0010
|
|
|
|
# composition of mask from slices:
|
|
let c = bitor(toMask[uint8](2 .. 3), toMask[uint8](5 .. 7))
|
|
doAssert c == 0b1110_1100'u8
|
|
block:
|
|
# bitslice versions of mask operations (non-mutating)
|
|
let a = 0b1100_1100'u8
|
|
doAssert a.masked(toMask[uint8](2 .. 3)) == 0b0000_1100
|
|
doAssert a.masked(2 .. 3) == 0b0000_1100
|
|
doAssert a.setMasked(0 .. 3) == 0b1100_1111
|
|
doAssert a.setMasked(3 .. 4) == 0b1101_1100
|
|
doAssert a.flipMasked(0 .. 3) == 0b1100_0011
|
|
doAssert a.flipMasked(0 .. 7) == 0b0011_0011
|
|
doAssert a.flipMasked(2 .. 3) == 0b1100_0000
|
|
doAssert a.clearMasked(2 .. 3) == 0b1100_0000
|
|
doAssert a.clearMasked(3 .. 6) == 0b1000_0100
|
|
block:
|
|
# single bit operations
|
|
var v: uint8
|
|
v.setBit(0)
|
|
doAssert v == 0x0000_0001
|
|
v.setBit(1)
|
|
doAssert v == 0b0000_0011
|
|
v.flipBit(7)
|
|
doAssert v == 0b1000_0011
|
|
v.clearBit(0)
|
|
doAssert v == 0b1000_0010
|
|
v.flipBit(1)
|
|
doAssert v == 0b1000_0000
|
|
doAssert v.testbit(7)
|
|
doAssert not v.testbit(6)
|
|
block:
|
|
# multi bit operations
|
|
var v: uint8
|
|
v.setBits(0, 1, 7)
|
|
doAssert v == 0b1000_0011
|
|
v.flipBits(2, 3)
|
|
doAssert v == 0b1000_1111
|
|
v.clearBits(7, 0, 1)
|
|
doAssert v == 0b0000_1100
|
|
block:
|
|
# signed
|
|
var v: int8
|
|
v.setBit(7)
|
|
doAssert v == -128
|
|
block:
|
|
var v: uint64
|
|
v.setBit(63)
|
|
doAssert v == 0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000'u64
|
|
|
|
block:
|
|
proc testReverseBitsInvo(x: SomeUnsignedInt) =
|
|
doAssert reverseBits(reverseBits(x)) == x
|
|
|
|
proc testReverseBitsPerType(x, reversed: uint64) =
|
|
doAssert reverseBits(x) == reversed
|
|
doAssert reverseBits(cast[uint32](x)) == cast[uint32](reversed shr 32)
|
|
doAssert reverseBits(cast[uint32](x shr 16)) == cast[uint32](reversed shr 16)
|
|
doAssert reverseBits(cast[uint16](x)) == cast[uint16](reversed shr 48)
|
|
doAssert reverseBits(cast[uint8](x)) == cast[uint8](reversed shr 56)
|
|
|
|
testReverseBitsInvo(x)
|
|
testReverseBitsInvo(cast[uint32](x))
|
|
testReverseBitsInvo(cast[uint16](x))
|
|
testReverseBitsInvo(cast[uint8](x))
|
|
|
|
proc testReverseBitsRefl(x, reversed: uint64) =
|
|
testReverseBitsPerType(x, reversed)
|
|
testReverseBitsPerType(reversed, x)
|
|
|
|
proc testReverseBitsShift(d, b: uint64) =
|
|
var
|
|
x = d
|
|
y = b
|
|
|
|
for i in 1..64:
|
|
testReverseBitsRefl(x, y)
|
|
x = x shl 1
|
|
y = y shr 1
|
|
|
|
proc testReverseBits(d, b: uint64) =
|
|
testReverseBitsShift(d, b)
|
|
|
|
testReverseBits(0x0u64, 0x0u64)
|
|
testReverseBits(0xffffffffffffffffu64, 0xffffffffffffffffu64)
|
|
testReverseBits(0x0123456789abcdefu64, 0xf7b3d591e6a2c480u64)
|
|
testReverseBits(0x5555555555555555u64, 0xaaaaaaaaaaaaaaaau64)
|
|
testReverseBits(0x5555555500000001u64, 0x80000000aaaaaaaau64)
|
|
testReverseBits(0x55555555aaaaaaaau64, 0x55555555aaaaaaaau64)
|
|
testReverseBits(0xf0f0f0f00f0f0f0fu64, 0xf0f0f0f00f0f0f0fu64)
|
|
testReverseBits(0x181881810ff00916u64, 0x68900ff081811818u64)
|
|
|
|
echo "OK"
|
|
|
|
# bug #7587
|
|
doAssert popcount(0b11111111'i8) == 8
|
|
|
|
block: # not ready for vm because exception is compile error
|
|
try:
|
|
var v: uint32
|
|
var i = 32
|
|
v.setBit(i)
|
|
doAssert false
|
|
except RangeDefect:
|
|
discard
|
|
except:
|
|
doAssert false
|
|
|
|
|
|
main()
|
|
static:
|
|
# test everything on vm as well
|
|
main()
|