Генерация случайного целого числа из диапазона

Мне нужна функция, которая генерирует случайное целое число в заданном диапазоне (включая значения границ). У меня нет необоснованных требований к качеству / случайности, у меня есть четыре требования:

• Мне нужно, чтобы это было быстро. Мой проект должен генерировать миллионы (а иногда даже десятки миллионов) случайных чисел, и моя текущая функция генератора оказалась узким местом.
• Мне нужно, чтобы он был достаточно равномерным (использование rand () прекрасно).
• диапазон минимальных и максимальных значений может быть от <0, 1> до <-32727, 32727>.
• это должно быть посеянным.

В настоящее время у меня есть следующий код C ++:

output = min + (rand() * (int)(max - min) / RAND_MAX)

Проблема в том, что он не является действительно единообразным - max возвращается только тогда, когда rand () = RAND_MAX (для Visual C ++ это 1/32727). Это главная проблема для небольших диапазонов, таких как <-1, 1>, где последнее значение почти никогда не возвращается.

Поэтому я взял ручку и бумагу и придумал следующую формулу (которая основывается на трюке округления целых чисел (int) (n + 0,5)):

Но это все еще не дает мне равномерное распределение. Повторные прогоны с 10000 выборками дают мне соотношение 37:50:13 для значений значений -1, 0,1.

Не могли бы вы предложить лучшую формулу? (или даже целая функция генератора псевдослучайных чисел)

Быстрое, несколько лучшее, чем у вас, но все еще не правильно распределенное решение

output = min + (rand() % static_cast<int>(max - min + 1))

За исключением случаев, когда размер диапазона является степенью 2, этот метод создает смещенные неоднородные распределенные числа независимо от качества rand(). Для всесторонней проверки качества этого метода, пожалуйста, прочитайте это .

Самый простой (и, следовательно, лучший) ответ C ++ (используя стандарт 2011 года)

#include <random>

std::random_device rd;     // only used once to initialise (seed) engine
std::mt19937 rng(rd());    // random-number engine used (Mersenne-Twister in this case)
std::uniform_int_distribution<int> uni(min,max); // guaranteed unbiased

auto random_integer = uni(rng);

Не нужно заново изобретать колесо. Не нужно беспокоиться о предвзятости. Не нужно беспокоиться об использовании времени в качестве случайного семени.

Если ваш компилятор поддерживает C ++ 0x и его использование является вариантом для вас, тогда новый стандартный <random>заголовок, вероятно, удовлетворит ваши потребности. Он имеет высокое качество, uniform_int_distributionкоторое принимает минимальные и максимальные границы (включительно по мере необходимости), и вы можете выбрать один из различных генераторов случайных чисел для подключения к этому распределению.

Вот код, который генерирует миллион случайных ints, равномерно распределенных в [-57, 365]. Я использовал новые <chrono>средства стандартизации для определения времени, так как вы упомянули, что производительность является серьезной проблемой для вас.

#include <iostream>
#include <random>
#include <chrono>

int main()
{
    typedef std::chrono::high_resolution_clock Clock;
    typedef std::chrono::duration<double> sec;
    Clock::time_point t0 = Clock::now();
    const int N = 10000000;
    typedef std::minstd_rand G;
    G g;
    typedef std::uniform_int_distribution<> D;
    D d(-57, 365);
    int c = 0;
    for (int i = 0; i < N; ++i) 
        c += d(g);
    Clock::time_point t1 = Clock::now();
    std::cout << N/sec(t1-t0).count() << " random numbers per second.\n";
    return c;
}

Для меня (Intel Core i5 2,8 ГГц) это распечатывает:

2.10268e + 07 случайных чисел в секунду.

Вы можете заполнить генератор, передав int в его конструктор:

    G g(seed);

Если позже вы обнаружите, что intон не охватывает диапазон, необходимый для вашего дистрибутива, это можно исправить, изменив uniform_int_distributionподобное так (например, на long long):

    typedef std::uniform_int_distribution<long long> D;

Если позже вы обнаружите, что minstd_randгенератор недостаточно высокого качества, его также можно легко заменить. Например:

    typedef std::mt19937 G;  // Now using mersenne_twister_engine

