switch to fastrand (not actually any faster)

colors.nim

@@ -1,17 +0,0 @@
-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]

combinators.nim

@@ -1,5 +1,5 @@
 import algorithm, random, sugar
-import fixedseq, game
+import fastrand, fixedseq, game
 
 
 proc nextPermutation(x: var FixedSeq): bool =
@@ -93,4 +93,4 @@ proc randomFuture*(dice: FixedSeq, r: var Rand): FixedSeq[5, Die, int8] =
   result.initFixedSeq
   let order = dice.dup(shuffle(r))
   for i, color in order:
-    result.add((color, r.rand(1..3)))
+    result.add((color, r.fastRand(1..3)))

fastrand.nim

@@ -0,0 +1,74 @@
+import random, math
+import times, std/monotimes, strformat, strutils
+
+
+proc formatNum(n: SomeNumber): string =
+  let s = $(n.round)
+  let t = s[0 .. s.len - 3]
+  var count = 1
+  for i in countdown(t.high, 0):
+    result.insert($t[i], 0)
+    if count mod 3 == 0 and i != 0:
+      result.insert(",", 0)
+    count += 1
+
+
+proc formatRate(n: Natural, d: Duration): string =
+  result = formatNum(1_000_000'f64 * n.float64 / d.inMicroseconds.float64)
+
+
+const upperBound = uint64(uint32.high)
+
+
+proc fastRand*[T: Natural](r: var Rand, x: T): T =
+  # Nim ranges are usually inclusive, but this algorithm is exclusive
+  let x = x.uint64 + 1
+  let num = if x <= upperBound:
+    ((r.next shr 32) * x.uint64) shr 32
+  else:
+    r.next mod x.uint64
+  result = T(num)
+
+
+proc fastRand*(r: var Rand; x, y: Natural): Natural =
+  let lim = (y - x)
+  result = fastRand(r, lim) + x
+
+
+proc fastRand*[T](r: var Rand, slice: HSlice[T, T]): T =
+  let n = fastRand(r, slice.a.Natural, slice.b.Natural)
+  result = T(n)
+
+
+proc testFastRand(num = 1_000_000_000): Duration =
+  var r = initRand(rand(int64))
+  let start = getMonoTime()
+  for i in 1 .. num:
+    discard r.fastRand(5)
+  result = getMonoTime() - start
+  # echo "fastrand execution rate: ",  1000 * num / dur.inMilliseconds.int, " generated per second."
+
+
+proc testStdRand(num = 1_000_000_000): Duration =
+  var r = initRand(rand(int64))
+  let start = getMonoTime()
+  for i in 1 .. num:
+    discard r.rand(4)
+  result = getMonoTime() - start
+  # echo "std rand execution rate: ", 1000 * num / dur.inMilliseconds.int, " generated per second."
+
+
+when isMainModule:
+  randomize()
+  var r = initRand(rand(int64))
+  let runs = 100_000_000
+  var totals: array[5..9, int]
+  for i in 1 .. runs:
+    let n = r.fastRand(5..9)
+    totals[n] += 1
+  echo totals
+
+  # let fr = testFastRand(runs)
+  # echo "fastrand execution rate: ", formatNum(1_000_000 * runs / fr.inMicroseconds.int)
+  # let sr = testStdRand(runs)
+  # echo "standard execution rate: ", formatNum(1_000_000 * runs / sr.inMicroseconds.int)

fixedseq.nim

@@ -25,16 +25,6 @@ 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.")
@@ -134,7 +124,7 @@ proc shuffle*(s: var FixedSeq, r: var Rand) =
 
 
 proc moveSubstack*(src, dst: var FixedSeq; start: Natural) =
-  var count: FixedSeq.Pointer = 0 # have to track this separately apparently
+  var count: typeof(src.last) = 0 # have to track this separately apparently
   for idx in start .. src.last:
     swap(src.data[idx], dst.data[dst.last + 1 + count])
     inc count
@@ -143,7 +133,7 @@ proc moveSubstack*(src, dst: var FixedSeq; start: Natural) =
 
 
 proc moveSubstackPre*(src, dst: var FixedSeq; start: Natural) =
-  let ssLen = FixedSeq.Pointer(src.last - start + 1) # length of substack
+  let ssLen = typeof(src.last)(src.last - start + 1) # length of substack
   for i in countdown(dst.last, 0):
     swap(dst.data[i], dst.data[i + ssLen])
 
@@ -154,5 +144,3 @@ proc moveSubstackPre*(src, dst: var FixedSeq; start: Natural) =
 
   dst.last += ssLen
   src.last -= ssLen
-
-include shiftstack

game.nim

@@ -1,9 +1,11 @@
 import hashes, options
-import fixedseq, colors
-export colors
+import fixedseq
 
 
 type
+  Color* = enum
+    cRed, cGreen, cBlue, cYellow, cPurple
+
   ColorStack* = FixedSeq[5, Color, int8]
 
 
@@ -11,7 +13,27 @@ proc initColorStack*: ColorStack =
   result.initFixedSeq
 
 
-proc `$`*[T](s: FixedSeq[T, Color, int8]): string =
+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 `$`*(s: ColorStack): string =
   result.add("St@[")
   for i, color in s:
     result.add($color)
@@ -28,7 +50,7 @@ type
     tForward = 1
 
   Square* = object
-    camels*: ShiftStack
+    camels*: ColorStack
     tile*: Option[Tile]
 
   Board* = object

shiftstack.nim

@@ -1,191 +0,0 @@
-# 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."

test.nim

@@ -1,7 +1,32 @@
-import math, random, strformat, times
+import math, random, strformat, times, std/monotimes
 import fixedseq, game, simulation, ui
 
 
+type
+  TestResults = object
+    ops: int
+    time: Duration
+
+
+proc summarize(tr: TestResults) =
+  let secs = tr.time.inMilliseconds.float / 1000
+  stdout.write("Test completed:\n")
+  stdout.write("  " & $tr.ops, " operations in " & $round(secs, 2) & " seconds\n")
+  stdout.write("  " & $round(tr.ops.float / secs, 2) & " operations per second")
+  stdout.flushFile()
+
+
+template executionTime(body: untyped): Duration =
+  let start = getMonoTime()
+  body
+  getMonoTime() - start
+
+
+proc getRand(): Rand =
+  randomize()
+  result = initRand(rand(int64))
+
+
 proc randomDice(r: var Rand): seq[tuple[c: Color, p: int]] = 
   for c in Color:
     let v = r.rand(1..3)
@@ -18,18 +43,15 @@ proc newRandomGame(r: var Rand): Board =
   result.setState(dice, [])
 
 
-proc testGames(n: SomeInteger = 100): auto =
-  var r = initRand(rand(int64))
-  let dice = randomDice(r)
-  var b: Board
-  b.init
-  b.setState(dice, [])
-  b.display(1, 5)
-
-  let startTime = cpuTime()
-  let scores = b.randomGames(n, parallel = true)
-  result = cpuTime() - startTime
-  scores.display()
+proc games(nTests, nSamples: SomeInteger, parallel = true): TestResults =
+  var r = getRand()
+  var scores: ScoreSet
+  for i in 1 .. nTests:
+    let b = newRandomGame(r)
+    let dur = executionTime:
+        let s = b.randomGames(nSamples, parallel = parallel)
+    result.ops += s.sum()
+    result.time += dur
 
 
 proc testLegs(n: Natural = 100): auto =
@@ -72,24 +94,4 @@ proc testSpread(nTests, nSamples: Natural) =
 
 
 when isMainModule:
-  randomize()
-  # var r = initRand(rand(int64))
-  # let b = newRandomGame(r)
-  # b.display(1, 5)
-  # echo b.showSpaces(1, 16)
-
-  # let scores = b.getLegScores
-  # 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:
-    let num_games = 100_000_005
-    let executionTime = testGames(num_games)
-    echo "Execution time: ", executionTime
-    echo "Full-game simulations per second: ", float(num_games) / executionTime
-    echo ""
-
-  # testSpread(100, 1_000_000)
+  games(10, 10_000_000).summarize()