libcxx/modules/std/random.inc

   1 // -*- C++ -*-
   2 //===----------------------------------------------------------------------===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 export namespace std {
  11   // [rand.req.urng], uniform random bit generator requirements
  12   using std::uniform_random_bit_generator;
  13
  14   // [rand.eng.lcong], class template linear_congruential_engine
  15   using std::linear_congruential_engine;
  16
  17   // [rand.eng.mers], class template mersenne_twister_engine
  18   using std::mersenne_twister_engine;
  19
  20   // [rand.eng.sub], class template subtract_with_carry_engine
  21   using std::subtract_with_carry_engine;
  22
  23   // [rand.adapt.disc], class template discard_block_engine
  24   using std::discard_block_engine;
  25
  26   // [rand.adapt.ibits], class template independent_bits_engine
  27   using std::independent_bits_engine;
  28
  29   // [rand.adapt.shuf], class template shuffle_order_engine
  30   using std::shuffle_order_engine;
  31
  32   // [rand.predef], engines and engine adaptors with predefined parameters
  33   using std::knuth_b;
  34   using std::minstd_rand;
  35   using std::minstd_rand0;
  36   using std::mt19937;
  37   using std::mt19937_64;
  38   using std::ranlux24;
  39   using std::ranlux24_base;
  40   using std::ranlux48;
  41   using std::ranlux48_base;
  42
  43   using std::default_random_engine;
  44
  45 #if _LIBCPP_HAS_RANDOM_DEVICE
  46   // [rand.device], class random_device
  47   using std::random_device;
  48 #endif
  49
  50   // [rand.util.seedseq], class seed_seq
  51   using std::seed_seq;
  52
  53   // [rand.util.canonical], function template generate_canonical
  54   using std::generate_canonical;
  55
  56   // [rand.dist.uni.int], class template uniform_int_distribution
  57   using std::uniform_int_distribution;
  58
  59   // [rand.dist.uni.real], class template uniform_real_distribution
  60   using std::uniform_real_distribution;
  61
  62   // [rand.dist.bern.bernoulli], class bernoulli_distribution
  63   using std::bernoulli_distribution;
  64
  65   // [rand.dist.bern.bin], class template binomial_distribution
  66   using std::binomial_distribution;
  67
  68   // [rand.dist.bern.geo], class template geometric_distribution
  69   using std::geometric_distribution;
  70
  71   // [rand.dist.bern.negbin], class template negative_binomial_distribution
  72   using std::negative_binomial_distribution;
  73
  74   // [rand.dist.pois.poisson], class template poisson_distribution
  75   using std::poisson_distribution;
  76
  77   // [rand.dist.pois.exp], class template exponential_distribution
  78   using std::exponential_distribution;
  79
  80   // [rand.dist.pois.gamma], class template gamma_distribution
  81   using std::gamma_distribution;
  82
  83   // [rand.dist.pois.weibull], class template weibull_distribution
  84   using std::weibull_distribution;
  85
  86   // [rand.dist.pois.extreme], class template extreme_value_distribution
  87   using std::extreme_value_distribution;
  88
  89   // [rand.dist.norm.normal], class template normal_distribution
  90   using std::normal_distribution;
  91
  92   // [rand.dist.norm.lognormal], class template lognormal_distribution
  93   using std::lognormal_distribution;
  94
  95   // [rand.dist.norm.chisq], class template chi_squared_distribution
  96   using std::chi_squared_distribution;
  97
  98   // [rand.dist.norm.cauchy], class template cauchy_distribution
  99   using std::cauchy_distribution;
 100
 101   // [rand.dist.norm.f], class template fisher_f_distribution
 102   using std::fisher_f_distribution;
 103
 104   // [rand.dist.norm.t], class template student_t_distribution
 105   using std::student_t_distribution;
 106
 107   // [rand.dist.samp.discrete], class template discrete_distribution
 108   using std::discrete_distribution;
 109
 110   // [rand.dist.samp.pconst], class template piecewise_constant_distribution
 111   using std::piecewise_constant_distribution;
 112
 113   // [rand.dist.samp.plinear], class template piecewise_linear_distribution
 114   using std::piecewise_linear_distribution;
 115 } // namespace std