Poster pour @FlopSetxk qui se bat avec l'éditeur d'OC :

Bonjour a tous ! Excusez moi de vous deranger, mais j'aurais besoin d'un petit peu d'aide (Ca fait quatre jours que je pietine...)
Je voudrais implementer un generateur de nombres aleatoires a la compilation, repondant aux criteres suivants:
- Supporte differents "Engines" (Linear congruential, subtract with carry...)
- Supporte tout type de nombre (Unsigned int, unsigned short...)
- Permet d'obtenir un nombre compris entre un maximum et un minimum
- Check la validite des parametres a la compilation

Et dans les trefonds de Github, j'ai trouver ca: https://github.com/cr-lupin/metarand
Ce code est base sur ce document: https://pdfs.semanticscholar.org/da32/da4c2b972693fc50e28518d9d44111f7d31c.pdf (Que j'ai du lire une bonne vingtaine de fois)

Le probleme de ce code, c'est que non seulement il ne permet pas de definir un encradrement min/max pour le resultat (Je pense pouvoir regler cela facilement avec un macro, mais une solution directement avec les templates ne serait-elle pas plus "propre" ?), mais surtout il ne verifie ni la valeur des parametres, ni le resultat des operations performees, ni la capacite des type arbitraires passes ! Ce qui conduit le compilateur (MSVC, Visual Studio 2017, C++ 17), a me signaler deux jolis "Integer overflow", dont le plus notable est ici:

static const UIntType value = (a * seed + c) % m;

J'ai donc mit les main dans le cambouis, et essayer de regler ca. Sauf que vous vous en doutez, si je suis la, c'est parce que j'ai pas reussi... en fait, les warnings disparaissent en baissant la valeur des parametres a, c et m, et de la graine, mais apres les resultats ne sont plus aleatoires. Et je suis pas assez bon en meta-programmation pour fixer ca.
Si quelqu’un pouvez m’expliquer comment régler ca... merci par avance !

PS: Desole pour l'orthographe et l'abscence d'accents, mais je suis sur un clavier QWERTY...

Les opérations sur les non signés sont parfaitement définit et ne causent pas de problème. Est-ce un avertissement ou une erreur ? Car il est possible de désactiver localement des avertissements avec des pragma. Après, c'est toujours possible de faire l'opération sur des uint64_t avant de les remettre dans le type demandé par l'utilisateur.

Pour l'intervalle de valeur, c'est aux distributions de le faire en se basant sur le min/max du générateur de nombre, eux même définit par l'algorithme du générateur et les valeurs initiales dans le template.

Poster pour @FlopSetxk qui se bat avec l'éditeur d'OC :

Salut et merci de la réponse. C’est des warnings, pas des erreurs. D’ailleurs le code compile et fonctionne tel quel. Mais je trouve qu’utiliser #pragma ça fait un peu “on planque les cigarettes sous le tapis”. Si le compilo sort des wanings, y doit bien y avoir une raison. Par ailleurs, je suis pas certain que GCC ou Clang soit aussi permissif.

Pour l’histoire du min/max j’ai pas compris ce que tu veux dire... Qu’est-ce que tu appelles distribution ?

> Par ailleurs, je suis pas certain que GCC ou Clang soit aussi permissif.

Si. Ils le sont pour les non-signés. Dans le cas de nombre signé, se sera une erreur. Pour msvc, les 2 sont des avertissements.

> Qu’est-ce que tu appelles distribution ?

si tu regardes ce que propose le standard pour les nombres aléatoires, il y a 2 choses:

• les générateurs
• les distributions

Les générateurs produisent un nombre en fonction d'une formule mathématique. Les limites du résultat sont imposés par les paramètres de l'algorithme, la formule utilisée et le type du résultat (u32, u64, etc). Le nombre généré est ensuite utilisé dans l'itération suivante. La graine utilisée comme valeur de départ correspond à la première itération, ou est une dérivée.

Si je prends std::mt19937, la limite et de 2**32-1. Pour linear_congruential_engine, la limite est du paramètre m qui sert de modulo. On pourrait se dire que le paramètre m sert à définir un intervalle, mais comme le résultat est utilisé pour l'itération suivante, une mauvaise valeur corrompt le générateur qui retourne alors toujours la même valeur ou un nombre très restreint.

