1//! Sfc64 pseudo-random number generator from Practically Random.
  2//! Fastest engine of pracrand and smallest footprint.
  3//! See http://pracrand.sourceforge.net/
  4
  5const std = @import("std");
  6const math = std.math;
  7const Sfc64 = @This();
  8
  9a: u64 = undefined,
 10b: u64 = undefined,
 11c: u64 = undefined,
 12counter: u64 = undefined,
 13
 14const Rotation = 24;
 15const RightShift = 11;
 16const LeftShift = 3;
 17
 18pub fn init(init_s: u64) Sfc64 {
 19    var x = Sfc64{};
 20
 21    x.seed(init_s);
 22    return x;
 23}
 24
 25pub fn random(self: *Sfc64) std.Random {
 26    return std.Random.init(self, fill);
 27}
 28
 29fn next(self: *Sfc64) u64 {
 30    const tmp = self.a +% self.b +% self.counter;
 31    self.counter += 1;
 32    self.a = self.b ^ (self.b >> RightShift);
 33    self.b = self.c +% (self.c << LeftShift);
 34    self.c = math.rotl(u64, self.c, Rotation) +% tmp;
 35    return tmp;
 36}
 37
 38fn seed(self: *Sfc64, init_s: u64) void {
 39    self.a = init_s;
 40    self.b = init_s;
 41    self.c = init_s;
 42    self.counter = 1;
 43    var i: u32 = 0;
 44    while (i < 12) : (i += 1) {
 45        _ = self.next();
 46    }
 47}
 48
 49pub fn fill(self: *Sfc64, buf: []u8) void {
 50    var i: usize = 0;
 51    const aligned_len = buf.len - (buf.len & 7);
 52
 53    // Complete 8 byte segments.
 54    while (i < aligned_len) : (i += 8) {
 55        var n = self.next();
 56        comptime var j: usize = 0;
 57        inline while (j < 8) : (j += 1) {
 58            buf[i + j] = @as(u8, @truncate(n));
 59            n >>= 8;
 60        }
 61    }
 62
 63    // Remaining. (cuts the stream)
 64    if (i != buf.len) {
 65        var n = self.next();
 66        while (i < buf.len) : (i += 1) {
 67            buf[i] = @as(u8, @truncate(n));
 68            n >>= 8;
 69        }
 70    }
 71}
 72
 73test "sequence" {
 74    // Unfortunately there does not seem to be an official test sequence.
 75    var r = Sfc64.init(0);
 76
 77    const seq = [_]u64{
 78        0x3acfa029e3cc6041,
 79        0xf5b6515bf2ee419c,
 80        0x1259635894a29b61,
 81        0xb6ae75395f8ebd6,
 82        0x225622285ce302e2,
 83        0x520d28611395cb21,
 84        0xdb909c818901599d,
 85        0x8ffd195365216f57,
 86        0xe8c4ad5e258ac04a,
 87        0x8f8ef2c89fdb63ca,
 88        0xf9865b01d98d8e2f,
 89        0x46555871a65d08ba,
 90        0x66868677c6298fcd,
 91        0x2ce15a7e6329f57d,
 92        0xb2f1833ca91ca79,
 93        0x4b0890ac9bf453ca,
 94    };
 95
 96    for (seq) |s| {
 97        try std.testing.expectEqual(s, r.next());
 98    }
 99}
100
101test fill {
102    // Unfortunately there does not seem to be an official test sequence.
103    var r = Sfc64.init(0);
104
105    const seq = [_]u64{
106        0x3acfa029e3cc6041,
107        0xf5b6515bf2ee419c,
108        0x1259635894a29b61,
109        0xb6ae75395f8ebd6,
110        0x225622285ce302e2,
111        0x520d28611395cb21,
112        0xdb909c818901599d,
113        0x8ffd195365216f57,
114        0xe8c4ad5e258ac04a,
115        0x8f8ef2c89fdb63ca,
116        0xf9865b01d98d8e2f,
117        0x46555871a65d08ba,
118        0x66868677c6298fcd,
119        0x2ce15a7e6329f57d,
120        0xb2f1833ca91ca79,
121        0x4b0890ac9bf453ca,
122    };
123
124    for (seq) |s| {
125        var buf0: [8]u8 = undefined;
126        var buf1: [7]u8 = undefined;
127        std.mem.writeInt(u64, &buf0, s, .little);
128        r.fill(&buf1);
129        try std.testing.expect(std.mem.eql(u8, buf0[0..7], buf1[0..]));
130    }
131}