A Java implementation of the MT19937 (Mersenne Twister) pseudo random number generator algorithm : Random « Development Class « Java






A Java implementation of the MT19937 (Mersenne Twister) pseudo random number generator algorithm

  
/*
 * This file is part of aion-emu <aion-emu.com>.
 *
 * aion-emu is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * aion-emu is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with aion-emu.  If not, see <http://www.gnu.org/licenses/>.
 */
//package com.aionemu.commons.utils;

import java.util.Random;
/**
 * @author Balancer
 * 
 */
public class Rnd
{
  private static final MTRandom  rnd  = new MTRandom();

  /**
   * @return rnd
   * 
   */
  public static float get() // get random number from 0 to 1
  {
    return rnd.nextFloat();
  }

  /**
   * Gets a random number from 0(inclusive) to n(exclusive)
   * 
   * @param n
   *            The superior limit (exclusive)
   * @return A number from 0 to n-1
   */
  public static int get(int n)
  {
    return (int) Math.floor(rnd.nextDouble() * n);
  }

  /**
   * @param min
   * @param max
   * @return value
   */
  public static int get(int min, int max) // get random number from
  // min to max (not max-1 !)
  {
    return min + (int) Math.floor(rnd.nextDouble() * (max - min + 1));
  }

  /**
   * @param n
   * @return n
   */
  public static int nextInt(int n)
  {
    return (int) Math.floor(rnd.nextDouble() * n);
  }

  /**
   * @return int
   */
  public static int nextInt()
  {
    return rnd.nextInt();
  }

  /**
   * @return double
   */
  public static double nextDouble()
  {
    return rnd.nextDouble();
  }

  /**
   * @return double
   */
  public static double nextGaussian()
  {
    return rnd.nextGaussian();
  }

  /**
   * @return double
   */
  public static boolean nextBoolean()
  {
    return rnd.nextBoolean();
  }
}

/**
 * @author David Beaumont, Copyright 2005
 *         <p/>
 *         A Java implementation of the MT19937 (Mersenne Twister) pseudo random number generator algorithm based upon
 *         the original C code by Makoto Matsumoto and Takuji Nishimura (see <a
 *         href="http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html">
 *         http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html</a> for more information.
 *         <p/>
 *         As a subclass of java.util.Random this class provides a single canonical method next() for generating bits in
 *         the pseudo random number sequence. Anyone using this class should invoke the public inherited methods
 *         (nextInt(), nextFloat etc.) to obtain values as normal. This class should provide a drop-in replacement for
 *         the standard implementation of java.util.Random with the additional advantage of having a far longer period
 *         and the ability to use a far larger seed value.
 *         <p/>
 *         This is <b>not</b> a cryptographically strong source of randomness and should <b>not</b> be used for
 *         cryptographic systems or in any other situation where true random numbers are required.
 *         <p/>
 *         <!-- Creative Commons License --> <a href="http://creativecommons.org/licenses/LGPL/2.1/"><img
 *         alt="CC-GNU LGPL" border="0" src="http://creativecommons.org/images/public/cc-LGPL-a.png" /></a><br />
 *         This software is licensed under the <a href="http://creativecommons.org/licenses/LGPL/2.1/">CC-GNU LGPL</a>.
 *         <!-- /Creative Commons License --> <!-- <rdf:RDF xmlns="http://web.resource.org/cc/"
 *         xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"> <Work
 *         rdf:about=""> <license rdf:resource="http://creativecommons.org/licenses/LGPL/2.1/" /> <dc:type
 *         rdf:resource="http://purl.org/dc/dcmitype/Software" /> </Work> <License
 *         rdf:about="http://creativecommons.org/licenses/LGPL/2.1/"> <permits
 *         rdf:resource="http://web.resource.org/cc/Reproduction" /> <permits
 *         rdf:resource="http://web.resource.org/cc/Distribution" /> <requires
 *         rdf:resource="http://web.resource.org/cc/Notice" /> <permits
 *         rdf:resource="http://web.resource.org/cc/DerivativeWorks" /> <requires
 *         rdf:resource="http://web.resource.org/cc/ShareAlike" /> <requires
 *         rdf:resource="http://web.resource.org/cc/SourceCode" /> </License> </rdf:RDF> -->
 * @version 1.0
 */
class MTRandom extends Random
{
  /**
   * Auto-generated serial version UID. Note that MTRandom does NOT support serialisation of its internal state and it
   * may even be necessary to implement read/write methods to re-seed it properly. This is only here to make Eclipse
   * shut up about it being missing.
   */
  private static final long  serialVersionUID  = -515082678588212038L;

