29 Numerics library [numerics]

В этом подпункте [rand]эффект создания экземпляра шаблона:

1. a)с параметром типа шаблона с именем Sseq undefined, если соответствующий аргумент шаблона не является cv-unqualified и удовлетворяет требованиям seed sequence.

2. b)с параметром типа шаблона с именем URBG undefined, если соответствующий аргумент шаблона не является cv-unqualified и удовлетворяет требованиям uniform random bit generator.

3. c)с параметром типа шаблона с именем Engine undefined, если соответствующий аргумент шаблона не является cv-unqualified и удовлетворяет требованиям random number engine.

4. d)что параметр типа шаблона с именем RealType не определен , если соответствующий аргумент шаблона не резюме, неквалифицированное и один из float, doubleили long double.

5. e)который имеет тип параметра шаблона с именем IntType не определен , если соответствующий аргумент шаблона не резюме, неквалифицированные и один из short, int, long, long long, unsigned short, unsigned int, unsigned long, или unsigned long long.

6. f)что параметр типа шаблона с именем UIntType не определен , если соответствующий аргумент шаблона не резюме, неквалифицированное и один из unsigned short, unsigned int, unsigned longили unsigned long long.

В этом подпункте [rand]фразы вида « x является итератором определенного типа» должны интерпретироваться как эквивалентные более формальному требованию, что « x является значением типа, удовлетворяющим требованиям указанного типа итератора».

В этом подпункте [rand]должен быть объявлен любой конструктор, который может быть вызван с одним аргументом и который удовлетворяет требованиям, указанным в этом подпункте explicit.

Является объектом , который потребляет последовательность целочисленных данных и производит требуемое число без знака целочисленных значений , на основе потребляемых данных. [ Такой объект предоставляет механизм, позволяющий избежать репликации потоков случайных значений. Это может быть полезно, например, в приложениях, требующих большого количества машин случайных чисел. ] seed sequence i $0\le i<2^{32}$ Note:  — end note 

Класс S удовлетворяет требованиям начальной последовательности, если выражения, показанные в таблице 102 , действительны и имеют указанную семантику, а S также если они удовлетворяют всем другим требованиям этого раздела [rand.req.seedseq]. В этой таблице и в этом разделе:

1. a)T тип, названный Sассоциированным result_­type;

2. b)q является значением S и, r возможно, константным значением S;

3. c)ib и ie являются итераторами ввода с целым числом без знака value_­type длиной не менее 32 бит;

4. d)rb и re являются изменяемыми итераторами произвольного доступа с целым числом без знака value_­type не менее 32 бит;

5. e)ob - итератор вывода; а также

6. f)il это значение initializer_­list<T>.

uniform random bit generator g Типа G является функция объекта возвращение целого числа без знака значения , такой , что каждое значение в диапазоне возможных результатов имеет ( в идеале) , равная вероятности быть возвращены. [  Note: Степень gприближения результатов к идеалу часто определяется статистически. ] — end note 

Класс G удовлетворяет требованиям a, uniform random bit generator если выражения, показанные в таблице 103 , действительны и имеют указанную семантику, а G также если удовлетворяет всем другим требованиям этого раздела [rand.req.urng]. В этой таблице и в этом разделе:

1. a)T тип, названный Gассоциированным result_­type, и

2. b)g это значение G.

Следующее соотношение должно занимать: G​::​min() < G​::​max().

random number engine (Обычно сокращенно engine) e типа E является равномерной случайной генератор битов , что дополнительно отвечает требованиям (например, для посева , а также для ввода / вывода) , указанные в данном разделе.

В любой момент времени e имеет состояние e${}_i$ для некоторого целого числа $i\ge 0$. При постройке e имеет исходное состояние e${}_0$. Состояние двигателя может быть установлено с помощью конструктора, seed функции, присваивания или подходящего operator>>.

Eспецификация должна определять:

1. a)размер Eсостояния, кратный размеру result_­type, заданному как интегральное постоянное выражение;

2. b) transition algorithm TA , с помощью которого e«s государства e${}_i$ продвигаются к его successor state e${}_{i+1}$; а также

3. c)с generation algorithm GA помощью которого состояние двигателя отображается на значение типа result_­type.

Класс, E который удовлетворяет требованиям a, uniform random bit generator также удовлетворяет требованиям a, random number engine если выражения, показанные в таблице 104 , действительны и имеют указанную семантику, а E также if удовлетворяет всем другим требованиям этого раздела [rand.req.eng]. В этой таблице и в этом разделе:

