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