Non-Uniform Random Variate Generator

This is a non-uniform random variate generator, a single-file header-only library written in C++.

Start
Usage
Examples
License

A Quick Start

Quick start source code(1):

    //test.cc
	#include <vg.hpp> // just copy this file  from include/vg.hpp
	#include <cmath>
	#include <map>
	#include <iostream>

	using namespace std;

	int main()
	{
    	// a gaussian variate generator with parameter 0(the mean) and 4(the variance)
    	vg::variate_generator<double, vg::gaussian, vg::mt19937> v(0, 4);

    	map<int, int> sample;

    	for ( unsigned long int i = 0; i != 500; ++i )
        	sample[static_cast<int>(round(v()))]++;

    	for ( auto i = sample.begin(); i != sample.end(); ++i )
    	{
        	cout << "\n" << (*i).first << "\t";
        	for ( auto j = 0; j < (*i).second; ++j ) cout << "*";
    	}
    	std::cout << "\n";

    	return 0;
	}

command to compile:

    $g++ -o ./gaussian_test ./test.cc -std=c++14 -O2 -Iinclude(PATH)

Output:

    -16 *
    -13 ***
    -12 ***
    -11 ***
    -10 *
    -9  ********
    -8  *********
    -7  **************
    -6  ************
    -5  ******************
    -4  **************************
    -3  *********************************
    -2  ******************************************
    -1  ****************************************************
    0   **************************************************
    1   **************************************************
    2   **********************************************
    3   ******************************
    4   ************************
    5   *******************
    6   ****************
    7   **************
    8   ******
    9   ****
    10  **
    11  ******
    12  *****
    14  *
    15  *
    16  *