1. a)T тип, названный Eассоциированным result_­type;

2. b)e это значение E, v является именующим из E, x и y которые (возможно const) значения E;

3. c)s значение T;

4. d)q является lvalue, удовлетворяющим требованиям a seed sequence;

5. e)z это значение типа unsigned long long;

6. f)os - lvalue типа некоторой специализации шаблона класса basic_­ostream<charT, traits>; а также

7. g)is - lvalue типа некоторой специализации шаблона класса basic_­istream<charT, traits>;

где charT и traits ограничены согласно пунктам [strings] и пунктам [input.output].

E должны соответствовать требованиям CopyConstructible и CopyAssignable типам. Каждая из этих операций должна быть по сложности не хуже $O\left(\text{size of state}\right)$.

random number engine adaptor (Обычно сокращенно adaptor) a типа A является случайным числом двигателя , который принимает значения , полученные с помощью какого - либо другого случайных чисел двигателя, и применяет алгоритм для этих значений для того , чтобы поставить последовательность значений с различными свойствами случайности. Двигатель b типа , B адаптированный таким образом, называется base engine в этом контексте. Выражение a.base() должно быть действительным и должно возвращать константную ссылку на aбазовый движок.

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

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

1. a)Сложность каждой функции не должна превышать сложность соответствующей функции, применяемой к базовому двигателю.

2. b)Состояние A должно включать состояние его базового двигателя. Размер Aгосударства должен быть не меньше размера базового двигателя.

3. c) AСостояние копирования (например, во время создания копии или назначения копии) должно включать в себя копирование состояния базового механизма A.

4. d)Текстовое представление A должно включать текстовое представление его базового двигателя.

random number distribution (Обычно сокращенно distribution) d типа D является функция объекта возвращение значения, которые распределены в соответствии с ассоциированным математическим probability density function p(z) или в соответствии с ассоциированным discrete probability function $P\left(z_i\right)$. Спецификация распределения определяет связанную с ним функцию вероятности p(z) или $P\left(z_i\right)$.

Соответствующая функция вероятности обычно выражается с помощью определенных поставляемых извне величин, известных как parameters of the distribution. Такие параметры распределения идентифицируются в этом контексте путем написания, например, $p(z|a,b)$ или $P(z_i|a,b)$для обозначения определенных параметров, или путем написания, например, p(z |{p}) или $P\left(z_i|\left\{\text{p}\right\}\right)$, для обозначения параметров распределения, p взятых в целом.

Класс D удовлетворяет требованиям a, random number distribution если выражения, показанные в таблице 105 , действительны и имеют указанную семантику, а if D и связанные с ним типы также удовлетворяют всем другим требованиям этого раздела [rand.req.dist]. В этой таблице и в этом разделе

1. a)T тип, названный Dассоциированным result_­type;

2. b)P тип, названный Dассоциированным param_­type;

3. c)d это значение D, а также x и y являются (возможно const) значения D;

4. d)glb и lub являются значениями T соответственно, соответствующими наибольшей нижней границе и наименьшей верхней границе значений, потенциально возвращаемых d's operator(), как определено текущими значениями dпараметров' s;

5. e)p является (возможно const) значением P;

6. f)g, g1и g2 являются l значениями типа, удовлетворяющими требованиям a uniform random bit generator;

7. g)os - lvalue типа некоторой специализации шаблона класса basic_­ostream<charT, traits>; а также

8. h)is - lvalue типа некоторой специализации шаблона класса basic_­istream<charT, traits>;

где charT и traits ограничены в соответствии с пунктами [strings] и [input.output].

D должны удовлетворять требованиям CopyConstructible и CopyAssignable типам.

Последовательность чисел, полученная при повторных вызовах, 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 только для удобства изложения.

P должен удовлетворять требования CopyConstructible, CopyAssignableи EqualityComparable типов.

Для каждого из конструкторов, D принимающих аргументы, соответствующие параметрам распределения, P должен быть соответствующий конструктор, подчиняющийся тем же требованиям и принимающий аргументы, идентичные по количеству, типу и значениям по умолчанию. Более того, для каждой из функций-членов D этих возвращаемых значений, соответствующих параметрам распределения, P должна быть соответствующая функция-член с идентичным именем, типом и семантикой.

P иметь декларацию по форме

using distribution_type =  D;

