How many times can I use randomGenerator.nextDouble () before I need to reload?

Question

I use the Random class in Java as a pseudo random number generator. I use the nextDouble function many times (~ 10 ^ 5). How many times before I have to repeat to prevent getting the same numbers? Is supersaturation required?

  Random generator = new Random(); double[] numbers = new double[n]; for (int i = 0; i < n; i++) numbers[i] = generator.nextDouble(); 

This is for experiment, numbers will be used as coordinates for points in space, so I want the distribution to be as uniform as possible.

Also how can I update? Where can i get int seed?

Answer 1

The random number generator will produce a random double of two random int values. The internal seed has 48 bits, so a random sequence is repeated after no more than 2 ^ 48 int values ​​or 2 ^ 47 double values.

Answer 2

You do not need to worry about reloading, etc. if you use Set (which guarantees unique values):

 Random generator = new Random(); Set<Double> numbers = new HashSet<Double>(); while (numbers.size() < n) numbers.add(generator.nextDouble()); 

Despite what you think, this is pretty fast: 60 milliseconds for 100,000 numbers on my (typical) PC.

If you really need an array, you can extract it from the set.
If you want to save the order in which they were generated, use LinkedHashSet (it had similar performance)

Answer 3

I'm sorry, I can not directly answer your question. I don’t remember the cycle time of the Java random number generator. Although I really think you are cutting it with the number of numbers you generate.

But what I learned in my computer engineering statistics classes may help you.

I learned that the best way to generate the most random numbers is to use the Mersen Twister random number generator. This generator will provide you with enough random numbers that will not need to be reordered, it has a period (2 ^ 19937) - 1

Here is the source code for MerseeneTwister

https://java2s.com/Open-Source/Java/Natural-Language-Processing/MorphAdorner/edu/northwestern/at/utils/math/randomnumbers/MersenneTwister.java.htm

Here is a class to generate your random numbers.

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

