switch to bitshifting operations (turns out to be slower, oh well)

colors.nim

@@ -0,0 +1,17 @@
+type
+  Color* = enum
+    cRed, cGreen, cBlue, cYellow, cPurple
+
+
+const 
+  colorNames: array[Color, string] =
+    ["Red", "Green", "Blue", "Yellow", "Purple"]
+  colorAbbrevs: array[Color, char] = ['R', 'G', 'B', 'Y', 'P']
+
+
+proc `$`*(c: Color): string =
+  result = colorNames[c]
+
+
+proc abbrev*(c: Color): char =
+  result = colorAbbrevs[c]

config.nims

@@ -1,5 +1,5 @@
-# --threads: on
+--threads: on
-# --d: release
+--d: release
-# --opt: speed
+--opt: speed
-# --passC: -flto
+--passC: -flto
-# --passL: -flto
+--passL: -flto

fixedseq.nim

@@ -25,6 +25,16 @@ proc `$`*(s: FixedSeq): string =
   result.add("]")
 
 
+proc `==`*[T1: FixedSeq, T2: FixedSeq](a: T1, b: T2): bool =
+  # generics are so that we can compare ShiftStack vs regular FixedSeq
+  if a.len != b.len:
+    return false
+  for i in 0 ..< a.len:
+    if a.data[i] != b.data[i]:
+      return false
+  return true
+
+
 proc `[]`*(s: FixedSeq, i: Natural): FixedSeq.Contents =
   if i > s.last:
     raise newException(IndexDefect, "index " & $i & " is out of bounds.")

game.nim

@@ -1,11 +1,9 @@
 import hashes, options
-import fixedseq
+import fixedseq, colors
+export colors
 
 
 type
-  Color* = enum
-    cRed, cGreen, cBlue, cYellow, cPurple
-
   ColorStack* = FixedSeq[5, Color, int8]
 
 
@@ -13,26 +11,6 @@ proc initColorStack*: ColorStack =
   result.initFixedSeq
 
 
-proc getAllColors: ColorStack = 
-  var i = 0
-  for c in Color.low .. Color.high:
-    result[i] = c
-
-const 
-  allColors* = getAllColors()
-  colorNames: array[Color, string] =
-    ["Red", "Green", "Blue", "Yellow", "Purple"]
-  colorAbbrevs: array[Color, char] = ['R', 'G', 'B', 'Y', 'P']
-
-
-proc `$`*(c: Color): string =
-  result = colorNames[c]
-
-
-proc abbrev*(c: Color): char =
-  result = colorAbbrevs[c]
-
-
 proc `$`*[T](s: FixedSeq[T, Color, int8]): string =
   result.add("St@[")
   for i, color in s:
@@ -50,7 +28,7 @@ type
     tForward = 1
 
   Square* = object
-    camels*: ColorStack
+    camels*: ShiftStack
     tile*: Option[Tile]
 
   Board* = object

shiftstack.nim

@@ -1,6 +1,6 @@
 # optimized bit-shifting versions of the FixedSequence substack operations
 import bitops, macros
-import game
+import colors
 
 
 macro show(expr: untyped) =
@@ -10,9 +10,8 @@ macro show(expr: untyped) =
 
 
 proc getMasks(): (array[9, uint64], array[9, uint64]) =
-  # on little-endian architectures, casting an array[8, Color]
+  # on little-endian architectures, casting an array[8, Color] to uint64 effectively
-  # to uint64 effectively reverses it. So we switch these masks
+  # reverses it. So we switch these masks so that we can refer to them consistently.
-  # so that we can refer to them consistently.
   let 
     left = [
       0'u64,
@@ -42,7 +41,7 @@ proc getMasks(): (array[9, uint64], array[9, uint64]) =
     result = (right, left)
 
 
-type ShiftStack = FixedSeq[8, Color, int8]
+type ShiftStack* = FixedSeq[8, Color, int8]
 const (masksLeft, masksRight) = getMasks()
 
 
@@ -78,11 +77,12 @@ proc moveSubstack*(src, dst: var ShiftStack; start: Natural) =
   # 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, otherwise:
+  if dst.len == start: # no shift necessary in this case
-  if dst.len > start:
+    substack = src.data
+  elif dst.len > start:
     substack = src.data shr (dst.len - start)
   elif dst.len < start:
-    substack = src.data shl (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)]
@@ -111,25 +111,16 @@ proc moveSubstackPre*(src, dst: var ShiftStack; start: Natural) =
   dst.last += ssLen
 
 