Механизм linear_­congruential_­engine случайных чисел производит беззнаковые целые случайные числа. Состояние из объекта имеет размер и состоит из одного целого числа. Алгоритм перехода представляет собой модульную линейную функцию формы ; алгоритм генерации есть . x${}_i$ linear_­congruential_­engine x 1$TA\left({\text{x}}_i\right)=(a\cdot {\text{x}}_i+c)modm$ $GA\left({\text{x}}_i\right)={\text{x}}_{i+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 

Если параметр шаблона m не равен 0, должны выполняться следующие отношения: a < m и c < m.

Текстовое представление состоит из значения x${}_i$.

Механизм mersenne_­twister_­engine случайных чисел 270 производит беззнаковые целые случайные числа в закрытом интервале $[0,2^w-1]$. Состояние из объекта имеет размер и состоит из последовательности из значений типа поставляемого ; все применяемые индексы следует брать по модулю .x${}_i$ mersenne_­twister_­engine x n X n x X n

Алгоритм перехода использует сдвиговый регистр с обобщенной обратной связью, определяемый значениями сдвига и , значением поворота и условной xor-маской . Чтобы улучшить однородность результата, биты необработанного регистра сдвига дополнительно (т. Е. Скремблируются) в соответствии с матрицей битового скремблирования, определенной значениями и . n m r a tempered $u,d,s,b,t,c,$ ℓ

Переход между состояниями выполняется следующим образом:

1. a)Соедините верхние $w-r$ биты $X_{i-n}$ с младшими r битами, $X_{i+1-n}$ чтобы получить беззнаковое целое число Y.

2. b)С $\alpha =a\cdot \left(Ybitand1\right)$, установите $X_i$ на $X_{i+m-n}xor\left(Yrshift1\right)xor\alpha$.

Последовательность X инициализируется с помощью множителя инициализации f.

Алгоритм генерации определяет беззнаковые целочисленные значения следующим образом, а затем выдает в качестве своего результата: $z_1,z_2,z_3,z_4$ $z_4$

1. a)Пусть $z_1=X_{i}xor(\left(X_{i}rshiftu\right)bitandd)$.

2. b)Пусть $z_2=z_{1}xor(\left(z_1{lshift}_{w}s\right)bitandb)$.

3. c)Пусть $z_3=z_{2}xor(\left(z_2{lshift}_{w}t\right)bitandc)$.

4. d)Пусть $z_4=z_{3}xor\left(z_{3}rshift\ell \right)$.

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  $2^w-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.

Текстовое представление о x${}_i$ состоит из значений $X_{i-n},\dots ,X_{i-1}$, в таком порядке.

Механизм subtract_­with_­carry_­engine случайных чисел производит беззнаковые целые случайные числа.

Состояние из объекта имеет размера , и состоит из последовательности из целочисленных значений ; все применяемые индексы следует брать по модулю . Состояние дополнительно состоит из целого числа (известного как ) , значение которого равно или . x${}_i$ subtract_­with_­carry_­engine x$O\left(r\right)$ X r $0\le X_i<m=2^w$ X r x${}_i$ c carry 0 1

Переход между состояниями выполняется следующим образом:

1. a)Пусть $Y=X_{i-s}-X_{i-r}-c$.

2. b)Установите $X_i$ на $y=Ymodm$. Установите c в 1, если $Y<0$, в противном случае установите c в 0.

[  Note: Этот алгоритм соответствует модульной линейной функции вида $TA\left({\text{x}}_i\right)=(a\cdot {\text{x}}_i)modb$, где b имеет вид $m^r-m^s+1$ и $a=b-(b-1)/m$. ] — end note 

Алгоритм генерации задается формулой , где - значение, полученное в результате улучшения состояния двигателя, как описано выше.$GA\left({\text{x}}_i\right)=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.

Текстовое представление состоит из значений в указанном порядке, за которыми следует . $X_{i-r},\dots ,X_{i-1}$ c

