Вопрос по random, java – Сколько раз я могу использовать randomGenerator.nextDouble (), прежде чем мне нужно будет выполнить повторное заполнение?

7

Я используюRandom класс в Java как генератор псевдослучайных чисел. Я использую функцию nextDouble много раз (~ 10 ^ 5). Сколько раз мне пришлось пересевать, чтобы не получить одинаковые цифры? Нужен ли пересев?

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

Это для эксперимента, числа будут использоваться в качестве координат для точек на пространстве, поэтому я хочу, чтобы распределение было как можно более равномерным.

Кроме того, как я могу повторно посеять? Где я могу получить семя int?

Ты виделstackoverflow.com/questions/7291911 ? Adrian Pronk
В общем, хороший генератор псевдослучайных чисел будет циклически перебирать весь набор целых чисел, которые он представляет, перед повторением. Случайно, кажется, имеет внутреннее целое число 48 эффективных бит Hot Licks

Ваш Ответ

3   ответа
0

что я не могу прямо ответить на ваш вопрос. Я не помню время цикла генератора случайных чисел на Java. Хотя я думаю, что вы сокращаете его с количеством генерируемых вами чисел.

Но то, что я выучил на занятиях по статистике компьютерной техники, может помочь вам.

Я узнал, что лучший метод генерации большинства случайных чисел - использование генератора случайных чисел Мерсенна Твистера. Этот генератор предоставит вам достаточное количество случайных чисел, чтобы его не нужно было повторять, период его (2 ^ 19937) & # x2212; 1

Вот исходный код для MerseeneTwister

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

Вот класс для генерации ваших случайных чисел.

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

Вот пример для генерации случайного числа. Обратите внимание, что я удалил комментарии из источника. Это может нарушить природу кода с открытым исходным кодом, но я не могу скопировать все это и отформатировать как код.

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 
//   w-r 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's a bug in Random's 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's best to make sure it's 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's bigger than an int (Mersenne Twister
 * only uses the first 32 bits for its seed).
 */
synchronized public void setSeed(final long seed) {
    // it's 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's 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 do,uble 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's not in java.util.Random.  */
public char nextChar() {
    // chars are 16-bit UniCode values
    return (char) (next(16));
}

/** For completeness' sake, though it's not in java.util.Random. */
public short nextShort() {
    return (short) (next(16));
}

/** For completeness' sake, though it's 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;
    }
}
}
5

х значений типа int. Внутреннее начальное число имеет 48 бит, поэтому случайная последовательность повторяется после не более 2 ^ 48 значений int или 2 ^ 47 двойных значений.

+1: если вы используете SecureRandom, вам не нужно повторно заполнять.
2

Если вы используете Set (который гарантирует уникальные значения):

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

Несмотря на то, что вы думаете, это выполняется довольно быстро: 60 миллисекунд на 100000 номеров на моем (типичном) ПК.

Если вы действительно хотите массив, вы можете извлечь его из набора.
Если вы хотите сохранить порядок, в котором они были созданы, используйтеLinkedHashSet (у него была похожая производительность)

@ChristianSemrau Потому что, если вы прочитаете вопрос, он на самом деле просит 10 ^ 5different двойники. Ответ "нет, он не нуждается в повторном посеве". если он использует этот импл.
Хм. Таким образом, тот факт, что это останавливается, говорит о том, что цикл больше 10 ^ 5, верно? Uri
@ Bohemian Как это отвечает на вопрос о продолжительности периода генератора?
@ Bohemian Ну, если генератор не создает дубликатов, оригинальное значение impl с использованием массива также хорошо. OTOH, если генератор создает дубликат, он будет продолжать это делать, потому что цикл исчерпал длину периода генератора, и ваш цикл не завершится. Чтобы генерировать уникальные значения без остановки программы, можно проверить возвращаемое значениеnumbers.add чтобы увидеть, если дубликат был найден.
@ChristianSemrau Хороший вопрос. Еслиn слишком велик, цикл никогда не закончится, но у вас не хватит памяти для удержания Setlong до того, как у вас закончатся числа, т. е. невозможно иметь достаточно памяти, которая может содержать 2 ^ 48 чисел ... для этого потребуется 262144 Гб! Я бы сказал, что использовать мою реализацию безопасно уже несколько лет.

Похожие вопросы