Julia是否支持类似Fortran的本地保存数据？Fortran转Julia的SAVE属性难题

嘿，太懂你这种Fortran转Julia时卡壳在SAVE变量上的感受了——尤其是像ran3.f这类依赖状态持久化的随机数生成器，原代码里的SAVE变量（不管是显式SAVE声明还是DATA语句初始化的）本质就是让局部变量在子程序调用之间保留状态，而Julia默认局部变量每次调用都会重置，这确实得换个思路实现。

下面给你几种Julia里复刻Fortran SAVE行为的实用方案，附ran3相关的示例片段：

这是最常用的方式，把需要保存的状态变量放在外层函数中，内层函数捕获这些变量，每次调用内层函数时都会复用同一个状态。完美对应Fortran里单子程序的SAVE逻辑：

function create_ran3(seed::Int)
    # 这些变量对应Fortran里带SAVE属性的局部变量
    idum = seed
    iy = 0
    iv = zeros(Int, 32)

    # 返回实际生成随机数的函数，它会持续更新外层的状态变量
    return function()
        # 复刻ran3的初始化逻辑（对应原代码里的DATA/SAVE初始化）
        if idum <= 0 || iy == 0
            idum = max(-idum, 1)
            for j in 32:-1:1
                k = idum ÷ 127773
                idum = 16807 * (idum - k*127773) - k*2836
                idum < 0 && (idum += 2147483647)
                j <= 24 && (iv[j] = idum)
            end
            iy = iv[1]
        end

        # ran3核心生成逻辑，更新状态
        k = idum ÷ 127773
        idum = 16807 * (idum - k*127773) - k*2836
        idum < 0 && (idum += 2147483647)
        j = (iy ÷ 1) + 1
        iy = iv[j]
        iv[j] = idum

        return min(iy * 4.656612875e-10, 1.0 - eps(Float64))
    end
end

# 使用方式：创建一个绑定了状态的ran3实例，每次调用都保留状态
my_ran3 = create_ran3(-12345)
println(my_ran3())  # 第一次调用，初始化状态
println(my_ran3())  # 第二次调用，复用上次的状态

如果原代码里的SAVE变量是多个子程序共享的，或者需要全局访问状态，可以把状态变量放在模块里。注意这种方式是全局状态，多线程场景下要加锁：

module Ran3Module
    export ran3, set_ran3_seed

    # 模块内的全局变量对应Fortran的SAVE变量
    idum = 0
    iy = 0
    iv = zeros(Int, 32)

    function set_ran3_seed(seed::Int)
        global idum = seed
        global iy = 0
        global iv = zeros(Int, 32)
    end

    function ran3()
        global idum, iy, iv
        # 核心逻辑和闭包版本完全一致
        if idum <= 0 || iy == 0
            idum = max(-idum, 1)
            for j in 32:-1:1
                k = idum ÷ 127773
                idum = 16807 * (idum - k*127773) - k*2836
                idum < 0 && (idum += 2147483647)
                j <= 24 && (iv[j] = idum)
            end
            iy = iv[1]
        end

        k = idum ÷ 127773
        idum = 16807 * (idum - k*127773) - k*2836
        idum < 0 && (idum += 2147483647)
        j = (iy ÷ 1) + 1
        iy = iv[j]
        iv[j] = idum

        return min(iy * 4.656612875e-10, 1.0 - eps(Float64))
    end
end

# 使用方式：
using .Ran3Module
Ran3Module.set_ran3_seed(-12345)
println(Ran3Module.ran3())
println(Ran3Module.ran3())

如果需要同时维护多个独立的随机数流（比如不同种子的ran3实例），可变结构体是最佳选择，每个实例对应一个独立的状态：

mutable struct Ran3State
    idum::Int
    iy::Int
    iv::Vector{Int}

    # 构造函数对应原代码的DATA初始化逻辑
    function Ran3State(seed::Int)
        idum = seed
        iy = 0
        iv = zeros(Int, 32)
        new(idum, iy, iv)
    end
end

# 定义更新状态并生成随机数的方法
function rand!(state::Ran3State)
    if state.idum <= 0 || state.iy == 0
        state.idum = max(-state.idum, 1)
        for j in 32:-1:1
            k = state.idum ÷ 127773
            state.idum = 16807 * (state.idum - k*127773) - k*2836
            state.idum < 0 && (state.idum += 2147483647)
            j <= 24 && (state.iv[j] = state.idum)
        end
        state.iy = state.iv[1]
    end

    k = state.idum ÷ 127773
    state.idum = 16807 * (state.idum - k*127773) - k*2836
    state.idum < 0 && (state.idum += 2147483647)
    j = (state.iy ÷ 1) + 1
    state.iy = state.iv[j]
    state.iv[j] = state.idum

    return min(state.iy * 4.656612875e-10, 1.0 - eps(Float64))
end

# 使用方式：创建两个独立的ran3实例，状态互不干扰
state1 = Ran3State(-12345)
state2 = Ran3State(-67890)
println(rand!(state1))
println(rand!(state2))
println(rand!(state1))  # 继续用state1的状态

• 单实例、简单需求：闭包最简洁，没有全局变量的副作用
• 多子程序共享状态：模块适合全局访问，但要注意线程安全
• 多独立状态、面向对象风格：可变结构体最灵活，适合复杂场景

内容的提问来源于stack exchange，提问作者GEBRU