piecewise_linear_distribution, classe
Génère une distribution linéaire par morceaux qui présente des intervalles de largeur variable avec une probabilité variable linéairement dans chaque intervalle.
Syntaxe
template<class RealType = double>
class piecewise_linear_distribution
{
public:
// types
typedef RealType result_type;
struct param_type;
// constructor and reset functions
piecewise_linear_distribution();
template <class InputIteratorI, class InputIteratorW>
piecewise_linear_distribution(
InputIteratorI firstI, InputIteratorI lastI, InputIteratorW firstW);
template <class UnaryOperation>
piecewise_linear_distribution(
initializer_list<result_type> intervals, UnaryOperation weightfunc);
template <class UnaryOperation>
piecewise_linear_distribution(
size_t count, result_type xmin, result_type xmax, UnaryOperation weightfunc);
explicit piecewise_linear_distribution(const param_type& parm);
void reset();
// generating functions
template <class URNG>
result_type operator()(URNG& gen);
template <class URNG>
result_type operator()(URNG& gen, 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;
};
Paramètres
RealType
Le type des résultats à virgule flottante est double par défaut. Pour les types possibles, consultez <aléatoire>.
Notes
Cette distribution d'échantillonnage présente des intervalles de largeur variable avec une probabilité variable linéairement dans chaque intervalle. Pour plus d’informations sur les autres distributions d’échantillonnage, consultez piecewise_linear_distribution et discrete_distribution.
Le tableau suivant contient des liens vers des articles sur différents membres :
piecewise_linear_distribution
param_type
La fonction de propriété intervals() retourne un vector<result_type> avec l'ensemble d'intervalles stockés de la distribution.
La fonction de propriété densities() retourne un vector<result_type> avec les densités stockées pour chaque ensemble d'intervalles, qui sont calculées en fonction des poids fournis dans les paramètres du constructeur.
Le membre de propriété param() définit ou retourne le package de paramètres de distribution stocké param_type.
Les fonctions membres min() et max() retournent respectivement le plus petit et le plus grand résultat possible.
La fonction membre reset() ignore toutes les valeurs mises en cache. Ainsi, le résultat de l’appel suivant à operator() ne dépend d’aucune valeur obtenue à partir du moteur avant l’appel.
Les fonctions membres operator() retournent la valeur générée suivante d’après le moteur URNG, à partir du package de paramètres actuel ou spécifié.
Pour plus d’informations sur les classes de distribution et leurs membres, consultez <aléatoire>.
Exemple
// compile with: /EHsc /W4
#include <random>
#include <iostream>
#include <iomanip>
#include <string>
#include <map>
using namespace std;
void test(const int s) {
// uncomment to use a non-deterministic generator
// random_device rd;
// mt19937 gen(rd());
mt19937 gen(1701);
// Three intervals, non-uniform: 0 to 1, 1 to 6, and 6 to 15
vector<double> intervals{ 0, 1, 6, 15 };
// weights determine the densities used by the distribution
vector<double> weights{ 1, 5, 5, 10 };
piecewise_linear_distribution<double> distr(intervals.begin(), intervals.end(), weights.begin());
cout << endl;
cout << "min() == " << distr.min() << endl;
cout << "max() == " << distr.max() << endl;
cout << "intervals (index: interval):" << endl;
vector<double> i = distr.intervals();
int counter = 0;
for (const auto& n : i) {
cout << fixed << setw(11) << counter << ": " << setw(14) << setprecision(10) << n << endl;
++counter;
}
cout << endl;
cout << "densities (index: density):" << endl;
vector<double> d = distr.densities();
counter = 0;
for (const auto& n : d) {
cout << fixed << setw(11) << counter << ": " << setw(14) << setprecision(10) << n << endl;
++counter;
}
cout << endl;
// generate the distribution as a histogram
map<int, int> histogram;
for (int i = 0; i < s; ++i) {
++histogram[distr(gen)];
}
// print results
cout << "Distribution for " << s << " samples:" << endl;
for (const auto& elem : histogram) {
cout << setw(5) << elem.first << '-' << elem.first + 1 << ' ' << string(elem.second, ':') << endl;
}
cout << endl;
}
int main()
{
int samples = 100;
cout << "Use CTRL-Z to bypass data entry and run using default values." << endl;
cout << "Enter an integer value for the sample count: ";
cin >> samples;
test(samples);
}
Use CTRL-Z to bypass data entry and run using default values.
Enter an integer value for the sample count: 100
min() == 0
max() == 15
intervals (index: interval):
0: 0.0000000000
1: 1.0000000000
2: 6.0000000000
3: 15.0000000000
densities (index: density):
0: 0.0645161290
1: 0.3225806452
2: 0.3225806452
3: 0.6451612903
Distribution for 100 samples:
0-1 :::::::::::::::::::::
1-2 ::::::
2-3 :::
3-4 :::::::
4-5 ::::::
5-6 ::::::
6-7 :::::
7-8 ::::::::::
8-9 ::::::::::
9-10 ::::::
10-11 ::::
11-12 :::
12-13 :::
13-14 :::::
14-15 :::::
Spécifications
Header :<random>
Espace de noms : std
piecewise_linear_distribution::piecewise_linear_distribution
Construit la distribution.
// default constructor
piecewise_linear_distribution();
// constructs using a range of intervals, [firstI, lastI), with
// matching weights starting at firstW
template <class InputIteratorI, class InputIteratorW>
piecewise_linear_distribution(InputIteratorI firstI, InputIteratorI lastI, InputIteratorW firstW);
// constructs using an initializer list for range of intervals,
// with weights generated by function weightfunc
template <class UnaryOperation>
piecewise_linear_distribution(initializer_list<RealType>
intervals, UnaryOperation weightfunc);
// constructs using an initializer list for range of count intervals,
// distributed uniformly over [xmin,xmax] with weights generated by function weightfunc
template <class UnaryOperation>
piecewise_linear_distribution(size_t count, RealType xmin, RealType xmax, UnaryOperation weightfunc);
// constructs from an existing param_type structure
explicit piecewise_linear_distribution(const param_type& parm);
Paramètres
firstI
Itérateur d'entrée du premier élément de la plage de distribution.
lastI
Itérateur d'entrée du dernier élément de la plage de distribution.
firstW
Itérateur d'entrée du premier élément de la plage de poids.
intervals
Un initializer_list avec les intervalles de la distribution.
count
Nombre d'éléments dans la plage de distribution.
xmin
Valeur la plus faible de la plage de distribution.
xmax
Valeur la plus élevée de la plage de distribution. Doit être supérieure à xmin.
weightfunc
Objet représentant la fonction de probabilité pour la distribution. Le paramètre et la valeur de retour doivent tous deux être convertibles en double.
parm
Structure de paramètre utilisée pour construire la distribution.
Notes
Le constructeur par défaut définit les paramètres stockés pour qu'il y ait un intervalle, de 0 à 1, avec une densité de probabilité de 1.
Le constructeur de plage d'itérateurs
template <class InputIteratorI, class InputIteratorW>
piecewise_linear_distribution(
InputIteratorI firstI,
InputIteratorI lastI,
InputIteratorW firstW);
construit un objet de distribution avec itnervals à partir d’itérateurs sur la séquence [ firstI, lastI) et une séquence de poids correspondante commençant au premierW.
Le constructeur de listes d'initialiseurs
template <class UnaryOperation>
piecewise_linear_distribution(
initializer_list<result_type> intervals,
UnaryOperation weightfunc);
construit un objet de distribution avec des intervalles à partir des intervalles de liste d’initialiseurs et des pondérations générés à partir de l’épaisseur de fonction.
Le constructeur défini en tant que
template <class UnaryOperation>
piecewise_linear_distribution(
size_t count,
result_type xmin,
result_type xmax,
UnaryOperation weightfunc);
construit un objet de distribution avec des intervalles de nombre distribués uniformément sur [ xmin,xmax], assignant chaque pondération d’intervalle en fonction du poids de fonction, et weightfunc doit accepter un paramètre et avoir une valeur de retour, dont les deux sont convertibles en double. Condition préalable :xmin < xmax
Le constructeur défini en tant que
explicit piecewise_linear_distribution(const param_type& parm);
construit un objet de distribution à l’aide de l’analyseur comme structure de paramètres stockée.
piecewise_linear_distribution::param_type
Stocke tous les paramètres de la distribution.
struct param_type {
typedef piecewise_linear_distribution<result_type> distribution_type;
param_type();
template <class IterI, class IterW>
param_type(
IterI firstI, IterI lastI, IterW firstW);
template <class UnaryOperation>
param_type(
size_t count, result_type xmin, result_type xmax, UnaryOperation weightfunc);
std::vector<result_type> densities() const;
std::vector<result_type> intervals() const;
bool operator==(const param_type& right) const;
bool operator!=(const param_type& right) const;
};
Paramètres
Consultez les paramètres de constructeur pour piecewise_linear_distribution.
Notes
Condition préalable : xmin < xmax
Cette structure peut être passée au constructeur de classe de la distribution au moment de l'instanciation, à la fonction membre param() pour définir les paramètres stockés d'une distribution existante et à operator() pour une utilisation à la place des paramètres stockés.