How to use

org.apache.commons.math3.random.MersenneTwister

constructor

/**
 * Create an object that will use a default RNG ({@link MersenneTwister}),
 * in order to generate the individual components.
 *
 * @param dimension Space dimension.
 */
public UnitSphereRandomVectorGenerator(final int dimension) {
  this(dimension, new MersenneTwister());
}

RandomWrapper(long seed) {
 random = new MersenneTwister(seed);
}

  @Override
  public MersenneTwister generator() {
    MersenneTwister random = new MersenneTwister();
    random.setSeed(seed);
    return random;
  }
}

public DefaultRandom(long seed) {
  this.seed = seed;
  this.randomGenerator = new SynchronizedRandomGenerator(new MersenneTwister(seed));
}

RandomWrapper() {
 random = new MersenneTwister();
 random.setSeed(System.currentTimeMillis() + System.identityHashCode(random));
}

  public static void main (String... args) {
    System.out.println("Testing histogram store with normal distribution, mean 0");
    Histogram h = new Histogram("Normal");

    MersenneTwister mt = new MersenneTwister();

    IntStream.range(0, 1000000).map(i -> (int) Math.round(mt.nextGaussian() * 20 + 2.5)).forEach(h::add);

    h.displayHorizontal();
    System.out.println("mean: " + h.mean());
  }
}

return new Iterator<List<HStoreFile>>() {
 private GaussianRandomGenerator gen =
   new GaussianRandomGenerator(new MersenneTwister(random.nextInt()));
 private int count = 0;

/**
 * Test if two clusters are significantly different in the metrics we look at for balancing.
 *
 * @param orig the utilization matrix from the original cluster
 * @param optimized the utilization matrix from the optimized cluster
 * @return The P value that the various derived resources come from the same probability distribution.  The probability
 * that the null hypothesis is correct.
 */
public static double[] testDifference(double[][] orig, double[][] optimized) {
 int nResources = RawAndDerivedResource.values().length;
 if (orig.length != nResources) {
  throw new IllegalArgumentException("orig must have number of rows equal to RawAndDerivedResource.");
 }
 if (optimized.length != nResources) {
  throw new IllegalArgumentException("optimized must have number of rows equal to RawAndDerivedResource.");
 }
 if (orig[0].length != optimized[0].length) {
  throw new IllegalArgumentException("The number of brokers must be the same.");
 }
 double[] pValues = new double[orig.length];
 //TODO:  For small N we want to do statistical bootstrapping (not the same as bootstrapping data).
 for (int resourceIndex = 0; resourceIndex < nResources; resourceIndex++) {
  RandomGenerator rng = new MersenneTwister(0x5d11121018463324L);
  KolmogorovSmirnovTest kolmogorovSmirnovTest = new KolmogorovSmirnovTest(rng);
  pValues[resourceIndex] =
    kolmogorovSmirnovTest.kolmogorovSmirnovTest(orig[resourceIndex], optimized[resourceIndex]);
 }
 return pValues;
}

@Override
public Random createRandom() {
  switch (randomType) {
    case JDK:
      return randomSeed == null ? new Random() : new Random(randomSeed);
    case MERSENNE_TWISTER:
      return new RandomAdaptor(randomSeed == null ? new MersenneTwister() : new MersenneTwister(randomSeed));
    case WELL512A:
      return new RandomAdaptor(randomSeed == null ? new Well512a() : new Well512a(randomSeed));
    case WELL1024A:
      return new RandomAdaptor(randomSeed == null ? new Well1024a() : new Well1024a(randomSeed));
    case WELL19937A:
      return new RandomAdaptor(randomSeed == null ? new Well19937a() : new Well19937a(randomSeed));
    case WELL19937C:
      return new RandomAdaptor(randomSeed == null ? new Well19937c() : new Well19937c(randomSeed));
    case WELL44497A:
      return new RandomAdaptor(randomSeed == null ? new Well44497a() : new Well44497a(randomSeed));
    case WELL44497B:
      return new RandomAdaptor(randomSeed == null ? new Well44497b() : new Well44497b(randomSeed));
    default:
      throw new IllegalStateException("The randomType (" + randomType + ") is not implemented.");
  }
}

/** Constructor */
public MersenneTwisterGenerator(long seed) {
 this.seed = seed ;
 rnd = new MersenneTwister(seed) ;
}

/**
 * Create an object that will use a default RNG ({@link MersenneTwister}),
 * in order to generate the individual components.
 *
 * @param dimension Space dimension.
 */
public UnitSphereRandomVectorGenerator(final int dimension) {
  this(dimension, new MersenneTwister());
}

/**
 * Create an object that will use a default RNG ({@link MersenneTwister}),
 * in order to generate the individual components.
 *
 * @param dimension Space dimension.
 */
public UnitSphereRandomVectorGenerator(final int dimension) {
  this(dimension, new MersenneTwister());
}

public RandomRangedToString(long min, long max, long seed) {
  this.theTwister = new MersenneTwister(seed);
  if (max<=min) {
    throw new RuntimeException("max must be >= min");
  }
  this.min = min;
  this.max = max;
  this._length = max - min;
}

 @Override
 public Solver get(long seed) {
  return new RandomSolver(new MersenneTwister(seed));
 }
};

/**
 * Creates a random route planner using the specified random seed.
 * @param seed The random seed.
 */
public RandomRoutePlanner(long seed) {
 LOGGER.info("constructor {}", seed);
 assignedParcels = LinkedHashMultiset.create();
 current = Optional.absent();
 rng = new RandomAdaptor(new MersenneTwister(seed));
}

public RandomLineToString(String filename, long seed) {
  this.rng = new MersenneTwister(seed);
  this.filename = filename;
  this.lines = ResourceFinder.readDataFileLines(filename);
  itemDistribution= new UniformIntegerDistribution(rng, 0, lines.size()-2);
}

public RandomLineToStringMap(String paramFile, int maxSize) {
  rng = new MersenneTwister(System.nanoTime());
  this.sizeDistribution = new UniformIntegerDistribution(rng, 0,maxSize-1);
  this.lineDataMapper = new RandomLineToString(paramFile);
}

public RandomLineToStringMap(String paramFile, int maxSize, long seed) {
  this.rng = new MersenneTwister(seed);
  this.sizeDistribution = new UniformIntegerDistribution(rng, 0,maxSize-1);
  this.lineDataMapper = new RandomLineToString(paramFile);
}

public RandomFileExtractToString(String fileName, int minsize, int maxsize, long seed) {
  this.fileName = fileName;
  this.minsize = minsize;
  this.maxsize = maxsize;
  loadData();
  this.rng = new MersenneTwister(seed);
  this.sizeDistribution = new UniformIntegerDistribution(rng, minsize, maxsize);
  this.positionDistribution = new UniformIntegerDistribution(rng, 1, fileDataImage.limit() - maxsize);
}

@Override
public void setSolverProvider(SimSolverBuilder provider) {
 solver =
  Optional.of(provider.setVehicles(new LinkedHashSet<>(asList(this)))
   .build(new RandomSolver(new MersenneTwister(123))));
}