  // Constants used in the original C implementation
  private final static int  UPPER_MASK      = 0x80000000;
  private final static int  LOWER_MASK      = 0x7fffffff;
  private final static int  N          = 624;
  private final static int  M          = 397;
  private final static int[]  MAGIC        =
                          { 0x0, 0x9908b0df };
  private final static int  MAGIC_FACTOR1    = 1812433253;
  private final static int  MAGIC_FACTOR2    = 1664525;
  private final static int  MAGIC_FACTOR3    = 1566083941;
  private final static int  MAGIC_MASK1      = 0x9d2c5680;
  private final static int  MAGIC_MASK2      = 0xefc60000;
  private final static int  MAGIC_SEED      = 19650218;
  private final static long  DEFAULT_SEED    = 5489L;

  // Internal state
  private transient int[]    mt;
  private transient int    mti;
  private transient boolean  compat        = false;

  // Temporary buffer used during setSeed(long)
  private transient int[]    ibuf;

  /**
   * The default constructor for an instance of MTRandom. This invokes the no-argument constructor for
   * java.util.Random which will result in the class being initialised with a seed value obtained by calling
   * System.currentTimeMillis().
   */
  public MTRandom()
  {
  }

  /**
   * This version of the constructor can be used to implement identical behaviour to the original C code version of
   * this algorithm including exactly replicating the case where the seed value had not been set prior to calling
   * genrand_int32.
   * <p/>
   * If the compatibility flag is set to true, then the algorithm will be seeded with the same default value as was
   * used in the original C code. Furthermore the setSeed() method, which must take a 64 bit long value, will be
   * limited to using only the lower 32 bits of the seed to facilitate seamless migration of existing C code into Java
   * where identical behaviour is required.
   * <p/>
   * Whilst useful for ensuring backwards compatibility, it is advised that this feature not be used unless
   * specifically required, due to the reduction in strength of the seed value.
   * 
   * @param compatible
   *            Compatibility flag for replicating original behaviour.
   */
  public MTRandom(boolean compatible)
  {
    super(0L);
    compat = compatible;
    setSeed(compat ? DEFAULT_SEED : System.currentTimeMillis());
  }

  /**
   * This version of the constructor simply initialises the class with the given 64 bit seed value. For a better
   * random number sequence this seed value should contain as much entropy as possible.
   * 
   * @param seed
   *            The seed value with which to initialise this class.
   */
  public MTRandom(long seed)
  {
    super(seed);
  }

  /**
   * This version of the constructor initialises the class with the given byte array. All the data will be used to
   * initialise this instance.
   * 
   * @param buf
   *            The non-empty byte array of seed information.
   * @throws NullPointerException
   *             if the buffer is null.
   * @throws IllegalArgumentException
   *             if the buffer has zero length.
   */
  public MTRandom(byte[] buf)
  {
    super(0L);
    setSeed(buf);
  }

  /**
   * This version of the constructor initialises the class with the given integer array. All the data will be used to
   * initialise this instance.
   * 
   * @param buf
   *            The non-empty integer array of seed information.
   * @throws NullPointerException
   *             if the buffer is null.
   * @throws IllegalArgumentException
   *             if the buffer has zero length.
   */
  public MTRandom(int[] buf)
  {
    super(0L);
    setSeed(buf);
  }

  // Initializes mt[N] with a simple integer seed. This method is
  // required as part of the Mersenne Twister algorithm but need
  // not be made public.
  /**
   * @param seed
   * 
   */
  private void setSeed(int seed)
  {

    // Annoying runtime check for initialisation of internal data
    // caused by java.util.Random invoking setSeed() during init.
    // This is unavoidable because no fields in our instance will
    // have been initialised at this point, not even if the code
    // were placed at the declaration of the member variable.
    if (mt == null)
      mt = new int[N];

    // ---- Begin Mersenne Twister Algorithm ----
    mt[0] = seed;
    for (mti = 1; mti < N; mti++)
    {
      mt[mti] = (MAGIC_FACTOR1 * (mt[mti - 1] ^ (mt[mti - 1] >>> 30)) + mti);
    }
    // ---- End Mersenne Twister Algorithm ----
  }

