How to use

MersenneTwister

in

org.apache.commons.math3.random

/**
 * 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());
}

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

  public void randomize () {
    for (TIntObjectIterator<int[]> it = offsets.iterator(); it.hasNext();) {
      it.advance();
      int[] newVal = new int[it.value().length];

      RaptorWorkerTimetable tt = data.timetablesForPattern.get(it.key());

      for (int i = 0; i < newVal.length; i++) {
        newVal[i] = mt.nextInt(tt.headwaySecs[i]);
      }

      it.setValue(newVal);
    }

  }
}

  setSeed(System.currentTimeMillis() + System.identityHashCode(this));
  return;
setSeed(19650218);
int i = 1;
int j = 0;
clear(); // Clear normal deviate cache

  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());
  }
}

 @Override
 public RandomGenerator sharedInstance(Class<?> clazz) {
  stateCheck();
  if (!classRngMap.containsKey(clazz)) {
   final RandomGenerator rng = new UnmodifiableRandomGenerator(
    new MersenneTwister(masterRandomGenerator.nextLong()));
   classRngMap.put(clazz, rng);
   return rng;
  }
  return classRngMap.get(clazz);
 }
}

  /**
   * Returns an instance of a random number generator, which can be used locally, e.g. in threads.
   */
  public static RandomGenerator getLocalGenerator() {
    return new MersenneTwister(rg.nextInt());
  }
}

     .build())));
final RandomGenerator rng = new MersenneTwister(seed);
for (int i = 0; i < 20; i++) {
 final long announceTime = rng.nextInt(DoubleMath.roundToInt(
  endTime * .8, RoundingMode.FLOOR));
 b.addEvent(AddParcelEvent.create(Parcel
  .builder(
   new Point(rng.nextDouble() * 10, rng.nextDouble() * 10),
   new Point(rng.nextDouble() * 10, rng.nextDouble() * 10))
  .orderAnnounceTime(announceTime)

final RandomGenerator rng = new MersenneTwister(123);
final double startLengthOfDay = 1000;
final int repetitions = 3;
  final List<Double> scenario = newArrayList();
  for (int i = 0; i < events; i++) {
   scenario.add(rng.nextDouble() * startLengthOfDay);

/**
 * Tests determinism of arrival times generators, given the same random number
 * generator and seed they should always return the same sequence.
 */
@Test
public void determinismTest() {
 final RandomGenerator outer = new MersenneTwister(123);
 for (int i = 0; i < 100; i++) {
  final long seed = outer.nextLong();
  final RandomGenerator inner = new MersenneTwister(seed);
  final List<Double> list1 = poisson.generate(inner.nextLong());
  for (int j = 0; j < 100; j++) {
   inner.setSeed(seed);
   final List<Double> list2 = poisson.generate(inner.nextLong());
   assertEquals(list1, list2);
  }
 }
}

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

 class RandomVariable {

/** Initialize Mersenne Twister generator. */
private static MersenneTwister rnd = new MersenneTwister();

public static double rand() {
  return rnd.nextDouble();
}

/** Generate a random number from a uniform random variable.
 *
 *  @param  min Mininum value for the random variable.
 *  @param  max Maximum value for the random variable.
 *
 *  @return     A random double between min and max.
 */
public static double uniform(double min, double max) {
  return min + (max - min) * rand();
}
}

 MersenneTwister rng = new MersenneTwister();
rng.setSeed(new int[] {1234567890});
System.out.println(rng.nextInt(Integer.MAX_VALUE)); // 1977150888

MersenneTwister twister = new MersenneTwister();
final int length = 27;
char[] chars = new char[length];
for (int i = 0; i < length; i++) {
  chars[i] = (char) ('a' + twister.nextInt(26));

BytesStore trend = NativeBytesStore.lazyNativeBytesStoreWithFixedCapacity(trendLength * 8L);
double x = start;
RandomGenerator rand = new MersenneTwister();
for (int i = 0; i < trendLength - 1; i++) {
  float f = rand.nextFloat();
  trend.writeDouble((long) i << 3, x);
  x += nd.inverseCumulativeProbability(f);
  tasks.add(fjp.submit(() -> {
    NormalDistribution nd2 = new NormalDistribution(0, sd2);
    RandomGenerator rand2 = new MersenneTwister();
    for (int j = si; j < ei; j++) {
      generateBrownian(col,

public MersenneTwisterFactory(long seed) {
  random.setSeed(seed);
}

@Override
protected MersenneTwisterGenerable next() {
  return new MersenneTwisterGenerable(random.nextLong());
}

@Override
public double nextDouble(double lowerBound, double upperBound) {
 return lowerBound + rnd.nextDouble()*(upperBound - lowerBound) ;
}

@Override
public RandomGenerator newInstance() {
 stateCheck();
 return new MersenneTwister(masterRandomGenerator.nextLong());
}

@Test
public void testRandomNode() {
 final RandomGenerator rnd = new MersenneTwister(456);
 for (int i = 0; i < 500; i++) {
  Graphs.addBiPath(graph, new Point(rnd.nextInt(), rnd.nextInt()),
   new Point(rnd.nextInt(), rnd.nextInt()));
 }
 final Graph<LengthData> unmod = Graphs.unmodifiableGraph(graph);
 final Point p1 = graph.getRandomNode(new MersenneTwister(123));
 final Point p2 = unmod.getRandomNode(new MersenneTwister(123));
 assertEquals(p1, p2);
}