Java 使用相同的种子或相同的随机流初始化多个分发？

我有一个Java模拟，其中我需要使用

Uniform

、

Exponential

、

Poisson

和

Gamma

分布，并且我需要用相同的种子初始化随机流和/或这些分布中的每一个（这样我就可以精确地重现给定固定种子的轨迹）

我正在使用（这是Colt的多线程版本）

对于

Uniform

，我可以正确地为

DoubleUniform

对象设定种子（从

cern.jet.random.t导入后），如下所示：

但是，对于
指数分布
、
泊松分布
和
伽马分布（全部在
cern.jet.random.tdouble
），我不能通过传递
fixedSeed
，因为它们期望传递
双随机引擎
对象：

施工总结

指数（双λ，双随机引擎随机生成器）


构造负指数分布

Poisson（双平均，双随机引擎随机生成器）


构造泊松分布

Gamma（双alpha、双lambda、双随机引擎随机生成器）


构造伽马分布

有没有一种方法可以像我使用
Uniform
时一样初始化这些（
index
、
Poisson
和
Gamma
）呢？或者我应该在
cern.jet.random.tdouble
中实例化一个父类/基类（如果是，如何？），从中扩展所有这些类

注:

同样，我希望有一个单一的随机流（以便
分发可以使用该流中的随机数）-这是
对再现性非常重要
一个示例模拟可能需要对这些分布进行数百万次的采样（总共），因此性能/速度始终是一个问题
它看起来像是扩展了DoubleRandomEngine的DoubleMersenneTwister，允许您在其构造函数中设置种子。
它看起来像是扩展了DoubleRandomEngine的DoubleMersenneTwister，允许您在其构造函数中设置种子。
所有类型的随机变量生成都从统一（0,1）开始随机数。
指数
、
泊松
和
伽马
构造函数中的最后一个参数是为您提供统一（0,1）的源，它扩展了
双随机引擎
抽象类。看起来像。您需要选择其中一个，为要生成的每个分发创建一个单独但种子相同的实例，然后使用您创建的一个
DoubleRandomEngine
实例构建每个分发对象。这样，底层的统一值流将是相同的，并且可以适当地转换为所需的分布

下面是一个相当简单的实现：

import cern.jet.random.tdouble.*;
import cern.jet.random.tdouble.engine.*;

public class RNG {
  public static void main(String[] args) {
    // create two instances of Mersenne Twister, seeded identically
    DoubleRandomEngine twister1 = new DoubleMersenneTwister(42);
    DoubleRandomEngine twister2 = new DoubleMersenneTwister(42);
    // print ten values from each, to show they produce identical U(0,1)'s'
    for(int i = 0; i < 10; ++i) {
      System.out.println(twister1.nextDouble() + ", " + twister2.nextDouble());
    }
    System.out.println("\nNow for some exponentials...\n");
    // instantiate two exponentials using our two twisters as the
    // underlying random engine
    Exponential exp1 = new Exponential(3, twister1);
    Exponential exp2 = new Exponential(3, twister2);
    // and print 10 of 'em to show they're synchronized.
    for(int i = 0; i < 10; ++i) {
      System.out.println(exp1.nextDouble() + ", " + exp2.nextDouble());
    }
  }
}

导入cern.jet.random.t双倍。*；
导入cern.jet.random.T双倍引擎。*；
公共类RNG{
公共静态void main（字符串[]args）{
//创建两个Mersenne Twister实例，种子相同
DoubleRandomEngine twister1=新的DoubleMersenneTwister（42）；
DoubleRandomEngine twister2=新的DoubleMersenneTwister（42）；
//打印每个值的十个值，以显示它们产生相同的U（0,1）'
对于（int i=0；i<10；++i）{
System.out.println（twister1.nextDouble（）+”，“+twister2.nextDouble（））；
}
System.out.println（“\n对于某些指数，现在…\n”）；
//使用我们的两个缠绕器作为
//底层随机引擎
指数exp1=新指数（3，twister1）；
指数exp2=新指数（3，twister2）；
//打印10张，显示它们是同步的。
对于（int i=0；i<10；++i）{
System.out.println（exp1.nextDouble（）+”，“+exp2.nextDouble（））；
}
}
}

由于
指数
类将“引擎”生成的制服供应流转换为指数RVs，并且制服的种子相同，因此指数实际上是相同的种子。
所有类型的随机变量生成都从均匀（0,1）随机数开始。
指数
、
泊松
和
伽马
构造函数中的最后一个参数是为您提供统一（0,1）的源，它扩展了
双随机引擎
抽象类。看起来像。您需要选择其中一个，为要生成的每个分发创建一个单独但种子相同的实例，然后使用您创建的一个
DoubleRandomEngine
实例构建每个分发对象。这样，底层的统一值流将是相同的，并且可以适当地转换为所需的分布

下面是一个相当简单的实现：

import cern.jet.random.tdouble.*;
import cern.jet.random.tdouble.engine.*;

public class RNG {
  public static void main(String[] args) {
    // create two instances of Mersenne Twister, seeded identically
    DoubleRandomEngine twister1 = new DoubleMersenneTwister(42);
    DoubleRandomEngine twister2 = new DoubleMersenneTwister(42);
    // print ten values from each, to show they produce identical U(0,1)'s'
    for(int i = 0; i < 10; ++i) {
      System.out.println(twister1.nextDouble() + ", " + twister2.nextDouble());
    }
    System.out.println("\nNow for some exponentials...\n");
    // instantiate two exponentials using our two twisters as the
    // underlying random engine
    Exponential exp1 = new Exponential(3, twister1);
    Exponential exp2 = new Exponential(3, twister2);
    // and print 10 of 'em to show they're synchronized.
    for(int i = 0; i < 10; ++i) {
      System.out.println(exp1.nextDouble() + ", " + exp2.nextDouble());
    }
  }
}

导入cern.jet.random.t双倍。*；
导入cern.jet.random.T双倍引擎。*；
公共类RNG{
公共静态void main（字符串[]args）{
//创建两个Mersenne Twister实例，种子相同
DoubleRandomEngine twister1=新的DoubleMersenneTwister（42）；
DoubleRandomEngine twister2=新的DoubleMersenneTwister（42）；
//打印每个值的十个值，以显示它们产生相同的U（0,1）'
对于（int i=0；i<10；++i）{
System.out.println（twister1.nextDouble（）+”，“+twister2.nextDouble（））；
}
System.out.println（“\n对于某些指数，现在…\n”）；
//使用我们的两个缠绕器作为
//底层随机引擎
指数exp1=新指数（3，twister1）；
指数exp2=新指数（3，twister2）；
//打印10张，显示它们是同步的。
对于（int i=0；i<10；++i）{
System.out.println（exp1.nextDoub