来自多个 64 位输入的确定性随机噪声发生器？

Question

我正在尝试在 C# 中创建一个伪随机数生成器，它在给定相同的输入集的情况下产生相同的输出。它需要速度快，接受 64 位数字，并且特别重要的是允许任意一组输入。输出应该是 [0 和 1} 之间的双精度值。

输入大部分是在应用程序生命周期内保持不变的种子值，以及一个或多个其他数值，例如 x、y、z 和 w 坐标，它们本身可能是输入 int32、int64 或 double。

我尝试过调整我发现的其他一些随机数生成器，但我一直遇到大量的聚集问题，主要是因为我不了解围绕该主题的理论或素数的数学属性，这似乎在大多数情况下都起作用。

我想使用此函数生成随机噪声，这些随机噪声将在许多其他算法（包括我自己的算法和标准算法（例如 Perlin 噪声）等）内部使用。

我该怎么办？

Answer 1

我找到了一个解决方案，我会一直使用它，直到有人说服我为什么不应该这样做。

下面的代码是我的课程的可用摘录。第一个Generate 函数可以接受任意数量的重载，具体取决于您的需要。您将输入转换为字节数组并将它们传递给私有的 Generate 方法，由该方法完成其余的工作。请注意，在内部有一个对 _seed 的引用，它本身只是一个字节数组，由您通过构造函数提供的种子值生成。

另外，代码依赖于this MurMurHash3 algorithm，这非常快。

我已经运行了大量的迭代来检查分布，它似乎分布非常均匀，在给定值周围没有明显的人类明显的聚集。我让它在英特尔酷睿 i7 上在大约 720 毫秒内生成一百万个值，这对于我的目的来说已经足够快了。我还测试了它在纹理上生成 2D 白噪声，噪声看起来非常随机。

public double Generate(double x, double y, double z, double w)
{
    return Generate(
        _seed,
        BitConverter.GetBytes(x),
        BitConverter.GetBytes(y),
        BitConverter.GetBytes(z),
        BitConverter.GetBytes(w)
    );
}

private double Generate(params byte[][] inputs)
{
    var len = 0;
    int i;
    for(i = 0; i < inputs.Length; i++)
        len += inputs[i].Length;
    var buffer = new byte[len];
    var offset = 0;
    for(i = 0; i < inputs.Length; i++)
    {
        var bytes = inputs[i];
        Buffer.BlockCopy(bytes, 0, buffer, offset, bytes.Length);
        offset += bytes.Length;
    }
    return Hash(buffer);
}

private double Hash(byte[] bytes)
{
    var hash = new Murmur3().ComputeHash(bytes);
    var buffer = new byte[8];
    for(var i = 0; i < hash.Length; i++)
        buffer[i%8] ^= hash[i];
    var n = BitConverter.ToInt64(buffer, 0);
    if(n < 0) n = -n;
    if(n == long.MaxValue) n--;
    return n / (double)long.MaxValue;
}

Answer 2

这仍然是一个相当慢的 rng，但比基于 Murmur3 的速度快大约 10 倍。为每个生成的数字重新播种是有成本的，因此需要大量对结果都有非系统性影响的种子也是如此。

更新：确实没有任何理由允许弱位，这个版本应该没有明显的模式。

class Prng
{
    const double shift3 = .125;
    const double shift9 = shift3 * shift3 * shift3;
    const double shift27 = shift9 * shift9 * shift9;
    const double shift53 = shift27 * shift27 * 2.0;
    public ulong rndlong(ulong a, ulong b, ulong c, ulong d){
        ulong e = ((a ^ (b >> 14 | b << 50)) + ((c >> 31 | c << 33) ^ (d >> 18 | d << 46)))*1911413418482053185;
        ulong f = (((a >> 30 | a << 34) ^ c) + ((b >> 32 | b << 32) ^ (d >> 50 | d << 14)))*1139072524405308145;
        ulong g = (((a >> 49 | a << 15) ^ (d >> 33 | d << 31)) + (b ^ (c >> 48 | c << 16)))*8792993707439626365;
        ulong h = (((a >> 17 | a << 47) ^ (b >> 47 | b << 17)) + ((c >> 15 | c << 49) ^ d))*1089642907432013597;
        return (e ^ f ^ (g >> 21 | g << 43) ^ (h >> 44 | h << 20)) * 2550117894111961111 +
            ((e >> 20 | e << 44) ^ (f >> 41 | f << 23) ^ (g >> 42 | g << 22) ^ h) * 8786584852613159497 +
            ((e >> 43 | e << 21) ^ (f >> 22 | f << 42) ^ g ^ (h >> 23 | h << 41)) * 3971056679291618767;
    }
    public double rnddouble(ulong a, ulong b, ulong c, ulong d)
    {
        return (double)(rndlong(a, b, c, d) >> 11) * shift53;
    }
}