mt.pony

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
class MT is Random
  """
  A Mersenne Twister. This is a non-cryptographic random number generator. This
  should only be used for legacy applications that require a Mersenne Twister,
  otherwise use Rand.
  """
  embed _state: Array[U64]
  var _index: USize

  new create(x: U64 = 5489, y: U64 = 0) =>
    """
    Create with the specified seed. Returned values are deterministic for a
    given seed.
    """
    _state = Array[U64](_n())
    _index = _n()

    var seed = x xor y

    _state.push(seed)
    var i: USize = 1

    while i < _n() do
      seed = ((seed xor (seed >> 62)) * 6364136223846793005) + i.u64()
      _state.push(seed)
      i = i + 1
    end

  fun ref next(): U64 =>
    """
    A random integer in [0, 2^64)
    """
    if _index >= _n() then
      _populate()
    end

    try
      var x = _state(_index)?
      _index = _index + 1

      x = x xor ((x >> 29) and 0x5555555555555555)
      x = x xor ((x << 17) and 0x71d67fffeda60000)
      x = x xor ((x << 37) and 0xfff7eee000000000)
      x xor (x >> 43)
    else
      0
    end

  fun ref _populate() =>
    """
    Repopulates the state array.
    """
    try
      _index = 0
      var x = _state(0)?
      var i: USize = 0

      while i < _m() do
        x = _lower(i, x)?
        i = i + 1
      end

      x = _state(_m())?
      i = _m()

      while i < _n1() do
        x = _upper(i, x)?
        i = i + 1
      end

      _wrap()?
    end

  fun tag _n(): USize => 312
  fun tag _m(): USize => 156
  fun tag _n1(): USize => _n() - 1

  fun tag _mask(x: U64, y: U64): U64 =>
    (x and 0xffffffff80000000) or (y and 0x000000007fffffff)

  fun tag _matrix(x: U64): U64 => (x and 1) * 0xb5026f5aa96619e9

  fun tag _mix(x: U64, y: U64): U64 =>
    let z = _mask(x, y)
    (z >> 1) xor _matrix(z)

  fun ref _lower(i: USize, x: U64): U64 ? =>
    let y = _state(i + 1)?
    _state(i)? = _state(i + _m())? xor _mix(x, y)
    y

  fun ref _upper(i: USize, x: U64): U64 ? =>
    let y = _state(i + 1)?
    _state(i)? = _state(i - _m())? xor _mix(x, y)
    y

  fun ref _wrap(): U64 ? =>
    let x = _state(_n1())?
    let y = _state(0)?
    _state(_n1())? = _state(_m() - 1)? xor _mix(x, y)
    y