  /**
   * This method resets the state of this instance using the 64 bits of seed data provided. Note that if the same seed
   * data is passed to two different instances of MTRandom (both of which share the same compatibility state) then the
   * sequence of numbers generated by both instances will be identical.
   * <p/>
   * If this instance was initialised in 'compatibility' mode then this method will only use the lower 32 bits of any
   * seed value passed in and will match the behaviour of the original C code exactly with respect to state
   * initialisation.
   * 
   * @param seed
   *            The 64 bit value used to initialise the random number generator state.
   */
  @Override
  public final synchronized void setSeed(long seed)
  {
    if (compat)
    {
      setSeed((int) seed);
    }
    else
    {

      // Annoying runtime check for initialisation of internal data
      // caused by java.util.Random invoking setSeed() during init.
      // This is unavoidable because no fields in our instance will
      // have been initialised at this point, not even if the code
      // were placed at the declaration of the member variable.
      if (ibuf == null)
        ibuf = new int[2];

      ibuf[0] = (int) seed;
      ibuf[1] = (int) (seed >>> 32);
      setSeed(ibuf);
    }
  }

  /**
   * This method resets the state of this instance using the byte array of seed data provided. Note that calling this
   * method is equivalent to calling "setSeed(pack(buf))" and in particular will result in a new integer array being
   * generated during the call. If you wish to retain this seed data to allow the pseudo random sequence to be
   * restarted then it would be more efficient to use the "pack()" method to convert it into an integer array first
   * and then use that to re-seed the instance. The behaviour of the class will be the same in both cases but it will
   * be more efficient.
   * 
   * @param buf
   *            The non-empty byte array of seed information.
   * @throws NullPointerException
   *             if the buffer is null.
   * @throws IllegalArgumentException
   *             if the buffer has zero length.
   */
  public final void setSeed(byte[] buf)
  {
    setSeed(pack(buf));
  }

  /**
   * This method resets the state of this instance using the integer array of seed data provided. This is the
   * canonical way of resetting the pseudo random number sequence.
   * 
   * @param buf
   *            The non-empty integer array of seed information.
   * @throws NullPointerException
   *             if the buffer is null.
   * @throws IllegalArgumentException
   *             if the buffer has zero length.
   */
  public final synchronized void setSeed(int[] buf)
  {
    int length = buf.length;
    if (length == 0)
      throw new IllegalArgumentException("Seed buffer may not be empty");
    // ---- Begin Mersenne Twister Algorithm ----
    int i = 1, j = 0, k = (N > length ? N : length);
    setSeed(MAGIC_SEED);
    for (; k > 0; k--)
    {
      mt[i] = (mt[i] ^ ((mt[i - 1] ^ (mt[i - 1] >>> 30)) * MAGIC_FACTOR2)) + buf[j] + j;
      i++;
      j++;
      if (i >= N)
      {
        mt[0] = mt[N - 1];
        i = 1;
      }
      if (j >= length)
        j = 0;
    }
    for (k = N - 1; k > 0; k--)
    {
      mt[i] = (mt[i] ^ ((mt[i - 1] ^ (mt[i - 1] >>> 30)) * MAGIC_FACTOR3)) - i;
      i++;
      if (i >= N)
      {
        mt[0] = mt[N - 1];
        i = 1;
      }
    }
    mt[0] = UPPER_MASK; // MSB is 1; assuring non-zero initial array
    // ---- End Mersenne Twister Algorithm ----
  }

