Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
Math::GSL::Randist(3) User Contributed Perl DocumentationMath::GSL::Randist(3)

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_funtion_here /.
	You can	also write use Math::GSL::Randist qw/:all/; to use all avaible functions of the	module.
	Other tags are also avaible, 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	informations on	the functions, we refer	you to the GSL offcial
       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-2020 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.

perl v5.32.1			  2021-08-27		 Math::GSL::Randist(3)

NAME | SYNOPSIS | DESCRIPTION | EXAMPLES | AUTHORS | COPYRIGHT AND LICENSE

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=Math::GSL::Randist&sektion=3&manpath=FreeBSD+13.0-RELEASE+and+Ports>

home | help