17.4.1. Процессоры случайных чисел и распределения

Процессоры случайных чисел — это классы объектов функции (см. раздел 14.8), определяющие оператор вызова, не получающий никаких аргументов и возвращающий случайное беззнаковое число. Вызвав объект типа процессора случайных чисел, можно получить простые случайные числа:

default_random_engine е; // создает случайное беззнаковое число

for (size_t i = 0; i < 10; ++i)

 // e() "вызывает" объект для создания следующего случайного числа

 cout << е() << " ";

На системе авторов эта программа выводит:

16807 282475249 1622650073 984943658 1144108930 470211272 ...

Здесь был определен объект е типа default_random_engine. В цикле for происходит вызов объекта е, возвращающий следующее случайное число.

Библиотека определяет несколько процессоров случайных чисел, отличающихся производительностью и качеством случайности. Каждый компилятор определяет один из этих процессоров как стандартный процессор случайных чисел (default random engine) (тип default_random_engine). Этот тип предназначен для процессоров с наиболее общеприменимыми свойствами (табл. 17.15). Список типов и функций процессоров, определенных стандартом, приведен в разделе А.3.2.

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

Типы распределения и процессоры

Чтобы получить число в определенном диапазоне, используется объект типа распределения:

// однородное распределение от 0 до 9 включительно

uniform_int_distribution<unsigned> u(0,9);

default_random_engine e; // создает случайные беззнаковые целые числа

for (size_t i = 0; i < 10; ++i)

 // u использует e как источник чисел

 // каждый вызов возвращает однородно распределенное значение

 // в заданном диапазоне

 cout << u(e) << " ";

Вывод таков:

0 1 7 4 5 2 0 6 6 9

Здесь u определяется как объект типа uniform_int_distribution<unsigned>. Этот тип создает однородно распределенные беззнаковые значения. При определении объекта этого типа можно задать минимум и максимум необходимых значений. Определение u(0, 9) указывает, что необходимы числа в диапазоне от 0 до 9 включительно. Распределение случайного числа использует включающие диапазоны, позволяющие получить любое возможное целочисленное значение в нем.

Подобно типам процессоров, типы распределения также являются классами объектов функции. Типы распределения определяют оператор вызова, получающий процессор случайных чисел как аргумент. Объект распределения использует свой аргумент процессора для создания случайного числа, которое объект распределения сопоставит с определенным распределением.

Обратите внимание на то, что объект процессора передается непосредственно, u(e). Если бы вызов был написан как u(е()), то произошла бы попытка передать следующее созданное е значение в u, что привело бы к ошибке при компиляции. Поскольку некоторые распределения вызывают процессор несколько раз, передается сам процессор, а не очередной результат его вызова.

Когда упоминается генератор случайных чисел (random-number generator), имеется в виду комбинация объекта распределения с объектом процессора.

Сравнение процессора случайных чисел и функции rand()

Читатели, знакомые с библиотечной функцией rand() языка С, вероятно заметили, что вывод вызова объекта default_random_engine подобен выводу функции rand(). Процессоры предоставляют целые беззнаковые числа в определенном системой диапазоне. Функция rand() имеет диапазон от 0 до RAND_MAX. Диапазон процессора возвращается при вызове функций-членов min() и max() объекта его типа:

cout << "min: " << e.min() << " max: " << e.max() << endl;

На системе авторов эта программа выводит следующее

min: 1 max: 2147483646

Таблица 17.15. Операции с процессором случайного числа

Процессоры создают последовательности чисел

У генераторов случайных чисел есть одно свойство, которое зачастую вызывает сомнения у новичков: даже при том, что создаваемые числа случайны, при каждом запуске данный генератор возвращает ту же последовательность чисел. Факт неизменности последовательности очень полезен во время проверки. С другой стороны, разработчики, использующие генераторы случайных чисел, должны учитывать этот факт.

Предположим, например, что необходима функция, создающая вектор из 100 случайных целых чисел, равномерно распределенных в диапазоне от 0 до 9. Могло бы показаться, что эту функцию следует написать следующим образом:

// безусловно неправильный способ создания

// вектора случайных целых чисел

// эта функция выводит те же 100 чисел при каждом вызове!

