Вопрос 7. Проиллюстрируйте закон больших чисел
Сложность: 2/3
Закон больших чисел (ЗБЧ) говорит, что при увеличении количества попыток случайная величина стремится к своему математическому ожиданию — всё усредняется. Подробнее об этом можно прочитать в нашей статье об основах математики для Data Science.
Код для иллюстрации ЗБЧ на примере честной монетки выглядит так:
Вначале мы импортировали уже знакомый нам модуль random и модуль matplotlib.plt — он нужен для рисования простых графиков. После этого определили переменные: общее количество бросков (total_flips), список из значений вероятностей (numerical_probability), количество выпавших орлов (H_count).
Теперь в цикле мы 5 000 раз «подбрасываем» монетку. Если выпадает орёл («H»), то делим текущее количество выпавших орлов на текущее количество бросков и добавляем итоговое значение в конец списка numerical_probability. В конце рисуем график.
Манипуляции с ГСЧ
Я уже обсуждал различия между истинным ГСЧ и псевдо ГСЧ и тот факт, что в играх используется псевдо ГСЧ, основанный на алгоритме. Некоторые увлеченные геймеры используют утилиты эмуляции для анализа игр и выявления лазеек, которые можно использовать для управления результатами, даже если используется алгоритм генератора случайных чисел.
ГСЧ на основе алгоритма использует начальное число, которое представляет собой комбинацию определенных факторов и генерирует результат в игре. Это применяемые законы математики, и поскольку 1+1 всегда равно 2, аналогично, если известны факторы в игре, которые приносят желаемый результат, то вы всегда можете достичь того же результата.
Например, если игра требует от игрока выбрать определенного персонажа с определенными усилениями, и результатом будет легкая битва с боссом, то этот шаблон будет постоянным, и все, кто выберет одни и те же варианты, будут иметь одинаковые результаты. Но, для обычного игрока это было бы невозможно, и псевдо-ГСЧ всегда казался бы истинным ГСЧ.
random.choice()
В модуле Python random есть функция choice(), используемая для выбора случайного элемента из списка или другой последовательности. Функция random.choice() используется для возврата случайного элемента из списка значений.
Синтаксис ramdom.choice()
random.choice(sequence)
или
random.choices(sequence, k=l)
Здесь последовательность параметров может быть строкой, списком, кортежем и random.choice() только одним случайным элементом.
В функции random.choices() k — количество возвращаемых элементов. Предположим, мы не упоминаем значение параметра k, random.choices() возвращает один элемент из последовательности или списка.
Пример 1:
В этом примере мы предоставляем последовательность(список) в качестве параметра и возвращаем один случайный элемент.
import random
listValue =
item = random.choice(listValue)
print("random item from list is: ", item)
Выход:
random item from list is: 10
Пример 2:
Функция random.choices() в основном используется для возврата случайных элементов с различными возможностями. Эта функция также принимает вес(k) — количество случайных выборов. Например, мы хотим напечатать 3 случайных названия фильмов из списка 5 фильмов.
import random
movieList =
randomMovies = random.choices(movieList, k=3)
print("random movies from list are: ", randomMovies)
Выход:
random movies from list are:
Внешние ссылки [ править ]
- RANDOM.ORG Служба истинных случайных чисел
- Случайные и псевдослучайных на В наше время на BBC
- jRand основанный на Java фреймворк для генерации последовательностей моделирования, включая псевдослучайные последовательности чисел.
- Генераторы случайных чисел в библиотеке NAG Fortran
- Маяк случайности в NIST , транслирующий полные энтропийные битовые строки блоками по 512 бит каждые 60 секунд. Предназначен для обеспечения непредсказуемости, автономности и согласованности.
- Системный вызов для случайных чисел: getrandom () , статья LWN.net, описывающая специальный системный вызов Linux.
- Статистические свойства псевдослучайных последовательностей и эксперименты с PHP и Debian OpenSSL
- Криптографический генератор псевдослучайных лотерейных номеров ISAAC
- Генератор случайных последовательностей на основе лавинного шума
| Авторитетный контроль |
|
|---|
Пример кода C99
Используя код C , ГСЧ Парк-Миллера можно записать следующим образом:
uint32_tlcg_parkmiller(uint32_t*state)
{
return*state=(uint64_t)*state*48271%0x7fffffff;
}
Эту функцию можно вызывать многократно для генерации псевдослучайных чисел, если вызывающая сторона тщательно инициализирует состояние любым числом больше нуля и меньше модуля. В этой реализации требуется 64-битная арифметика; в противном случае произведение двух 32-битных целых чисел может переполниться.
Чтобы избежать 64-битного деления, сделайте сокращение вручную:
uint32_tlcg_parkmiller(uint32_t*state)
{
uint64_tproduct=(uint64_t)*state*48271;
uint32_tx=(product&0x7fffffff)+(product>>31);
x=(x&0x7fffffff)+(x>>31);
return*state=x;
}
Чтобы использовать только 32-битную арифметику, используйте метод Шраге:
uint32_tlcg_parkmiller(uint32_t*state)
{
// Precomputed parameters for Schrage's method
constuint32_tM=0x7fffffff;
constuint32_tA=48271;
constuint32_tQ=MA;// 44488
constuint32_tR=M%A;// 3399
uint32_tdiv=*stateQ;// max: M / Q = A = 48,271
uint32_trem=*state%Q;// max: Q - 1 = 44,487
int32_ts=rem*A;// max: 44,487 * 48,271 = 2,147,431,977 = 0x7fff3629
int32_tt=div*R;// max: 48,271 * 3,399 = 164,073,129
int32_tresult=s-t;
if(result<)
result+=M;
return*state=result;
}
или используйте два умножения размером 16 × 16 бит:
uint32_tlcg_parkmiller(uint32_t*state)
{
constuint32_tA=48271;
uint32_tlow=(*state&0x7fff)*A;// max: 32,767 * 48,271 = 1,581,695,857 = 0x5e46c371
uint32_thigh=(*state>>15)*A;// max: 65,535 * 48,271 = 3,163,439,985 = 0xbc8e4371
uint32_tx=low+((high&0xffff)<<15)+(high>>16);// max: 0x5e46c371 + 0x7fff8000 + 0xbc8e = 0xde46ffff
x=(x&0x7fffffff)+(x>>31);
return*state=x;
}
Другой популярный генератор Лемера использует простой модуль 2 32 −5:
uint32_tlcg_rand(uint32_t*state)
{
return*state=(uint64_t)*state*279470273u%0xfffffffb;
}
Это также можно записать без 64-битного деления:
uint32_tlcg_rand(uint32_t*state)
{
uint64_tproduct=(uint64_t)*state*279470273u;
uint32_tx;
// Not required because 5 * 279470273 = 0x5349e3c5 fits in 32 bits.
// product = (product & 0xffffffff) + 5 * (product >> 32);
// A multiplier larger than 0x33333333 = 858,993,459 would need it.
// The multiply result fits into 32 bits, but the sum might be 33 bits.
product=(product&0xffffffff)+5*(uint32_t)(product>>32);
product+=4;
// This sum is guaranteed to be 32 bits.
x=(uint32_t)product+5*(uint32_t)(product>>32);
return*state=x-4;
}
Многие другие генераторы Lehmer обладают хорошими свойствами. Следующий генератор Лемера по модулю 2 128 требует 128-битной поддержки от компилятора и использует множитель, вычисленный L’Ecuyer. Имеет период 2 126 :
staticunsigned__int128state;
/* The state must be seeded with an odd value. */
voidseed(unsigned__int128seed)
{
state=seed<<1|1;
}
uint64_tnext(void)
{
// GCC cannot write 128-bit literals, so we use an expression
constunsigned__int128mult=
(unsigned__int128)0x12e15e35b500f16e<<64|
0x2e714eb2b37916a5;
state*=mult;
returnstate>>64;
}
Генератор вычисляет нечетное 128-битное значение и возвращает его старшие 64 бита.
Следующая основная процедура повышает скорость выполнения вышеуказанного кода для целочисленных рабочих нагрузок (если компилятор позволяет оптимизировать объявление константы вне цикла вычислений):
uint64_tnext(void)
{
uint64_tresult=state>>64;
// GCC cannot write 128-bit literals, so we use an expression
constunsigned__int128mult=
(unsigned__int128)0x12e15e35b500f16e<<64|
0x2e714eb2b37916a5;
state*=mult;
returnresult;
}
Однако, поскольку умножение отложено, оно не подходит для хеширования, поскольку первый вызов просто возвращает верхние 64 бита начального состояния.
Как создать случайное число в Bash?
Как создать случайное число в диапазоне в Bash?
Используйте $RANDOM . Это часто полезно в сочетании с простой арифметикой оболочки. Например, для генерации случайного числа между 1 и 10:
Фактический генератор находится в variables.c , функции brand() . Старые версии были простым линейным генератором. Версия 4.0 из bash использует генератор
Попробуйте это из своей оболочки:
Здесь -t d указывает, что формат вывода должен быть подписан десятичным; -N 1 говорит читать один байт от /dev/urandom .
Вы также можете использовать shuf (доступно в coreutils).
вы также можете получить случайное число из awk
Существует $RANDOM. Я точно не знаю, как это работает. Но это работает. Для тестирования вы можете:
![Генерация случайных чисел содержание а также практическое применение и использование [ править ]](https://fuzeservers.ru/wp-content/uploads/8/2/3/8234c46e697d7c8afe474027159b6af0.jpeg)
Случайное число от 0 до 9 включительно.
Если вы используете систему linux, вы можете получить случайное число из /dev/random или/dev/urandom. Будьте осторожны /dev/random будет блокироваться, если не будет достаточно случайных чисел. Если вам нужна скорость над случайностью, используйте /dev/urandom.
Эти “файлы” будут заполнены случайными числами, сгенерированными операционной системой. Это зависит от реализации /dev/random в вашей системе, если вы получаете истинные или псевдослучайные числа. Истинные случайные числа генерируются с помощью формы сигнала, собранной из драйверов устройств, таких как мышь, жесткий диск, сеть.
Вы можете получить случайные числа из файла с помощью dd
Я взял несколько из этих идей и сделал функцию, которая должна выполняться быстро, если требуется множество случайных чисел.
вызов od стоит дорого, если вам нужно много случайных чисел. Вместо этого я вызываю его один раз и сохраняю 1024 случайных числа из /dev/urandom. Когда вызывается rand , последнее случайное число возвращается и масштабируется. Затем он удаляется из кеша. Когда кеш пуст, считываются еще 1024 случайных числа.
Возвращает случайное число в RET между 0 и 9 включительно.
UPDATE: это не так хорошо для всех N. Он также отбрасывает случайные биты, если используется с малым N. Отмечая, что (в этом случае) 32-битное случайное число имеет достаточно энтропии для 9 случайных чисел от 0 до 9 ( 10 * 9 = 1,000,000,000 Ответ №11
Чтение из /dev/random или/dev/urandom символов специальных файлов – это путь.
Эти два файла являются интерфейсом для рандомизации ядра, в частности
который извлекает поистине случайные байты из аппаратного обеспечения, если такая функция осуществляется с помощью аппаратного обеспечения (как правило, это), или она извлекается из пула энтропии (состоящего из таймингов между событиями, такими как прерывания мыши и клавиатуры и другие прерывания, зарегистрированные в SA_SAMPLE_RANDOM).
Это работает, но записывает ненужный вывод из dd в stdout. Приведенная ниже команда дает только целое число, которое мне нужно. Я даже могу получить определенное количество случайных бит, сколько мне нужно, отрегулировав битмаску, заданную для арифметического расширения:
Генерировать случайное число в диапазоне от 0 до n (16-битное целое число). Результат устанавливается в переменной $RAND. Например:
Может быть, я немного опоздал, но как насчет использования jot для генерации случайного числа в диапазоне в Bash?
Это генерирует случайное ( -r ) число с точностью до 3 десятичных знаков ( -p ). В этом конкретном случае вы получите одно число от 0 до 1 ( 1 0 1 ). Вы также можете распечатать последовательные данные. Источник случайного числа, согласно руководству, является:
Основанный на замечательных ответах @Nelson, @Barun и @Robert, вот скрипт Bash, который генерирует случайные числа.
- Может генерировать, сколько цифр вы хотите.
- каждая цифра генерируется отдельно /dev/urandom , что намного лучше, чем встроенная в Bash $RANDOM
Источник
Отладка программ, использующих случайные числа
Программы, использующие случайные числа, может быть трудно отлаживать, потому что программа при каждом запуске может вести себя по-разному. Иногда это может сработать, а иногда нет. При отладке полезно следить за тем, чтобы ваша программа каждый раз выполняла один и тот же (неправильный) путь. Таким образом, вы можете запускать программу столько раз, сколько необходимо, чтобы определить причину ошибки.
По этой причине при отладке полезно установить случайное начальное число (через ) на определенное значение (например, 0), которое вызывает ошибочное поведение. Это гарантирует, что ваша программа каждый раз будет генерировать одни и те же результаты, что упростит отладку. Как только вы обнаружите ошибку, вы можете снова использовать системные часы, чтобы снова начать генерировать рандомизированные результаты.
Функция random() – «случайные» вещественные числа
Чтобы получить случайное вещественное число, или, как говорят, число с плавающей точкой, следует использовать функцию из одноименного модуля языка Python. Она не принимает никаких аргументов и возвращает число от 0 до 1, не включая 1:
>>> random.random() 0.17855729241927576 >>> random.random() 0.3310978930421846
или
>>> random() 0.025328854415995194
Результат содержит много знаков после запятой. Чтобы его округлить, можно воспользоваться встроенной в Python функцией :
>>> a = random.random() >>> a 0.8366142721623201 >>> round(a, 2) 0.84 >>> round(random.random(), 3) 0.629
Чтобы получать случайные вещественные числа в иных пределах, отличных от [0; 1), прибегают к математическим приемам. Так если умножить полученное из число на любое целое, то получится вещественное в диапазоне от 0 до этого целого, не включая его:
>>> random.random() * 10 2.510618091637596 >>> random.random() * 10 6.977540211221759
Если нижняя граница должна быть отличной от нуля, то число из надо умножать на разницу между верхней и нижней границами, после чего прибавить нижнюю:
>>> random.random() * (10 - 4) + 4 9.517280589233597 >>> random.random() * (10 - 4) + 4 6.4429124181215975 >>> random.random() * (10 - 4) + 4 4.9231983600782385
В данном примере число умножается на 6. В результате получается число от 0 до 6. Прибавив 4, получаем число от 4 до 10.
Пример получения случайных чисел от -1 до 1:
>>> random.random() * (1 + 1) - 1 -0.673382618351051 >>> random.random() * (1 + 1) - 1 0.34121487148075924 >>> random.random() * (1 + 1) - 1 -0.988751324713907 >>> random.random() * (1 + 1) - 1 0.44137358363477674
Нижняя граница равна -1. При вычитании получается +. Когда добавляется нижняя граница, то плюс заменяется на минус ( +(-1) = — 1).
Для получения псевдослучайных чисел можно пользоваться исключительно функцией . Если требуется получить целое, то всегда можно округлить до него с помощью или отбросить дробную часть с помощью :
>>> int(random.random() * 100) 61 >>> round(random.random() * 100 - 50) -33
Работа с предвзятостью
Битовый поток из таких систем склонен к смещению с преобладанием единиц или нулей. Есть два подхода к устранению предвзятости и других артефактов. Первый — спроектировать ГСЧ, чтобы минимизировать смещение, присущее работе генератора. Один из методов исправления этого — обратная связь сгенерированного битового потока, отфильтрованного фильтром нижних частот, для регулировки смещения генератора. Согласно центральной предельной теореме , контур обратной связи будет иметь тенденцию хорошо настраиваться « почти все время ». Этот метод часто используют сверхвысокоскоростные генераторы случайных чисел. Даже в этом случае полученные числа обычно несколько необъективны.
Программное отбеливание
Второй подход к преодолению предвзятости — уменьшить ее после генерации (программно или аппаратно). Существует несколько методов уменьшения смещения и корреляции, часто называемых алгоритмами « отбеливания », по аналогии с соответствующей проблемой создания белого шума из коррелированного сигнала.
Джон фон Нейман изобрел простой алгоритм, чтобы исправить простую систематическую ошибку и уменьшить корреляцию. Он одновременно рассматривает два бита (неперекрывающиеся), выполняя одно из трех действий: когда два последовательных бита равны, они отбрасываются; последовательность 1,0 становится 1; и последовательность 0,1 становится нулем. Таким образом, он представляет собой спадающий фронт с 1 и передний фронт с 0. Это устраняет простое смещение и легко реализуется в виде компьютерной программы или в цифровой логике. Этот метод работает независимо от того, как были сгенерированы биты. Однако он не может гарантировать случайность вывода. Что он может сделать (со значительным количеством отброшенных битов), так это преобразовать смещенный случайный поток битов в несмещенный.
Другой метод улучшения битового потока, близкого к случайному, заключается в том, чтобы исключить или исключить битовый поток с выходом высококачественного криптографически безопасного генератора псевдослучайных чисел, такого как Blum Blum Shub или надежного потокового шифра . Это может улучшить декорреляцию и смещение цифр при небольших затратах; это можно сделать с помощью оборудования, например ПЛИС, что быстрее, чем с помощью программного обеспечения.
Связанный метод, который уменьшает смещение в потоке битов, близком к случайному, состоит в том, чтобы взять два или более некоррелированных потока битов, близких к случайным, и исключить их вместе. Пусть вероятность того, что поток битов создаст 0, равна 1/2 + e , где -1/2 ≤ e ≤ 1/2. Тогда е — это смещение битового потока. Если два некоррелированных потока битов со смещением e объединяются по принципу «исключающее или единое», то смещение результата будет равно 2 e 2 . Это можно повторить с другими битовыми потоками (см. Также лемму о накоплении ).
В некоторых проектах применяются криптографические хеш-функции, такие как MD5 , SHA-1 или RIPEMD-160, или даже функция CRC для всего или части битового потока, а затем используются выходные данные как случайный битовый поток. Это привлекательно, отчасти потому, что это относительно быстро.
Многие физические явления могут быть использованы для генерации битов с сильным смещением, но каждый бит не зависит от других. Счетчик Гейгера (с временем выборки, превышающим время восстановления трубки) или полупрозрачный зеркальный фотонный детектор генерируют потоки битов, которые в основном равны «0» (бесшумный или пропускающий) с периодической «1» (щелчок или отражение). Если каждый бит независим от других, стратегия фон Неймана генерирует один случайный несмещенный выходной бит для каждого из редких битов «1» в таком сильно смещенном потоке битов. Методы отбеливания, такие как Расширенная многоуровневая стратегия (AMLS), могут извлекать больше выходных битов — выходных битов, которые столь же случайны и несмещены — из такого сильно смещенного битового потока.
ГПСЧ с периодически обновляемым случайным ключом
Другие конструкции используют то, что считается истинными случайными битами, в качестве ключа для алгоритма высококачественного блочного шифрования , принимая зашифрованный вывод как случайный поток битов
Однако в этих случаях необходимо соблюдать осторожность, чтобы выбрать подходящий режим блокировки. В некоторых реализациях PRNG запускается для ограниченного числа цифр, в то время как устройство генерирования аппаратных средств создает новое начальное число.
random.randint()
Функция Python random.randint() используется для генерации случайного целого числа в указанном диапазоне.
Синтаксис:
random.randint(start, stop)
Функция random.randint() принимает два параметра: start (начальный диапазон) и stop (конечный диапазон). Оба параметра включаются при генерации случайного числа.
Пример random.randint(), генерирующий список случайных целых чисел:
В этом примере будет создан список из нескольких случайных целых чисел с помощью функции randint(). Создание списка из 5 случайных целых чисел от 1 до 100, включая оба значения.
import random
randomListValue = []
# specifing length of list equal to 5
for i in range(0, 5):
# generates random numbers from 1 to 100
randomListValue.append(random.randint(1, 100))
print("Printing list of 5 generated random numbers")
print(randomListValue)
Выход:
Printing list of 5 generated random numbers
Однако может существовать вероятность того, что функция random.randint() вернет повторяющееся число в выходном результате. Чтобы избежать дублирования случайного целого числа в результате, используйте функцию random.sample().
Дополнительный материал: как работает предыдущая функция?
Функция может показаться немного сложной, но всё не так уж плохо.
Вернемся к нашей цели. Функция возвращает число от 0 до (включительно). Мы хотим каким-то образом преобразовать результат в число от до (включительно). Это означает, что когда мы выполняем преобразование, 0 должен стать , а должен стать с равномерным распределением чисел между ними.
Мы делаем это в пять этапов:
- Умножаем наш результат от на дробь . Это преобразует результат в число с плавающей запятой от 0 (включительно) до 1 (не включая).
- Если возвращает 0, тогда по-прежнему равно 0. Если возвращает , тогда равно , что немного меньше 1. Любые другие числа, возвращаемые функцией будут равномерно распределены между этими двумя точками.
- Затем нам нужно знать, сколько чисел мы можем вернуть. Другими словами, сколько чисел находится между (включительно) и (включительно)?
- Это просто (). Например, если = 8 и = 5, ( — + 1) = (8 — 5 + 1) = 4. Между 5 и 8 есть 4 числа (то есть 5, 6, 7 и 8).
- Умножаем два предыдущих результата вместе. Если у нас было число с плавающей запятой от 0 (включительно) до 1 (не включая), а затем мы умножили его на (), теперь у нас есть число с плавающей запятой между 0 (включительно) и () (не включая).
- Преобразуем предыдущий результат в целое число. Это удаляет любую дробную составляющую, оставляя нам целочисленный результат от 0 (включительно) до ( — ) (включительно).
- Наконец, мы добавляем , что переводит наш результат в целое число от (включительно) до (включительно).
Алгоритм Фибоначчи с запаздываниями
Этот алгоритм, выраженный уравнением, выглядит так:
Если на словах, то новое случайное число является тем, которое было сгенерировано 7 раз назад, плюс случайное число, сгенерированное 10 раз назад, и деленное по модулю на большое значение m. Значения (7, 10) можно изменять, как я вскоре поясню.
Допустим, что в некий момент времени последовательность сгенерированных чисел следующая:
где 561 — самое последнее из сгенерированных значений. Если m = 100, то следующим случайным числом будет:
Заметьте, что в любой момент вам всегда нужны 10 самых последних сгенерированных значений. Поэтому ключевая задача в алгоритме Фибоначчи с запаздываниями состоит в генерации начальных значений, необходимых для запуска процесса. Демонстрационная реализация алгоритма Фибоначчи с запаздываниями приведена на рис. 5.
Рис. 5. Реализация алгоритма Фибоначчи с запаздываниями
Демонстрационный код использует предыдущие случайные числа X(i–7) и X(i–10) для генерации следующего случайного числа. В научно-исследовательской литературе по этой тематике значения (7, 10) обычно обозначаются (j, k). Существуют другие пары (j, k), которые можно применять для алгоритма Фибоначчи с запаздываниями. Несколько значений, рекомендованных в хорошо известной книге «Art of Computer Programming» (Addison-Wesley, 1968), — (24,55), (38,89), (37,100), (30,127), (83,258), (107,378).
Чтобы инициализировать (j, k) в RNG Фибоначчи с запаздываниями, вы должны предварительно заполнить список значениями k. Это можно сделать несколькими способами. Однако наименьшее из начальных значений k обязательно должно быть нечетным. В демонстрации применяется грубый метод копирования значения параметра seed для всех начальных значений k с последующим удалением первой 1000 сгенерированных значений. Если значение параметра seed четное, тогда первое из значений k выставляется равным 11 (произвольному нечетному числу).
Чтобы предотвратить арифметическое переполнение, метод Next использует тип long для вычислений и математическое свойство: (a + b) mod n = mod n.
Вопрос 4. Как повторить случайную последовательность?
Сложность: 2/3
Истинно случайную последовательность повторить невозможно. Но для повторения псевдослучайных чисел в обеих основных библиотеках — random и numpy.random есть функция seed (), которая отвечает за инициализацию («посев») последовательности.
Передавая аргумент 42 в функцию seed(), мы указываем конкретное место в псевдослучайной последовательности, поэтому команда random.random() в третьей и последней строках выдаёт одинаковое число — оно идёт первым после точки, помеченной как seed (42).
В seed() можно передать целые и дробные числа, а также строки и кортежи. Если оставить скобки пустыми, то в качестве аргумента seed() возьмёт текущее системное время.
Аналогичная функция есть в модуле numpy.random:
Выбор модуля
Чаще всего модуль выбирается как простое число, что делает выбор взаимно простого начального числа тривиальным ( подойдет любое 0 < X < m ). Это обеспечивает наилучшее качество вывода, но вносит некоторую сложность в реализацию, и диапазон вывода вряд ли будет соответствовать желаемому приложению; преобразование в желаемый диапазон требует дополнительного умножения.
Для достижения этого периода, множитель должен удовлетворять а ≡ ± 3 ( по модулю 
и семя Х должно быть нечетным.
Использование составного модуля возможно, но генератор должен быть заполнен значением, взаимно простым с m , иначе период будет значительно сокращен. Например, модуль F 5 = 2 32 +1 может показаться привлекательным, поскольку выходные данные могут быть легко отображены в 32-битное слово 0 ≤ X i −1 <2 32 . Однако начальное значение X = 6700417 (которое делит 2 32 +1) или любое кратное значение приведет к выходу с периодом только 640.
Более популярной реализацией для больших периодов является комбинированный линейный конгруэнтный генератор ; объединение (например, суммирования их выходов) нескольких генераторов эквивалентно выходу одного генератора, модуль которого является произведением модулей генераторов компонентов. и период которой является наименьшим общим кратным из составляющих периодов. Хотя периоды будут иметь общий делитель 2, модули можно выбрать так, чтобы это был единственный общий делитель, а результирующий период был равен ( m 1 −1) ( m 2 −1) ( m 2 ··· ( m k — 1) / 2 k − 1. Одним из примеров этого является генератор Вихмана – Хилла .
Зачем нужны функции getstate() и setstate() ?
Если вы получили предыдущее состояние и восстановили его, тогда вы сможете оперировать одними и теми же случайными данными раз за разом. Помните, что использовать другую функцию random в данном случае нельзя. Также нельзя изменить значения заданных параметров. Сделав это, вы измените значение состояния .
Для закрепления понимания принципов работы и в генераторе случайных данных Python рассмотрим следующий пример:
Python
import random
number_list =
print(«Первая выборка «, random.sample(number_list,k=5))
# хранит текущее состояние в объекте state
state = random.getstate()
print(«Вторая выборка «, random.sample(number_list,k=5))
# Восстанавливает состояние state, используя setstate
random.setstate(state)
#Теперь будет выведен тот же список второй выборки
print(«Третья выборка «, random.sample(number_list,k=5))
# Восстанавливает текущее состояние state
random.setstate(state)
# Вновь будет выведен тот же список второй выборки
print(«Четвертая выборка «, random.sample(number_list,k=5))
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
importrandom number_list=3,6,9,12,15,18,21,24,27,30 print(«Первая выборка «,random.sample(number_list,k=5)) state=random.getstate() print(«Вторая выборка «,random.sample(number_list,k=5)) random.setstate(state) print(«Третья выборка «,random.sample(number_list,k=5)) random.setstate(state) print(«Четвертая выборка «,random.sample(number_list,k=5)) |
Вывод:
Shell
Первая выборка
Вторая выборка
Третья выборка
Четвертая выборка
|
1 2 3 4 |
Перваявыборка18,15,30,9,6 Втораявыборка27,15,12,9,6 Третьявыборка27,15,12,9,6 Четвертаявыборка27,15,12,9,6 |
Как можно заметить в результате вывода — мы получили одинаковые наборы данных. Это произошло из-за сброса генератора случайных данных.
Функции модуля random
| Функция | Описание |
| seed(A) | Каждому сгенерированному числу соответствует свое зерно выборки A. Это некий параметр, по которому модуль выбирает псевдослучайный результат. Если это зерно не указано, модуль использует значение системного времени. Если же одно и то же значение зерна указать в разных местах кода, вы получите один и тот же псевдослучайный результат. |
| getstate() | Запоминает состояние генератора псевдослучайных величин, чтобы использовать впоследствии с функцией setstate(). |
| setstate() | Восстанавливает состояние генератора псевдослучайных величин. |
| randrange(A, B, C) |
Эта функция определяет случайное число, выбранное в заданном диапазоне от A до В с указанным шагом С. Функция может использоваться только с одним аргументом, в этом случае случайная величина будет генерироваться в «полуоткрытом» диапазоне от нуля (включительно) до значения этого аргумента (не включая это число).
Это можно записать также как [0, A). Если функция randrange содержит только два аргумента, она работает как randint, генерируя числа в полуоткрытом диапазоне [A, B). |
| randint(A, B) | Функция, которая генерирует случайное целое число в заданном диапазоне от A до B. |
| choice(имя_списка) | Функция, позволяющая сгенерировать случайный выбор из компонентов заранее описанного списка. |
| choices(имя_списка, A) | Эта функция выбирает несколько (A) случайных элементов из списка. |
| shuffle(имя_списка) | Функция дает возможность установить элементы списка в случайном порядке. Аргументом функции служит имя_списка. |
| sample(имя_списка, A) | Используется для случайного выбора определенного количества элементов из списка, где A — число выбираемых элементов списка. |
| random() | Одноименная функция модуля random для генерирования чисел с плавающей точкой в диапазоне от нуля до единицы, не включая единицу. |
| uniform(A, B) | Функция, позволяющая получить число с плавающей запятой между числами A и B, где оба числа указаны с плавающей запятой, например, uniform(10.5, 25.5). |
| Функции, перечисленные ниже, применяются для решения узкоспециализированных задач, таких как статистические методы и теория вероятности | |
| betavariate() | Используется для получения случайного числа с плавающей запятой от до 1 на основе бета-распределения (применяется для статистических расчетов). |
|
expovariate() |
Генерирует случайное число с плавающей запятой на основе экспоненциального распределения (используется в статистике). |
| gammavariate() | Функция создает случайное число с плавающей запятой на основе гамма-распределения (используется для программирования со статистическими методами). |
| gauss() | Генерирует случайное число с плавающей запятой на основе распределения Гаусса (используется в теории вероятности). |
| lognormvariate() | Генерирует случайное число с плавающей запятой на основе логнормального распределения (используется в задачах, связанных с теорией вероятности). |
| normalvariate() | Функция генерирует случайное число с плавающей запятой на основе нормального распределения (используется в задачах по теории вероятности). |
| vonmisesvariate() | Создает случайное число с плавающей запятой на основе распределения фон Мизеса (используется в направленной статистике). |
| paretovariate() | |
| weibullvariate() |
Алгоритм Вичмана-Хилла
Этот алгоритм датируется 1982 годом. Идея Вичмана-Хилла заключается в генерации трех предварительных результатов и последующего их объединения в один финальный результат. Код, реализующий алгоритм Вичмана-Хилла, представлен на рис. 3. Демонстрационный код основан на статье Б. А. Вичмана (B. A. Wichmann) и А. Д. Хилла (I. D. Hill) «Algorithm AS 183: An Efficient and Portable Pseudo-Random Number Generator».
Рис. 3. Реализация алгоритма Вичмана-Хилла
Поскольку алгоритм Вичмана-Хилла использует три разных генерирующих уравнения, он требует трех начальных значений. В этом алгоритме три m-значения равны 30269, 30307 и 30323, поэтому вам понадобятся три начальных значения в диапазоне . Вы могли бы написать конструктор, принимающий эти три значения, но тогда вы получили бы несколько раздражающий программный интерфейс. В демонстрации применяется параметр с одним начальным значением, генерирующим три рабочих зародыша.
Вызов RNG Вичмана-Хилла осуществляется по тому же шаблону, что и других демонстрационных RNG:
Алгоритм Вичмана-Хилла лишь немного труднее в реализации, чем алгоритм Лемера. Преимущество первого над вторым в том, что алгоритм Вичмана-Хилла генерирует более длинную последовательность (более 6 000 000 000 000 значений) до того, как начнет повторяться.
