Генерування випадкових цілих чисел з діапазону

Мені потрібна функція, яка б генерувала випадкове ціле число в заданому діапазоні (включаючи граничні значення). Я не пред'являю необґрунтованих вимог до якості / випадковості, у мене є чотири вимоги:

• Мені це потрібно, щоб бути швидким. Мій проект повинен генерувати мільйони (а іноді навіть десятки мільйонів) випадкових чисел, і моя поточна функція генератора виявилася вузьким місцем.
• Мені потрібно, щоб вона була достатньо рівномірною (використання rand () ідеально).
• діапазони min-max можуть бути від 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>засоби std , щоб встигнути, оскільки ви згадали про ефективність, для вас головна проблема.

#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;
}

Для мене (2,8 ГГц Intel Core i5) це друкує:

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, ймовірно, корисніша на практиці. Ви не повинні реалізовувати цей матеріал самостійно. Я бачив багато реалізацій вибірки відхилень, і часто буває дуже важко зрозуміти, правильно чи ні.

Як щодо Mersenne Twister ? Реалізація поштовху досить проста у використанні та добре перевірена у багатьох реальних програмах. Я сам це використовував у кількох академічних проектах, таких як штучний інтелект та еволюційні алгоритми.

Ось їхній приклад, коли вони виконують просту функцію для прокатки шестигранної плашки:

#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 - це дуже великий регістр зсуву лінійної зворотної зв'язку. Алгоритм працює на 19 937 бітовому насінні, що зберігається в 624-елементному масиві 32-бітних непідписаних цілих чисел. Значення 2 ^ 19937-1 - прайм Мерсена; техніка маніпулювання насінням базується на старовинному алгоритмі «скручування» - звідси назва «Мерсен Твістер».

Привабливим аспектом 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 , вона дуже детальна і добре задокументована, дозволяє чітко вказати, який дистрибутив ви хочете, а в некриптографічних сценаріях насправді може перевершити типову реалізацію ранду бібліотеки С.

припустимо, що 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, просто витрачається. Ви створюєте з нього лише одне випадкове число, тоді як є звукова процедура, яка може дати вам більше.

Припустимо, що ви хочете [хв, макс] область цілих випадкових чисел. Починаємо з [0, макс-хв]

Візьміть за основу 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.