Provided by: libmath-gsl-perl_0.43-4build1_amd64 bug

NAME

       Math::GSL::Randist - Probability Distributions

SYNOPSIS

        use Math::GSL::RNG;
        use Math::GSL::Randist qw/:all/;

        my $rng = Math::GSL::RNG->new();
        my $coinflip = gsl_ran_bernoulli($rng->raw(), .5);

DESCRIPTION

       Here is a list of all the functions included in this module. For all sampling methods, the
       first argument $r is a raw gsl_rnd structure retrieve by calling raw() on an
       Math::GSL::RNG object.

   Bernoulli
       gsl_ran_bernoulli($r, $p)
           This function returns either 0 or 1, the result of a Bernoulli trial with probability
           $p. The probability distribution for a Bernoulli trial is, p(0) = 1 - $p and  p(1) =
           $p. $r is a gsl_rng structure.

       gsl_ran_bernoulli_pdf($k, $p)
           This function computes the probability p($k) of obtaining $k from a Bernoulli
           distribution with probability parameter $p, using the formula given above.

   Beta
       gsl_ran_beta($r, $a, $b)
           This function returns a random variate from the beta distribution. The distribution
           function is, p($x) dx = {Gamma($a+$b) \ Gamma($a) Gamma($b)} $x**{$a-1} (1-$x)**{$b-1}
           dx for 0 <= $x <= 1.$r is a gsl_rng structure.

       gsl_ran_beta_pdf($x, $a, $b)
           This function computes the probability density p($x) at $x for a beta distribution
           with parameters $a and $b, using the formula given above.

   Binomial
       gsl_ran_binomial($k, $p, $n)
           This function returns a random integer from the binomial distribution, the number of
           successes in n independent trials with probability $p. The probability distribution
           for binomial variates is p($k) = {$n! \ $k! ($n-$k)! } $p**$k (1-$p)^{$n-$k} for 0 <=
           $k <= $n.  Uses Binomial Triangle Parallelogram Exponential algorithm.

       gsl_ran_binomial_knuth($k, $p, $n)
           Alternative and original implementation for gsl_ran_binomial using Knuth's algorithm.

       gsl_ran_binomial_tpe($k, $p, $n)
           Same as gsl_ran_binomial.

       gsl_ran_binomial_pdf($k, $p, $n)
           This function computes the probability p($k) of obtaining $k from a binomial
           distribution with parameters $p and $n, using the formula given above.

   Exponential
       gsl_ran_exponential($r, $mu)
           This function returns a random variate from the exponential distribution with mean
           $mu. The distribution is, p($x) dx = {1 \ $mu} exp(-$x/$mu) dx for $x >= 0. $r is a
           gsl_rng structure.

       gsl_ran_exponential_pdf($x, $mu)
           This function computes the probability density p($x) at $x for an exponential
           distribution with mean $mu, using the formula given above.

   Exponential Power
       gsl_ran_exppow($r, $a, $b)
           This function returns a random variate from the exponential power distribution with
           scale parameter $a and exponent $b. The distribution is, p(x) dx = {1 / 2 $a
           Gamma(1+1/$b)} exp(-|$x/$a|**$b) dx for $x >= 0. For $b = 1 this reduces to the
           Laplace distribution. For $b = 2 it has the same form as a gaussian distribution, but
           with $a = sqrt(2) sigma. $r is a gsl_rng structure.

       gsl_ran_exppow_pdf($x, $a, $b)
           This function computes the probability density p($x) at $x for an exponential power
           distribution with scale parameter $a and exponent $b, using the formula given above.

   Cauchy
       gsl_ran_cauchy($r, $scale)
           This function returns a random variate from the Cauchy distribution with $scale. The
           probability distribution for Cauchy random variates is,

            p(x) dx = {1 / $scale pi (1 + (x/$$scale)**2) } dx

           for x in the range -infinity to +infinity.  The Cauchy distribution is also known as
           the Lorentz distribution. $r is a gsl_rng structure.

       gsl_ran_cauchy_pdf($x, $scale)
           This function computes the probability density p($x) at $x for a Cauchy distribution
           with $scale, using the formula given above.

   Chi-Squared
       gsl_ran_chisq($r, $nu)
           This function returns a random variate from the chi-squared distribution with $nu
           degrees of freedom. The distribution function is, p(x) dx = {1 / 2 Gamma($nu/2) }
           (x/2)**{$nu/2 - 1} exp(-x/2) dx for $x >= 0. $r is a gsl_rng structure.

       gsl_ran_chisq_pdf($x, $nu)
           This function computes the probability density p($x) at $x for a chi-squared
           distribution with $nu degrees of freedom, using the formula given above.

   Dirichlet
       gsl_ran_dirichlet($r, $alpha)
           This function returns an array of K (where K = length of $alpha array) random variates
           from a Dirichlet distribution of order K-1. The distribution function is

             p(\theta_1, ..., \theta_K) d\theta_1 ... d\theta_K =
                (1/Z) \prod_{i=1}^K \theta_i^{\alpha_i - 1} \delta(1 -\sum_{i=1}^K \theta_i) d\theta_1 ... d\theta_K

           for theta_i >= 0 and alpha_i > 0. The delta function ensures that \sum \theta_i = 1.
           The normalization factor Z is

             Z = {\prod_{i=1}^K \Gamma(\alpha_i)} / {\Gamma( \sum_{i=1}^K \alpha_i)}

           The random variates are generated by sampling K values from gamma distributions with
           parameters a=alpha_i, b=1, and renormalizing. See A.M. Law, W.D. Kelton, Simulation
           Modeling and Analysis (1991).

       gsl_ran_dirichlet_pdf($theta, $alpha)
           This function computes the probability density p(\theta_1, ... , \theta_K) at theta[K]
           for a Dirichlet distribution with parameters alpha[K], using the formula given above.
           $alpha and $theta should be array references of the same size.  Theta should be
           normalized to sum to 1.

       gsl_ran_dirichlet_lnpdf($theta, $alpha)
           This function computes the logarithm of the probability density p(\theta_1, ...  ,
           \theta_K) for a Dirichlet distribution with parameters alpha[K]. $alpha and $theta
           should be array references of the same size.  Theta should be normalized to sum to 1.

   Erlang
       gsl_ran_erlang($r, $scale, $shape)
           Equivalent to gsl_ran_gamma($r, $shape, $scale) where $shape is an integer.

       gsl_ran_erlang_pdf
           Equivalent to gsl_ran_gamma_pdf($r, $shape, $scale) where $shape is an integer.

   F-distribution
       gsl_ran_fdist($r, $nu1, $nu2)
           This function returns a random variate from the F-distribution with degrees of freedom
           nu1 and nu2. The distribution function is, p(x) dx = { Gamma(($nu_1 + $nu_2)/2) /
           Gamma($nu_1/2) Gamma($nu_2/2) } $nu_1**{$nu_1/2} $nu_2**{$nu_2/2} x**{$nu_1/2 - 1}
           ($nu_2 + $nu_1 x)**{-$nu_1/2 -$nu_2/2} for $x >= 0. $r is a gsl_rng structure.

       gsl_ran_fdist_pdf($x, $nu1, $nu2)
           This function computes the probability density p(x) at x for an F-distribution with
           nu1 and nu2 degrees of freedom, using the formula given above.

   Uniform/Flat distribution
       gsl_ran_flat($r, $a, $b)
           This function returns a random variate from the flat (uniform) distribution from a to
           b. The distribution is, p(x) dx = {1 / ($b-$a)} dx if $a <= x < $b and 0 otherwise. $r
           is a gsl_rng structure.

       gsl_ran_flat_pdf($x, $a, $b)
           This function computes the probability density p($x) at $x for a uniform distribution
           from $a to $b, using the formula given above.

   Gamma
       gsl_ran_gamma($r, $shape, $scale)
           This function returns a random variate from the gamma distribution. The distribution
           function is,
                     p(x) dx = {1 \over \Gamma($shape) $scale^$shape} x^{$shape-1} e^{-x/$scale}
           dx for x > 0.  Uses Marsaglia-Tsang method. Can also be called as gsl_ran_gamma_mt.

       gsl_ran_gamma_pdf($x, $shape, $scale)
           This function computes the probability density p($x) at $x for a gamma distribution
           with parameters $shape and $scale, using the formula given above.

       gsl_ran_gamma($r, $shape, $scale)
           Same as gsl_ran_gamma.

       gsl_ran_gamma_knuth($r, $shape, $scale)
           Alternative implementation for gsl_ran_gamma, using algorithm in Knuth volume 2.

   Gaussian/Normal
       gsl_ran_gaussian($r, $sigma)
           This function returns a Gaussian random variate, with mean zero and standard deviation
           $sigma. The probability distribution for Gaussian random variates is, p(x) dx = {1 /
           sqrt{2 pi $sigma**2}} exp(-x**2 / 2 $sigma**2) dx for x in the range -infinity to
           +infinity. $r is a gsl_rng structure.  Uses Box-Mueller (polar) method.

       gsl_ran_gaussian_ratio_method($r, $sigma)
           This function computes a Gaussian random variate using the alternative Kinderman-
           Monahan-Leva ratio method.

       gsl_ran_gaussian_ziggurat($r, $sigma)
           This function computes a Gaussian random variate using the alternative Marsaglia-Tsang
           ziggurat ratio method. The Ziggurat algorithm is the fastest available algorithm in
           most cases. $r is a gsl_rng structure.

       gsl_ran_gaussian_pdf($x, $sigma)
           This function computes the probability density p($x) at $x for a Gaussian distribution
           with standard deviation sigma, using the formula given above.

       gsl_ran_ugaussian($r)
       gsl_ran_ugaussian_ratio_method($r)
       gsl_ran_ugaussian_pdf($x)
           This function computes results for the unit Gaussian distribution. It is equivalent to
           the gaussian functions above with a standard deviation of one, sigma = 1.

       gsl_ran_bivariate_gaussian($r, $sigma_x, $sigma_y, $rho)
           This function generates a pair of correlated Gaussian variates, with mean zero,
           correlation coefficient rho and standard deviations $sigma_x and $sigma_y in the x and
           y directions. The first value returned is x and the second y. The probability
           distribution for bivariate Gaussian random variates is, p(x,y) dx dy = {1 / 2 pi
           $sigma_x $sigma_y sqrt{1-$rho**2}} exp (-(x**2/$sigma_x**2 + y**2/$sigma_y**2 - 2 $rho
           x y/($sigma_x $sigma_y))/2(1- $rho**2)) dx dy for x,y in the range -infinity to
           +infinity. The correlation coefficient $rho should lie between 1 and -1. $r is a
           gsl_rng structure.

       gsl_ran_bivariate_gaussian_pdf($x, $y, $sigma_x, $sigma_y, $rho)
           This function computes the probability density p($x,$y) at ($x,$y) for a bivariate
           Gaussian distribution with standard deviations $sigma_x, $sigma_y and correlation
           coefficient $rho, using the formula given above.

   Gaussian Tail
       gsl_ran_gaussian_tail($r, $a, $sigma)
           This function provides random variates from the upper tail of a Gaussian distribution
           with standard deviation sigma. The values returned are larger than the lower limit a,
           which must be positive. The probability distribution for Gaussian tail random variates
           is, p(x) dx = {1 / N($a; $sigma) sqrt{2 pi sigma**2}} exp(- x**2/(2 sigma**2)) dx for
           x > $a where N($a; $sigma) is the normalization constant, N($a; $sigma) = (1/2)
           erfc($a / sqrt(2 $sigma**2)). $r is a gsl_rng structure.

       gsl_ran_gaussian_tail_pdf($x, $a, $gaussian)
           This function computes the probability density p($x) at $x for a Gaussian tail
           distribution with standard deviation sigma and lower limit $a, using the formula given
           above.

       gsl_ran_ugaussian_tail($r, $a)
           This functions compute results for the tail of a unit Gaussian distribution. It is
           equivalent to the functions above with a standard deviation of one, $sigma = 1. $r is
           a gsl_rng structure.

       gsl_ran_ugaussian_tail_pdf($x, $a)
           This functions compute results for the tail of a unit Gaussian distribution. It is
           equivalent to the functions above with a standard deviation of one, $sigma = 1.

   Landau
       gsl_ran_landau($r)
           This function returns a random variate from the Landau distribution. The probability
           distribution for Landau random variates is defined analytically by the complex
           integral, p(x) = (1/(2 \pi i)) \int_{c-i\infty}^{c+i\infty} ds exp(s log(s) + x s) For
           numerical purposes it is more convenient to use the following equivalent form of the
           integral, p(x) = (1/\pi) \int_0^\infty dt \exp(-t \log(t) - x t) \sin(\pi t). $r is a
           gsl_rng structure.

       gsl_ran_landau_pdf($x)
           This function computes the probability density p($x) at $x for the Landau distribution
           using an approximation to the formula given above.

   Geometric
       gsl_ran_geometric($r, $p)
           This function returns a random integer from the geometric distribution, the number of
           independent trials with probability $p until the first success. The probability
           distribution for geometric variates is, p(k) =  p (1-$p)^(k-1) for k >= 1. Note that
           the distribution begins with k=1 with this definition. There is another convention in
           which the exponent k-1 is replaced by k. $r is a gsl_rng structure.

       gsl_ran_geometric_pdf($k, $p)
           This function computes the probability p($k) of obtaining $k from a geometric
           distribution with probability parameter p, using the formula given above.

   Hypergeometric
       gsl_ran_hypergeometric($r, $n1, $n2, $t)
           This function returns a random integer from the hypergeometric distribution. The
           probability distribution for hypergeometric random variates is, p(k) =  C(n_1, k)
           C(n_2, t - k) / C(n_1 + n_2, t) where C(a,b) = a!/(b!(a-b)!) and t <= n_1 + n_2. The
           domain of k is max(0,t-n_2), ..., min(t,n_1). If a population contains n_1 elements of
           "type 1" and n_2 elements of "type 2" then the hypergeometric distribution gives the
           probability of obtaining k elements of "type 1" in t samples from the population
           without replacement. $r is a gsl_rng structure.

       gsl_ran_hypergeometric_pdf($k, $n1, $n2, $t)
           This function computes the probability p(k) of obtaining k from a hypergeometric
           distribution with parameters $n1, $n2 $t, using the formula given above.

   Gumbel
       gsl_ran_gumbel1($r, $a, $b)
           This function returns a random variate from the Type-1 Gumbel distribution. The Type-1
           Gumbel distribution function is, p(x) dx = a b \exp(-(b \exp(-ax) + ax)) dx for
           -\infty < x < \infty. $r is a gsl_rng structure.

       gsl_ran_gumbel1_pdf($x, $a, $b)
           This function computes the probability density p($x) at $x for a Type-1 Gumbel
           distribution with parameters $a and $b, using the formula given above.

       gsl_ran_gumbel2($r, $a, $b)
           This function returns a random variate from the Type-2 Gumbel distribution. The Type-2
           Gumbel distribution function is, p(x) dx = a b x^{-a-1} \exp(-b x^{-a}) dx for 0 < x <
           \infty. $r is a gsl_rng structure.

       gsl_ran_gumbel2_pdf($x, $a, $b)
           This function computes the probability density p($x) at $x for a Type-2 Gumbel
           distribution with parameters $a and $b, using the formula given above.

   Logistic
       gsl_ran_logistic($r, $a)
           This function returns a random variate from the logistic distribution. The
           distribution function is, p(x) dx = { \exp(-x/a) \over a (1 + \exp(-x/a))^2 } dx for
           -\infty < x < +\infty. $r is a gsl_rng structure.

       gsl_ran_logistic_pdf($x, $a)
           This function computes the probability density p($x) at $x for a logistic distribution
           with scale parameter $a, using the formula given above.

   Lognormal
       gsl_ran_lognormal($r, $zeta, $sigma)
           This function returns a random variate from the lognormal distribution. The
           distribution function is, p(x) dx = {1 \over x \sqrt{2 \pi \sigma^2} } \exp(-(\ln(x) -
           \zeta)^2/2 \sigma^2) dx for x > 0. $r is a gsl_rng structure.

       gsl_ran_lognormal_pdf($x, $zeta, $sigma)
           This function computes the probability density p($x) at $x for a lognormal
           distribution with parameters $zeta and $sigma, using the formula given above.

   Logarithmic
       gsl_ran_logarithmic($r, $p)
           This function returns a random integer from the logarithmic distribution. The
           probability distribution for logarithmic random variates is, p(k) = {-1 \over
           \log(1-p)} {(p^k \over k)} for k >= 1. $r is a gsl_rng structure.

       gsl_ran_logarithmic_pdf($k, $p)
           This function computes the probability p($k) of obtaining $k from a logarithmic
           distribution with probability parameter $p, using the formula given above.

   Multinomial
       gsl_ran_multinomial($r, $P, $N)
           This function computes and returns a random sample n[] from the multinomial
           distribution formed by N trials from an underlying distribution p[K]. The distribution
           function for n[] is,

            P(n_1, n_2, ..., n_K) =
               (N!/(n_1! n_2! ... n_K!)) p_1^n_1 p_2^n_2 ... p_K^n_K

           where (n_1, n_2, ..., n_K) are nonnegative integers with sum_{k=1}^K n_k = N, and
           (p_1, p_2, ..., p_K) is a probability distribution with \sum p_i = 1. If the array
           p[K] is not normalized then its entries will be treated as weights and normalized
           appropriately.

           Random variates are generated using the conditional binomial method (see C.S.  Davis,
           The computer generation of multinomial random variates, Comp. Stat. Data Anal. 16
           (1993) 205-217 for details).

       gsl_ran_multinomial_pdf($counts, $P)
           This function returns the probability for the multinomial distribution P(counts[1],
           counts[2], ..., counts[K]) with parameters p[K].

       gsl_ran_multinomial_lnpdf($counts, $P)
           This function returns the logarithm of the probability for the multinomial
           distribution P(counts[1], counts[2], ..., counts[K]) with parameters p[K].

   Negative Binomial
       gsl_ran_negative_binomial($r, $p, $n)
           This function returns a random integer from the negative binomial distribution, the
           number of failures occurring before n successes in independent trials with probability
           p of success. The probability distribution for negative binomial variates is, p(k) =
           {\Gamma(n + k) \over \Gamma(k+1) \Gamma(n) } p^n (1-p)^k Note that n is not required
           to be an integer.

       gsl_ran_negative_binomial_pdf($k, $p, $n)
           This function computes the probability p($k) of obtaining $k from a negative binomial
           distribution with parameters $p and $n, using the formula given above.

   Pascal
       gsl_ran_pascal($r, $p, $n)
           This function returns a random integer from the Pascal distribution. The Pascal
           distribution is simply a negative binomial distribution with an integer value of $n.
           p($k) = {($n + $k - 1)! \ $k! ($n - 1)! } $p**$n (1-$p)**$k for $k >= 0. $r is gsl_rng
           structure

       gsl_ran_pascal_pdf($k, $p, $n)
           This function computes the probability p($k) of obtaining $k from a Pascal
           distribution with parameters $p and $n, using the formula given above.

   Pareto
       gsl_ran_pareto($r, $a, $b)
           This function returns a random variate from the Pareto distribution of order $a. The
           distribution function is p($x) dx = ($a/$b) / ($x/$b)^{$a+1} dx for $x >= $b. $r is a
           gsl_rng structure

       gsl_ran_pareto_pdf($x, $a, $b)
           This function computes the probability density p(x) at x for a Pareto distribution
           with exponent a and scale b, using the formula given above.

   Poisson
       gsl_ran_poisson($r, $lambda)
           This function returns a random integer from the Poisson distribution with mean
           $lambda. $r is a gsl_rng structure. The probability distribution for Poisson variates
           is,

            p(k) = {$lambda**$k \ $k!} exp(-$lambda)

           for $k >= 0. $r is a gsl_rng structure.

       gsl_ran_poisson_pdf($k, $lambda)
           This function computes the probability p($k) of obtaining $k from a Poisson
           distribution with mean $lambda, using the formula given above.

   Rayleigh
       gsl_ran_rayleigh($r, $sigma)
           This function returns a random variate from the Rayleigh distribution with scale
           parameter sigma. The distribution is, p(x) dx = {x \over \sigma^2} \exp(- x^2/(2
           \sigma^2)) dx for x > 0. $r is a gsl_rng structure

       gsl_ran_rayleigh_pdf($x, $sigma)
           This function computes the probability density p($x) at $x for a Rayleigh distribution
           with scale parameter sigma, using the formula given above.

       gsl_ran_rayleigh_tail($r, $a, $sigma)
           This function returns a random variate from the tail of the Rayleigh distribution with
           scale parameter $sigma and a lower limit of $a. The distribution is, p(x) dx = {x
           \over \sigma^2} \exp ((a^2 - x^2) /(2 \sigma^2)) dx for x > a. $r is a gsl_rng
           structure

       gsl_ran_rayleigh_tail_pdf($x, $a, $sigma)
           This function computes the probability density p($x) at $x for a Rayleigh tail
           distribution with scale parameter $sigma and lower limit $a, using the formula given
           above.

   Student-t
       gsl_ran_tdist($r, $nu)
           This function returns a random variate from the t-distribution. The distribution
           function is, p(x) dx = {\Gamma((\nu + 1)/2) \over \sqrt{\pi \nu} \Gamma(\nu/2)} (1 +
           x^2/\nu)^{-(\nu + 1)/2} dx for -\infty < x < +\infty.

       gsl_ran_tdist_pdf($x, $nu)
           This function computes the probability density p($x) at $x for a t-distribution with
           nu degrees of freedom, using the formula given above.

   Laplace
       gsl_ran_laplace($r, $a)
           This function returns a random variate from the Laplace distribution with width $a.
           The distribution is, p(x) dx = {1 \over 2 a}  \exp(-|x/a|) dx for -\infty < x <
           \infty.

       gsl_ran_laplace_pdf($x, $a)
           This function computes the probability density p($x) at $x for a Laplace distribution
           with width $a, using the formula given above.

   Levy
       gsl_ran_levy($r, $c, $alpha)
           This function returns a random variate from the Levy symmetric stable distribution
           with scale $c and exponent $alpha. The symmetric stable probability distribution is
           defined by a fourier transform, p(x) = {1 \over 2 \pi} \int_{-\infty}^{+\infty} dt
           \exp(-it x - |c t|^alpha) There is no explicit solution for the form of p(x) and the
           library does not define a corresponding pdf function. For \alpha = 1 the distribution
           reduces to the Cauchy distribution. For \alpha = 2 it is a Gaussian distribution with
           \sigma = \sqrt{2} c. For \alpha < 1 the tails of the distribution become extremely
           wide. The algorithm only works for 0 < alpha <= 2. $r is a gsl_rng structure

       gsl_ran_levy_skew($r, $c, $alpha, $beta)
           This function returns a random variate from the Levy skew stable distribution with
           scale $c, exponent $alpha and skewness parameter $beta. The skewness parameter must
           lie in the range [-1,1]. The Levy skew stable probability distribution is defined by a
           fourier transform, p(x) = {1 \over 2 \pi} \int_{-\infty}^{+\infty} dt \exp(-it x - |c
           t|^alpha (1-i beta sign(t) tan(pi alpha/2))) When \alpha = 1 the term \tan(\pi
           \alpha/2) is replaced by -(2/\pi)\log|t|. There is no explicit solution for the form
           of p(x) and the library does not define a corresponding pdf function. For $alpha = 2
           the distribution reduces to a Gaussian distribution with $sigma = sqrt(2) $c and the
           skewness parameter has no effect. For $alpha < 1 the tails of the distribution become
           extremely wide. The symmetric distribution corresponds to $beta = 0. The algorithm
           only works for 0 < $alpha <= 2. The Levy alpha-stable distributions have the property
           that if N alpha-stable variates are drawn from the distribution p(c, \alpha, \beta)
           then the sum Y = X_1 + X_2 + \dots + X_N will also be distributed as an alpha-stable
           variate, p(N^(1/\alpha) c, \alpha, \beta). $r is a gsl_rng structure

   Weibull
       gsl_ran_weibull($r, $scale, $exponent)
           This function returns a random variate from the Weibull distribution with $scale and
           $exponent (aka scale). The distribution function is

            p(x) dx = {$exponent \over $scale^$exponent} x^{$exponent-1}
                      \exp(-(x/$scale)^$exponent) dx

           for x >= 0. $r is a gsl_rng structure

       gsl_ran_weibull_pdf($x, $scale, $exponent)
           This function computes the probability density p($x) at $x for a Weibull distribution
           with $scale and $exponent, using the formula given above.

   Spherical Vector
       gsl_ran_dir_2d($r)
           This function returns two values. The first is $x and the second is $y of a random
           direction vector v = ($x,$y) in two dimensions. The vector is normalized such that
           |v|^2 = $x^2 + $y^2 = 1. $r is a gsl_rng structure

       gsl_ran_dir_2d_trig_method($r)
           This function returns two values. The first is $x and the second is $y of a random
           direction vector v = ($x,$y) in two dimensions. The vector is normalized such that
           |v|^2 = $x^2 + $y^2 = 1. $r is a gsl_rng structure

       gsl_ran_dir_3d($r)
           This function returns three values. The first is $x, the second $y and the third $z of
           a random direction vector v = ($x,$y,$z) in three dimensions. The vector is normalized
           such that |v|^2 = x^2 + y^2 + z^2 = 1. The method employed is due to Robert E. Knop
           (CACM 13, 326 (1970)), and explained in Knuth, v2, 3rd ed, p136. It uses the
           surprising fact that the distribution projected along any axis is actually uniform
           (this is only true for 3 dimensions).

       gsl_ran_dir_nd (Not yet implemented )
           This function returns a random direction vector v = (x_1,x_2,...,x_n) in n dimensions.
           The vector is normalized such that

               |v|^2 = x_1^2 + x_2^2 + ... + x_n^2 = 1.

           The method uses the fact that a multivariate Gaussian distribution is spherically
           symmetric. Each component is generated to have a Gaussian distribution, and then the
           components are normalized. The method is described by Knuth, v2, 3rd ed, p135-136, and
           attributed to G. W. Brown, Modern Mathematics for the Engineer (1956).

   Shuffling and Sampling
       gsl_ran_shuffle
           Please use the "shuffle" method in the GSL::RNG module OO interface.

       gsl_ran_choose
           Please use the "choose" method in the GSL::RNG module OO interface.

       gsl_ran_sample
           Please use the "sample" method in the GSL::RNG module OO interface.

       gsl_ran_discrete_preproc
       gsl_ran_discrete($r, $g)
           After gsl_ran_discrete_preproc has been called, you use this function to get the
           discrete random numbers. $r is a gsl_rng structure and $g is a gsl_ran_discrete
           structure

       gsl_ran_discrete_pdf($k, $g)
           Returns the probability P[$k] of observing the variable $k. Since P[$k] is not stored
           as part of the lookup table, it must be recomputed; this computation takes O(K), so if
           K is large and you care about the original array P[$k] used to create the lookup
           table, then you should just keep this original array P[$k] around. $r is a gsl_rng
           structure and $g is a gsl_ran_discrete structure

       gsl_ran_discrete_free($g)
           De-allocates the gsl_ran_discrete pointed to by g.

        You have to add the functions you want to use inside the qw /put_function_here /.
        You can also write use Math::GSL::Randist qw/:all/; to use all available functions of the module.
        Other tags are also available, here is a complete list of all tags for this module :

       logarithmic
       choose
       exponential
       gumbel1
       exppow
       sample
       logistic
       gaussian
       poisson
       binomial
       fdist
       chisq
       gamma
       hypergeometric
       dirichlet
       negative
       flat
       geometric
       discrete
       tdist
       ugaussian
       rayleigh
       dir
       pascal
       gumbel2
       shuffle
       landau
       bernoulli
       weibull
       multinomial
       beta
       lognormal
       laplace
       erlang
       cauchy
       levy
       bivariate
       pareto

        For example the beta tag contains theses functions : gsl_ran_beta, gsl_ran_beta_pdf.

       For more information on the functions, we refer you to the GSL official documentation:
       <http://www.gnu.org/software/gsl/manual/html_node/>

        You might also want to write

           use Math::GSL::RNG qw/:all/;

       since a lot of the functions of Math::GSL::Randist take as argument a structure that is
       created by Math::GSL::RNG.  Refer to Math::GSL::RNG documentation to see how to create
       such a structure.

       Math::GSL::CDF also contains a structure named gsl_ran_discrete_t. An example is given in
       the EXAMPLES part on how to use the function related to this structure.

EXAMPLES

           use Math::GSL::Randist qw/:all/;
           print gsl_ran_exponential_pdf(5,2) . "\n";

           use Math::GSL::Randist qw/:all/;
           my $x = Math::GSL::gsl_ran_discrete_t::new;

AUTHORS

       Jonathan "Duke" Leto <jonathan@leto.net> and Thierry Moisan <thierry.moisan@gmail.com>

COPYRIGHT AND LICENSE

       Copyright (C) 2008-2021 Jonathan "Duke" Leto and Thierry Moisan

       This program is free software; you can redistribute it and/or modify it under the same
       terms as Perl itself.