-proc `==`[T1: FixedSeq, T2: FixedSeq](a: T1, b: T2): bool =
-  if a.len != b.len:
-    return false
-  for i in 0 ..< a.len:
-    if a.data[i] != b.data[i]:
-      return false
-  return true
-
-
 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.moveSubstackPre(a2, i)
+  a1.moveSubstack(a2, i)
-  b1.moveSubstackPre(b2, i)
+  b1.moveSubstack(b2, i)
   if a1 != b1 or a2 != b2:
     echo "Failed!"
     show orig_b1
     show orig_b2
-    echo "<< move ", i, ">>"
+    echo "<<move ", i, ">>"
     show b1
     show b2
     return false
@@ -145,16 +136,22 @@ when isMainModule:
   var s2: ShiftStack
   s2.initFixedSeq
 
-  # s1.add(cPurple)
+  c1.add(cPurple)
-  # s1.add(cRed)
+  c1.add(cRed)
-  # s1.add(cYellow)
+  c1.add(cYellow)
-  # s1.add(cBlue)
+  c1.add(cBlue)
-  # s1.add(cGreen)
+  c1.add(cGreen)
+
+  s1.add(cPurple)
+  s1.add(cRed)
+  s1.add(cYellow)
+  s1.add(cBlue)
+  s1.add(cGreen)
 
   # show s1
   # show s2
-  # echo "<<move 4>>"
+  # echo "<<move 2>>"
-  # s1.moveSubstack(s2, 4)
+  # s1.moveSubstack(s2, 2)
   # show s1
   # show s2
 
@@ -163,20 +160,32 @@ when isMainModule:
   var r = initRand(rand(int64))
   var success = true
 
-  for n in 1 .. 10000:
+  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."

test.nim

@@ -27,7 +27,7 @@ proc testGames(n: SomeInteger = 100): auto =
   b.display(1, 5)
 
   let startTime = cpuTime()
-  let scores = b.randomGames(n)
+  let scores = b.randomGames(n, parallel = true)
   result = cpuTime() - startTime
   scores.display()
 
@@ -73,23 +73,23 @@ proc testSpread(nTests, nSamples: Natural) =
 
 when isMainModule:
   randomize()
-  var r = initRand(rand(int64))
+  # var r = initRand(rand(int64))
-  let b = newRandomGame(r)
+  # let b = newRandomGame(r)
-  b.display(1, 5)
+  # b.display(1, 5)
-  echo b.showSpaces(1, 16)
+  # echo b.showSpaces(1, 16)
 
-  let scores = b.getLegScores
+  # let scores = b.getLegScores
-  echo scores.showPercents
+  # echo scores.showPercents
   # let start_states = 2_000
   # let executionTime = testLegs(start_states)
   # echo "Execution time: ", executionTime
   # echo "Leg simulations per second: ", float(start_states * 29_160) / executionTime
 
-  # for i in 1 .. 1:
+  for i in 1 .. 1:
-  #   let num_games = 100_000_005
+    let num_games = 100_000_005
-  #   let executionTime = testGames(num_games)
+    let executionTime = testGames(num_games)
-  #   echo "Execution time: ", executionTime
+    echo "Execution time: ", executionTime
-  #   echo "Full-game simulations per second: ", float(num_games) / executionTime
+    echo "Full-game simulations per second: ", float(num_games) / executionTime
-  #   echo ""
+    echo ""
 
   # testSpread(100, 1_000_000)