Имея отдельный контроль над генератором случайных чисел, и случайное распределение может быть довольно освобождающим.

Я также вычислил (не показано) первые 4 «момента» этого распределения (используя minstd_rand) и сравнил их с теоретическими значениями в попытке количественно оценить качество распределения:

min = -57
max = 365
mean = 154.131
x_mean = 154
var = 14931.9
x_var = 14910.7
skew = -0.00197375
x_skew = 0
kurtosis = -1.20129
x_kurtosis = -1.20001

( x_Префикс относится к «ожидаемому»)

Давайте разделим проблему на две части:

• Генерация случайного числа nв диапазоне от 0 до (макс-мин).
• Добавить мин к этому числу

Первая часть, очевидно, самая сложная. Давайте предположим, что возвращаемое значение rand () совершенно одинаково. Использование по модулю добавит смещение к первым (RAND_MAX + 1) % (max-min+1)числам. Так что, если мы могли бы волшебным образом изменить , RAND_MAXчтобы RAND_MAX - (RAND_MAX + 1) % (max-min+1), не было бы больше не будут какие - либо предубеждения.

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

Время выполнения теперь распределено геометрически с ожидаемым значением, 1/pгде pесть вероятность получить достаточно малое число с первой попытки. Так RAND_MAX - (RAND_MAX + 1) % (max-min+1)как всегда меньше чем (RAND_MAX + 1) / 2, мы знаем это p > 1/2, поэтому ожидаемое количество итераций всегда будет меньше двух для любого диапазона. С помощью этой техники должна быть возможность генерировать десятки миллионов случайных чисел менее чем за секунду на стандартном процессоре.

РЕДАКТИРОВАТЬ:

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

Как насчет Мерсена Твистера ? Реализация boost довольно проста в использовании и хорошо протестирована во многих реальных приложениях. Я сам использовал его в нескольких научных проектах, таких как искусственный интеллект и эволюционные алгоритмы.

Вот их пример, где они делают простую функцию, чтобы бросить шестигранный кубик:

#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/random/variate_generator.hpp>

boost::mt19937 gen;

int roll_die() {
    boost::uniform_int<> dist(1, 6);
    boost::variate_generator<boost::mt19937&, boost::uniform_int<> > die(gen, dist);
    return die();
}

О, и вот еще несколько сводов этого генератора на тот случай, если вы не уверены, что вам следует использовать его гораздо хуже rand():

Mersenne Twister - это генератор «случайных чисел», изобретенный Макото Мацумото и Такудзи Нисимура; их сайт включает в себя многочисленные реализации алгоритма.

По сути, Mersenne Twister является очень большим регистром сдвига с линейной обратной связью. Алгоритм работает с начальным разрядом 19 937, хранящимся в массиве из 624 элементов из 32-разрядных целых чисел без знака. Значение 2 ^ 19937-1 - простое число Мерсенна; Техника для манипулирования семенем основана на более старом алгоритме «скручивания» - отсюда и название «Mersenne Twister».

Привлекательным аспектом Mersenne Twister является использование двоичных операций - в отличие от трудоемкого умножения - для генерации чисел. Алгоритм также имеет очень длительный период и хорошую детализацию. Это быстро и эффективно для некриптографических приложений.

int RandU(int nMin, int nMax)
{
    return nMin + (int)((double)rand() / (RAND_MAX+1) * (nMax-nMin+1));
}

Это отображение 32768 целых чисел в (nMax-nMin + 1) целых чисел. Отображение будет очень хорошим, если (nMax-nMin + 1) мало (как в вашем требовании). Однако обратите внимание, что если (nMax-nMin + 1) велико, отображение не будет работать (например, вы не можете отобразить 32768 значений в 30000 значений с равной вероятностью). Если такие диапазоны необходимы - вы должны использовать 32-битный или 64-битный случайный источник вместо 15-битной rand () или игнорировать результаты rand (), которые выходят за пределы допустимого диапазона.

Вот непредвзятая версия, которая генерирует числа в [low, high]:

int r;
do {
  r = rand();
} while (r < ((unsigned int)(RAND_MAX) + 1) % (high + 1 - low));
return r % (high + 1 - low) + low;

