Compiler Explorer

Source code

// fills a buffer with random bytes, the bytes are reproducible if
// the provided generator is reproducible.
func fill(_ buffer: UnsafeMutableRawBufferPointer, using rng: inout some RandomNumberGenerator) {
    guard var base = buffer.baseAddress else { return }
    var count = buffer.count
    while count > 0 {
        let stride = min(count, MemoryLayout<UInt64>.size)
        withUnsafeBytes(of: rng.next()) {
            let bytes = $0.baseAddress.unsafelyUnwrapped
            base.copyMemory(from: bytes, byteCount: stride)
        }
        (base, count) = (base + stride, count &- stride)
    }
}

struct SplitMix64: RandomNumberGenerator {
  var state: UInt64
  init(seed: UInt64) { state = seed }
  init(from rng: inout some RandomNumberGenerator) {
    state = rng.next()
  }
  mutating func next() -> UInt64 {
    state &+= 0x9e37_79b9_7f4a_7c15
    var z = state
    z = (z ^ (z >> 30)) &* 0xbf58_476d_1ce4_e5b9
    z = (z ^ (z >> 27)) &* 0x94d0_49bb_1331_11eb
    return z ^ (z >> 31)
  }
}

struct BigEndianRNG<T: RandomNumberGenerator>: RandomNumberGenerator {
    var wrapped: T
    init(_ wrapped: T) {
        self.wrapped = wrapped
    }
    mutating func next() -> UInt64 {
        wrapped.next().bigEndian
    }
}
struct LittleEndianRNG<T: RandomNumberGenerator>: RandomNumberGenerator {
    var wrapped: T
    init(_ wrapped: T) {
        self.wrapped = wrapped
    }
    mutating func next() -> UInt64 {
        wrapped.next().littleEndian
    }
}

func test(_ rng: consuming some RandomNumberGenerator) {
    var ne = copy rng
    var le = LittleEndianRNG(copy rng)
    var be = BigEndianRNG(rng)
    // bytes as if generated on a little-endian machine
    let leBytes = [UInt8](unsafeUninitializedCapacity: 7) { buff, initializedCount in
        fill(UnsafeMutableRawBufferPointer(buff), using: &le)
        initializedCount = buff.count
    }
    // bytes as if generated on a big-endian machine
    let beBytes = [UInt8](unsafeUninitializedCapacity: 7) { buff, initializedCount in
        fill(UnsafeMutableRawBufferPointer(buff), using: &be)
        initializedCount = buff.count
    }
    let neBytes = [UInt8](unsafeUninitializedCapacity: 7) { buff, initializedCount in
        fill(UnsafeMutableRawBufferPointer(buff), using: &ne)
        initializedCount = buff.count
    }
    print("Little endian: \(leBytes)")
    print("Big endian:    \(beBytes)")
    print("Native endian: \(neBytes)")
    print("Bytes are the same: \(Set(leBytes) == Set(beBytes) && Set(leBytes) == Set(neBytes))")
}

do {
    let seed: UInt64 = 0x4DE12D496011118A
    print("Seed: 0x\(String(seed, radix: 16, uppercase: true))")
    test(SplitMix64(seed: seed))
}