Here is a sample for generating a random number. Please note that I removed the comments from the source. This may affect the nature of the open source code, but I could not completely copy and create it as code.

 import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; public class sample{ public static void main(String args[]){ RandomVariable gen = new RandomVariable(); double num = gen.uniform(-1,1); int n = 10000; Set<Double> nums = new HashSet<Double>(); while (numbers.size() < n) nums.add(gen.uniform(-1,1)); } } 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(); } } class MersenneTwister extends java.util.Random implements Serializable { // Period parameters private static final int N = 624; private static final int M = 397; private static final int MATRIX_A = 0x9908b0df; // private static final //* constant vector a private static final int UPPER_MASK = 0x80000000; // most significant // wr bits private static final int LOWER_MASK = 0x7fffffff; // least significant // r bits // Tempering parameters private static final int TEMPERING_MASK_B = 0x9d2c5680; private static final int TEMPERING_MASK_C = 0xefc60000; private int mt[]; // the array for the state vector private int mti; // mti==N+1 means mt[N] is not initialized private int mag01[]; // a good initial seed (of int size, though stored in a long) // private static final long GOOD_SEED = 4357; /* implemented here because there a bug in Random implementation of the Gaussian code (divide by zero, and log(0), ugh!), yet its gaussian variables are private so we can't access them here. :-( */ private double __nextNextGaussian; private boolean __haveNextNextGaussian; /** * Constructor using the default seed. */ public MersenneTwister() { this(System.currentTimeMillis()); } /** * Constructor using a given seed. Though you pass this seed in * as a long, it best to make sure it actually an integer. */ public MersenneTwister(final long seed) { super(seed); /* just in case */ setSeed(seed); } /** * Constructor using an array. */ public MersenneTwister(final int[] array) { super(System.currentTimeMillis()); /* pick something at random just in case */ setSeed(array); } /** * Initalize the pseudo random number generator. Don't * pass in a long that bigger than an int (Mersenne Twister * only uses the first 32 bits for its seed). */ synchronized public void setSeed(final long seed) { // it always good style to call super super.setSeed(seed); // Due to a bug in java.util.Random clear up to 1.2, we're // doing our own Gaussian variable. __haveNextNextGaussian = false; mt = new int[N]; mag01 = new int[2]; mag01[0] = 0x0; mag01[1] = MATRIX_A; mt[0] = (int) (seed & 0xfffffff); for (mti = 1; mti < N; mti++) { mt[mti] = (1812433253 * (mt[mti - 1] ^ (mt[mti - 1] >>> 30)) + mti); /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */ /* In the previous versions, MSBs of the seed affect */ /* only MSBs of the array mt[]. */ /* 2002/01/09 modified by Makoto Matsumoto */ mt[mti] &= 0xffffffff; /* for >32 bit machines */ } } /** * An alternative, more complete, method of seeding the * pseudo random number generator. array must be an * array of 624 ints, and they can be any value as long as * they're not *all* zero. */ synchronized public void setSeed(final int[] array) { int i, j, k; setSeed(19650218); i = 1; j = 0; k = (N > array.length ? N : array.length); for (; k != 0; k--) { mt[i] = (mt[i] ^ ((mt[i - 1] ^ (mt[i - 1] >>> 30)) * 1664525)) + array[j] + j; /* non linear */ mt[i] &= 0xffffffff; /* for WORDSIZE > 32 machines */ i++; j++; if (i >= N) { mt[0] = mt[N - 1]; i = 1; } if (j >= array.length) { j = 0; } } for (k = N - 1; k != 0; k--) { mt[i] = (mt[i] ^ ((mt[i - 1] ^ (mt[i - 1] >>> 30)) * 1566083941)) - i; /* non linear */ mt[i] &= 0xffffffff; /* for WORDSIZE > 32 machines */ i++; if (i >= N) { mt[0] = mt[N - 1]; i = 1; } } mt[0] = 0x80000000; /* MSB is 1; assuring non-zero initial array */ } /** * Returns an integer with <em>bits</em> bits filled with a random number. */ synchronized protected int next(final int bits) { int y; if (mti >= N) // generate N words at one time { int kk; final int[] mt = this.mt; // locals are slightly faster final int[] mag01 = this.mag01; // locals are slightly faster for (kk = 0; kk < N - M; kk++) { y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK); mt[kk] = mt[kk + M] ^ (y >>> 1) ^ mag01[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) ^ mag01[y & 0x1]; } y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK); mt[N - 1] = mt[M - 1] ^ (y >>> 1) ^ mag01[y & 0x1]; mti = 0; } y = mt[mti++]; y ^= y >>> 11; // TEMPERING_SHIFT_U(y) y ^= (y << 7) & TEMPERING_MASK_B; // TEMPERING_SHIFT_S(y) y ^= (y << 15) & TEMPERING_MASK_C; // TEMPERING_SHIFT_T(y) y ^= (y >>> 18); // TEMPERING_SHIFT_L(y) return y >>> (32 - bits); // hope that right! } /* If you've got a truly old version of Java, you can omit these two next methods. */ private synchronized void writeObject(final ObjectOutputStream out) throws IOException { // just so we're synchronized. out.defaultWriteObject(); } private synchronized void readObject(final ObjectInputStream in) throws IOException, ClassNotFoundException { // just so we're synchronized. in.defaultReadObject(); } /** This method is missing from jdk 1.0.x and below. JDK 1.1 includes this for us, but what the heck.*/ public boolean nextBoolean() { return next(1) != 0; } /** This generates a coin flip with a probability <tt>probability</tt> of returning true, else returning false. <tt>probability</tt> must be between 0.0 and 1.0, inclusive. Not as precise a random real event as nextBoolean(double), but twice as fast. To explicitly use this, remember you may need to cast to float first. */ public boolean nextBoolean(final float probability) { if (probability < 0.0f || probability > 1.0f) { throw new IllegalArgumentException("probability must be between 0.0" + " and 1.0 inclusive."); } if (probability == 0.0f) { return false; // fix half-open issues } else if (probability == 1.0f) { return true; // fix half-open issues } return nextFloat() < probability; } /** This generates a coin flip with a probability <tt>probability</tt> of returning true, else returning false. <tt>probability</tt> must be between 0.0 and 1.0, inclusive. */ public boolean nextBoolean(final double probability) { if (probability < 0.0 || probability > 1.0) { throw new IllegalArgumentException("probability must be between 0.0" + " and 1.0 inclusive."); } if (probability == 0.0) { return false; // fix half-open issues } else if (probability == 1.0) { return true; // fix half-open issues } return nextDouble() < probability; } /** This method is missing from JDK 1.1 and below. JDK 1.2 includes this for us, but what the heck. */ public int nextInt(final int n) { if (n <= 0) { throw new IllegalArgumentException("n must be >= 0"); } if ((n & -n) == n) { return (int) ((n * (long) next(31)) >> 31); } int bits, val; do { bits = next(31); val = bits % n; } while (bits - val + (n - 1) < 0); return val; } /** This method is for completness' sake. Returns a long drawn uniformly from 0 to n-1. Suffice it to say, n must be > 0, or an IllegalArgumentException is raised. */ public long nextLong(final long n) { if (n <= 0) { throw new IllegalArgumentException("n must be >= 0"); } long bits, val; do { bits = (nextLong() >>> 1); val = bits % n; } while (bits - val + (n - 1) < 0); return val; } /** A bug fix for versions of JDK 1.1 and below. JDK 1.2 fixes this for us, but what the heck. */ public double nextDouble() { return (((long) next(26) << 27) + next(27)) / (double) (1L << 53); } /** A bug fix for versions of JDK 1.1 and below. JDK 1.2 fixes this for us, but what the heck. */ public float nextFloat() { return next(24) / ((float) (1 << 24)); } /** A bug fix for all versions of the JDK. The JDK appears to use all four bytes in an integer as independent byte values! Totally wrong. I've submitted a bug report. */ public void nextBytes(final byte[] bytes) { for (int x = 0; x < bytes.length; x++) { bytes[x] = (byte) next(8); } } /** For completeness' sake, though it not in java.util.Random. */ public char nextChar() { // chars are 16-bit UniCode values return (char) (next(16)); } /** For completeness' sake, though it not in java.util.Random. */ public short nextShort() { return (short) (next(16)); } /** For completeness' sake, though it not in java.util.Random. */ public byte nextByte() { return (byte) (next(8)); } /** A bug fix for all JDK code including 1.2. nextGaussian can theoretical * ly ask for the log of 0 and divide it by 0! See Java bug <a href="http://developer.java.sun.com/developer/bugParade/bugs/4254501.h * tml"> http://developer.java.sun.com/developer/bugParade/bugs/4254501.html</a> */ synchronized public double nextGaussian() { if (__haveNextNextGaussian) { __haveNextNextGaussian = false; return __nextNextGaussian; } else { double v1, v2, s; do { v1 = 2 * nextDouble() - 1; // between -1.0 and 1.0 v2 = 2 * nextDouble() - 1; // between -1.0 and 1.0 s = v1 * v1 + v2 * v2; } while (s >= 1 || s == 0); double multiplier = /* Strict*/ Math.sqrt(-2 * /* Strict*/ Math.log(s) / s); __nextNextGaussian = v2 * multiplier; __haveNextNextGaussian = true; return v1 * multiplier; } } }