192 lines
5.2 KiB
Nim
192 lines
5.2 KiB
Nim
# optimized bit-shifting versions of the FixedSequence substack operations
|
|
import bitops, macros
|
|
import colors
|
|
|
|
|
|
macro show(expr: untyped) =
|
|
let node = expr.toStrLit
|
|
quote do:
|
|
echo `node`, " => ", `expr`
|
|
|
|
|
|
proc getMasks(): (array[9, uint64], array[9, uint64]) =
|
|
# on little-endian architectures, casting an array[8, Color] to uint64 effectively
|
|
# reverses it. So we switch these masks so that we can refer to them consistently.
|
|
let
|
|
left = [
|
|
0'u64,
|
|
0xff_00_00_00_00_00_00_00'u64,
|
|
0xff_ff_00_00_00_00_00_00'u64,
|
|
0xff_ff_ff_00_00_00_00_00'u64,
|
|
0xff_ff_ff_ff_00_00_00_00'u64,
|
|
0xff_ff_ff_ff_ff_00_00_00'u64,
|
|
0xff_ff_ff_ff_ff_ff_00_00'u64,
|
|
0xff_ff_ff_ff_ff_ff_ff_00'u64,
|
|
0xff_ff_ff_ff_ff_ff_ff_ff'u64,
|
|
]
|
|
right = [
|
|
0'u64,
|
|
0x00_00_00_00_00_00_00_ff'u64,
|
|
0x00_00_00_00_00_00_ff_ff'u64,
|
|
0x00_00_00_00_00_ff_ff_ff'u64,
|
|
0x00_00_00_00_ff_ff_ff_ff'u64,
|
|
0x00_00_00_ff_ff_ff_ff_ff'u64,
|
|
0x00_00_ff_ff_ff_ff_ff_ff'u64,
|
|
0x00_ff_ff_ff_ff_ff_ff_ff'u64,
|
|
0xff_ff_ff_ff_ff_ff_ff_ff'u64,
|
|
]
|
|
when cpuEndian == bigEndian:
|
|
result = (left, right)
|
|
when cpuEndian == littleEndian:
|
|
result = (right, left)
|
|
|
|
|
|
type ShiftStack* = FixedSeq[8, Color, int8]
|
|
const (masksLeft, masksRight) = getMasks()
|
|
|
|
|
|
template `shl`(a: array[8, Color], offset: Natural): array[8, Color] =
|
|
when cpuEndian == bigEndian:
|
|
cast[array[8, Color]](cast[uint64](a) shl (offset * 8))
|
|
when cpuEndian == littleEndian: # direction is reversed
|
|
cast[array[8, Color]](cast[uint64](a) shr (offset * 8))
|
|
|
|
|
|
template `shr`(a: array[8, Color], offset: Natural): array[8, Color] =
|
|
when cpuEndian == bigEndian:
|
|
cast[array[8, Color]](cast[uint64](a) shr (offset * 8))
|
|
when cpuEndian == littleEndian:
|
|
cast[array[8, Color]](cast[uint64](a) shl (offset * 8))
|
|
|
|
|
|
template `and`(a: array[8, Color], mask: uint64): array[8, Color] =
|
|
cast[array[8, Color]](cast[uint64](a) and mask)
|
|
|
|
|
|
template `or`(a: array[8, Color], mask: uint64): array[8, Color] =
|
|
cast[array[8, Color]](cast[uint64](a) or mask)
|
|
|
|
|
|
template `or`(a: array[8, Color], mask: array[8, Color]): array[8, Color] =
|
|
cast[array[8, Color]](cast[uint64](a) or cast[uint64](mask))
|
|
|
|
|
|
import strutils # remove later
|
|
proc moveSubstack*(src, dst: var ShiftStack; start: Natural) =
|
|
# shift the source stack to position the substack above its final resting place
|
|
# offset is the length of the destination stack, minus the number of items NOT being moved
|
|
# number of items not being moved is the same as the start index
|
|
var substack: array[8, Color]
|
|
if dst.len == start: # no shift necessary in this case
|
|
substack = src.data
|
|
elif dst.len > start:
|
|
substack = src.data shr (dst.len - start)
|
|
elif dst.len < start:
|
|
substack = src.data shl (start - dst.len)
|
|
# next, mask the source data to present only the items being moved
|
|
# dst.len of 0 corresponds to last mask in masksRight, aka masksRight[^1]
|
|
substack = substack and masksRight[^(dst.len + 1)]
|
|
# then combine
|
|
dst.data = dst.data or substack
|
|
# then git rid of the moved items from the source stack
|
|
src.data = src.data and masksLeft[start]
|
|
# a little bookkeeping
|
|
let ssLen = int8(src.len - start)
|
|
src.last -= ssLen
|
|
dst.last += ssLen
|
|
|
|
|
|
proc moveSubstackPre*(src, dst: var ShiftStack; start: Natural) =
|
|
let ssLen = int8(src.len - start)
|
|
# shift the destination stack to make room for the new items
|
|
dst.data = dst.data shr ssLen
|
|
# shift source stack to line up the substack with its final resting place
|
|
let substack = src.data shl start
|
|
# combine
|
|
dst.data = dst.data or substack
|
|
# get rid of the moved items
|
|
src.data = src.data and masksLeft[start]
|
|
# more bookkeeping
|
|
src.last -= ssLen
|
|
dst.last += ssLen
|
|
|
|
|
|
proc testMove[T1, T2: FixedSeq](a1, a2: var T1; b1, b2: var T2; i: Natural): bool =
|
|
let (orig_a1, orig_a2) = (a1, a2)
|
|
let (orig_b1, orig_b2) = (b1, b2)
|
|
a1.moveSubstack(a2, i)
|
|
b1.moveSubstack(b2, i)
|
|
if a1 != b1 or a2 != b2:
|
|
echo "Failed!"
|
|
show orig_b1
|
|
show orig_b2
|
|
echo "<<move ", i, ">>"
|
|
show b1
|
|
show b2
|
|
return false
|
|
return true
|
|
|
|
|
|
when isMainModule:
|
|
var c1 = initFixedSeq(5, Color, int8)
|
|
var c2 = initFixedSeq(5, Color, int8)
|
|
|
|
var s1: ShiftStack
|
|
s1.initFixedSeq
|
|
var s2: ShiftStack
|
|
s2.initFixedSeq
|
|
|
|
c1.add(cPurple)
|
|
c1.add(cRed)
|
|
c1.add(cYellow)
|
|
c1.add(cBlue)
|
|
c1.add(cGreen)
|
|
|
|
s1.add(cPurple)
|
|
s1.add(cRed)
|
|
s1.add(cYellow)
|
|
s1.add(cBlue)
|
|
s1.add(cGreen)
|
|
|
|
# show s1
|
|
# show s2
|
|
# echo "<<move 2>>"
|
|
# s1.moveSubstack(s2, 2)
|
|
# show s1
|
|
# show s2
|
|
|
|
import random
|
|
randomize()
|
|
var r = initRand(rand(int64))
|
|
var success = true
|
|
|
|
for n in 1 .. 1_000_000:
|
|
var ranFirst, ranSecond: bool
|
|
|
|
if c1.len > 0:
|
|
let i = r.rand(c1.high)
|
|
ranFirst = true
|
|
if not testMove(c1, c2, s1, s2, i):
|
|
success = false
|
|
echo "Failed after ", n, " iterations."
|
|
break
|
|
else:
|
|
ranFirst = false
|
|
|
|
if c2.len > 0:
|
|
let j = r.rand(c2.high)
|
|
ranSecond = true
|
|
if not testMove(c2, c1, s2, s1, j):
|
|
success = false
|
|
echo "Failed after ", n, " iterations."
|
|
break
|
|
else:
|
|
ranSecond = false
|
|
|
|
if (not ranFirst) and (not ranSecond):
|
|
echo "Ran neither first nor second move."
|
|
break
|
|
|
|
if success:
|
|
echo "Success."
|