Add Xoroshiro and Xoshiro random number generators

Author: wigging

Sources/Numerix/Documentation.docc/Random.md

@@ -9,6 +9,9 @@ Numerix provides random number generators
 ## Topics
 
 - ``Wyrand``
+- ``Xoshiro128Plus``
+- ``Xoroshiro128Plus``
+- ``Xoroshiro128PlusPlus``
 - ``Vector/random(size:seed:)``
 - ``Vector/randomDistribution(size:dist:)``
 - ``Vector/randomBNNS(size:bounds:seed:)``

Sources/Numerix/RandomModule/Wyrand.swift

@@ -23,11 +23,17 @@ public struct Wyrand: RandomNumberGenerator {
         return mul.low ^ mul.high
     }
 
+    /// Generate a random single-precision value from a uniform distribution over [0, 1) which includes zero but
+    /// excludes one.
+    /// - Returns: Random single-precision value.
     public mutating func nextUniform() -> Float {
         let x = self.next()
         return Float(x >> 40) * 0x1.0p-24
     }
 
+    /// Generate a random double-precision value from a uniform distribution over [0, 1) which includes zero but
+    /// excludes one.
+    /// - Returns: Random double-precision value.
     public mutating func nextUniform() -> Double {
         let x = self.next()
         return Double(x >> 11) * 0x1.0p-53

Sources/Numerix/RandomModule/Xoroshiro.swift

@@ -0,0 +1,69 @@
+/*
+Xoroshiro128+ and Xoroshiro128++ pseudorandom number generators (PRNGs).
+*/
+
+import Accelerate
+
+func rotl(_ x: UInt64, _ k: Int) -> UInt64 {
+    (x &<< k) | (x &>> (64 &- k))
+}
+
+/// Xoroshiro128+ is a 64-bit pseudorandom number generator (PRNG) for double-precision values.
+public struct Xoroshiro128Plus: RandomNumberGenerator {
+    private var state: (UInt64, UInt64)
+
+    public init(seed: (UInt64, UInt64)? = nil) {
+        let a = UInt64.random(in: 0..<UInt64.max)
+        let b = UInt64.random(in: 0..<UInt64.max)
+        state = seed ?? (a, b)
+    }
+
+    public mutating func next() -> UInt64 {
+        let s0 = state.0
+        var s1 = state.1
+        let result = s0 &+ s1
+
+        s1 ^= s0
+        state.0 = rotl(s0, 24) ^ s1 ^ (s1 << 16)
+        state.1 = rotl(s1, 37)
+
+        return result
+    }
+
+    /// Generate a random double-precision value from a uniform distribution over [0, 1) which includes zero but
+    /// excludes one.
+    /// - Returns: Random double-precision value.
+    public mutating func next() -> Double {
+        Double(next() >> 11) * 0x1.0p-53
+    }
+}
+
+/// Xoroshiro128++ is a 64-bit pseudorandom number generator (PRNG) for double-precision values.
+public struct Xoroshiro128PlusPlus: RandomNumberGenerator {
+    private var state: (UInt64, UInt64)
+
+    public init(seed: (UInt64, UInt64)? = nil) {
+        let a = UInt64.random(in: 0..<UInt64.max)
+        let b = UInt64.random(in: 0..<UInt64.max)
+        state = seed ?? (a, b)
+    }
+
+    public mutating func next() -> UInt64 {
+        let s0 = state.0
+        var s1 = state.1
+        let result = rotl(s0 &+ s1, 17) &+ s0
+
+        s1 ^= s0
+        state.0 = rotl(s0, 49) ^ s1 ^ (s1 << 21)
+        state.1 = rotl(s1, 28)
+
+        return result
+    }
+    
+    /// Generate a random double-precision value from a uniform distribution over [0, 1) which includes zero but
+    /// excludes one.
+    /// - Returns: Random double-precision value.
+    public mutating func next() -> Double {
+        Double(next() >> 11) * 0x1.0p-53
+    }
+}

Sources/Numerix/RandomModule/Xoshiro.swift

@@ -0,0 +1,37 @@
+/*
+Xoshiro128+ pseudorandom number generator (PRNG).
+*/
+
+import Accelerate
+
+/// Xoshiro128+ is a 32-bit pseudorandom number generator (PRNG) for single-precision (floating point) values.
+public struct Xoshiro128Plus {
+    private var state: (UInt32, UInt32, UInt32, UInt32)
+
+    public init(seed: (UInt32, UInt32, UInt32, UInt32)? = nil) {
+        state = seed ?? (arc4random(), arc4random(), arc4random(), arc4random())
+    }
+
+    public mutating func next() -> UInt32 {
+        let result = state.0 &+ state.3
+        let t = state.1 << 9
+
+        state.2 ^= state.0
+        state.3 ^= state.1
+        state.1 ^= state.2
+        state.0 ^= state.3
+
+        state.2 ^= t
+
+        state.3 = (state.3 << 11) | (state.3 >> (32 - 11))
+
+        return result
+    }
+
+    /// Generate a random single-precision value from a uniform distribution over [0, 1) which includes zero but
+    /// excludes one.
+    /// - Returns: Random single-precision value.
+    public mutating func next() -> Float {
+        Float(next() >> 8) * 0x1.0p-24
+    }
+}

Tests/RandomTests.swift

@@ -3,11 +3,11 @@ Tests for random numbers and random vectors.
 */
 
 import Testing
-@testable import Numerix
+import Numerix
 
 struct RandomTests {
 
-    @Test func randomWyRand() {
+    @Test func wyrand() {
         var rand = Wyrand(seed: 12345)
         #expect(rand.next() == 13157676964440363053)
 
@@ -18,6 +18,22 @@ struct RandomTests {
         #expect(b ==  0.7952823641045631)
     }
 
+    @Test func xoshiro() {
+        var rng = Xoshiro128Plus(seed: (2719949631, 2719949631, 2719949631, 2719949631))
+        let a: Float = rng.next()
+        #expect(a == 0.26657522)
+    }
+
+    @Test func xoroshiro() {
+        var rng = Xoroshiro128Plus(seed: (12274935454779349997, 7213431619994351707))
+        let a: Double = rng.next()
+        #expect(a == 0.05646649603323106)
+
+        var rngg = Xoroshiro128PlusPlus(seed: (12274935454779349997, 7213431619994351707))
+        let b: Double = rngg.next()
+        #expect(b == 0.8419936520290631)
+    }
+
     @Test func randomVector() {
         // No seed
         let a = Vector<Float>.random(size: 3)