Quick start source code(2):

    //make_passwd.cc
    #include <vg.hpp>
	#include <iostream>
	#include <vector>
	#include <iterator>
	#include <algorithm>

	int main()
	{
    	char chars[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
    	//char chars[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890`~!@#$%^&*()_+\\|[]{}'\";:/?>.<,";
    	vg::variate_generator<unsigned long> v{ 0UL, sizeof(chars)/sizeof(char) };
    	unsigned long const password_length = std::max( v(), 10UL );
    	std::vector<char> password( password_length );
    	std::generate( password.begin(), password.end(), [&](){ return chars[v()]; } );
    	std::copy( password.begin(), password.end(), std::ostream_iterator<char>( std::cout, "" ) );
    	std::cout << "\n";

    	return 0;
	}

compile:

    g++ -o make_passwd make_passwd.cc -std=c++14 -O2 -I(PATH)

Output:

5Tq5kxmmnULP3qh1qa5pT9bOYzJ

Basic usage

First create a generator

vg::variate_generator<double, vg::exponential, vg::mt19937> gen{ 1.0 };

in which

double is the data type we want to generate,
vg::exponentional is the random distribution,
vg::mt19937 is the random number engine, and
1.0 is the parameter possed to the random distribution vg::exponential.

we use gen as a generator/functor

for ( int i = 0; i < 10; ++i )
    std::cout << gen();

Examples

arcsin distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::arcsin, vg::mt19937> gen{  };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

balding_nichols distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::balding_nichols, vg::mt19937> gen{ 0.5, 0.5 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

bernoulli distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::bernoulli, vg::mt19937> gen{ 0.5 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

beta distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::beta, vg::mt19937> gen{ 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

beta_binomial distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::beta_binomial, vg::mt19937> gen{ 10.0, 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

beta_pascal distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::beta_pascal, vg::mt19937> gen{ 3.0, 3.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

beta_pascal distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::beta_pascal, vg::mt19937> gen{ 3.0, 3.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

binomial distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<unsigned long, vg::binomial, vg::mt19937> gen{ 1, 0.5 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

burr distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::burr, vg::mt19937> gen{ 1, 1.0, 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

cauchy distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::cauchy, vg::mt19937> gen{ 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

chi_square distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::chi_square, vg::mt19937> gen{ 10 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

digamma distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::digamma, vg::mt19937> gen{ 3, 3 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

erlang distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::erlang, vg::mt19937> gen{ 1.0, 10.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

exponential distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::exponential, vg::mt19937> gen{ 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

exponential_power distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::exponential_power, vg::mt19937> gen{ 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

extreme_value distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::extreme_value, vg::mt19937> gen{ 0.0, 1.0, 0.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

f distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::f, vg::mt19937> gen{ 2.0, 2.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

factorial distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::factorial, vg::mt19937> gen{ 3.0, 3.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

gamma distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::gamma, vg::mt19937> gen{ 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

gaussian distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::gaussian, vg::mt19937> gen{ 0.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

gaussian_tail distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::gaussian_tail, vg::mt19937> gen{ 0.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

generalized_hypergeometric_b3 distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::generalized_hypergeometric_b3, vg::mt19937> gen{ 1.0, 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

generalized_waring distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::generalized_waring, vg::mt19937> gen{ 1.0, 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

geometric distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::geometric, vg::mt19937> gen{ 0.5 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

grassia distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::grassia, vg::mt19937> gen{ 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

gumbel_1 distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::gumbel_1, vg::mt19937> gen{ 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

gumbel_2 distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::gumbel_2, vg::mt19937> gen{ 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

hyperbolic_secant distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::hyperbolic_secant, vg::mt19937> gen{  };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

hypergeometric distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<unsigned long, vg::hypergeometric, vg::mt19937> gen{ 1, 0, 1 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

inverse_gaussian distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::inverse_gaussian, vg::mt19937> gen{ 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

inverse_polya_eggenberger distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::inverse_polya_eggenberger, vg::mt19937> gen{ 1.0, 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

lambda distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::lambda, vg::mt19937> gen{ 1.0, 1.0, 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

laplace distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::laplace, vg::mt19937> gen{ 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

levy distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::levy, vg::mt19937> gen{ 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

logarithmic distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::logarithmic, vg::mt19937> gen{ 0.5 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

logistic distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::logistic, vg::mt19937> gen{ 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

lognormal distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::lognormal, vg::mt19937> gen{ 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

mizutani distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::mizutani, vg::mt19937> gen{ 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

negative_binomial distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::negative_binomial, vg::mt19937> gen{ 1, 0.5 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

negative_binomial_beta distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::negative_binomial_beta, vg::mt19937> gen{ 1.0, 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

normal distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::normal, vg::mt19937> gen{  };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

pareto distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::pareto, vg::mt19937> gen{ 1.0, 2.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

pascal distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::pascal, vg::mt19937> gen{ 1.0, 0.5 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

pearson distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::pearson, vg::mt19937> gen{ 1.0, 1.0, 1.0, 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

planck distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::planck, vg::mt19937> gen{ 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

poisson distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::poisson, vg::mt19937> gen{ 10.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

polya distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::polya, vg::mt19937> gen{ 1.0, 0.5 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

polya_aeppli distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::polya_aeppli, vg::mt19937> gen{ 1.0, 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

rademacher distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::rademacher, vg::mt19937> gen{  };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

rayleigh distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::rayleigh, vg::mt19937> gen{ 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

rayleigh_tail distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::rayleigh_tail, vg::mt19937> gen{ 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

singh_maddala distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::singh_maddala, vg::mt19937> gen{ 1.0, 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

t distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::t, vg::mt19937> gen{ 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

teichroew distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::teichroew, vg::mt19937> gen{ 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

triangular distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::triangular, vg::mt19937> gen{ 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

trigamma distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::trigamma, vg::mt19937> gen{ 3.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

uniform distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::uniform, vg::mt19937> gen{ 0.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

von_mises distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::von_mises, vg::mt19937> gen{ 0.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

wald distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::wald, vg::mt19937> gen{ 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

waring distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::waring, vg::mt19937> gen{ 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

weibull distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::weibull, vg::mt19937> gen{ 1.0, 1.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

yule distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::yule, vg::mt19937> gen{ 2.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

zipf distribution

#include <vg.hpp>
#include <vector>
#include <iostream>

int main()
{
    unsigned long const n = 1000000;
    std::vector<double> x(n);
    vg::variate_generator<double, vg::zipf, vg::mt19937> gen{ 2.0 };
    for ( unsigned long idx = 0; idx < n; ++idx ) x[idx] = gen();

    std::cout << "Testing arcsin distribution: with " << n << " examples.\n" ;
    std::cout << "Mean:	" << vg::mean( x.begin(), x.end() ) << "\n";
    std::cout << "Variance:	" << vg::variance( x.begin(), x.end() ) << "\n";
    std::cout << "Skewness:	" << vg::skewness( x.begin(), x.end() ) << "\n";

    return 0;
}

License

LGPL

Name		Name	Last commit message	Last commit date
Latest commit History 190 Commits
doc		doc
example		example
include		include
misc		misc
test		test
.gitignore		.gitignore
Makefile		Makefile
ReadMe.md		ReadMe.md
TODO		TODO
distributions.todo.txt		distributions.todo.txt
gpl.txt		gpl.txt
lgpl.txt		lgpl.txt

fengwang/random_variate_generator

Folders and files

Latest commit

History

Repository files navigation

Non-Uniform Random Variate Generator

A Quick Start

Basic usage

Examples

arcsin distribution

balding_nichols distribution

bernoulli distribution

beta distribution

beta_binomial distribution

beta_pascal distribution

beta_pascal distribution

binomial distribution

burr distribution

cauchy distribution

chi_square distribution

digamma distribution

erlang distribution

exponential distribution

exponential_power distribution

extreme_value distribution

f distribution

factorial distribution

gamma distribution

gaussian distribution

gaussian_tail distribution

generalized_hypergeometric_b3 distribution

generalized_waring distribution

geometric distribution

grassia distribution

gumbel_1 distribution

gumbel_2 distribution

hyperbolic_secant distribution

hypergeometric distribution

inverse_gaussian distribution

inverse_polya_eggenberger distribution

lambda distribution

laplace distribution

levy distribution

logarithmic distribution

logistic distribution

lognormal distribution

mizutani distribution

negative_binomial distribution

negative_binomial_beta distribution

normal distribution

pareto distribution

pascal distribution

pearson distribution

planck distribution

poisson distribution

polya distribution

polya_aeppli distribution

rademacher distribution

rayleigh distribution

rayleigh_tail distribution

singh_maddala distribution

t distribution

teichroew distribution

triangular distribution

trigamma distribution

uniform distribution

von_mises distribution

wald distribution

waring distribution

weibull distribution

yule distribution

zipf distribution

License

About

Resources

Stars

Watchers

Forks

Languages