class template
<random>

std::student_t_distribution

template <class RealType = double> class student_t_distribution;
Student T-Distribution
Random number distribution that produces floating-point values according to a Student T-distribution, which is described by the following probability density function:



This distribution produces random numbers as the result of normalizing the values of a relatively small sample (n+1 values) of independent normally-distributed values. As the sample size increases, the distribution approaches a standard normal distribution.

The distribution parameter, n, is set on construction.

To produce a random value following this distribution, call its member function operator().

Template parameters

RealType
A floating-point type. Aliased as member type result_type.
By default, this is double.

Member types

The following aliases are member types of normal_distribution:

member typedefinitionnotes
result_typeThe first template parameter (RealType)The type of the numbers generated (defaults to double)
param_typenot specifiedThe type returned by member param.

Member functions

(constructor)
Construct Student T-distribution (public member function)
operator()
Generate random number (public member function)
reset
Reset distribution (public member function)
param
Distribution parameters (public member function)
min
Minimum value (public member function )
max
Maximum value (public member function )

Distribution parameters:

student_t_distribution::n
Degrees of freedom (public member function)

Non-member functions

operator<<
Insert into output stream (function template )
operator>>
Extract from input stream (function template )
relational operators
Relational operators (function template )

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
// student_t_distribution
#include <iostream>
#include <random>

int main()
{
  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  // intervals definitions:
  const int nintervals=12;
  const double first=-3.0;
  const double span=0.5;

  std::default_random_engine generator;
  std::student_t_distribution<double> distribution(10.0);

  int p[nintervals]={};

  for (int i=0; i<nrolls; ++i) {
    double number = distribution(generator);
    if ((number>=first)&&(number<first+nintervals*span))
      ++p[int((number-first)/span)];
  }

  std::cout << "fisher_f_distribution (10.0):" << std::endl;
  std::cout << std::fixed; std::cout.precision(1);

  for (int i=0; i<nintervals; ++i) {
    std::cout.width(4); std::cout << (first+i*span) << "..";
    std::cout.width(4); std::cout << (first+(i+1)*span) << ": ";
    std::cout << std::string(p[i]*nstars/nrolls,'*') << std::endl;
  }

  return 0;
}


Possible output:

student_t_distribution (10.0):
-3.0..-2.5: 
-2.5..-2.0: **
-2.0..-1.5: ****
-1.5..-1.0: *********
-1.0..-0.5: ***************
-0.5.. 0.0: ********************
 0.0.. 0.5: *********************
 0.5.. 1.0: ***************
 1.0.. 1.5: *********
 1.5.. 2.0: ****
 2.0.. 2.5: **
 2.5.. 3.0: *

See also

normal_distribution
Normal distribution (class template )
lognormal_distribution
Lognormal distribution (class template )
chi_squared_distribution
Chi-squared distribution (class template )
cauchy_distribution
Cauchy distribution (class template )
fisher_f_distribution
Fisher F-distribution (class template )

C++