Lua 4.0 随机数生成器

我没有安装 Lua 4.0，也从未与它一起工作，因此以下代码可能需要一些调整。

这是Lua 5.1上的一些东西。它是Park和Miller生成器实现的一个粗略的适应（用C编写，使用32位整数）。我试图接近4.0的语法（从你的片断中猜测出来）。测试并查看其周期是否符合您的需求。原始版本约为2e9的周期，但转换为浮点运算可能会导致出现问题（这些生成器是娇嫩的东西）。

local mod = math.fmod
local floor = math.floor

local B = 2 ^ 31
-- 粗略适应Park-Miller生成器
function srandom(seedobj，fVal1，fVal2)
    local seed = seedobj [1]
    local k = mod（floor（seed / 127773），B）
    seed = mod（16807 *（seed-mod（k * 127773，B）），B）
    seed = seed - mod（2836 * k，B）
    if seed <0 then seed = mod（seed + B-1，B）end
    seedobj [1] =种子
    local temp_rand =种子/（B-1）
    if fVal2 then
        返回floor（fVal1 + 0.5 + temp_rand *（fVal2-fVal1））
    elseif fVal1 then
        返回floor（temp_rand * fVal1）+1
    否则
        返回temp_rand
    end
end

-- 测试
local seedobj = {2} //第一个元素是种子，不得为0
对于i = 1,100做
    print（srandom（seedobj，100,1000））
end

这里是另一种尝试（仍然是Lua 5.1代码），使用Knuth的减法生成器的C语言适配（不是线性同余）。根据Knuth的说法，它应该能够使用FP算术（甚至是单精度）。

local mod = math.fmod
local floor = math.floor
local abs = math.abs

local B = 4000000

-- Knuth浮点数生成器的粗略适配
function srandom(seedobj, fVal1, fVal2)
    local ma = seedobj.ma
    local seed = seedobj.seed
    local mj, mk
    if seed < 0 or not ma then
        ma = {}
        seedobj.ma = ma
        mj = abs(1618033 - abs(seed))
        mj = mod(mj, B)
        ma[55] = mj
        mk = 1
        for i = 1, 54 do
            local ii = mod(21 * i, 55)
            ma[ii] = mk
            mk = mj - mk
            if mk < 0 then mk = mk + B end
            mj = ma[ii]
        end
        for k = 1, 4 do
            for i = 1, 55 do
                ma[i] = ma[i] - ma[1 + mod(i + 30, 55)]
                if ma[i] < 0 then ma[i] = ma[i] + B end
            end
        end
        seedobj.inext = 0
        seedobj.inextp = 31
        seedobj.seed = 1
    end
    local inext = seedobj.inext
    local inextp = seedobj.inextp
    inext = inext + 1
    if inext == 56 then inext = 1 end
    seedobj.inext = inext
    inextp = inextp + 1
    if inextp == 56 then inextp = 1 end
    seedobj.inextp = inextp
    mj = ma[inext] - ma[inextp]
    if mj < 0 then mj = mj + B end
    ma[inext] = mj
    local temp_rand = mj / B
    if fVal2 then
        return floor(fVal1 + 0.5 + temp_rand * (fVal2 - fVal1))
    elseif fVal1 then
        return floor(temp_rand * fVal1) + 1
    else
        return temp_rand
    end
end

-- 测试

-- 注意：seedobj必须是带有一个名为“seed”的字段的表；
-- 这个字段必须为负数；在生成第一个数字之后，seedobj表将被填充
-- 需要生成数字的附加状态；将其“seed”字段更改为负数将重新初始化
-- 生成器并开始一个新的伪随机序列。
local seedobj = {seed = -232343}
for i = 1, 100 do
    print(srandom(seedobj, 100, 1000))
end

我在这里找到了一个解决方案 here:

function mul16(a, b)
    local a_lo, b_lo = mod(a, 2^8), mod(b, 2^8)
    local a_hi, b_hi = a - a_lo, b - b_lo
    return mod(a_lo * b_lo + mod(a_lo * b_hi, 2^16) + mod(a_hi * b_lo, 2^16) + mod(a_hi * b_hi, 2^16), 2^16)
end

function lcg(s, r)
    local temp = {}
    function temp:random(a, b)
        local y = mod(mul16(self.a, self.x) + self.c, self.m)
        self.x = y
        if not a then
            return y / 65536
        elseif not b then
            if a == 0 then
                return y
            else
                return 1 + mod(y, a)
            end
        else
            return a + mod(y, b - a + 1)
        end
    end
    function temp:randomseed(s)
        if not s then
            s = seed()
        end
        self.x = mod(s, 2147483648)
    end
    -- 'Numerical Recipes' parameters
    temp.a = 26125
    temp.c = 62303
    temp.m = 65536
    temp:randomseed(s)
    return temp
end

local R = lcg(0974)
local rand_table = {}
for i = 1, 10000 do
    local new_value = R:random()
    rand_table[i] = new_value
    if (i > 1) then
        for j = 1, i - 1 do
            local old_value = rand_table[j]
            if (new_value == old_value) then
                print("\ti = " .. i .. "\n\tj = " .. j .. "\n\tnew_value = " .. new_value .. "\n\told_value = " .. old_value)
                break
            end
        end
    end
end

我不知道其统计特性如何，但这个函数即使经过数千次迭代也没有返回重复值。无论如何，感谢所有人的帮助！