vector<unsigned> bad_randVec() {

 default_random_engine e;

 uniform_int_distribution<unsigned> u(0,9);

 vector<unsigned> ret;

 for (size_t i = 0; i < 100; ++i)

  ret.push_back(u(e));

 return ret;

}

Однако при каждом вызове эта функция возвратит тот же вектор:

vector<unsigned> v1(bad_randVec());

vector<unsigned> v2(bad_randVec());

// выводит equal

cout << ((v1 == v2) ? "equal" : "not equal") << endl;

Этот код выводит "equal", поскольку векторы v1 и v2 имеют те же значения.

Для правильного написания этой функции объекты процессора и распределения следует сделать статическими (см. раздел 6.1.1):

// возвращает вектор из 100 равномерно распределенных случайных чисел

vector<unsigned> good_randVec() {

 // поскольку процессоры и распределения хранят состояние, их следует

 // сделать статическими, чтобы при каждом вызове создавались новые

 // числа

 static default_random_engine е;

 static uniform_int_distribution<unsigned> u(0,9);

 vector<unsigned> ret;

 for (size_t i = 0; i < 100; ++i)

  ret.push_back(u(e));

 return ret;

}

Поскольку объекты e и u являются статическими, они хранят свое состояние на протяжении вызовов функции. Первый вызов будет использовать первые 100 случайных чисел из последовательности, созданной вызовом u(e), а второй вызов создаст следующие 100 чисел и т.д.

Каждый генератор случайных чисел всегда создает ту же последовательность чисел. Функция с локальным генератором случайных чисел должна сделать объекты процессора и распределения статическими. В противном случае функция будет создавать ту же последовательность при каждом вызове.

Начальное число генератора

Тот факт, что генератор возвращает ту же последовательность чисел, полезен во время отладки. Но после проверки программы необходимо заставить ее создавать разные случайные результаты при каждом запуске. Для этого предоставляется начальное число (seed). Начальное число — это значение, которое процессор может использовать для начала создания чисел с нового пункта в последовательности.

Начальное число генератора можно задать одним из двух способов: предоставить его при создании объекта процессора либо вызвать функцию-член seed() класса процессора:

default_random_engine e1; // использует стандартное начальное число

default_random_engine e2(2147483646); // использует заданное значение

                                      // начального числа

// e3 и e4 создадут ту же последовательность,

// поскольку они используют то же начальное число

default_random_engine e3; // использует стандартное начальное число

e3.seed(32767); // вызывает функцию seed() для установки нового

                // значения начального числа

default_random_engine e4(32767); // устанавливает начальное число 32767

for (size_t i = 0; i != 100; ++i) {

 if (e1() == e2())

  cout << "unseeded match at iteration: " << i << endl;

 if (e3() ! = e4())

  cout << "seeded differs at iteration: " << i << endl;

Здесь определены четыре процессора. Первые два, e1 и e2, имеют разные начальные числа и должны создавать разные последовательности. У двух вторых, e3 и e4, то же значение начального числа. Эти два объекта создадут ту же последовательность.

Выбор подходящего начального числа, как и почти все при создании хороших наборов случайных чисел, на удивление сложен. Вероятно, наиболее распространен подход вызова системной функции time(). Эта функция, определенная в заголовке ctime, возвращает количество секунд, начиная с заданной эпохи. Функция time() получает один параметр, являющийся указателем на структуру для записи времени. Если этот указатель нулевой, функция только возвращает время:

default_random_engine e1(time(0)); // почти случайное начальное число

Поскольку функция time() возвращает время как количество секунд, такое начальное число применимо только для приложений, создающих начальное число на уровне секунд или больших интервалов.

Функция time() обычно не используется как источник начального числа, если программа многократно запускается как часть автоматизированного процесса, поскольку она могла бы быть запущена с тем же начальным числом несколько раз.

Упражнения раздела 17.4.1

Упражнение 17.28. Напишите функцию, создающую и возвращающую равномерно распределенную последовательность случайных беззнаковых целых чисел при каждом вызове.

Упражнение 17.29. Позвольте пользователю предоставлять начальное число как необязательный аргумент функции, написанной в предыдущем упражнении.

Упражнение 17.30. Снова пересмотрите предыдущую функцию, позволив ей получать минимальное и максимальное значения для возвращаемых случайных чисел.