Если ваш диапазон достаточно мал, нет причин кэшировать правую часть сравнения в doцикле.

Я рекомендую библиотеку Boost.Random , она очень детализирована и хорошо документирована, она позволяет вам явно указать, какой дистрибутив вы хотите, и в не криптографических сценариях может фактически превзойти типичную реализацию ранда библиотеки C.

предположим, что min и max являются значениями int, [и] означает, что включают это значение, (и) означает, что не включают это значение, используя выше, чтобы получить правильное значение с помощью c ++ rand ()

ссылка: для () [] определить, посетить:

https://en.wikipedia.org/wiki/Interval_(mathematics)

для функций rand и srand или определения RAND_MAX посетите:

http://en.cppreference.com/w/cpp/numeric/random/rand

[мин Макс]

int randNum = rand() % (max - min + 1) + min

(мин Макс]

int randNum = rand() % (max - min) + min + 1

[мин Макс)

int randNum = rand() % (max - min) + min

(мин Макс)

int randNum = rand() % (max - min - 1) + min + 1

В этой теме выборка отклонения уже обсуждалась, но я хотел предложить одну оптимизацию, основанную на том факте, что rand() % 2^something она не вносит никакого смещения, как уже упоминалось выше.

Алгоритм действительно прост:

• рассчитать наименьшую степень 2 больше длины интервала
• рандомизировать одно число в этом «новом» интервале
• вернуть это число, если оно меньше длины исходного интервала
  • отклонить иначе

Вот мой пример кода:

int randInInterval(int min, int max) {
    int intervalLen = max - min + 1;
    //now calculate the smallest power of 2 that is >= than `intervalLen`
    int ceilingPowerOf2 = pow(2, ceil(log2(intervalLen)));

    int randomNumber = rand() % ceilingPowerOf2; //this is "as uniform as rand()"

    if (randomNumber < intervalLen)
        return min + randomNumber;      //ok!
    return randInInterval(min, max);    //reject sample and try again
} 

Это хорошо работает, особенно для небольших интервалов, потому что степень 2 будет «ближе» к реальной длине интервала, и поэтому число промахов будет меньше.

PS
Очевидно, что избегать рекурсии было бы более эффективно (не нужно вычислять снова и снова потолок бревна ...), но я подумал, что это будет более читабельно для этого примера.

Обратите внимание, что в большинстве предложений начальное случайное значение, которое вы получаете от функции rand (), обычно от 0 до RAND_MAX, просто теряется. Вы создаете только одно случайное число из него, в то время как есть надежная процедура, которая может дать вам больше.

Предположим, что вы хотите [min, max] область целых случайных чисел. Начнем с [0, max-min]

Взять базу b = max-min + 1

Начните с представления числа, полученного вами из rand () в базе b.

Таким образом, вы получите слово (log (b, RAND_MAX)), потому что каждая цифра в базе b, за исключением, возможно, последней, представляет случайное число в диапазоне [0, max-min].

Конечно, последний сдвиг к [min, max] прост для каждого случайного числа r + min.

int n = NUM_DIGIT-1;
while(n >= 0)
{
    r[n] = res % b;
    res -= r[n];
    res /= b;
    n--;
}

Если NUM_DIGIT - это число цифр в базе b, которое вы можете извлечь, и это

NUM_DIGIT = floor(log(b,RAND_MAX))

тогда вышеизложенное представляет собой простую реализацию извлечения случайных чисел NUM_DIGIT от 0 до b-1 из одного случайного числа RAND_MAX, обеспечивая b <RAND_MAX.

Формула для этого очень проста, поэтому попробуйте это выражение,

 int num = (int) rand() % (max - min) + min;  
 //Where rand() returns a random number between 0.0 and 1.0

Следующее выражение должно быть беспристрастным, если я не ошибаюсь:

std::floor( ( max - min + 1.0 ) * rand() ) + min;

Здесь я предполагаю, что rand () дает вам случайное значение в диапазоне от 0,0 до 1,0, НЕ включая 1,0, и что max и min являются целыми числами с условием, что min <max.