RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://cplusplus.com/reference/random/student_t_distribution/ below:

class template

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 type definition notes result_type The first template parameter (RealType) The type of the numbers generated (defaults to double) param_type not specified The 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

// 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: *