#include <random>
#include <iostream>
int main()
{
  std::linear_congruential_engine<unsigned, 4, 11, 28> engine(1);
  for (int i = 0; i < 22; ++i)
    std::cout << engine() << "\n"; // toujours 15
}

Du coup, la plage de valeur est calculée par des lois de probabilité: les distributions qui s'occupent de répartir les valeurs du générateur dans les limites imposées. Par exemple, on peut trouver la loi normale qui donne une courbe en cloche. Ou comme dans metarand, la loi de Bernoulli qui définit la probabilité d'avoir 1 par rapport à 0.

Poster pour @FlopSetxk qui se bat avec l'éditeur d'OC :

Ok, donc concretement tu me conseil de faire quoi ? Implemeter la loi normale (Que je ne connais absolument pas) par dessus les congruences lineaires ? N'est-il pas simplement possible de reutiliser l'implementation de la STL, mais lors de la compilation au lieu de l'execution ?

De plus, voici la sortie de visual studio:

1>main.cpp
1>f:\test\meta_number.h(86): warning C4307: '*': integral constant overflow
1>f:\tetst\meta_number.h(71): note: see reference to class template instantiation 'Eval<MetaRandomNumbersGenerator>' being compiled
1> with
1> [
1> MetaRandomNumbersGenerator=X
1> ]
1>f:\test\main.cpp(50): note: see reference to class template instantiation 'MetaRandomNumberNext<X>' being compiled

Obtenu pour le code suivant:

int main()
{
typedef MetaRandomNumbersGeneratorInit<MetaLinearCongruentialEngine<unsigned long, default_seed, 400, 2345, UINT_MAX>>::type X;
typedef MetaRandomNumberNext<X>::type X0;
std::cout << X0::value << std::endl;
typedef MetaRandomNumberNext<X0>::type X1;
std::cout << X1::value << std::endl;

...

return(0);
}

Si je modifie ceci:

template<typename UIntType, const unsigned int Seed, UIntType a, UIntType c, UIntType m>
struct Eval<MetaLinearCongruentialEngine<UIntType, Seed, a, c, m>>
{
static const UIntType value = ((a * Seed + c) % m);
typedef MetaLinearCongruentialEngine<UIntType, ((a * Seed + c) % m), a, c, m> type;
};

Par:
template<typename UIntType, const unsigned int Seed, UIntType a, UIntType c, UIntType m>
struct Eval<MetaLinearCongruentialEngine<UIntType, Seed, a, c, m>>
{
static const unsigned long long long_value = static_cast<unsigned long long>((a * Seed + c) % m);
static const UIntType value = static_cast<UIntType>(long_value);
typedef MetaLinearCongruentialEngine<UIntType, value, a, c, m> type;
};

J'ai toujours les memes Warnings. Mais si je modifie ca:

typedef MetaRandomNumbersGeneratorInit<MetaLinearCongruentialEngine<unsigned long, default_seed, 400, 2345, UINT_MAX>>::type X; // Nombres choisis completement au hasard

Par ca:

typedef MetaRandomNumbersGeneratorInit<MetaLinearCongruentialEngine<unsigned long, default_seed, 2, 11, UINT_MAX>>::type X; // Nombres choisis completement au hasard

Les Warnings disparaissent, mais la sortie n'est plus aleatoire !

> Ok, donc concretement tu me conseil de faire quoi ? (1) Implemeter la loi normale (Que je ne connais absolument pas) par dessus les congruences lineaires ? (2) N'est-il pas simplement possible de reutiliser l'implementation de la STL, mais lors de la compilation au lieu de l'execution ?

Oui et oui. Par contre, il faut recopier l'implémentation pour la mettre dans des fonctions constexpr...

Tu peux regarder les sources de msvc qui sont sur ton système ou celle de libc++ (clang) (dans random et algorithm).

> si je modifie [...] par [...], les Warnings disparaissent, mais la sortie n'est plus aleatoire !

