В дополнении к нескольким утилитам, четыре категории субъектов описана: uniform random bit generators, random number engines, random number engine adaptors, и random number distributions. Эти классификации применимы к типам, которые удовлетворяют соответствующим требованиям, к объектам, экземплярам которых создаются из таких типов, и к шаблонам, создающим такие типы при создании экземпляров. [ Note: Эти сущности определены таким образом, чтобы разрешить привязку любого однородного объекта генератора случайных битов e в качестве аргумента к любому объекту распределения случайных чисел d, создавая таким образом объект функции с нулевым аргументом, такой как заданный bind(d,e). ] — end note
Каждая из сущностей, указанных в этом подпункте, имеет ассоциированный объект, arithmetic type обозначенный как result_type. В T качестве result_type связанного с такой сущностью, эта сущность характеризуется:
a)как boolean или эквивалентно как boolean-valued, если T есть bool;
b)иначе как integral или эквивалентно как integer-valued, если numeric_limits<T>::is_integer есть true;
c)иначе как floating или эквивалентно как real-valued.
В случае целочисленного значения объект может дополнительно характеризоваться как signed или unsigned, в соответствии с numeric_limits<T>::is_signed.
Если не указано иное, во всех описаниях вычислений в этом подпункте используются математические действительные числа.
В этом подпункте операторы bitand , bitor и xor обозначают соответствующие стандартные побитовые операции. Дальше:
В этом подпункте [rand]эффект создания экземпляра шаблона:
a)с параметром типа шаблона с именем Sseq undefined, если соответствующий аргумент шаблона не является cv-unqualified и удовлетворяет требованиям seed sequence.
b)с параметром типа шаблона с именем URBG undefined, если соответствующий аргумент шаблона не является cv-unqualified и удовлетворяет требованиям uniform random bit generator.
c)с параметром типа шаблона с именем Engine undefined, если соответствующий аргумент шаблона не является cv-unqualified и удовлетворяет требованиям random number engine.
d)что параметр типа шаблона с именем RealType не определен , если соответствующий аргумент шаблона не резюме, неквалифицированное и один из float, doubleили long double.
e)который имеет тип параметра шаблона с именем IntType не определен , если соответствующий аргумент шаблона не резюме, неквалифицированные и один из short, int, long, long long, unsigned short, unsigned int, unsigned long, или unsigned long long.
f)что параметр типа шаблона с именем UIntType не определен , если соответствующий аргумент шаблона не резюме, неквалифицированное и один из unsigned short, unsigned int, unsigned longили unsigned long long.
В этом подпункте [rand]фразы вида « x является итератором определенного типа» должны интерпретироваться как эквивалентные более формальному требованию, что « x является значением типа, удовлетворяющим требованиям указанного типа итератора».
Является объектом , который потребляет последовательность целочисленных данных и производит требуемое число без знака целочисленных значений , на основе потребляемых данных. [ Такой объект предоставляет механизм, позволяющий избежать репликации потоков случайных значений. Это может быть полезно, например, в приложениях, требующих большого количества машин случайных чисел. ] seed sequence i 0≤i<232 Note: — end note
Класс S удовлетворяет требованиям начальной последовательности, если выражения, показанные в таблице 102 , действительны и имеют указанную семантику, а S также если они удовлетворяют всем другим требованиям этого раздела [rand.req.seedseq]. В этой таблице и в этом разделе:
a)T тип, названный Sассоциированным result_type;
b)q является значением S и, r возможно, константным значением S;
c)ib и ie являются итераторами ввода с целым числом без знака value_type длиной не менее 32 бит;
d)rb и re являются изменяемыми итераторами произвольного доступа с целым числом без знака value_type не менее 32 бит;
e)ob - итератор вывода; а также
f)il это значение initializer_list<T>.
Выражение | Тип возврата | До / после состояния | Сложность |
S::result_type | T | T представляет собой , unsigned integer type по меньшей мере , 32 бита. | время компиляции |
S() | Создает начальную последовательность с тем же начальным состоянием, что и все другие исходные последовательности типа, сконструированные по умолчанию S. | постоянный | |
S(ib,ie) | Создает начальную последовательность, имеющую внутреннее состояние, которое зависит от некоторых или всех битов предоставленной последовательности [ib,ie). | O(ie−ib) | |
S(il) | То же, что и S(il.begin(), il.end()). | такой же как S(il.begin(), il.end()) | |
q.generate(rb,re) | void | Ничего не делает, если rb == re. В противном случае заполняет предоставленную последовательность [rb,re) 32-битными величинами, которые зависят от последовательности, предоставленной конструктору, и, возможно, также зависят от истории generateпредыдущих вызовов. | O(re−rb) |
r.size() | size_t | Количество 32-битных единиц, которые будут скопированы при вызове r.param. | постоянный |
r.param(ob) | void | Копирует в указанное место назначения последовательность 32-битных единиц, которые могут быть предоставлены конструктору второго объекта типа S, и которые будут воспроизводить в этом втором объекте состояние, неотличимое от состояния первого объекта. | O(r.size()) |
uniform random bit generator g Типа G является функция объекта возвращение целого числа без знака значения , такой , что каждое значение в диапазоне возможных результатов имеет ( в идеале) , равная вероятности быть возвращены. [ Note: Степень gприближения результатов к идеалу часто определяется статистически. ] — end note
Класс G удовлетворяет требованиям a, uniform random bit generator если выражения, показанные в таблице 103 , действительны и имеют указанную семантику, а G также если удовлетворяет всем другим требованиям этого раздела [rand.req.urng]. В этой таблице и в этом разделе:
Выражение | Тип возврата | До / после состояния | Сложность |
G::result_type | T | T это unsigned integer type. | время компиляции |
g() | T | Возвращает значение в замкнутом интервале [G::min(), G::max()]. | амортизированная постоянная |
G::min() | T | Обозначает наименьшее значение, которое потенциально может вернуть operator(). | время компиляции |
G::max() | T | Обозначает наибольшее значение, которое потенциально может вернуть operator(). | время компиляции |
random number engine (Обычно сокращенно engine) e типа E является равномерной случайной генератор битов , что дополнительно отвечает требованиям (например, для посева , а также для ввода / вывода) , указанные в данном разделе.
В любой момент времени e имеет состояние ei для некоторого целого числа i≥0. При постройке e имеет исходное состояние e0. Состояние двигателя может быть установлено с помощью конструктора, seed функции, присваивания или подходящего operator>>.
Eспецификация должна определять:
a)размер Eсостояния, кратный размеру result_type, заданному как интегральное постоянное выражение;
b) transition algorithm TA , с помощью которого e«s государства ei продвигаются к его successor state ei+1; а также
c)с generation algorithm GA помощью которого состояние двигателя отображается на значение типа result_type.
Класс, E который удовлетворяет требованиям a, uniform random bit generator также удовлетворяет требованиям a, random number engine если выражения, показанные в таблице 104 , действительны и имеют указанную семантику, а E также if удовлетворяет всем другим требованиям этого раздела [rand.req.eng]. В этой таблице и в этом разделе:
a)T тип, названный Eассоциированным result_type;
b)e это значение E, v является именующим из E, x и y которые (возможно const) значения E;
c)s значение T;
d)q является lvalue, удовлетворяющим требованиям a seed sequence;
e)z это значение типа unsigned long long;
f)os - lvalue типа некоторой специализации шаблона класса basic_ostream<charT, traits>; а также
g)is - lvalue типа некоторой специализации шаблона класса basic_istream<charT, traits>;
где charT и traits ограничены согласно пунктам [strings] и пунктам [input.output].
Выражение | Тип возврата | До / после состояния | Сложность |
E() | Создает механизм с тем же начальным состоянием, что и все другие механизмы типа, построенные по умолчанию E. | O(size of state) | |
E(x) | Создает движок, который сравнивает равный x. | O(size of state) | |
E(s) | Создает движок с начальным состоянием, определяемым s. | O(size of state) | |
E(q)268 | Создает движок с начальным состоянием, которое зависит от последовательности, созданной одним вызовом q.generate. | q.generate такая же, как сложность вызываемой последовательности, длина которой равна размеру состояния | |
e.seed() | void | Postconditions: e == E(). | такой же как E() |
e.seed(s) | void | Postconditions: e == E(s). | такой же как E(s) |
e.seed(q) | void | Postconditions: e == E(q). | такой же как E(q) |
e() | T | Авансы eдержавотворческая ei к ei+1 =TA(ei) и возвращается GA(ei). | за таблицу 103 |
e.discard(z) 269 | void | Авансы eдержавотворческих ei к ei+z любому способу эквивалентного z последовательным вызовов e(). | не хуже сложности z последовательных звонков e() |
x == y | bool | Этот оператор является отношением эквивалентности. С Sx и Sy как бесконечные последовательности значений, которые будут сгенерированы повторными вызовами в будущем, x() и y(), соответственно, возвращает true if Sx=Sy; иначе возвращается false. | O(size of state) |
x != y | bool | !(x == y). | O(size of state) |
os << x | ссылка на тип os | Если os.fmtflags задано значение ios_base::dec|ios_base::left и символ заполнения установлен на пробел, os выполняется запись в текстовое представление xтекущего состояния. В выводе соседние числа разделяются одним или несколькими пробелами. И символ - заполнитель не изменяются. Postconditions: os.fmtflags | O(size of state) |
is >> v | ссылка на тип is | Если is.fmtflags установлено в ios_base::dec, устанавливает vсостояние, определяемое чтением его текстового представления из is. Если обнаружен неверный ввод, гарантирует, что vсостояние не изменится в результате операции и вызовов is.setstate(ios::failbit) (которые могут вызывать throw ios::failure ( [iostate.flags])). Если текстовое представление, записанное через, os << x было впоследствии прочитано через is >> v, то x == v при условии, что не было промежуточных вызовов of x или of v. Requires: is предоставляет текстовое представление, которое ранее было написано с использованием выходного потока, встроенная локаль которого была такой же, как и у is, и аргументы специализации шаблона charT и для которого traits были, соответственно, такими же, как у is. Неизменны. Postconditions: is.fmtflags | O(size of state) |
E должны соответствовать требованиям CopyConstructible и CopyAssignable типам. Каждая из этих операций должна быть по сложности не хуже O(size of state).
Этот конструктор (а также последующая соответствующая seed() функция) может быть особенно полезен для приложений, требующих большого количества независимых случайных последовательностей.
Эта операция распространена в пользовательском коде и часто может быть реализована специфичным для движка способом, чтобы обеспечить значительное улучшение производительности по сравнению с эквивалентным наивным циклом, который выполняет z последовательные вызовы e().
random number engine adaptor (Обычно сокращенно adaptor) a типа A является случайным числом двигателя , который принимает значения , полученные с помощью какого - либо другого случайных чисел двигателя, и применяет алгоритм для этих значений для того , чтобы поставить последовательность значений с различными свойствами случайности. Двигатель b типа , B адаптированный таким образом, называется base engine в этом контексте. Выражение a.base() должно быть действительным и должно возвращать константную ссылку на aбазовый движок.
Требования к типу двигателя со случайным числом должны интерпретироваться следующим образом по отношению к типу адаптера двигателя со случайным числом.
A::A();
bool operator==(const A& a1, const A& a2);
Returns: true если a1базовый двигатель равен a2базовому двигателю. В противном случае возвращается false.
A::A(result_type s);
template<class Sseq> A::A(Sseq& q);
void seed();
void seed(result_type s);
template<class Sseq> void seed(Sseq& q);
A также должны удовлетворять следующим дополнительным требованиям:
a)Сложность каждой функции не должна превышать сложность соответствующей функции, применяемой к базовому двигателю.
b)Состояние A должно включать состояние его базового двигателя. Размер Aгосударства должен быть не меньше размера базового двигателя.
c) AСостояние копирования (например, во время создания копии или назначения копии) должно включать в себя копирование состояния базового механизма A.
d)Текстовое представление A должно включать текстовое представление его базового двигателя.
random number distribution (Обычно сокращенно distribution) d типа D является функция объекта возвращение значения, которые распределены в соответствии с ассоциированным математическим probability density function p(z) или в соответствии с ассоциированным discrete probability function P(zi). Спецификация распределения определяет связанную с ним функцию вероятности p(z) или P(zi).
Соответствующая функция вероятности обычно выражается с помощью определенных поставляемых извне величин, известных как parameters of the distribution. Такие параметры распределения идентифицируются в этом контексте путем написания, например, p(z|a,b) или P(zi|a,b)для обозначения определенных параметров, или путем написания, например, p(z |{p}) или P(zi|{p}), для обозначения параметров распределения, p взятых в целом.
Класс D удовлетворяет требованиям a, random number distribution если выражения, показанные в таблице 105 , действительны и имеют указанную семантику, а if D и связанные с ним типы также удовлетворяют всем другим требованиям этого раздела [rand.req.dist]. В этой таблице и в этом разделе
a)T тип, названный Dассоциированным result_type;
b)P тип, названный Dассоциированным param_type;
c)d это значение D, а также x и y являются (возможно const) значения D;
d)glb и lub являются значениями T соответственно, соответствующими наибольшей нижней границе и наименьшей верхней границе значений, потенциально возвращаемых d's operator(), как определено текущими значениями dпараметров' s;
e)p является (возможно const) значением P;
f)g, g1и g2 являются l значениями типа, удовлетворяющими требованиям a uniform random bit generator;
g)os - lvalue типа некоторой специализации шаблона класса basic_ostream<charT, traits>; а также
h)is - lvalue типа некоторой специализации шаблона класса basic_istream<charT, traits>;
где charT и traits ограничены в соответствии с пунктами [strings] и [input.output].
Выражение | Тип возврата | До / после состояния | Сложность |
D::result_type | T | T это arithmetic type. | время компиляции |
D::param_type | P | время компиляции | |
D() | Создает распределение, поведение которого неотличимо от поведения любого другого вновь созданного по умолчанию распределения типа D. | постоянный | |
D(p) | Создает распределение, поведение которого неотличимо от поведения вновь созданного распределения, непосредственно из значений, используемых для построения p. | такая же, как pи конструкция | |
d.reset() | void | Последующее использование d не зависит от значений, созданных каким-либо механизмом перед вызовом reset. | постоянный |
x.param() | P | Возвращает такое значение p , что D(p).param() == p. | не хуже, чем сложность D(p) |
d.param(p) | void | Postconditions: d.param() == p. | не хуже, чем сложность D(p) |
d(g) | T | С p=d.param(), последовательность чисел, возвращаемая последовательными вызовами одного и того же объекта g , случайным образом распределяется в соответствии с ассоциированной функцией p(z |{p}) или P(zi|{p}). | амортизируемое постоянное количество вызовов g |
d(g,p) | T | Последовательность чисел, возвращаемая последовательными вызовами одних g и тех же объектов, p случайным образом распределяется в соответствии с ассоциированной функцией p(z |{p}) или P(zi|{p})функцией. | амортизируемое постоянное количество вызовов g |
x.min() | T | Возврат glb. | постоянный |
x.max() | T | Возврат lub. | постоянный |
x == y | bool | Этот оператор является отношением эквивалентности. Возвращает true if x.param() == y.param() и S1=S2, где S1 и S2 - бесконечные последовательности значений, которые будут генерироваться, соответственно, повторными вызовами в будущем x(g1) и y(g2) всякий раз g1 == g2. В противном случае возвращается false. | постоянный |
x != y | bool | !(x == y). | так же, как x == y. |
os << x | ссылка на тип os | Записывает в os текстовое представление параметры и дополнительные внутренние данные x. И символ - заполнитель не изменяются. Postconditions: os.fmtflags | |
is >> d | ссылка на тип is | Восстанавливается из is параметров и дополнительных внутренних данных lvalue d. Если обнаружен неправильный ввод, гарантирует, что d операция и вызовы не изменят его is.setstate(ios::failbit) (что может вызвать throw ios::failure ( [iostate.flags])). Requires: is обеспечивает текстовое представление , которое было ранее написанным используя os которого пронизана локаль и чьи аргументы шаблона специализации типа в charT и traits были такими же , как те is. Неизменны. Postconditions: is.fmtflags |
Последовательность чисел, полученная при повторных вызовах, d(g) должна быть независимой от любого вызова os << d или какой-либо const функции-члена D между любыми вызовами d(g).
Если текстовое представление написано с использованием os << x и это представление восстанавливается в тот же или другой объект y того же типа с использованием is >> y, повторные вызовы y(g) должны производить ту же последовательность чисел, что и повторные вызовы x(g).
Не указано, D::param_type объявлен ли он как (вложенный) class или через typedef. В этом подпункте [rand]объявления D::param_type используются в форме typedefs только для удобства изложения.
Для каждого из конструкторов, D принимающих аргументы, соответствующие параметрам распределения, P должен быть соответствующий конструктор, подчиняющийся тем же требованиям и принимающий аргументы, идентичные по количеству, типу и значениям по умолчанию. Более того, для каждой из функций-членов D этих возвращаемых значений, соответствующих параметрам распределения, P должна быть соответствующая функция-член с идентичным именем, типом и семантикой.
#include <initializer_list> namespace std { // [rand.eng.lcong], class template linear_congruential_engine template<class UIntType, UIntType a, UIntType c, UIntType m> class linear_congruential_engine; // [rand.eng.mers], class template mersenne_twister_engine template<class UIntType, size_t w, size_t n, size_t m, size_t r, UIntType a, size_t u, UIntType d, size_t s, UIntType b, size_t t, UIntType c, size_t l, UIntType f> class mersenne_twister_engine; // [rand.eng.sub], class template subtract_with_carry_engine template<class UIntType, size_t w, size_t s, size_t r> class subtract_with_carry_engine; // [rand.adapt.disc], class template discard_block_engine template<class Engine, size_t p, size_t r> class discard_block_engine; // [rand.adapt.ibits], class template independent_bits_engine template<class Engine, size_t w, class UIntType> class independent_bits_engine; // [rand.adapt.shuf], class template shuffle_order_engine template<class Engine, size_t k> class shuffle_order_engine; // [rand.predef], engines and engine adaptors with predefined parameters using minstd_rand0 = see below; using minstd_rand = see below; using mt19937 = see below; using mt19937_64 = see below; using ranlux24_base = see below; using ranlux48_base = see below; using ranlux24 = see below; using ranlux48 = see below; using knuth_b = see below; using default_random_engine = see below; // [rand.device], class random_device class random_device; // [rand.util.seedseq], class seed_seq class seed_seq; // [rand.util.canonical], function template generate_canonical template<class RealType, size_t bits, class URBG> RealType generate_canonical(URBG& g); // [rand.dist.uni.int], class template uniform_int_distribution template<class IntType = int> class uniform_int_distribution; // [rand.dist.uni.real], class template uniform_real_distribution template<class RealType = double> class uniform_real_distribution; // [rand.dist.bern.bernoulli], class bernoulli_distribution class bernoulli_distribution; // [rand.dist.bern.bin], class template binomial_distribution template<class IntType = int> class binomial_distribution; // [rand.dist.bern.geo], class template geometric_distribution template<class IntType = int> class geometric_distribution; // [rand.dist.bern.negbin], class template negative_binomial_distribution template<class IntType = int> class negative_binomial_distribution; // [rand.dist.pois.poisson], class template poisson_distribution template<class IntType = int> class poisson_distribution; // [rand.dist.pois.exp], class template exponential_distribution template<class RealType = double> class exponential_distribution; // [rand.dist.pois.gamma], class template gamma_distribution template<class RealType = double> class gamma_distribution; // [rand.dist.pois.weibull], class template weibull_distribution template<class RealType = double> class weibull_distribution; // [rand.dist.pois.extreme], class template extreme_value_distribution template<class RealType = double> class extreme_value_distribution; // [rand.dist.norm.normal], class template normal_distribution template<class RealType = double> class normal_distribution; // [rand.dist.norm.lognormal], class template lognormal_distribution template<class RealType = double> class lognormal_distribution; // [rand.dist.norm.chisq], class template chi_squared_distribution template<class RealType = double> class chi_squared_distribution; // [rand.dist.norm.cauchy], class template cauchy_distribution template<class RealType = double> class cauchy_distribution; // [rand.dist.norm.f], class template fisher_f_distribution template<class RealType = double> class fisher_f_distribution; // [rand.dist.norm.t], class template student_t_distribution template<class RealType = double> class student_t_distribution; // [rand.dist.samp.discrete], class template discrete_distribution template<class IntType = int> class discrete_distribution; // [rand.dist.samp.pconst], class template piecewise_constant_distribution template<class RealType = double> class piecewise_constant_distribution; // [rand.dist.samp.plinear], class template piecewise_linear_distribution template<class RealType = double> class piecewise_linear_distribution; }
Каждый тип, созданный из шаблона класса, указанного в этом разделе, [rand.eng] удовлетворяет требованиям random number engine типа.
Если не указано иное, сложность каждой функции, указанной в этом разделе, [rand.eng] является постоянной.
Если не указано иное, ни одна функция, описанная в этом разделе, не [rand.eng] вызывает исключение.
Каждая функция, описанная в этом разделе, [rand.eng] которая имеет параметр функции q типа Sseq& для параметра типа шаблона с именем Sseq , отличным от типа, seed_seq вызывает то, что и когда q.generate вызывает вызов throw.
Описания представлены в этом разделе [rand.eng] только для операций двигателя, которые не описаны, [rand.req.eng] или для операций, для которых имеется дополнительная семантическая информация. В частности, объявления для конструкторов копирования, для операторов присваивания копий, для операторов потоковой передачи и для операторов равенства и неравенства не показаны в резюме.
Каждый шаблон, указанный в этом разделе, [rand.eng] требует удержания одного или нескольких отношений, включающих значение (значения) не относящихся к типу параметров шаблона. Программа, реализующая любой из этих шаблонов, плохо сформирована, если какая-либо такая требуемая взаимосвязь не выполняется.
Для каждого механизма случайных чисел и для каждого адаптера механизма случайных чисел, X определенных в этом подпункте ( [rand.eng]) и в подпункте [rand.adapt]:
если конструктор
template <class Sseq> explicit X(Sseq& q);
вызывается с типом Sseq , который не квалифицируется как начальная последовательность, тогда этот конструктор не должен участвовать в разрешении перегрузки;
если функция-член
template <class Sseq> void seed(Sseq& q);
вызывается с типом Sseq , который не квалифицируется как начальная последовательность, то эта функция не должна участвовать в разрешении перегрузки.
Степень, в которой реализация определяет, что тип не может быть начальной последовательностью, не указана, за исключением того, что, как минимум, тип не должен квалифицироваться как начальная последовательность, если он неявно конвертируется в X::result_type.
Механизм linear_congruential_engine случайных чисел производит беззнаковые целые случайные числа. Состояние из объекта имеет размер и состоит из одного целого числа. Алгоритм перехода представляет собой модульную линейную функцию формы ; алгоритм генерации есть . xi linear_congruential_engine x 1TA(xi)=(a⋅xi+c)modm GA(xi)=xi+1
template<class UIntType, UIntType a, UIntType c, UIntType m> class linear_congruential_engine { public: // types using result_type = UIntType; // engine characteristics static constexpr result_type multiplier = a; static constexpr result_type increment = c; static constexpr result_type modulus = m; static constexpr result_type min() { return c == 0u ? 1u: 0u; } static constexpr result_type max() { return m - 1u; } static constexpr result_type default_seed = 1u; // constructors and seeding functions explicit linear_congruential_engine(result_type s = default_seed); template<class Sseq> explicit linear_congruential_engine(Sseq& q); void seed(result_type s = default_seed); template<class Sseq> void seed(Sseq& q); // generating functions result_type operator()(); void discard(unsigned long long z); };
Если параметр шаблона m равен 0, модуль, m используемый в этом разделе, равен плюсу . [ не обязательно представлять как значение типа . ] [rand.eng.lcong] numeric_limits<result_type>::max() 1 Note: m result_type — end note
explicit linear_congruential_engine(result_type s = default_seed);
Effects: Создает linear_congruential_engine объект. Если cmodm есть 0 и smodm есть 0, устанавливает состояние двигателя в 1, в противном случае устанавливает состояние двигателя в smodm.
template<class Sseq> explicit linear_congruential_engine(Sseq& q);
Effects: Создает linear_congruential_engine объект. С k=⌈log2m32⌉ и a массивом (или эквивалентом) длины k+3вызывает, q.generate(a+0, a+k+3) а затем вычисляет S=(∑k−1j=0aj+3⋅232j)modm. Если cmodm есть 0 и S есть 0, устанавливает состояние двигателя в 1, иначе устанавливает состояние двигателя в S.
Механизм mersenne_twister_engine случайных чисел 270 производит беззнаковые целые случайные числа в закрытом интервале [0,2w−1]. Состояние из объекта имеет размер и состоит из последовательности из значений типа поставляемого ; все применяемые индексы следует брать по модулю .xi mersenne_twister_engine x n X n x X n
Алгоритм перехода использует сдвиговый регистр с обобщенной обратной связью, определяемый значениями сдвига и , значением поворота и условной xor-маской . Чтобы улучшить однородность результата, биты необработанного регистра сдвига дополнительно (т. Е. Скремблируются) в соответствии с матрицей битового скремблирования, определенной значениями и . n m r a tempered u,d,s,b,t,c, ℓ
Переход между состояниями выполняется следующим образом:
a)Соедините верхние w−r биты Xi−n с младшими r битами, Xi+1−n чтобы получить беззнаковое целое число Y.
b)С α=a⋅(Ybitand1), установите Xi на Xi+m−nxor(Yrshift1)xorα.
Последовательность X инициализируется с помощью множителя инициализации f.
Алгоритм генерации определяет беззнаковые целочисленные значения следующим образом, а затем выдает в качестве своего результата: z1,z2,z3,z4 z4
a)Пусть z1=Xixor((Xirshiftu)bitandd).
b)Пусть z2=z1xor((z1lshiftws)bitandb).
c)Пусть z3=z2xor((z2lshiftwt)bitandc).
d)Пусть z4=z3xor(z3rshiftℓ).
template<class UIntType, size_t w, size_t n, size_t m, size_t r, UIntType a, size_t u, UIntType d, size_t s, UIntType b, size_t t, UIntType c, size_t l, UIntType f> class mersenne_twister_engine { public: // types using result_type = UIntType; // engine characteristics static constexpr size_t word_size = w; static constexpr size_t state_size = n; static constexpr size_t shift_size = m; static constexpr size_t mask_bits = r; static constexpr UIntType xor_mask = a; static constexpr size_t tempering_u = u; static constexpr UIntType tempering_d = d; static constexpr size_t tempering_s = s; static constexpr UIntType tempering_b = b; static constexpr size_t tempering_t = t; static constexpr UIntType tempering_c = c; static constexpr size_t tempering_l = l; static constexpr UIntType initialization_multiplier = f; static constexpr result_type min() { return 0; } static constexpr result_type max() { return 2w−1; } static constexpr result_type default_seed = 5489u; // constructors and seeding functions explicit mersenne_twister_engine(result_type value = default_seed); template<class Sseq> explicit mersenne_twister_engine(Sseq& q); void seed(result_type value = default_seed); template<class Sseq> void seed(Sseq& q); // generating functions result_type operator()(); void discard(unsigned long long z); };
Следующие соотношения должны занимать: 0 < m, m <= n, 2u < w, r <= w, u <= w, s <= w, t <= w, l <= w, w <= numeric_limits<UIntType>::digits, a <= (1u<<w) - 1u, b <= (1u<<w) - 1u, c <= (1u<<w) - 1u, d <= (1u<<w) - 1u, и f <= (1u<<w) - 1u.
explicit mersenne_twister_engine(result_type value = default_seed);
Effects: Создает mersenne_twister_engine объект. Устанавливается X−n на valuemod2w. Затем итеративно для i=1−n,…,−1, наборы Xi для
[f⋅(Xi−1xor(Xi−1rshift(w−2)))+imodn]mod2w.
template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
Effects: Создает mersenne_twister_engine объект. With k=⌈w/32⌉ и a массив (или эквивалент) длины n⋅kвызывает, q.generate(a+0, a+n⋅k) а затем, итеративно для i=−n,…,−1, устанавливает Xi значение (∑k−1j=0ak(i+n)+j⋅232j)mod2w. Наконец, если наиболее значимые w−r биты X−n равны нуль, и если каждый из других в результате чего Xi это 0, изменяется X−n с 2w−1.
Название этого механизма частично относится к свойству его периода: для правильно выбранных значений параметров период тесно связан с большим простым числом Мерсенна.
Механизм subtract_with_carry_engine случайных чисел производит беззнаковые целые случайные числа.
Состояние из объекта имеет размера , и состоит из последовательности из целочисленных значений ; все применяемые индексы следует брать по модулю . Состояние дополнительно состоит из целого числа (известного как ) , значение которого равно или . xi subtract_with_carry_engine xO(r) X r 0≤Xi<m=2w X r xi c carry 0 1
Переход между состояниями выполняется следующим образом:
a)Пусть Y=Xi−s−Xi−r−c.
b)Установите Xi на y=Ymodm. Установите c в 1, если Y<0, в противном случае установите c в 0.
[ Note: Этот алгоритм соответствует модульной линейной функции вида TA(xi)=(a⋅xi)modb, где b имеет вид mr−ms+1 и a=b−(b−1)/m. ] — end note
Алгоритм генерации задается формулой , где - значение, полученное в результате улучшения состояния двигателя, как описано выше.GA(xi)=y y
template<class UIntType, size_t w, size_t s, size_t r> class subtract_with_carry_engine { public: // types using result_type = UIntType; // engine characteristics static constexpr size_t word_size = w; static constexpr size_t short_lag = s; static constexpr size_t long_lag = r; static constexpr result_type min() { return 0; } static constexpr result_type max() { return m−1; } static constexpr result_type default_seed = 19780503u; // constructors and seeding functions explicit subtract_with_carry_engine(result_type value = default_seed); template<class Sseq> explicit subtract_with_carry_engine(Sseq& q); void seed(result_type value = default_seed); template<class Sseq> void seed(Sseq& q); // generating functions result_type operator()(); void discard(unsigned long long z); };
Следующие соотношения должны проводить: 0u < s, s < r, 0 < w, и w <= numeric_limits<UIntType>::digits.
Текстовое представление состоит из значений в указанном порядке, за которыми следует . Xi−r,…,Xi−1 c
explicit subtract_with_carry_engine(result_type value = default_seed);
Effects: Создает subtract_with_carry_engine объект. Устанавливает значения X−r,…,X−1в указанном ниже порядке в указанном ниже порядке. Если X−1 есть, то 0устанавливается c в 1; в противном случае устанавливается c на 0.
Для того, чтобы установить значение Xk, первые построить e, А linear_congruential_engine объект, как если бы по следующему определению:
linear_congruential_engine<result_type, 40014u,0u,2147483563u> e(value == 0u ? default_seed : value);
Затем, чтобы установить каждый Xk, получить новые значения z0,…,zn−1 из n=⌈w/32⌉ последовательных вызовов e взятого по модулю 232. Установите Xk на (∑n−1j=0zj⋅232j)modm.
template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
Effects: Создает subtract_with_carry_engine объект. With k=⌈w/32⌉ и a массив (или эквивалент) длины r⋅kвызывает, q.generate(a+0, a+r⋅k) а затем, итеративно для i=−r,…,−1, устанавливает Xi значение (∑k−1j=0ak(i+r)+j⋅232j)modm. Если X−1 есть, то 0устанавливается c в 1; в противном случае устанавливается c на 0.
Каждый тип, созданный из шаблона класса, указанного в этом разделе, [rand.adapt] удовлетворяет требованиям random number engine adaptor типа.
Если не указано иное, сложность каждой функции, указанной в этом разделе, [rand.adapt] является постоянной.
Если не указано иное, ни одна функция, описанная в этом разделе, не [rand.adapt] вызывает исключение.
Каждая функция, описанная в этом разделе, [rand.adapt] которая имеет параметр функции q типа Sseq& для параметра типа шаблона с именем Sseq , отличным от типа, seed_seq вызывает то, что и когда q.generate вызывает вызов throw.
Описание предоставляется в этом разделе [rand.adapt] только для операций адаптера, которые не описаны в разделе, [rand.req.adapt] или для операций, для которых существует дополнительная семантическая информация. В частности, объявления для конструкторов копирования, для операторов присваивания копий, для операторов потоковой передачи и для операторов равенства и неравенства не показаны в резюме.
Каждый шаблон, указанный в этом разделе, [rand.adapt] требует удержания одного или нескольких отношений, включающих значение (значения) не относящихся к типу параметров шаблона. Программа, реализующая любой из этих шаблонов, плохо сформирована, если какая-либо такая требуемая взаимосвязь не выполняется.
discard_block_engine Случайным образом номера адаптер двигателя производит случайные числа , выбранные из производства некоторых базового двигателя e. Состояние из объекта адаптера двигателя состоит из состояния своего базового двигателя и дополнительного целого числа . Размер государства равен размеру государства плюс . xi discard_block_engine x ei e n e 1
Алгоритм перехода отбрасывает все значения, кроме значений, из каждого блока значений, предоставленного . Переход между состояниями выполняется следующим образом: Если , переместите состояние из в и установите в . В любом случае, затем увеличивайте и продвигайте текущее состояние до . r>0 p≥r e n≥r e ei ei+p−r n 0 n e ej ej+1
Алгоритм генерации выдает значение, возвращенное последним вызовом состояния при продвижении , как описано выше. e() e
template<class Engine, size_t p, size_t r> class discard_block_engine { public: // types using result_type = typename Engine::result_type; // engine characteristics static constexpr size_t block_size = p; static constexpr size_t used_block = r; static constexpr result_type min() { return Engine::min(); } static constexpr result_type max() { return Engine::max(); } // constructors and seeding functions discard_block_engine(); explicit discard_block_engine(const Engine& e); explicit discard_block_engine(Engine&& e); explicit discard_block_engine(result_type s); template<class Sseq> explicit discard_block_engine(Sseq& q); void seed(); void seed(result_type s); template<class Sseq> void seed(Sseq& q); // generating functions result_type operator()(); void discard(unsigned long long z); // property functions const Engine& base() const noexcept { return e; }; private: Engine e; // exposition only int n; // exposition only };
В дополнение к своему поведению в соответствии с разделом [rand.req.adapt]каждый конструктор, который не является конструктором копирования, устанавливает n значение 0.
An independent_bits_engine адаптер сочетает в себе случайное число случайных чисел двигателей, которые производятся некоторым базовым двигателем e, таким образом , чтобы произвести случайные числа с заданным количеством битов w. Состояние из объекта адаптера двигателя состоит из состояния своего базового двигателя ; размер государства - это размер российского государства. xi independent_bits_engine x ei e e
Алгоритмы перехода и генерации описываются следующими интегральными константами:
a)Пусть R=e.max() - e.min() + 1 и m=⌊log2R⌋.
b)С , n как определено ниже, пусть w0=⌊w/n⌋, n0=n−wmodn, y0=2w0⌊R/2w0⌋и y1=2w0+1⌊R/2w0+1⌋.
c)Пусть n=⌈w/m⌉ тогда и только тогда, когда в результате соотношение R−y0≤⌊y0/n⌋ выполняется. Иначе пусть n=1+⌈w/m⌉.
[ Note: Отношение w=n0w0+(n−n0)(w0+1) всегда сохраняется. ] — end note
Алгоритм перехода выполняется путем вызова по мере необходимости для получения значений меньше чем и значений меньше чем . e() n0y0+e.min() n−n0 y1+e.min()
Алгоритм генерации использует значения, полученные при продвижении состояния, как описано выше, чтобы получить количество, полученное, как если бы по следующему алгоритму: S
S = 0; for (k = 0; k≠n0; k += 1) { do u = e() - e.min(); while (u≥y0); S = 2w0⋅S+umod2w0; } for (k = n0; k≠n; k += 1) { do u = e() - e.min(); while (u≥y1); S = 2w0+1⋅S+umod2w0+1; }
template<class Engine, size_t w, class UIntType> class independent_bits_engine { public: // types using result_type = UIntType; // engine characteristics static constexpr result_type min() { return 0; } static constexpr result_type max() { return 2w−1; } // constructors and seeding functions independent_bits_engine(); explicit independent_bits_engine(const Engine& e); explicit independent_bits_engine(Engine&& e); explicit independent_bits_engine(result_type s); template<class Sseq> explicit independent_bits_engine(Sseq& q); void seed(); void seed(result_type s); template<class Sseq> void seed(Sseq& q); // generating functions result_type operator()(); void discard(unsigned long long z); // property functions const Engine& base() const noexcept { return e; }; private: Engine e; // exposition only };
shuffle_order_engine Случайным образом номер адаптера двигатель производит те же самые случайные числа, которые производятся некоторым базовым двигателем e, но доставляет их в другой последовательности. Состояние из объекта адаптера двигателя состоит из состояния своего базового двигателя , дополнительное значение типа поставляемого и дополнительная последовательность из значений и типа поставляемого . Размер государства равен размеру государства плюс . xi shuffle_order_engine x ei e Y e V k e e k+1
Алгоритм перехода переставляет значения, создаваемые . Переход между состояниями выполняется следующим образом: e
Алгоритм генерации выдает последнее значение, полученное при продвижении , как описано выше. Y e
template<class Engine, size_t k> class shuffle_order_engine { public: // types using result_type = typename Engine::result_type; // engine characteristics static constexpr size_t table_size = k; static constexpr result_type min() { return Engine::min(); } static constexpr result_type max() { return Engine::max(); } // constructors and seeding functions shuffle_order_engine(); explicit shuffle_order_engine(const Engine& e); explicit shuffle_order_engine(Engine&& e); explicit shuffle_order_engine(result_type s); template<class Sseq> explicit shuffle_order_engine(Sseq& q); void seed(); void seed(result_type s); template<class Sseq> void seed(Sseq& q); // generating functions result_type operator()(); void discard(unsigned long long z); // property functions const Engine& base() const noexcept { return e; }; private: Engine e; // exposition only result_type V[k]; // exposition only result_type Y; // exposition only };
Текстовое представление состоит из текстового представления , за которым следуют значения , за которыми следует значение . e k V Y
В дополнение к своему поведению в соответствии с разделом [rand.req.adapt], каждый конструктор, который не является конструктором копирования, инициализируется V[0],…,V[k-1] и Yв этом порядке значениями, возвращаемыми последовательными вызовами e().
using minstd_rand0 =
linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>;
Required behavior: 10000th Последовательный вызов по умолчанию построенного объекта типа а minstd_rand0 должен получить значение 1043618065.
using minstd_rand =
linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>;
Required behavior: 10000th Последовательный вызов по умолчанию построенного объекта типа а minstd_rand должен получить значение 399268537.
using mt19937 =
mersenne_twister_engine<uint_fast32_t,
32,624,397,31,0x9908b0df,11,0xffffffff,7,0x9d2c5680,15,0xefc60000,18,1812433253>;
Required behavior: 10000th Последовательный вызов по умолчанию построенного объекта типа а mt19937 должен получить значение 4123659995.
using mt19937_64 =
mersenne_twister_engine<uint_fast64_t,
64,312,156,31,0xb5026f5aa96619e9,29,
0x5555555555555555,17,
0x71d67fffeda60000,37,
0xfff7eee000000000,43,
6364136223846793005>;
Required behavior: 10000th Последовательный вызов по умолчанию построенного объекта типа а mt19937_64 должен получить значение 9981545732273789042.
using ranlux24_base =
subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>;
Required behavior: 10000th Последовательный вызов по умолчанию построенного объекта типа а ranlux24_base должен получить значение 7937952.
using ranlux48_base =
subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>;
Required behavior: 10000th Последовательный вызов по умолчанию построенного объекта типа а ranlux48_base должен получить значение 61839128582725.
using ranlux24 = discard_block_engine<ranlux24_base, 223, 23>;
Required behavior: 10000th Последовательный вызов по умолчанию построенного объекта типа а ranlux24 должен получить значение 9901578.
using ranlux48 = discard_block_engine<ranlux48_base, 389, 11>;
Required behavior: 10000th Последовательный вызов по умолчанию построенного объекта типа а ranlux48 должен получить значение 249142670248501.
using knuth_b = shuffle_order_engine<minstd_rand0,256>;
Required behavior: 10000th Последовательный вызов по умолчанию построенного объекта типа а knuth_b должен получить значение 1112339016.
using default_random_engine = implementation-defined;
Remarks: Выбор типа двигателя, названного этим, typedef определяется реализацией. [ Note: Реализация может выбрать этот тип на основе производительности, размера, качества или любой комбинации таких факторов, чтобы обеспечить, по крайней мере, приемлемое поведение двигателя для относительно случайного, неопытного и / или легкого использования. Поскольку разные реализации могут выбирать разные типы базовых механизмов, код, использующий это, typedef не должен генерировать идентичные последовательности для разных реализаций. ] — end note
random_device Равномерный случайный бит генератор производит недетерминированные случайные числа.
Если ограничения реализации не позволяют генерировать недетерминированные случайные числа, реализация может использовать механизм случайных чисел.
class random_device { public: // types using result_type = unsigned int; // generator characteristics static constexpr result_type min() { return numeric_limits<result_type>::min(); } static constexpr result_type max() { return numeric_limits<result_type>::max(); } // constructors explicit random_device(const string& token = implementation-defined); // generating functions result_type operator()(); // property functions double entropy() const noexcept; // no copy functions random_device(const random_device& ) = delete; void operator=(const random_device& ) = delete; };
explicit random_device(const string& token = implementation-defined);
double entropy() const noexcept;
result_type operator()();
Параметр предназначен для того, чтобы реализация могла различать разные источники случайности.
Если у устройства есть n состояния, соответствующие вероятности которых равны
P0,…,Pn−1, энтропия устройства S определяется как
S=−∑n−1i=0Pi⋅logPi.
class seed_seq { public: // types using result_type = uint_least32_t; // constructors seed_seq(); template<class T> seed_seq(initializer_list<T> il); template<class InputIterator> seed_seq(InputIterator begin, InputIterator end); // generating functions template<class RandomAccessIterator> void generate(RandomAccessIterator begin, RandomAccessIterator end); // property functions size_t size() const noexcept; template<class OutputIterator> void param(OutputIterator dest) const; // no copy functions seed_seq(const seed_seq& ) = delete; void operator=(const seed_seq& ) = delete; private: vector<result_type> v; // exposition only };
seed_seq();
template<class T>
seed_seq(initializer_list<T> il);
template<class InputIterator>
seed_seq(InputIterator begin, InputIterator end);
Requires: InputIterator должны удовлетворять требованиям input iterator типа. Кроме того, iterator_traits<InputIterator>::value_type будет обозначать целочисленный тип.
Effects: Создает seed_seq объект по следующему алгоритму:
for( InputIterator s = begin; s != end; ++s)
v.push_back((*s)mod232);
template<class RandomAccessIterator>
void generate(RandomAccessIterator begin, RandomAccessIterator end);
Requires: RandomAccessIterator должен соответствовать требованиям изменяемого random access iterator. Кроме того, iterator_traits<RandomAccessIterator>::value_type должен обозначать беззнаковый целочисленный тип, способный вместить 32-битные величины.
Effects: Ничего не делает, если begin == end. В противном случае, с помощью s=v.size() и n=end−beginзаполняет предоставленный диапазон в [begin,end) соответствии со следующим алгоритмом, в котором каждая операция должна выполняться по модулю 232, каждый примененный оператор индексации begin должен приниматься по модулю nи T(x) определяется как xxor(xrshift27):
a)В качестве инициализации установите значение каждого элемента диапазона 0x8b8b8b8b. Кроме того, для использования на последующих этапах, пусть p=(n−t)/2 и пусть q=p+t, где
t=(n≥623) ? 11 : (n≥68) ? 7 : (n≥39) ? 5 : (n≥7) ? 3 : (n−1)/2;
b)С m как большее из s+1 и nпреобразовать элементы диапазона: итеративно для k=0,…,m−1, вычислить значения
r1=1664525⋅T(begin[k]xorbegin[k+p]xorbegin[k−1])r2=r1+⎧⎪⎨⎪⎩s, k=0kmodn+v[k−1], 0<k≤skmodn, s<k
и, по порядку, увеличить begin[k+p] на r1, увеличить begin[k+q] на r2и установить begin[k] в r2.
c)Снова преобразовать элементы диапазона, начиная с того места, где закончился предыдущий шаг: итеративно для k=m,…,m+n−1, вычислить значения
r3=1566083941⋅T(begin[k]+begin[k+p]+begin[k−1])r4=r3−(kmodn)
и, по порядку, обновить begin[k+p] , зафиксировав его r3, обновить begin[k+q] , зафиксировав его r4, и установить begin[k] в r4.
size_t size() const noexcept;
template<class OutputIterator>
void param(OutputIterator dest) const;
Requires: OutputIterator должны удовлетворять требованиям output iterator. Более того, выражение *dest = rt должно быть действительным для значения rt типа result_type.
Effects: Копирует последовательность подготовленных 32-битных модулей в заданное место назначения, как если бы выполняя следующий оператор:
copy(v.begin(), v.end(), dest);
Каждая функция экземпляр из шаблона , описанный в этом разделе [rand.util.canonical] отображает результат одного или несколько призываний в комплекте поставку равномерного случайного генератора бит g одного из членов указанной RealType таким образом, что, если значения , gi полученные g равномерно распределены, результаты Инстанцирования в tj, 0≤tj<1, распределяются как можно более равномерно, как указано ниже.
[ Note: Получение значения таким образом может быть полезным этапом в процессе преобразования значения, сгенерированного генератором однородных случайных битов, в значение, которое может быть доставлено распределением случайных чисел. ] — end note
template<class RealType, size_t bits, class URBG>
RealType generate_canonical(URBG& g);
Effects: Вызывает g() k время для получения значений g0,…,gk−1соответственно. Рассчитывает количество
S=k−1∑i=0(gi−g.min())⋅Ri
используя арифметику типа RealType.
b вводится, чтобы избежать любых попыток произвести больше битов случайности, чем может быть удержано RealType.
Каждый тип, созданный из шаблона класса, указанного в этом разделе, [rand.dist] удовлетворяет требованиям random number distribution типа.
Описания представлены в этом разделе [rand.dist] только для операций распространения, которые не описаны, [rand.req.dist] или для операций, для которых имеется дополнительная семантическая информация. В частности, объявления для конструкторов копирования, для операторов присваивания копий, для операторов потоковой передачи и для операторов равенства и неравенства не показаны в резюме.
uniform_int_distribution Случайное распределение числа производит случайные целые числа i, a≤i≤b, распределенные в соответствии с постоянной дискретной функцией вероятности
P(i|a,b)=1/(b−a+1).
template<class IntType = int> class uniform_int_distribution { public: // types using result_type = IntType; using param_type = unspecified; // constructors and reset functions explicit uniform_int_distribution(IntType a = 0, IntType b = numeric_limits<IntType>::max()); explicit uniform_int_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions result_type a() const; result_type b() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
explicit uniform_int_distribution(IntType a = 0, IntType b = numeric_limits<IntType>::max());
Effects: Строит uniform_int_distribution объект; a и b соответствуют соответствующим параметрам распределения.
result_type a() const;
result_type b() const;
uniform_real_distribution Случайное распределение числа производит случайные числа x, a≤x<b, распределенные в соответствии с функцией плотности вероятности постоянной
p(x|a,b)=1/(b−a).
[ Note: Это означает, что p(x|a,b) не определено, когда a == b. ] — end note
template<class RealType = double> class uniform_real_distribution { public: // types using result_type = RealType; using param_type = unspecified; // constructors and reset functions explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0); explicit uniform_real_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions result_type a() const; result_type b() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0);
Effects: Строит uniform_real_distribution объект; a и b соответствуют соответствующим параметрам распределения.
result_type a() const;
result_type b() const;
bernoulli_distribution Распределение случайных чисел производит bool значения , b распределенных в соответствии с дискретной вероятностной функцией
P(b|p)={pifb=true1−pifb=false.
class bernoulli_distribution { public: // types using result_type = bool; using param_type = unspecified; // constructors and reset functions explicit bernoulli_distribution(double p = 0.5); explicit bernoulli_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions double p() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
explicit bernoulli_distribution(double p = 0.5);
double p() const;
binomial_distribution Случайное распределение числа производит целые значения i≥0 распределены по дискретной функции вероятности
P(i|t,p)=(ti)⋅pi⋅(1−p)t−i.
template<class IntType = int> class binomial_distribution { public: // types using result_type = IntType; using param_type = unspecified; // constructors and reset functions explicit binomial_distribution(IntType t = 1, double p = 0.5); explicit binomial_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions IntType t() const; double p() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
explicit binomial_distribution(IntType t = 1, double p = 0.5);
Effects: Строит binomial_distribution объект; t и p соответствуют соответствующим параметрам распределения.
IntType t() const;
double p() const;
geometric_distribution Случайное распределение числа производит целые значения i≥0 распределены по дискретной функции вероятности
P(i|p)=p⋅(1−p)i.
template<class IntType = int> class geometric_distribution { public: // types using result_type = IntType; using param_type = unspecified; // constructors and reset functions explicit geometric_distribution(double p = 0.5); explicit geometric_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions double p() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
explicit geometric_distribution(double p = 0.5);
double p() const;
negative_binomial_distribution Случайное распределение числа производит случайные целые числа , i≥0 распределенные в соответствии с дискретной вероятностной функцией
P(i|k,p)=(k+i−1i)⋅pk⋅(1−p)i.
[ Note: Это означает, что P(i|k,p) не определено, когда p == 1. ] — end note
template<class IntType = int> class negative_binomial_distribution { public: // types using result_type = IntType; using param_type = unspecified; // constructor and reset functions explicit negative_binomial_distribution(IntType k = 1, double p = 0.5); explicit negative_binomial_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions IntType k() const; double p() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
explicit negative_binomial_distribution(IntType k = 1, double p = 0.5);
Effects: Строит negative_binomial_distribution объект; k и p соответствуют соответствующим параметрам распределения.
IntType k() const;
double p() const;
poisson_distribution Случайное распределение числа производит целые значения i≥0 распределены по дискретной функции вероятности
P(i|μ)=e−μμii!.
Параметр распределения μ также известен как это распределение . mean
template<class IntType = int> class poisson_distribution { public: // types using result_type = IntType; using param_type = unspecified; // constructors and reset functions explicit poisson_distribution(double mean = 1.0); explicit poisson_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions double mean() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
explicit poisson_distribution(double mean = 1.0);
double mean() const;
exponential_distribution Случайное распределение числа производит случайные числа , x>0 распределенные в соответствии с функцией плотности вероятности
p(x|λ)=λe−λx.
template<class RealType = double> class exponential_distribution { public: // types using result_type = RealType; using param_type = unspecified; // constructors and reset functions explicit exponential_distribution(RealType lambda = 1.0); explicit exponential_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions RealType lambda() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
explicit exponential_distribution(RealType lambda = 1.0);
RealType lambda() const;
gamma_distribution Случайное распределение числа производит случайные числа , x>0 распределенные в соответствии с функцией плотности вероятности
p(x|α,β)=e−x/ββα⋅Γ(α)⋅xα−1.
template<class RealType = double> class gamma_distribution { public: // types using result_type = RealType; using param_type = unspecified; // constructors and reset functions explicit gamma_distribution(RealType alpha = 1.0, RealType beta = 1.0); explicit gamma_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions RealType alpha() const; RealType beta() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
explicit gamma_distribution(RealType alpha = 1.0, RealType beta = 1.0);
RealType alpha() const;
RealType beta() const;
weibull_distribution Случайное распределение числа производит случайные числа , x≥0 распределенные в соответствии с функцией плотности вероятности
p(x|a,b)=ab⋅(xb)a−1⋅exp(−(xb)a).
template<class RealType = double> class weibull_distribution { public: // types using result_type = RealType; using param_type = unspecified; // constructor and reset functions explicit weibull_distribution(RealType a = 1.0, RealType b = 1.0); explicit weibull_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions RealType a() const; RealType b() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
explicit weibull_distribution(RealType a = 1.0, RealType b = 1.0);
Effects: Строит weibull_distribution объект; a и b соответствуют соответствующим параметрам распределения.
RealType a() const;
RealType b() const;
extreme_value_distribution Случайное распределение числа производит случайные числа , x распределенные в соответствии с функцией плотности вероятности274
p(x|a,b)=1b⋅exp(a−xb−exp(a−xb)).
template<class RealType = double> class extreme_value_distribution { public: // types using result_type = RealType; using param_type = unspecified; // constructor and reset functions explicit extreme_value_distribution(RealType a = 0.0, RealType b = 1.0); explicit extreme_value_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions RealType a() const; RealType b() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
explicit extreme_value_distribution(RealType a = 0.0, RealType b = 1.0);
Effects: Создает extreme_value_distribution объект; a и b соответствуют соответствующим параметрам распределения.
RealType a() const;
RealType b() const;
Распределение, соответствующее этой функции плотности вероятности, также известно (с возможным изменением переменной) как распределение Гамбеля типа I, лог-Вейбулла или распределение Фишера-Типпетта типа I.
normal_distribution Случайное распределение числа производит случайные числа , x распределенные в соответствии с функцией плотности вероятности
p(x|μ,σ)=1σ√2π⋅exp(−(x−μ)22σ2).
Параметры распределения μ и σ также известны как этого распределения и . mean standard deviation
template<class RealType = double> class normal_distribution { public: // types using result_type = RealType; using param_type = unspecified; // constructors and reset functions explicit normal_distribution(RealType mean = 0.0, RealType stddev = 1.0); explicit normal_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions RealType mean() const; RealType stddev() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
explicit normal_distribution(RealType mean = 0.0, RealType stddev = 1.0);
Effects: Строит normal_distribution объект; mean и stddev соответствуют соответствующим параметрам распределения.
RealType mean() const;
RealType stddev() const;
lognormal_distribution Случайное распределение числа производит случайные числа , x>0 распределенные в соответствии с функцией плотности вероятности
p(x|m,s)=1sx√2π⋅exp(−(lnx−m)22s2).
template<class RealType = double> class lognormal_distribution { public: // types using result_type = RealType; using param_type = unspecified; // constructor and reset functions explicit lognormal_distribution(RealType m = 0.0, RealType s = 1.0); explicit lognormal_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions RealType m() const; RealType s() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
explicit lognormal_distribution(RealType m = 0.0, RealType s = 1.0);
Effects: Строит lognormal_distribution объект; m и s соответствуют соответствующим параметрам распределения.
RealType m() const;
RealType s() const;
chi_squared_distribution Случайное распределение числа производит случайные числа , x>0 распределенные в соответствии с функцией плотности вероятности
p(x|n)=x(n/2)−1⋅e−x/2Γ(n/2)⋅2n/2.
template<class RealType = double> class chi_squared_distribution { public: // types using result_type = RealType; using param_type = unspecified; // constructor and reset functions explicit chi_squared_distribution(RealType n = 1); explicit chi_squared_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions RealType n() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
explicit chi_squared_distribution(RealType n = 1);
RealType n() const;
cauchy_distribution Случайное распределение числа производит случайные числа , x распределенные в соответствии с функцией плотности вероятности
p(x|a,b)=(πb(1+(x−ab)2))−1.
template<class RealType = double> class cauchy_distribution { public: // types using result_type = RealType; using param_type = unspecified; // constructor and reset functions explicit cauchy_distribution(RealType a = 0.0, RealType b = 1.0); explicit cauchy_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions RealType a() const; RealType b() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
explicit cauchy_distribution(RealType a = 0.0, RealType b = 1.0);
Effects: Строит cauchy_distribution объект; a и b соответствуют соответствующим параметрам распределения.
RealType a() const;
RealType b() const;
fisher_f_distribution Случайное распределение числа производит случайные числа , x≥0 распределенные в соответствии с функцией плотности вероятности
p(x|m,n)=Γ((m+n)/2)Γ(m/2)Γ(n/2)⋅(mn)m/2⋅x(m/2)−1⋅(1+mxn)−(m+n)/2.
template<class RealType = double> class fisher_f_distribution { public: // types using result_type = RealType; using param_type = unspecified; // constructor and reset functions explicit fisher_f_distribution(RealType m = 1, RealType n = 1); explicit fisher_f_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions RealType m() const; RealType n() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
explicit fisher_f_distribution(RealType m = 1, RealType n = 1);
Effects: Строит fisher_f_distribution объект; m и n соответствуют соответствующим параметрам распределения.
RealType m() const;
RealType n() const;
student_t_distribution Случайное распределение числа производит случайные числа , x распределенные в соответствии с функцией плотности вероятности
p(x|n)=1√nπ⋅Γ((n+1)/2)Γ(n/2)⋅(1+x2n)−(n+1)/2.
template<class RealType = double> class student_t_distribution { public: // types using result_type = RealType; using param_type = unspecified; // constructor and reset functions explicit student_t_distribution(RealType n = 1); explicit student_t_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions RealType n() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
explicit student_t_distribution(RealType n = 1);
RealType n() const;
discrete_distribution Случайное распределение числа производит случайные целые числа i, 0≤i<n, распределенных в соответствии с дискретной вероятностной функции
P(i|p0,…,pn−1)=pi.
Если не указано иное, параметры распределения рассчитываются как:, pk=wk/S for k=0,…,n−1 в котором значения wk, обычно известные как , должны быть неотрицательными, отличными от NaN и бесконечными. Кроме того, соотношение должно занимать: . weights 0<S=w0+⋯+wn−1
template<class IntType = int> class discrete_distribution { public: // types using result_type = IntType; using param_type = unspecified; // constructor and reset functions discrete_distribution(); template<class InputIterator> discrete_distribution(InputIterator firstW, InputIterator lastW); discrete_distribution(initializer_list<double> wl); template<class UnaryOperation> discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw); explicit discrete_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions vector<double> probabilities() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
discrete_distribution();
Effects: Создает discrete_distribution объект с помощью n=1 и p0=1. [ Note: Такой объект всегда будет иметь ценность 0. ] — end note
template<class InputIterator>
discrete_distribution(InputIterator firstW, InputIterator lastW);
Requires: InputIterator должны удовлетворять требованиям input iterator. Кроме того, iterator_traits<InputIterator>::value_type будет обозначать тип, в который можно преобразовать double. Если firstW == lastW, пусть n=1 и w0=1. В противном случае [firstW,lastW) формируется последовательность w длины n>0.
discrete_distribution(initializer_list<double> wl);
template<class UnaryOperation>
discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw);
Requires: Каждый экземпляр типа UnaryOperation должен быть function object типом возвращаемого значения, в который можно преобразовать double. Более того, double должен быть преобразован в тип UnaryOperationединственного параметра. Если nw=0, пусть n=1, иначе пусть n=nw. Отношение 0<δ=(xmax−xmin)/n должно сохраняться.
Effects: Создает discrete_distribution объект с вероятностями, заданными формулой выше, используя следующие значения: Если nw=0, пусть w0=1. В противном случае пусть wk=fw(xmin+k⋅δ+δ/2) для k=0,…,n−1.
vector<double> probabilities() const;
piecewise_constant_distribution Случайное распределение числа производит случайные числа x, b0≤x<bnравномерно распределяется по каждому подинтервалу в [bi,bi+1) соответствии с функцией плотности вероятности
p(x|b0,…,bn,ρ0,…,ρn−1)=ρi, for bi≤x<bi+1.
Параметры n+1 распределения bi, также известные как это распределение , должны удовлетворять соотношению для . Если не указано иное, остальные параметры распределения рассчитываются как: interval boundaries bi<bi+1 i=0,…,n−1 n
ρk=wkS⋅(bk+1−bk) for k=0,…,n−1,
в котором значения wk, обычно известные как the , должны быть неотрицательными, отличными от NaN и бесконечными. Кроме того, соотношение должно занимать: . weights 0<S=w0+⋯+wn−1
template<class RealType = double> class piecewise_constant_distribution { public: // types using result_type = RealType; using param_type = unspecified; // constructor and reset functions piecewise_constant_distribution(); template<class InputIteratorB, class InputIteratorW> piecewise_constant_distribution(InputIteratorB firstB, InputIteratorB lastB, InputIteratorW firstW); template<class UnaryOperation> piecewise_constant_distribution(initializer_list<RealType> bl, UnaryOperation fw); template<class UnaryOperation> piecewise_constant_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw); explicit piecewise_constant_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions vector<result_type> intervals() const; vector<result_type> densities() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
piecewise_constant_distribution();
template<class InputIteratorB, class InputIteratorW>
piecewise_constant_distribution(InputIteratorB firstB, InputIteratorB lastB,
InputIteratorW firstW);
Requires: InputIteratorB и InputIteratorW каждый должен удовлетворять требованиям своего input iterator типа. Кроме того, каждый iterator_traits<InputIteratorB>::value_type и iterator_traits<InputIteratorW>::value_typeдолжен обозначать тип, в который можно преобразовать double. Если firstB == lastB или ++firstB == lastB, пусть n=1, w0=1, b0=0и b1=1. В противном случае [firstB,lastB) должен формировать последовательность b длины n+1, длина последовательности, w начиная с, firstW должна быть не менее n, и любое значение wk for k≥n должно игнорироваться распределением.
template<class UnaryOperation>
piecewise_constant_distribution(initializer_list<RealType> bl, UnaryOperation fw);
Requires: Каждый экземпляр типа UnaryOperation должен быть function object типом возвращаемого значения, в который можно преобразовать double. Более того, double должен быть преобразован в тип UnaryOperationединственного параметра.
Effects: Создает piecewise_constant_distribution объект с параметрами , принятых или вычисленных из следующих значений: Если bl.size()<2, пусть n=1, w0=1, b0=0и b1=1. В противном случае позвольте [bl.begin(),bl.end()) сформировать последовательность b0,…,bnи позвольте wk=fw((bk+1+bk)/2) для k=0,…,n−1.
template<class UnaryOperation>
piecewise_constant_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);
Requires: Каждый экземпляр типа UnaryOperation должен быть function object типом возвращаемого значения, в который можно преобразовать double. Более того, double должен быть преобразован в тип UnaryOperationединственного параметра. Если nw=0, пусть n=1, иначе пусть n=nw. Отношение 0<δ=(xmax−xmin)/n должно сохраняться.
Effects: Создает piecewise_constant_distribution объект с параметрами, взятыми или вычисленными из следующих значений: Let bk=xmin+k⋅δ for k=0,…,nи wk=fw(bk+δ/2) for k=0,…,n−1.
vector<result_type> intervals() const;
Returns: Объект vector<result_type> , size член которого возвращается n+1 и operator[] член которого возвращается bk при вызове с аргументом k for k=0,…,n.
vector<result_type> densities() const;
piecewise_linear_distribution Случайное распределение числа производит случайные числа x, b0≤x<bn, распределяется по каждому подинтервалу в [bi,bi+1) соответствии с функцией плотности вероятности
p(x|b0,…,bn,ρ0,…,ρn)=ρi⋅bi+1−xbi+1−bi+ρi+1⋅x−bibi+1−bi, for bi≤x<bi+1.
Параметры n+1 распределения bi, также известные как это распределение , должны удовлетворять соотношению для . Если не указано иное, остальные параметры распределения вычисляются как , в котором значения , обычно известные как , должны быть неотрицательными, отличными от NaN и бесконечными. Кроме того, должно выполняться следующее соотношение: interval boundaries bi<bi+1 i=0,…,n−1 n+1 ρk=wk/S for k=0,…,n wk weights at boundaries
0<S=12⋅n−1∑k=0(wk+wk+1)⋅(bk+1−bk).
template<class RealType = double> class piecewise_linear_distribution { public: // types using result_type = RealType; using param_type = unspecified; // constructor and reset functions piecewise_linear_distribution(); template<class InputIteratorB, class InputIteratorW> piecewise_linear_distribution(InputIteratorB firstB, InputIteratorB lastB, InputIteratorW firstW); template<class UnaryOperation> piecewise_linear_distribution(initializer_list<RealType> bl, UnaryOperation fw); template<class UnaryOperation> piecewise_linear_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw); explicit piecewise_linear_distribution(const param_type& parm); void reset(); // generating functions template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // property functions vector<result_type> intervals() const; vector<result_type> densities() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
piecewise_linear_distribution();
template<class InputIteratorB, class InputIteratorW>
piecewise_linear_distribution(InputIteratorB firstB, InputIteratorB lastB,
InputIteratorW firstW);
Requires: InputIteratorB и InputIteratorW каждый должен удовлетворять требованиям своего input iterator типа. Кроме того, каждый iterator_traits<InputIteratorB>::value_type и iterator_traits<InputIteratorW>::value_typeдолжен обозначать тип, в который можно преобразовать double. Если firstB == lastB или ++firstB == lastB, пусть n=1, ρ0=ρ1=1, b0=0и b1=1. В противном случае [firstB,lastB) должен формировать последовательность b длины n+1, длина последовательности, w начиная с, firstW должна быть не менее n+1, и любое значение wk for k≥n+1 должно игнорироваться распределением.
template<class UnaryOperation>
piecewise_linear_distribution(initializer_list<RealType> bl, UnaryOperation fw);
Requires: Каждый экземпляр типа UnaryOperation должен быть function object типом возвращаемого значения, в который можно преобразовать double. Более того, double должен быть преобразован в тип UnaryOperationединственного параметра.
Effects: Создает piecewise_linear_distribution объект с параметрами , принятых или вычисленных из следующих значений: Если bl.size()<2, пусть n=1, ρ0=ρ1=1, b0=0и b1=1. В противном случае позвольте [bl.begin(),bl.end()) сформировать последовательность b0,…,bnи позвольте wk=fw(bk) для k=0,…,n.
template<class UnaryOperation>
piecewise_linear_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);
Requires: Каждый экземпляр типа UnaryOperation должен быть function object типом возвращаемого значения, в который можно преобразовать double. Более того, double должен быть преобразован в тип UnaryOperationединственного параметра. Если nw=0, пусть n=1, иначе пусть n=nw. Отношение 0<δ=(xmax−xmin)/n должно сохраняться.
Effects: Создает piecewise_linear_distribution объект с параметрами, взятыми или вычисленными из следующих значений: Let bk=xmin+k⋅δ for k=0,…,nи wk=fw(bk) for k=0,…,n.
vector<result_type> intervals() const;
Returns: Объект vector<result_type> , size член которого возвращается n+1 и operator[] член которого возвращается bk при вызове с аргументом k for k=0,…,n.
vector<result_type> densities() const;
int rand();
void srand(unsigned int seed);
Remarks: Реализация может указывать, что могут вызывать определенные библиотечные функции rand. Это определяется реализацией, rand может ли функция вводить данные races ( [res.on.data.races]). [ Другие средства генерации случайных чисел в этом международном стандарте ( ) часто предпочтительнее , потому что лежащий в основе алгоритм не определен. Поэтому использование по- прежнему непереносимо, с непредсказуемым и часто сомнительным качеством и производительностью. ] Note: [rand] rand rand rand — end note
См. Также: ISO C 7.22.2