Каждый тип, созданный из шаблона класса, указанного в этом разделе, [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. Состояние из объекта адаптера двигателя состоит из состояния своего базового двигателя и дополнительного целого числа . Размер государства равен размеру государства плюс . x${}_i$ discard_­block_­engine x e${}_i$ e n e 1

Алгоритм перехода отбрасывает все значения, кроме значений, из каждого блока значений, предоставленного . Переход между состояниями выполняется следующим образом: Если , переместите состояние из в и установите в . В любом случае, затем увеличивайте и продвигайте текущее состояние до . $r>0$ $p\ge r$ e $n\ge r$ e e${}_i$ e${}_{i+p-r}$ n 0 n e e${}_j$ e${}_{j+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
  };

Имеют место следующие отношения: 0 < r и r <= p.

Текстовое представление состоит из текстового представления, за которым следует значение . e n

В дополнение к своему поведению в соответствии с разделом [rand.req.adapt]каждый конструктор, который не является конструктором копирования, устанавливает n значение 0.

An independent_­bits_­engine адаптер сочетает в себе случайное число случайных чисел двигателей, которые производятся некоторым базовым двигателем e, таким образом , чтобы произвести случайные числа с заданным количеством битов w. Состояние из объекта адаптера двигателя состоит из состояния своего базового двигателя ; размер государства - это размер российского государства. x${}_i$ independent_­bits_­engine x e${}_i$ e e

Алгоритмы перехода и генерации описываются следующими интегральными константами:

1. a)Пусть $R=\text{e.max() - e.min() + 1}$ и $m=\lfloor {\log }_{2}R\rfloor$.

2. b)С , n как определено ниже, пусть $w_0=\lfloor w/n\rfloor$, $n_0=n-wmodn$, $y_0=2^{w_0}\lfloor R/2^{w_0}\rfloor$и $y_1=2^{w_0+1}\lfloor R/2^{w_0+1}\rfloor$.

3. c)Пусть $n=\lceil w/m\rceil$ тогда и только тогда, когда в результате соотношение $R-y_0\le \lfloor y_0/n\rfloor$ выполняется. Иначе пусть $n=1+\lceil w/m\rceil$.

[  Note: Отношение $w=n_0{w}_0+(n-n_0)(w_0+1)$ всегда сохраняется. ] — end note 

Алгоритм перехода выполняется путем вызова по мере необходимости для получения значений меньше чем и значений меньше чем . e() $n_0$$y_0+\text{e.min()}$ $n-n_0$ $y_1+\text{e.min()}$

Алгоритм генерации использует значения, полученные при продвижении состояния, как описано выше, чтобы получить количество, полученное, как если бы по следующему алгоритму: S

S = 0;
for (k = 0; $k\ne n_0$; k += 1)  {
 do u = e() - e.min(); while ($u\ge y_0$);
 S = $2^{w_0}\cdot S+umod{2}^{w_0}$;
}
for (k = $n_0$; $k\ne n$; k += 1)  {
 do u = e() - e.min(); while ($u\ge y_1$);
 S = $2^{w_0+1}\cdot S+umod{2}^{w_0+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 $2^w-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
  };

Имеют место следующие отношения: 0 < w и w <= numeric_­limits<result_­type>​::​digits.

Текстовое представление состоит из текстового представления . e

shuffle_­order_­engine Случайным образом номер адаптера двигатель производит те же самые случайные числа, которые производятся некоторым базовым двигателем e, но доставляет их в другой последовательности. Состояние из объекта адаптера двигателя состоит из состояния своего базового двигателя , дополнительное значение типа поставляемого и дополнительная последовательность из значений и типа поставляемого . Размер государства равен размеру государства плюс . x${}_i$ shuffle_­order_­engine x e${}_i$ e Y e V k e e $k+1$

Алгоритм перехода переставляет значения, создаваемые . Переход между состояниями выполняется следующим образом: e

1. a)Вычислить целое число $j=\lfloor \frac{k\cdot (Y-e_{min})}{e_{max}-e_{min}+1}\rfloor$ .

2. b)Набор Y для $V_j$ и затем установить $V_j$ в 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
  };

Следующее соотношение должно занимать: 0 < k.

Текстовое представление состоит из текстового представления , за которым следуют значения , за которыми следует значение . e k V Y

В дополнение к своему поведению в соответствии с разделом [rand.req.adapt], каждый конструктор, который не является конструктором копирования, инициализируется $\text{V[0]},\dots ,\text{V[k-1]}$ и Yв этом порядке значениями, возвращаемыми последовательными вызовами e().

Каждая функция экземпляр из шаблона , описанный в этом разделе [rand.util.canonical] отображает результат одного или несколько призываний в комплекте поставку равномерного случайного генератора бит g одного из членов указанной RealType таким образом, что, если значения , $g_i$ полученные g равномерно распределены, результаты Инстанцирования в $t_j$, $0\le t_j<1$, распределяются как можно более равномерно, как указано ниже.

[  Note: Получение значения таким образом может быть полезным этапом в процессе преобразования значения, сгенерированного генератором однородных случайных битов, в значение, которое может быть доставлено распределением случайных чисел. ] — end note