  /**
   * This method forms the basis for generating a pseudo random number sequence from this class. If given a value of
   * 32, this method behaves identically to the genrand_int32 function in the original C code and ensures that using
   * the standard nextInt() function (inherited from Random) we are able to replicate behaviour exactly.
   * <p/>
   * Note that where the number of bits requested is not equal to 32 then bits will simply be masked out from the top
   * of the returned integer value. That is to say that:
   * <p/>
   * 
   * <pre>
   * mt.setSeed(12345);
   * int foo = mt.nextInt(16) + (mt.nextInt(16) &lt;&lt; 16);
   * </pre>
   * 
   * <p/>
   * will not give the same result as
   * <p/>
   * 
   * <pre>
   * mt.setSeed(12345);
   * int foo = mt.nextInt(32);
   * </pre>
   * 
   * @param bits
   *            The number of significant bits desired in the output.
   * @return The next value in the pseudo random sequence with the specified number of bits in the lower part of the
   *         integer.
   */
  @Override
  protected final synchronized int next(int bits)
  {
    // ---- Begin Mersenne Twister Algorithm ----
    int y, kk;
    if (mti >= N)
    { // generate N words at one time

      // In the original C implementation, mti is checked here
      // to determine if initialisation has occurred; if not
      // it initialises this instance with DEFAULT_SEED (5489).
      // This is no longer necessary as initialisation of the
      // Java instance must result in initialisation occurring
      // Use the constructor MTRandom(true) to enable backwards
      // compatible behaviour.

      for (kk = 0; kk < N - M; kk++)
      {
        y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK);
        mt[kk] = mt[kk + M] ^ (y >>> 1) ^ MAGIC[y & 0x1];
      }
      for (; kk < N - 1; kk++)
      {
        y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK);
        mt[kk] = mt[kk + (M - N)] ^ (y >>> 1) ^ MAGIC[y & 0x1];
      }
      y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK);
      mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ MAGIC[y & 0x1];

      mti = 0;
    }

    y = mt[mti++];

    // Tempering
    y ^= (y >>> 11);
    y ^= (y << 7) & MAGIC_MASK1;
    y ^= (y << 15) & MAGIC_MASK2;
    y ^= (y >>> 18);
    // ---- End Mersenne Twister Algorithm ----
    return (y >>> (32 - bits));
  }

  // This is a fairly obscure little code section to pack a
  // byte[] into an int[] in little endian ordering.

  /**
   * This simply utility method can be used in cases where a byte array of seed data is to be used to repeatedly
   * re-seed the random number sequence. By packing the byte array into an integer array first, using this method, and
   * then invoking setSeed() with that; it removes the need to re-pack the byte array each time setSeed() is called.
   * <p/>
   * If the length of the byte array is not a multiple of 4 then it is implicitly padded with zeros as necessary. For
   * example:
   * <p/>
   * 
   * <pre>
   *     byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 }
   * </pre>
   * 
   * <p/>
   * becomes
   * <p/>
   * 
   * <pre>
   *     int[]  { 0x04030201, 0x00000605 }
   * </pre>
   * 
   * <p/>
   * <p/>
   * Note that this method will not complain if the given byte array is empty and will produce an empty integer array,
   * but the setSeed() method will throw an exception if the empty integer array is passed to it.
   * 
   * @param buf
   *            The non-null byte array to be packed.
   * @return A non-null integer array of the packed bytes.
   * @throws NullPointerException
   *             if the given byte array is null.
   */
  public static int[] pack(byte[] buf)
  {
    int k, blen = buf.length, ilen = ((buf.length + 3) >>> 2);
    int[] ibuf = new int[ilen];
    for (int n = 0; n < ilen; n++)
    {
      int m = (n + 1) << 2;
      if (m > blen)
        m = blen;
      for (k = buf[--m] & 0xff; (m & 0x3) != 0; k = (k << 8) | buf[--m] & 0xff)
        ;
      ibuf[n] = k;
    }
    return ibuf;
  }
}

   
    
  








Related examples in the same category

1.Create random number
2.Create two random number generators with the same seed
3.Does Math.random() produce 0.0 and 1.0
4.Random numbers between 1 and 100
5.Random number between 0 AND 10
6.Random integers that range from from 0 to n
7.Random.nextInt(n) returns a distributed int value between 0 (inclusive) and n (exclusive).
8.Round Java float and double numbers using Math.round
9.Randomizer
10.nextDouble() and nextGaussian() in java.util.Random
11.Generating random numbers
12.Generate random ints by asking Random() for
13.Getting random numbers: nextGaussian
14.Generate a random array of numbers
15.Next double and next int
16.Random bytes
17.Random boolean
18.Random long type number
19.Random float type number
20.Random double type number
21.Math.random
22.A wrapper that supports all possible Random methods via the java.lang.Math#random() method and its system-wide {@link Random} object.
23.Operations for random Strings
24.Random Util with ReentrantLock
25.Randomizer
26.Random: Properly synchronized and can be used in a multithreaded environment
27.A predictable random number generator.
28.Random GUID
29.A random.org seeded random generator.
30.Generates a secure random word with the given length consisting of uppercase and lowercase letters and numbers.
31.A random choice maker
32.Memory-efficient map of keys to values with list-style random-access semantics.
33.Generates a random integer inside the lo and hi interval
34.Randomizer
35.RandomGUID generates truly random GUIDs
36.A random access text file allows a text file to be accessed randomly starting at any position.
37.A garbage-free randomised quicksort
38.A linear random method based on xor shifts
39.Mersenne Twister Random
40.A GaussianHat is a random number generator that will give you numbers based on a population mean and standard deviation.
41.Randomly permutes the elements of the specified array
42.generate string consists of random characters.
43.Atomic Pseudo Random
44.Atomic Simple Random
45.Mersenne
46.Mersenne Twister
47.Mersenne Twister Fast
48.Mersenne Twister algorithm
49.Emulates a dice