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

本文关键字：确定性 随机噪声 发生器 输入 64位 | 更新日期: 2023-09-27 18:35:07

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

在大多数情况下，输入将是在应用生存期内保持不变的种子值，以及一个或多个其他数值，例如 x、y、z 和 w 坐标，它们本身可能是 int32、int64 或双精度型。

我

尝试过改编我发现的其他一些随机数生成器，但我不断遇到大量的聚集问题，主要是因为我不知道围绕这个主题的理论，或者素数的数学性质，这似乎在大多数情况下发挥作用。

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

我应该怎么做？

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

这仍然是一个相当慢的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;
    }
}

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

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

此外，代码依赖于这个MurMurHash3算法，该算法非常快。

我已经运行了大量迭代来检查分布，它似乎分布非常均匀，在给定值周围没有明显的人类明显的聚集。我让它在英特尔酷睿 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;
}
相关文章：