Случайные числа необходимы в ряде различных проблемных доменов, таких как:

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

В зависимости от требований проблемной области уместны различные вариации генераторов случайных чисел:

Все вариации имеют некоторые общие свойства, понятия (в смысле STL) называютсяUniformRandomNumberGenerator.. Эта концепция будет определена в следующем разделе.

Цели этой библиотеки следующие:

Единый генератор случайных чисел обеспечивает последовательность случайных чисел, равномерно распределенных в заданном диапазоне. Диапазон может быть фиксированным или доступным (только) после выполнения строительства объекта.

узкая нижняя границанекоторого (конечного) множества S является (уникальным) членом l в S, так что для всех v в S, l< = v удерживает. Аналогично,плотная верхняя границанекоторого (конечного) множества S является (уникальным) членом u в S, так что для всех v в S, v< = u удерживает.

В следующей таблице X обозначает число генераторного класса возвращающихся объектов типа T, а v — конст-значение X.

Функции членов<min>,<max>и<operator()>должны иметь амортизированную постоянную временную сложность.

Note

Для целых генераторов (т.е. целых<T>), генерируемые значения<x>выполняют<min() <=x <=max()>, для нецелых генераторов (т.е. нецелых<T>), генерируемые значения<x>выполняют<min()<=x<max()>. Обоснование: Описание диапазона с min и max служит двум целям. Во-первых, он позволяет масштабировать значения до некоторого канонического диапазона, такого как [0,1]. Во-вторых, он описывает значительные биты значений, которые могут быть актуальны для дальнейшей обработки. Диапазон представляет собой закрытый интервал [min,max] для целых чисел, поскольку базовый тип может не представлять полуоткрытый интервал [min,max+1). Это полуоткрытый интервал [min, max] для неинтеграторов, потому что это гораздо более практично для пограничных случаев непрерывного распределения.

	Note
	Концепция UniformRandomNumberGeneratorне требует<operator()(long)>и, таким образом, не соответствует<RandomNumberGenerator>(std:25.2.11 [lib.alg.random.shuffle]) требованиям. Используйте для этого<random_number_generator>адаптер. Обоснование:<operator()(long)>не предусмотрено, потому что отображение выхода некоторого генератора с целым диапазоном до другого целого диапазона не тривиально.

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

Класс<random_device>является моделью для недетерминированного генератора случайных чисел.

Note

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

Генератор псевдослучайных чисел представляет собойUniformRandomNumberGenerator, который обеспечивает детерминированную последовательность псевдослучайных чисел, основанную на некотором алгоритме и внутреннем состоянии.<Linear congruential>и<inversive congruential>генераторы являются примерами такихгенераторов псевдослучайных чисел. Часто эти генераторы очень чувствительны к своим параметрам. Чтобы предотвратить использование неправильных реализаций, внешний испытуемый должен проверить, что генерируемая последовательность и предоставленное значение валидации действительно совпадают.

Дональд Э. Кнут дает обширный обзор псевдослучайной генерации чисел в своей книге «Искусство компьютерного программирования, том 2, 3-е издание, Аддисон-Уэсли, 1997». В описаниях конкретных генераторов содержатся дополнительные ссылки.

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

В дополнение к требованиямUniformRandomNumberGeneratorгенератор псевдослучайных чисел имеет некоторые дополнительные требования. В следующей таблице<X>обозначает класс генератора псевдослучайных чисел,<u>является значением<X>,<i>является значением интегрального типа,<s>является значением типа, который моделируетSeedSeq, и<j>значением типа<unsignedlong long>.

Классы, моделирующие генератор псевдослучайных чисел, должны также моделироватьРавенствоСравнимое, т.е. реализовывать<operator==>. Два генератора псевдослучайных чисел определены какэквивалент, если они оба возвращают идентичную последовательность чисел, начиная с данного состояния.

Классы, которые моделируют генератор псевдослучайных чисел, должны также моделировать концепцию Streamable, т.е. реализовать<operator<<>и<operator>>>.<operator<<>записывает все текущее состояние генератора псевдослучайных чисел в данное<ostream>, чтобы<operator>>>мог восстановить состояние в более позднее время. Государство должно быть написано независимо от платформы, но предполагается, что<locales>, используемые для письма и чтения, одинаковы. Генератор псевдослучайных чисел с восстановленным состоянием и оригинал в только что написанном состоянии должны быть эквивалентными.

Классы, которые моделируют генератор псевдослучайных чисел, также должны моделировать концепцииCopyConstructibleиAssignable. Однако обратите внимание, что последовательности оригинала и копии сильно коррелируют (на самом деле они идентичны), что может сделать их непригодными для некоторых проблемных доменов. Таким образом, копирование генераторов псевдослучайных чисел не рекомендуется; они всегда должны быть переданы ссылкой.

Классы<rand48>,<minstd_rand>и<mt19937>являются моделями для генератора псевдослучайных чисел.

Note

