Swift 4.2+ ensemence un générateur de nombres aléatoires

Alors je Martin R suggestion de l'utilisation GamePlayKit de GKMersenneTwisterRandomSource pour faire une classe qui était conforme au protocole RandomNumberGenerator, que j'ai pu utiliser une instance de fonctions comme Int.random() :

// Make a random seed and store in a database
let seed = UInt64.random(in: UInt64.min ... UInt64.max)
var generator = Generator(seed: seed)
// Or if you just need the seeding ability for testing,
// var generator = Generator()
// uses a default seed of 0

let chars = ['a','b','c','d','e','f']
let randomChar = chars.randomElement(using: &generator)
let randomInt = Int.random(in: 0 ..< 1000, using: &generator)
// etc.

Usage:

import GameplayKit

class SeededGenerator: RandomNumberGenerator {
    let seed: UInt64
    private let generator: GKMersenneTwisterRandomSource
    convenience init() {
        self.init(seed: 0)
    }
    init(seed: UInt64) {
        self.seed = seed
        generator = GKMersenneTwisterRandomSource(seed: seed)
    }
    func next<T>(upperBound: T) -> T where T : FixedWidthInteger, T : UnsignedInteger {
        return T(abs(generator.nextInt(upperBound: Int(upperBound))))
    }
    func next<T>() -> T where T : FixedWidthInteger, T : UnsignedInteger {
        return T(abs(generator.nextInt()))
    }
}

Cela m'a donné la flexibilité et l'implémentation facile dont j'avais besoin en combinant la fonctionnalité d' GKMersenneTwisterRandomSource de GKMersenneTwisterRandomSource et la simplicité des fonctions aléatoires de la bibliothèque standard (comme .randomElement() pour les tableaux et .random() pour Int, Bool, Double, etc.)

Voici une alternative à la réponse de RPatel99 qui prend en compte la plage de valeurs GKRandom.

import GameKit

struct ArbitraryRandomNumberGenerator : RandomNumberGenerator {

    mutating func next() -> UInt64 {
        // GKRandom produces values in [INT32_MIN, INT32_MAX] range; hence we need two numbers to produce 64-bit value.
        let next1 = UInt64(bitPattern: Int64(gkrandom.nextInt()))
        let next2 = UInt64(bitPattern: Int64(gkrandom.nextInt()))
        return next1 ^ (next2 << 32)
    }

    init(seed: UInt64) {
        self.gkrandom = GKMersenneTwisterRandomSource(seed: seed)
    }

    private let gkrandom: GKRandom
}

var g = SystemRandomNumberGenerator()

lazy private var random1 = Double.random(in: 0..<1, using: &self.g)
Ref:https://developer.apple.com/documentation/swift/systemrandomnumbergenerator

On dirait que l'implémentation par Swift de RandomNumberGenerator.next(using:) changé en 2019 . Cela affecte Collection.randomElement(using:) et l'oblige à toujours renvoyer le premier élément si l'implémentation next()->UInt64 votre générateur ne produit pas de valeurs uniformément dans le domaine de UInt64 . La solution GKRandom fournie ici est donc problématique car c'est la méthode suivante- next->Int :

public struct ARC4RandomNumberGenerator: RandomNumberGenerator {
  var state: [UInt8] = Array(0...255)
  var iPos: UInt8 = 0
  var jPos: UInt8 = 0

  /// Initialize ARC4RandomNumberGenerator using an array of UInt8. The array
  /// must have length between 1 and 256 inclusive.
  public init(seed: [UInt8]) {
    precondition(seed.count > 0, "Length of seed must be positive")
    precondition(seed.count <= 256, "Length of seed must be at most 256")
    var j: UInt8 = 0
    for i: UInt8 in 0...255 {
      j &+= S(i) &+ seed[Int(i) % seed.count]
      swapAt(i, j)
    }
  }

  // Produce the next random UInt64 from the stream, and advance the internal
  // state.
  public mutating func next() -> UInt64 {
    var result: UInt64 = 0
    for _ in 0..<UInt64.bitWidth / UInt8.bitWidth {
      result <<= UInt8.bitWidth
      result += UInt64(nextByte())
    }
    print(result)
    return result
  }

  // Helper to access the state.
  private func S(_ index: UInt8) -> UInt8 {
    return state[Int(index)]
  }

  // Helper to swap elements of the state.
  private mutating func swapAt(_ i: UInt8, _ j: UInt8) {
    state.swapAt(Int(i), Int(j))
  }

  // Generates the next byte in the keystream.
  private mutating func nextByte() -> UInt8 {
    iPos &+= 1
    jPos &+= S(iPos)
    swapAt(iPos, jPos)
    return S(S(iPos) &+ S(jPos))
  }
}

Voici une solution qui fonctionne pour moi en utilisant le RNG dans TensorFlow de Swift trouvé ici :

     * The value is in the range of [INT32_MIN, INT32_MAX].

Pointe du chapeau à mes collègues Samuel, Noah et Stephen qui m'ont aidé à aller au fond des choses.