C'est ce que je disais dans mon message précédent, jouer avec les valeurs des générateurs est très risqué et c'est facile de tourner sur les mêmes valeurs.

Pour l'overflow: https://gcc.godbolt.org/z/6BYjSb

• msvc compile avec un avertissement pour unsigned et int (même s'il n'affiche que le premier avertissement car la ligne est la même)
• gcc/clang ne donne pas d'avertissement pour les non signés, mais une erreur pour les signés (avec en plus un avertissement).

Le plus simple reste de désactiver localement les avertissements, il ne faut pas croire que tous les avertissements sont légitimes quel que soit le contexte.

Poster pour @FlopSetxk qui se bat avec l'éditeur d'OC :

Réutiliser le code de la STL est tentant, mais rien que dans <random> il doit y avoir... quoi... 5500 lignes de code ? Au bas mot ? Dont une partie qui repose sur des implementations de la STL qui ne sont pas sensé être exposées au code utilisateur je suppose... Comment je suis censé utiliser ça ?

Les seules fonctions inintéressante sont les operator() des distributions. Après, ce n'est qu'une bête implémentation d'une suite mathématique qui se trouve sur Wikipédia.

Poster pour @FlopSetxk qui se bat avec l'éditeur d'OC :

Je suis desole, mais la tu me parles chinois... ou au minimum vietnamien. Meme si je copie les operateurs, ca veut dire que je doit reecrire tout le reste du code a la main non ? J'ai bien compris que je peut pas faire un copier-coller de la STL, mais dans le lien que tu m'a donne, le fichier <random> commence par un commentaire. Celui-ci (Attention, c'est long):

/*
random synopsis

#include <initializer_list>

namespace std
{

// Engines

template <class UIntType, UIntType a, UIntType c, UIntType m>
class linear_congruential_engine
{
public:
// types
typedef UIntType result_type;

// 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);
};

template <class UIntType, UIntType a, UIntType c, UIntType m>
bool
operator==(const linear_congruential_engine<UIntType, a, c, m>& x,
const linear_congruential_engine<UIntType, a, c, m>& y);

template <class UIntType, UIntType a, UIntType c, UIntType m>
bool
operator!=(const linear_congruential_engine<UIntType, a, c, m>& x,
const linear_congruential_engine<UIntType, a, c, m>& y);

template <class charT, class traits,
class UIntType, UIntType a, UIntType c, UIntType m>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const linear_congruential_engine<UIntType, a, c, m>& x);

template <class charT, class traits,
class UIntType, UIntType a, UIntType c, UIntType m>
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
linear_congruential_engine<UIntType, a, c, m>& x);

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
typedef UIntType result_type;

// 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 result_type xor_mask = a;
static constexpr size_t tempering_u = u;
static constexpr result_type tempering_d = d;
static constexpr size_t tempering_s = s;
static constexpr result_type tempering_b = b;
static constexpr size_t tempering_t = t;
static constexpr result_type tempering_c = c;
static constexpr size_t tempering_l = l;
static constexpr result_type 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);
};

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>
bool
operator==(
const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x,
const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& y);

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>
bool
operator!=(
const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x,
const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& y);

template <class charT, class traits,
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>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x);

template <class charT, class traits,
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>
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x);

template<class UIntType, size_t w, size_t s, size_t r>
class subtract_with_carry_engine
{
public:
// types
typedef UIntType result_type;

// 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);
};

template<class UIntType, size_t w, size_t s, size_t r>
bool
operator==(
const subtract_with_carry_engine<UIntType, w, s, r>& x,
const subtract_with_carry_engine<UIntType, w, s, r>& y);

template<class UIntType, size_t w, size_t s, size_t r>
bool
operator!=(
const subtract_with_carry_engine<UIntType, w, s, r>& x,
const subtract_with_carry_engine<UIntType, w, s, r>& y);

template <class charT, class traits,
class UIntType, size_t w, size_t s, size_t r>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const subtract_with_carry_engine<UIntType, w, s, r>& x);

template <class charT, class traits,
class UIntType, size_t w, size_t s, size_t r>
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
subtract_with_carry_engine<UIntType, w, s, r>& x);

template<class Engine, size_t p, size_t r>
class discard_block_engine
{
public:
// types
typedef typename Engine::result_type 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;
};

template<class Engine, size_t p, size_t r>
bool
operator==(
const discard_block_engine<Engine, p, r>& x,
const discard_block_engine<Engine, p, r>& y);

template<class Engine, size_t p, size_t r>
bool
operator!=(
const discard_block_engine<Engine, p, r>& x,
const discard_block_engine<Engine, p, r>& y);

template <class charT, class traits,
class Engine, size_t p, size_t r>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const discard_block_engine<Engine, p, r>& x);

template <class charT, class traits,
class Engine, size_t p, size_t r>
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
discard_block_engine<Engine, p, r>& x);

template<class Engine, size_t w, class UIntType>
class independent_bits_engine
{
public:
// types
typedef UIntType result_type;

// 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;
};

template<class Engine, size_t w, class UIntType>
bool
operator==(
const independent_bits_engine<Engine, w, UIntType>& x,
const independent_bits_engine<Engine, w, UIntType>& y);

template<class Engine, size_t w, class UIntType>
bool
operator!=(
const independent_bits_engine<Engine, w, UIntType>& x,
const independent_bits_engine<Engine, w, UIntType>& y);

template <class charT, class traits,
class Engine, size_t w, class UIntType>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const independent_bits_engine<Engine, w, UIntType>& x);

template <class charT, class traits,
class Engine, size_t w, class UIntType>
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
independent_bits_engine<Engine, w, UIntType>& x);

template<class Engine, size_t k>
class shuffle_order_engine
{
public:
// types
typedef typename Engine::result_type 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;
};

template<class Engine, size_t k>
bool
operator==(
const shuffle_order_engine<Engine, k>& x,
const shuffle_order_engine<Engine, k>& y);

template<class Engine, size_t k>
bool
operator!=(
const shuffle_order_engine<Engine, k>& x,
const shuffle_order_engine<Engine, k>& y);

template <class charT, class traits,
class Engine, size_t k>
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const shuffle_order_engine<Engine, k>& x);

template <class charT, class traits,
class Engine, size_t k>
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
shuffle_order_engine<Engine, k>& x);

typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>
minstd_rand0;
typedef linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>
minstd_rand;
typedef mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31,
0x9908b0df,
11, 0xffffffff,
7, 0x9d2c5680,
15, 0xefc60000,
18, 1812433253> mt19937;
typedef mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,
0xb5026f5aa96619e9,
29, 0x5555555555555555,
17, 0x71d67fffeda60000,
37, 0xfff7eee000000000,
43, 6364136223846793005> mt19937_64;
typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24> ranlux24_base;
typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12> ranlux48_base;
typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
typedef minstd_rand default_random_engine;

// Generators

class random_device
{
public:
// types
typedef unsigned int result_type;

// 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 = "/dev/urandom");

// 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;
};

// Utilities

class seed_seq
{
public:
// types
typedef uint_least32_t result_type;

// 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;
template<class OutputIterator>
void param(OutputIterator dest) const;

// no copy functions
seed_seq(const seed_seq&) = delete;
void operator=(const seed_seq& ) = delete;
};

template<class RealType, size_t bits, class URNG>
RealType generate_canonical(URNG& g);

// Distributions

template<class IntType = int>
class uniform_int_distribution
{
public:
// types
typedef IntType result_type;

class param_type
{
public:
typedef uniform_int_distribution distribution_type;

explicit param_type(IntType a = 0,
IntType b = numeric_limits<IntType>::max());

result_type a() const;
result_type b() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// 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 URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& 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;

friend bool operator==(const uniform_int_distribution& x,
const uniform_int_distribution& y);
friend bool operator!=(const uniform_int_distribution& x,
const uniform_int_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const uniform_int_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
uniform_int_distribution& x);
};

template<class RealType = double>
class uniform_real_distribution
{
public:
// types
typedef RealType result_type;

class param_type
{
public:
typedef uniform_real_distribution distribution_type;

explicit param_type(RealType a = 0,
RealType b = 1);

result_type a() const;
result_type b() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// 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 URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& 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;

friend bool operator==(const uniform_real_distribution& x,
const uniform_real_distribution& y);
friend bool operator!=(const uniform_real_distribution& x,
const uniform_real_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const uniform_real_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
uniform_real_distribution& x);
};

class bernoulli_distribution
{
public:
// types
typedef bool result_type;

class param_type
{
public:
typedef bernoulli_distribution distribution_type;

explicit param_type(double p = 0.5);

double p() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// constructors and reset functions
explicit bernoulli_distribution(double p = 0.5);
explicit bernoulli_distribution(const param_type& parm);
void reset();

// generating functions
template<class URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& 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;

friend bool operator==(const bernoulli_distribution& x,
const bernoulli_distribution& y);
friend bool operator!=(const bernoulli_distribution& x,
const bernoulli_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const bernoulli_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
bernoulli_distribution& x);
};

template<class IntType = int>
class binomial_distribution
{
public:
// types
typedef IntType result_type;

class param_type
{
public:
typedef binomial_distribution distribution_type;

explicit param_type(IntType t = 1, double p = 0.5);

IntType t() const;
double p() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// 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 URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& 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;

friend bool operator==(const binomial_distribution& x,
const binomial_distribution& y);
friend bool operator!=(const binomial_distribution& x,
const binomial_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const binomial_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
binomial_distribution& x);
};

template<class IntType = int>
class geometric_distribution
{
public:
// types
typedef IntType result_type;

class param_type
{
public:
typedef geometric_distribution distribution_type;

explicit param_type(double p = 0.5);

double p() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// constructors and reset functions
explicit geometric_distribution(double p = 0.5);
explicit geometric_distribution(const param_type& parm);
void reset();

// generating functions
template<class URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& 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;

friend bool operator==(const geometric_distribution& x,
const geometric_distribution& y);
friend bool operator!=(const geometric_distribution& x,
const geometric_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const geometric_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
geometric_distribution& x);
};

template<class IntType = int>
class negative_binomial_distribution
{
public:
// types
typedef IntType result_type;

class param_type
{
public:
typedef negative_binomial_distribution distribution_type;

explicit param_type(result_type k = 1, double p = 0.5);

result_type k() const;
double p() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// constructor and reset functions
explicit negative_binomial_distribution(result_type k = 1, double p = 0.5);
explicit negative_binomial_distribution(const param_type& parm);
void reset();

// generating functions
template<class URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& g, const param_type& parm);

// property functions
result_type k() const;
double p() const;

param_type param() const;
void param(const param_type& parm);

result_type min() const;
result_type max() const;

friend bool operator==(const negative_binomial_distribution& x,
const negative_binomial_distribution& y);
friend bool operator!=(const negative_binomial_distribution& x,
const negative_binomial_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const negative_binomial_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
negative_binomial_distribution& x);
};

template<class IntType = int>
class poisson_distribution
{
public:
// types
typedef IntType result_type;

class param_type
{
public:
typedef poisson_distribution distribution_type;

explicit param_type(double mean = 1.0);

double mean() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// constructors and reset functions
explicit poisson_distribution(double mean = 1.0);
explicit poisson_distribution(const param_type& parm);
void reset();

// generating functions
template<class URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& 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;

friend bool operator==(const poisson_distribution& x,
const poisson_distribution& y);
friend bool operator!=(const poisson_distribution& x,
const poisson_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const poisson_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
poisson_distribution& x);
};

template<class RealType = double>
class exponential_distribution
{
public:
// types
typedef RealType result_type;

class param_type
{
public:
typedef exponential_distribution distribution_type;

explicit param_type(result_type lambda = 1.0);

result_type lambda() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// constructors and reset functions
explicit exponential_distribution(result_type lambda = 1.0);
explicit exponential_distribution(const param_type& parm);
void reset();

// generating functions
template<class URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& g, const param_type& parm);

// property functions
result_type lambda() const;

param_type param() const;
void param(const param_type& parm);

result_type min() const;
result_type max() const;

friend bool operator==(const exponential_distribution& x,
const exponential_distribution& y);
friend bool operator!=(const exponential_distribution& x,
const exponential_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const exponential_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
exponential_distribution& x);
};

template<class RealType = double>
class gamma_distribution
{
public:
// types
typedef RealType result_type;

class param_type
{
public:
typedef gamma_distribution distribution_type;

explicit param_type(result_type alpha = 1, result_type beta = 1);

result_type alpha() const;
result_type beta() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// constructors and reset functions
explicit gamma_distribution(result_type alpha = 1, result_type beta = 1);
explicit gamma_distribution(const param_type& parm);
void reset();

// generating functions
template<class URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& g, const param_type& parm);

// property functions
result_type alpha() const;
result_type beta() const;

param_type param() const;
void param(const param_type& parm);

result_type min() const;
result_type max() const;

friend bool operator==(const gamma_distribution& x,
const gamma_distribution& y);
friend bool operator!=(const gamma_distribution& x,
const gamma_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const gamma_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
gamma_distribution& x);
};

template<class RealType = double>
class weibull_distribution
{
public:
// types
typedef RealType result_type;

class param_type
{
public:
typedef weibull_distribution distribution_type;

explicit param_type(result_type alpha = 1, result_type beta = 1);

result_type a() const;
result_type b() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// constructor and reset functions
explicit weibull_distribution(result_type a = 1, result_type b = 1);
explicit weibull_distribution(const param_type& parm);
void reset();

// generating functions
template<class URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& 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;

friend bool operator==(const weibull_distribution& x,
const weibull_distribution& y);
friend bool operator!=(const weibull_distribution& x,
const weibull_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const weibull_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
weibull_distribution& x);
};

template<class RealType = double>
class extreme_value_distribution
{
public:
// types
typedef RealType result_type;

class param_type
{
public:
typedef extreme_value_distribution distribution_type;

explicit param_type(result_type a = 0, result_type b = 1);

result_type a() const;
result_type b() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// constructor and reset functions
explicit extreme_value_distribution(result_type a = 0, result_type b = 1);
explicit extreme_value_distribution(const param_type& parm);
void reset();

// generating functions
template<class URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& 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;

friend bool operator==(const extreme_value_distribution& x,
const extreme_value_distribution& y);
friend bool operator!=(const extreme_value_distribution& x,
const extreme_value_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const extreme_value_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
extreme_value_distribution& x);
};

template<class RealType = double>
class normal_distribution
{
public:
// types
typedef RealType result_type;

class param_type
{
public:
typedef normal_distribution distribution_type;

explicit param_type(result_type mean = 0, result_type stddev = 1);

result_type mean() const;
result_type stddev() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// constructors and reset functions
explicit normal_distribution(result_type mean = 0, result_type stddev = 1);
explicit normal_distribution(const param_type& parm);
void reset();

// generating functions
template<class URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& g, const param_type& parm);

// property functions
result_type mean() const;
result_type stddev() const;

param_type param() const;
void param(const param_type& parm);

result_type min() const;
result_type max() const;

friend bool operator==(const normal_distribution& x,
const normal_distribution& y);
friend bool operator!=(const normal_distribution& x,
const normal_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const normal_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
normal_distribution& x);
};

template<class RealType = double>
class lognormal_distribution
{
public:
// types
typedef RealType result_type;

class param_type
{
public:
typedef lognormal_distribution distribution_type;

explicit param_type(result_type m = 0, result_type s = 1);

result_type m() const;
result_type s() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// constructor and reset functions
explicit lognormal_distribution(result_type m = 0, result_type s = 1);
explicit lognormal_distribution(const param_type& parm);
void reset();

// generating functions
template<class URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& g, const param_type& parm);

// property functions
result_type m() const;
result_type s() const;

param_type param() const;
void param(const param_type& parm);

result_type min() const;
result_type max() const;

friend bool operator==(const lognormal_distribution& x,
const lognormal_distribution& y);
friend bool operator!=(const lognormal_distribution& x,
const lognormal_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const lognormal_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
lognormal_distribution& x);
};

template<class RealType = double>
class chi_squared_distribution
{
public:
// types
typedef RealType result_type;

class param_type
{
public:
typedef chi_squared_distribution distribution_type;

explicit param_type(result_type n = 1);

result_type n() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// constructor and reset functions
explicit chi_squared_distribution(result_type n = 1);
explicit chi_squared_distribution(const param_type& parm);
void reset();

// generating functions
template<class URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& g, const param_type& parm);

// property functions
result_type n() const;

param_type param() const;
void param(const param_type& parm);

result_type min() const;
result_type max() const;

friend bool operator==(const chi_squared_distribution& x,
const chi_squared_distribution& y);
friend bool operator!=(const chi_squared_distribution& x,
const chi_squared_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const chi_squared_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
chi_squared_distribution& x);
};

template<class RealType = double>
class cauchy_distribution
{
public:
// types
typedef RealType result_type;

class param_type
{
public:
typedef cauchy_distribution distribution_type;

explicit param_type(result_type a = 0, result_type b = 1);

result_type a() const;
result_type b() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// constructor and reset functions
explicit cauchy_distribution(result_type a = 0, result_type b = 1);
explicit cauchy_distribution(const param_type& parm);
void reset();

// generating functions
template<class URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& 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;

friend bool operator==(const cauchy_distribution& x,
const cauchy_distribution& y);
friend bool operator!=(const cauchy_distribution& x,
const cauchy_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const cauchy_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
cauchy_distribution& x);
};

template<class RealType = double>
class fisher_f_distribution
{
public:
// types
typedef RealType result_type;

class param_type
{
public:
typedef fisher_f_distribution distribution_type;

explicit param_type(result_type m = 1, result_type n = 1);

result_type m() const;
result_type n() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// constructor and reset functions
explicit fisher_f_distribution(result_type m = 1, result_type n = 1);
explicit fisher_f_distribution(const param_type& parm);
void reset();

// generating functions
template<class URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& g, const param_type& parm);

// property functions
result_type m() const;
result_type n() const;

param_type param() const;
void param(const param_type& parm);

result_type min() const;
result_type max() const;

friend bool operator==(const fisher_f_distribution& x,
const fisher_f_distribution& y);
friend bool operator!=(const fisher_f_distribution& x,
const fisher_f_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const fisher_f_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
fisher_f_distribution& x);
};

template<class RealType = double>
class student_t_distribution
{
public:
// types
typedef RealType result_type;

class param_type
{
public:
typedef student_t_distribution distribution_type;

explicit param_type(result_type n = 1);

result_type n() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// constructor and reset functions
explicit student_t_distribution(result_type n = 1);
explicit student_t_distribution(const param_type& parm);
void reset();

// generating functions
template<class URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& g, const param_type& parm);

// property functions
result_type n() const;

param_type param() const;
void param(const param_type& parm);

result_type min() const;
result_type max() const;

friend bool operator==(const student_t_distribution& x,
const student_t_distribution& y);
friend bool operator!=(const student_t_distribution& x,
const student_t_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const student_t_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
student_t_distribution& x);
};

template<class IntType = int>
class discrete_distribution
{
public:
// types
typedef IntType result_type;

class param_type
{
public:
typedef discrete_distribution distribution_type;

param_type();
template<class InputIterator>
param_type(InputIterator firstW, InputIterator lastW);
param_type(initializer_list<double> wl);
template<class UnaryOperation>
param_type(size_t nw, double xmin, double xmax, UnaryOperation fw);

vector<double> probabilities() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// 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 URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& 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;

friend bool operator==(const discrete_distribution& x,
const discrete_distribution& y);
friend bool operator!=(const discrete_distribution& x,
const discrete_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const discrete_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
discrete_distribution& x);
};

template<class RealType = double>
class piecewise_constant_distribution
{
// types
typedef RealType result_type;

class param_type
{
public:
typedef piecewise_constant_distribution distribution_type;

param_type();
template<class InputIteratorB, class InputIteratorW>
param_type(InputIteratorB firstB, InputIteratorB lastB,
InputIteratorW firstW);
template<class UnaryOperation>
param_type(initializer_list<result_type> bl, UnaryOperation fw);
template<class UnaryOperation>
param_type(size_t nw, result_type xmin, result_type xmax,
UnaryOperation fw);

vector<result_type> intervals() const;
vector<result_type> densities() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// 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<result_type> bl,
UnaryOperation fw);
template<class UnaryOperation>
piecewise_constant_distribution(size_t nw, result_type xmin,
result_type xmax, UnaryOperation fw);
explicit piecewise_constant_distribution(const param_type& parm);
void reset();

// generating functions
template<class URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& 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;

friend bool operator==(const piecewise_constant_distribution& x,
const piecewise_constant_distribution& y);
friend bool operator!=(const piecewise_constant_distribution& x,
const piecewise_constant_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const piecewise_constant_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
piecewise_constant_distribution& x);
};

template<class RealType = double>
class piecewise_linear_distribution
{
// types
typedef RealType result_type;

class param_type
{
public:
typedef piecewise_linear_distribution distribution_type;

param_type();
template<class InputIteratorB, class InputIteratorW>
param_type(InputIteratorB firstB, InputIteratorB lastB,
InputIteratorW firstW);
template<class UnaryOperation>
param_type(initializer_list<result_type> bl, UnaryOperation fw);
template<class UnaryOperation>
param_type(size_t nw, result_type xmin, result_type xmax,
UnaryOperation fw);

vector<result_type> intervals() const;
vector<result_type> densities() const;

friend bool operator==(const param_type& x, const param_type& y);
friend bool operator!=(const param_type& x, const param_type& y);
};

// 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<result_type> bl,
UnaryOperation fw);

template<class UnaryOperation>
piecewise_linear_distribution(size_t nw, result_type xmin,
result_type xmax, UnaryOperation fw);

explicit piecewise_linear_distribution(const param_type& parm);
void reset();

// generating functions
template<class URNG> result_type operator()(URNG& g);
template<class URNG> result_type operator()(URNG& 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;

friend bool operator==(const piecewise_linear_distribution& x,
const piecewise_linear_distribution& y);
friend bool operator!=(const piecewise_linear_distribution& x,
const piecewise_linear_distribution& y);

template <class charT, class traits>
friend
basic_ostream<charT, traits>&
operator<<(basic_ostream<charT, traits>& os,
const piecewise_linear_distribution& x);

template <class charT, class traits>
friend
basic_istream<charT, traits>&
operator>>(basic_istream<charT, traits>& is,
piecewise_linear_distribution& x);
};

} // std
*/

Au-dela du fait que je comprends pas ce que cette implementation fait commentee, je reve ou une majorite des methodes sont declarees en constexpr ? Ne puis-je pas utiliser ce code ?

Sinon, j'ai trouver ca: https://github.com/effolkronium/random
Je vois pas pourquoi trois implementations, mais ne puis-je pas utiliser la premiere, (random static), pour parvenir a mes fin ?

> Je suis desole, mais la tu me parles chinois... ou au minimum vietnamien. Meme si je copie les operateurs, ca veut dire que je doit reecrire tout le reste du code a la main non ?

Tout se trouve les fonctions operator(), le reste du code ne te sert pas.

> J'ai bien compris que je peut pas faire un copier-coller de la STL

Si, 90% de copier/coller, 10% de glus pour déplacer les variables membres en paramètre template.

> mais dans le lien que tu m'a donne, le fichier <random> commence par un commentaire. Celui-ci (Attention, c'est long): [...]

C'est l'interface publique qu'on retrouve sur cppreference.com, il n'y aucune implémentation dans le commentaire.

> je reve ou une majorite des methodes sont declarees en constexpr ?

Oui, tu rêves. Seulement min()/max() sont constexpr, les autres sont des variables membres statiques initialisées avec les paramètres de template.

> Je vois pas pourquoi trois implementations, mais ne puis-je pas utiliser la premiere, (random static), pour parvenir a mes fin ?

Il utilise les objets random de la STL qui ne fonctionnent pas dans un contexte compile-time, donc non.</random>