Этот тип генератора случайных чисел полезен для цифр, игр и тестирования. Конструктор(ы) ненулевых аргументов и функция(ы) элемента<seed()>позволяют устанавливать в генераторе состояние, обеспеченное пользователем. Это полезно для отладки алгоритмов Монте-Карло и анализа конкретных сценариев тестирования. Концепция Streamable позволяет сохранить/восстановить состояние генератора, например, повторно запустить тестовый набор в более позднее время.

SeedSeq представляет собой последовательность значений, которые могут быть использованы для установки начального состоянияPseudoRandomNumberGenerator.<i>и<j>являются итераторами случайного доступа, чей<value_type>является неподписанным целым типом с по меньшей мере 32 битами.

Класс<seed_seq>и каждыйUniformRandomNumberGenerator, предоставляемый библиотекой, являются моделямиSeedSeq.

Случайное распределение производит случайные числа, распределенные в соответствии с некоторым распределением, заданные равномерно распределенные случайные значения в качестве входных данных. В следующей таблице<X>обозначает случайный класс распределения, возвращающий объекты типа<T>,<u>является значением<X>,<x>и<y>являются (возможно, конст) значениями<X>,<P>является<param_type>распределения,<p>является значением<P>, и<e>является значением произвольного типа, которое соответствует требованиямUniformRandomNumberGenerator, возвращающие значения типа<U>.

Дополнительные требования: Последовательность чисел, создаваемых повторными вызовами<x(e)>, не изменяется, вызывается ли<os <<x>между любыми вызовами<x(e)>. Если текстовое представление записано с использованием<os <<x>и это представление восстановлено в том же или другом объекте<y>того же типа с использованием<is>> y>, повторные вызовы<y(e)>производят ту же последовательность случайных чисел, что и повторные вызовы<x(e)>.

namespace boost {
  namespace random {
    template<typename MLCG1, typename MLCG2> class additive_combine_engine;
    typedef additive_combine_engine< linear_congruential_engine< uint32_t, 40014, 0, 2147483563 >, linear_congruential_engine< uint32_t, 40692, 0, 2147483399 >> ecuyer1988;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double> class bernoulli_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double> class beta_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename IntType = int, typename RealType = double> 
      class binomial_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double> class cauchy_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double> class chi_squared_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename UniformRandomNumberGenerator, std::size_t p, 
             std::size_t r> 
      class discard_block_engine;
  }
}

namespace boost {
  namespace random {
    template<typename IntType = int, typename WeightType = double> 
      class discrete_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double> class exponential_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double> class extreme_value_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double> class fisher_f_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double> class gamma_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename RealType, std::size_t bits, typename URNG> 
      RealType generate_canonical(URNG &);
  }
}

namespace boost {
  namespace random {
    template<typename IntType = int, typename RealType = double> 
      class geometric_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename RealT = double> class hyperexponential_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename Engine, std::size_t w, typename UIntType> 
      class independent_bits_engine;
  }
}

namespace boost {
  namespace random {
    template<typename IntType, IntType a, IntType b, IntType p> 
      class inversive_congruential_engine;
    typedef inversive_congruential_engine< uint32_t, 9102, 2147483647-36884165, 2147483647 > hellekalek1995;
  }
}

namespace boost {
  namespace random {
    template<typename UIntType, int w, unsigned int p, unsigned int q> 
      class lagged_fibonacci_engine;
    template<typename RealType, int w, unsigned int p, unsigned int q> 
      class lagged_fibonacci_01_engine;
    typedef lagged_fibonacci_01_engine< double, 48, 607, 273 > lagged_fibonacci607;
    typedef lagged_fibonacci_01_engine< double, 48, 1279, 418 > lagged_fibonacci1279;
    typedef lagged_fibonacci_01_engine< double, 48, 2281, 1252 > lagged_fibonacci2281;
    typedef lagged_fibonacci_01_engine< double, 48, 3217, 576 > lagged_fibonacci3217;
    typedef lagged_fibonacci_01_engine< double, 48, 4423, 2098 > lagged_fibonacci4423;
    typedef lagged_fibonacci_01_engine< double, 48, 9689, 5502 > lagged_fibonacci9689;
    typedef lagged_fibonacci_01_engine< double, 48, 19937, 9842 > lagged_fibonacci19937;
    typedef lagged_fibonacci_01_engine< double, 48, 23209, 13470 > lagged_fibonacci23209;
    typedef lagged_fibonacci_01_engine< double, 48, 44497, 21034 > lagged_fibonacci44497;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double> class laplace_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename IntType, IntType a, IntType c, IntType m> 
      class linear_congruential_engine;
    class rand48;
    typedef linear_congruential_engine< uint32_t, 16807, 0, 2147483647 > minstd_rand0;
    typedef linear_congruential_engine< uint32_t, 48271, 0, 2147483647 > minstd_rand;
  }
}

namespace boost {
  namespace random {
    template<typename UIntType, int w, int k, int q, int s> 
      class linear_feedback_shift_engine;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double> class lognormal_distribution;
  }
}

BOOST_RANDOM_MERSENNE_TWISTER_DISCARD_THRESHOLD

namespace boost {
  namespace random {
    template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, 
             std::size_t r, UIntType a, std::size_t u, UIntType d, 
             std::size_t s, UIntType b, std::size_t t, UIntType c, 
             std::size_t l, UIntType f> 
      class mersenne_twister_engine;
    typedef mersenne_twister_engine< uint32_t, 32, 351, 175, 19, 0xccab8ee7, 11, 0xffffffff, 7, 0x31b6ab00, 15, 0xffe50000, 17, 1812433253 > mt11213b;
    typedef mersenne_twister_engine< uint32_t, 32, 624, 397, 31, 0x9908b0df, 11, 0xffffffff, 7, 0x9d2c5680, 15, 0xefc60000, 18, 1812433253 > mt19937;
    typedef mersenne_twister_engine< uint64_t, 64, 312, 156, 31, 0xb5026f5aa96619e9ull, 29, 0x5555555555555555ull, 17, 0x71d67fffeda60000ull, 37, 0xfff7eee000000000ull, 43, 6364136223846793005ull > mt19937_64;
  }
}

namespace boost {
  namespace random {
    template<typename IntType = int, typename RealType = double> 
      class negative_binomial_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double> 
      class non_central_chi_squared_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double> class normal_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double, typename WeightType = double> 
      class piecewise_constant_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double> class piecewise_linear_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename IntType = int, typename RealType = double> 
      class poisson_distribution;
  }
}

namespace boost {
  namespace random {
    class random_device;
  }
}

namespace boost {
  namespace random {
    template<typename URNG, typename IntType = long> 
      class random_number_generator;
  }
}

namespace boost {
  namespace random {
    typedef subtract_with_carry_engine< uint32_t, 24, 10, 24 > ranlux_base;
    typedef subtract_with_carry_01_engine< float, 24, 10, 24 > ranlux_base_01;
    typedef subtract_with_carry_01_engine< double, 48, 10, 24 > ranlux64_base_01;
    typedef discard_block_engine< ranlux_base, 223, 24 > ranlux3;
    typedef discard_block_engine< ranlux_base, 389, 24 > ranlux4;
    typedef discard_block_engine< ranlux_base_01, 223, 24 > ranlux3_01;
    typedef discard_block_engine< ranlux_base_01, 389, 24 > ranlux4_01;
    typedef discard_block_engine< ranlux64_base_01, 223, 24 > ranlux64_3_01;
    typedef discard_block_engine< ranlux64_base_01, 389, 24 > ranlux64_4_01;
    typedef subtract_with_carry_engine< uint64_t, 48, 10, 24 > ranlux64_base;
    typedef discard_block_engine< ranlux64_base, 223, 24 > ranlux64_3;
    typedef discard_block_engine< ranlux64_base, 389, 24 > ranlux64_4;
    typedef subtract_with_carry_engine< uint32_t, 24, 10, 24 > ranlux24_base;
    typedef subtract_with_carry_engine< uint64_t, 48, 5, 12 > ranlux48_base;
    typedef discard_block_engine< ranlux24_base, 223, 23 > ranlux24;
    typedef discard_block_engine< ranlux48_base, 389, 11 > ranlux48;
  }
}

namespace boost {
  namespace random {
    class seed_seq;
  }
}

namespace boost {
  namespace random {
    template<typename UniformRandomNumberGenerator, std::size_t k> 
      class shuffle_order_engine;
    typedef shuffle_order_engine< linear_congruential_engine< uint32_t, 1366, 150889, 714025 >, 97 > kreutzer1986;
    typedef shuffle_order_engine< minstd_rand0, 256 > knuth_b;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double> class student_t_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename IntType, std::size_t w, std::size_t s, std::size_t r> 
      class subtract_with_carry_engine;
    template<typename RealType, std::size_t w, std::size_t s, std::size_t r> 
      class subtract_with_carry_01_engine;
  }
}

namespace boost {
  namespace random {
    typedef xor_combine_engine< xor_combine_engine< linear_feedback_shift_engine< uint32_t, 32, 31, 13, 12 >, 0, linear_feedback_shift_engine< uint32_t, 32, 29, 2, 4 >, 0 >, 0, linear_feedback_shift_engine< uint32_t, 32, 28, 3, 17 >, 0 > taus88;
  }
}

namespace boost {
  namespace random {
    namespace traits {
      template<typename T> struct make_unsigned;
      template<typename T> struct make_unsigned_or_unbounded;
      template<typename T> struct is_integral;
      template<typename T> struct is_signed;
    }
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double> class triangle_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double> class uniform_01;
  }
}

namespace boost {
  namespace random {
    template<typename IntType = int> class uniform_int_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double, 
             typename Cont = std::vector<RealType> > 
      class uniform_on_sphere;
  }
}

namespace boost {
  namespace random {
    template<typename RealType = double> class uniform_real_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename IntType = int> class uniform_smallint;
  }
}

namespace boost {
  template<typename Engine, typename Distribution> class variate_generator;
}

namespace boost {
  namespace random {
    template<typename RealType = double> class weibull_distribution;
  }
}

namespace boost {
  namespace random {
    template<typename URNG1, int s1, typename URNG2, int s2> 
      class xor_combine_engine;
  }
}