---
name: "PDL::GSL::RNG"
section: "3pm"
platform: "linux"
package: "pdl"
version: "1:2.081-2"
release: "Debian 12 (Bookworm)"
platforms: ["linux"]
url: "https://new.carta.tech/PDL::GSL::RNG"
---

# PDL::GSL::RNG(3pm)

PDL interface to RNG and randist routines in GSL

## NAME

PDL::GSL::RNG - PDL interface to RNG and randist routines in GSL

## DESCRIPTION

This is an interface to the rng and randist packages present in the GNU Scientific Library.

## SYNOPSIS

```
   use PDL;
   use PDL::GSL::RNG;
   $rng = PDL::GSL::RNG->new('taus');
   $rng->set_seed(time());
   $x=zeroes(5,5,5)
   $rng->get_uniform($x); # inplace
   $y=$rng->get_uniform(3,4,5); # creates new pdl
```

## NOMENCLATURE

Throughout this documentation we strive to use the same variables that are present in the original GSL documentation (see See Also). Oftentimes those variables are called `"a"` and `"b"`. Since good Perl coding practices discourage the use of Perl variables `$a` and `$b`, here we refer to Parameters `"a"` and `"b"` as `$pa` and `$pb`, respectively, and Limits (of domain or integration) as `$la` and `$lb`.

## FUNCTIONS

### new

The new method initializes a new instance of the RNG.

The available RNGs are:

```
 coveyou cmrg fishman18 fishman20 fishman2x gfsr4 knuthran
 knuthran2 knuthran2002 lecuyer21 minstd mrg mt19937 mt19937_1999
 mt19937_1998 r250 ran0 ran1 ran2 ran3 rand rand48 random128_bsd
 random128_glibc2 random128_libc5 random256_bsd random256_glibc2
 random256_libc5 random32_bsd random32_glibc2 random32_libc5
 random64_bsd random64_glibc2 random64_libc5 random8_bsd
 random8_glibc2 random8_libc5 random_bsd random_glibc2
 random_libc5 randu ranf ranlux ranlux389 ranlxd1 ranlxd2 ranlxs0
 ranlxs1 ranlxs2 ranmar slatec taus taus2 taus113 transputer tt800
 uni uni32 vax waterman14 zuf default
```

The last one (default) uses the environment variable GSL\_RNG\_TYPE.

Note that only a few of these rngs are recommended for general use. Please check the GSL documentation for more information.

Usage:

```
   $blessed_ref = PDL::GSL::RNG->new($RNG_name);
```

Example:

```
   $rng = PDL::GSL::RNG->new('taus');
```

### set\_seed

Sets the RNG seed.

Usage:

```
   $rng->set_seed($integer);
   # or
   $rng = PDL::GSL::RNG->new('taus')->set_seed($integer);
```

Example:

```
   $rng->set_seed(666);
```

### min

Return the minimum value generable by this RNG.

Usage:

```
   $integer = $rng->min();
```

Example:

```
   $min = $rng->min(); $max = $rng->max();
```

### max

Return the maximum value generable by the RNG.

Usage:

```
   $integer = $rng->max();
```

Example:

```
   $min = $rng->min(); $max = $rng->max();
```

### name

Returns the name of the RNG.

Usage:

```
   $string = $rng->name();
```

Example:

```
   $name = $rng->name();
```

### get

This function creates an ndarray with given dimensions or accepts an existing ndarray and fills it. **get()** returns integer values between a minimum and a maximum specific to every RNG.

Usage:

```
   $ndarray = $rng->get($list_of_integers)
   $rng->get($ndarray);
```

Example:

```
   $x = zeroes 5,6;
   $o = $rng->get(10,10); $rng->get($x);
```

### get\_int

This function creates an ndarray with given dimensions or accepts an existing ndarray and fills it. **get\_int()** returns integer values between 0 and `$max`.

Usage:

```
   $ndarray = $rng->get($max, $list_of_integers)
   $rng->get($max, $ndarray);
```

Example:

```
   $x = zeroes 5,6; $max=100;
   $o = $rng->get(10,10); $rng->get($x);
```

### get\_uniform

This function creates an ndarray with given dimensions or accepts an existing ndarray and fills it. **get\_uniform()** returns values 0\<=x\<1,

Usage:

```
   $ndarray = $rng->get_uniform($list_of_integers)
   $rng->get_uniform($ndarray);
```

Example:

```
   $x = zeroes 5,6; $max=100;
   $o = $rng->get_uniform(10,10); $rng->get_uniform($x);
```

### get\_uniform\_pos

This function creates an ndarray with given dimensions or accepts an existing ndarray and fills it. **get\_uniform\_pos()** returns values 0\<x\<1,

Usage:

```
   $ndarray = $rng->get_uniform_pos($list_of_integers)
   $rng->get_uniform_pos($ndarray);
```

Example:

```
   $x = zeroes 5,6;
   $o = $rng->get_uniform_pos(10,10); $rng->get_uniform_pos($x);
```

### ran\_shuffle

Shuffles values in ndarray

Usage:

```
   $rng->ran_shuffle($ndarray);
```

### ran\_shuffle\_vec

Shuffles values in ndarray

Usage:

```
   $rng->ran_shuffle_vec(@vec);
```

### ran\_choose

Chooses values from `$inndarray` to `$outndarray`.

Usage:

```
   $rng->ran_choose($inndarray,$outndarray);
```

### ran\_choose\_vec

Chooses `$n` values from `@vec`.

Usage:

```
   @chosen = $rng->ran_choose_vec($n,@vec);
```

### ran\_gaussian

Fills output ndarray with random values from Gaussian distribution with mean zero and standard deviation `$sigma`.

Usage:

```
 $ndarray = $rng->ran_gaussian($sigma,[list of integers = output ndarray dims]);
 $rng->ran_gaussian($sigma, $output_ndarray);
```

Example:

```
  $o = $rng->ran_gaussian($sigma,10,10);
  $rng->ran_gaussian($sigma,$o);
```

### ran\_gaussian\_var

This method is similar to "ran\_gaussian" except that it takes the parameters of the distribution as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_gaussian_var($sigma_ndarray);
   $rng->ran_gaussian_var($sigma_ndarray, $output_ndarray);
```

Example:

```
   $sigma_pdl = rvals zeroes 11,11;
   $o = $rng->ran_gaussian_var($sigma_pdl);
```

### ran\_additive\_gaussian

Add Gaussian noise of given sigma to an ndarray.

Usage:

```
   $rng->ran_additive_gaussian($sigma,$ndarray);
```

Example:

```
   $rng->ran_additive_gaussian(1,$image);
```

### ran\_bivariate\_gaussian

Generates `$n` bivariate gaussian random deviates.

Usage:

```
   $ndarray = $rng->ran_bivariate_gaussian($sigma_x,$sigma_y,$rho,$n);
```

Example:

```
   $o = $rng->ran_bivariate_gaussian(1,2,0.5,1000);
```

### ran\_poisson

Fills output ndarray by with random integer values from the Poisson distribution with mean `$mu`.

Usage:

```
   $ndarray = $rng->ran_poisson($mu,[list of integers = output ndarray dims]);
   $rng->ran_poisson($mu,$output_ndarray);
```

### ran\_poisson\_var

Similar to "ran\_poisson" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_poisson_var($mu_ndarray);
```

### ran\_additive\_poisson

Add Poisson noise of given `$mu` to a `$ndarray`.

Usage:

```
   $rng->ran_additive_poisson($mu,$ndarray);
```

Example:

```
   $rng->ran_additive_poisson(1,$image);
```

### ran\_feed\_poisson

This method simulates shot noise, taking the values of ndarray as values for `$mu` to be fed in the poissonian RNG.

Usage:

```
   $rng->ran_feed_poisson($ndarray);
```

Example:

```
   $rng->ran_feed_poisson($image);
```

### ran\_bernoulli

Fills output ndarray with random values 0 or 1, the result of a Bernoulli trial with probability `$p`.

Usage:

```
   $ndarray = $rng->ran_bernoulli($p,[list of integers = output ndarray dims]);
   $rng->ran_bernoulli($p,$output_ndarray);
```

### ran\_bernoulli\_var

Similar to "ran\_bernoulli" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_bernoulli_var($p_ndarray);
```

### ran\_beta

Fills output ndarray with random variates from the beta distribution with parameters `$pa` and `$pb`.

Usage:

```
   $ndarray = $rng->ran_beta($pa,$pb,[list of integers = output ndarray dims]);
   $rng->ran_beta($pa,$pb,$output_ndarray);
```

### ran\_beta\_var

Similar to "ran\_beta" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_beta_var($a_ndarray, $b_ndarray);
```

### ran\_binomial

Fills output ndarray with random integer values from the binomial distribution, the number of successes in `$n` independent trials with probability `$p`.

Usage:

```
   $ndarray = $rng->ran_binomial($p,$n,[list of integers = output ndarray dims]);
   $rng->ran_binomial($p,$n,$output_ndarray);
```

### ran\_binomial\_var

Similar to "ran\_binomial" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_binomial_var($p_ndarray, $n_ndarray);
```

### ran\_cauchy

Fills output ndarray with random variates from the Cauchy distribution with scale parameter `$pa`.

Usage:

```
   $ndarray = $rng->ran_cauchy($pa,[list of integers = output ndarray dims]);
   $rng->ran_cauchy($pa,$output_ndarray);
```

### ran\_cauchy\_var

Similar to "ran\_cauchy" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_cauchy_var($a_ndarray);
```

### ran\_chisq

Fills output ndarray with random variates from the chi-squared distribution with `$nu` degrees of freedom.

Usage:

```
   $ndarray = $rng->ran_chisq($nu,[list of integers = output ndarray dims]);
   $rng->ran_chisq($nu,$output_ndarray);
```

### ran\_chisq\_var

Similar to "ran\_chisq" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_chisq_var($nu_ndarray);
```

### ran\_exponential

Fills output ndarray with random variates from the exponential distribution with mean `$mu`.

Usage:

```
   $ndarray = $rng->ran_exponential($mu,[list of integers = output ndarray dims]);
   $rng->ran_exponential($mu,$output_ndarray);
```

### ran\_exponential\_var

Similar to "ran\_exponential" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_exponential_var($mu_ndarray);
```

### ran\_exppow

Fills output ndarray with random variates from the exponential power distribution with scale parameter `$pa` and exponent `$pb`.

Usage:

```
   $ndarray = $rng->ran_exppow($pa,$pb,[list of integers = output ndarray dims]);
   $rng->ran_exppow($pa,$pb,$output_ndarray);
```

### ran\_exppow\_var

Similar to "ran\_exppow" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_exppow_var($a_ndarray, $b_ndarray);
```

### ran\_fdist

Fills output ndarray with random variates from the F-distribution with degrees of freedom `$nu1` and `$nu2`.

Usage:

```
   $ndarray = $rng->ran_fdist($nu1, $nu2,[list of integers = output ndarray dims]);
   $rng->ran_fdist($nu1, $nu2,$output_ndarray);
```

### ran\_fdist\_var

Similar to "ran\_fdist" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_fdist_var($nu1_ndarray, $nu2_ndarray);
```

### ran\_flat

Fills output ndarray with random variates from the flat (uniform) distribution from `$la` to `$lb`.

Usage:

```
   $ndarray = $rng->ran_flat($la,$lb,[list of integers = output ndarray dims]);
   $rng->ran_flat($la,$lb,$output_ndarray);
```

### ran\_flat\_var

Similar to "ran\_flat" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_flat_var($a_ndarray, $b_ndarray);
```

### ran\_gamma

Fills output ndarray with random variates from the gamma distribution.

Usage:

```
   $ndarray = $rng->ran_gamma($pa,$pb,[list of integers = output ndarray dims]);
   $rng->ran_gamma($pa,$pb,$output_ndarray);
```

### ran\_gamma\_var

Similar to "ran\_gamma" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_gamma_var($a_ndarray, $b_ndarray);
```

### ran\_geometric

Fills output ndarray with random integer values from the geometric distribution, the number of independent trials with probability `$p` until the first success.

Usage:

```
   $ndarray = $rng->ran_geometric($p,[list of integers = output ndarray dims]);
   $rng->ran_geometric($p,$output_ndarray);
```

### ran\_geometric\_var

Similar to "ran\_geometric" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_geometric_var($p_ndarray);
```

### ran\_gumbel1

Fills output ndarray with random variates from the Type-1 Gumbel distribution.

Usage:

```
   $ndarray = $rng->ran_gumbel1($pa,$pb,[list of integers = output ndarray dims]);
   $rng->ran_gumbel1($pa,$pb,$output_ndarray);
```

### ran\_gumbel1\_var

Similar to "ran\_gumbel1" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_gumbel1_var($a_ndarray, $b_ndarray);
```

### ran\_gumbel2

Fills output ndarray with random variates from the Type-2 Gumbel distribution.

Usage:

```
   $ndarray = $rng->ran_gumbel2($pa,$pb,[list of integers = output ndarray dims]);
   $rng->ran_gumbel2($pa,$pb,$output_ndarray);
```

### ran\_gumbel2\_var

Similar to "ran\_gumbel2" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_gumbel2_var($a_ndarray, $b_ndarray);
```

### ran\_hypergeometric

Fills output ndarray with random integer values from the hypergeometric distribution. If a population contains `$n1` elements of type 1 and `$n2` elements of type 2 then the hypergeometric distribution gives the probability of obtaining `$x` elements of type 1 in `$t` samples from the population without replacement.

Usage:

```
   $ndarray = $rng->ran_hypergeometric($n1, $n2, $t,[list of integers = output ndarray dims]);
   $rng->ran_hypergeometric($n1, $n2, $t,$output_ndarray);
```

### ran\_hypergeometric\_var

Similar to "ran\_hypergeometric" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_hypergeometric_var($n1_ndarray, $n2_ndarray, $t_ndarray);
```

### ran\_laplace

Fills output ndarray with random variates from the Laplace distribution with width `$pa`.

Usage:

```
   $ndarray = $rng->ran_laplace($pa,[list of integers = output ndarray dims]);
   $rng->ran_laplace($pa,$output_ndarray);
```

### ran\_laplace\_var

Similar to "ran\_laplace" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_laplace_var($a_ndarray);
```

### ran\_levy

Fills output ndarray with random variates from the Levy symmetric stable distribution with scale `$c` and exponent `$alpha`.

Usage:

```
   $ndarray = $rng->ran_levy($mu,$x,[list of integers = output ndarray dims]);
   $rng->ran_levy($mu,$x,$output_ndarray);
```

### ran\_levy\_var

Similar to "ran\_levy" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_levy_var($mu_ndarray, $a_ndarray);
```

### ran\_logarithmic

Fills output ndarray with random integer values from the logarithmic distribution.

Usage:

```
   $ndarray = $rng->ran_logarithmic($p,[list of integers = output ndarray dims]);
   $rng->ran_logarithmic($p,$output_ndarray);
```

### ran\_logarithmic\_var

Similar to "ran\_logarithmic" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_logarithmic_var($p_ndarray);
```

### ran\_logistic

Fills output ndarray with random random variates from the logistic distribution.

Usage:

```
   $ndarray = $rng->ran_logistic($m,[list of integers = output ndarray dims]u)
   $rng->ran_logistic($m,$output_ndarray)
```

### ran\_logistic\_var

Similar to "ran\_logistic" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_logistic_var($m_ndarray);
```

### ran\_lognormal

Fills output ndarray with random variates from the lognormal distribution with parameters `$mu` (location) and `$sigma` (scale).

Usage:

```
   $ndarray = $rng->ran_lognormal($mu,$sigma,[list of integers = output ndarray dims]);
   $rng->ran_lognormal($mu,$sigma,$output_ndarray);
```

### ran\_lognormal\_var

Similar to "ran\_lognormal" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_lognormal_var($mu_ndarray, $sigma_ndarray);
```

### ran\_negative\_binomial

Fills output ndarray with random integer values from the negative binomial distribution, the number of failures occurring before `$n` successes in independent trials with probability `$p` of success. Note that `$n` is not required to be an integer.

Usage:

```
   $ndarray = $rng->ran_negative_binomial($p,$n,[list of integers = output ndarray dims]);
   $rng->ran_negative_binomial($p,$n,$output_ndarray);
```

### ran\_negative\_binomial\_var

Similar to "ran\_negative\_binomial" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_negative_binomial_var($p_ndarray, $n_ndarray);
```

### ran\_pareto

Fills output ndarray with random variates from the Pareto distribution of order `$pa` and scale `$lb`.

Usage:

```
   $ndarray = $rng->ran_pareto($pa,$lb,[list of integers = output ndarray dims]);
   $rng->ran_pareto($pa,$lb,$output_ndarray);
```

### ran\_pareto\_var

Similar to "ran\_pareto" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_pareto_var($a_ndarray, $b_ndarray);
```

### ran\_pascal

Fills output ndarray with random integer values from the Pascal distribution. The Pascal distribution is simply a negative binomial distribution (see "ran\_negative\_binomial") with an integer value of `$n`.

Usage:

```
   $ndarray = $rng->ran_pascal($p,$n,[list of integers = output ndarray dims]);
   $rng->ran_pascal($p,$n,$output_ndarray);
```

### ran\_pascal\_var

Similar to "ran\_pascal" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_pascal_var($p_ndarray, $n_ndarray);
```

### ran\_rayleigh

Fills output ndarray with random variates from the Rayleigh distribution with scale parameter `$sigma`.

Usage:

```
   $ndarray = $rng->ran_rayleigh($sigma,[list of integers = output ndarray dims]);
   $rng->ran_rayleigh($sigma,$output_ndarray);
```

### ran\_rayleigh\_var

Similar to "ran\_rayleigh" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_rayleigh_var($sigma_ndarray);
```

### ran\_rayleigh\_tail

Fills output ndarray with random variates from the tail of the Rayleigh distribution with scale parameter `$sigma` and a lower limit of `$la`.

Usage:

```
   $ndarray = $rng->ran_rayleigh_tail($la,$sigma,[list of integers = output ndarray dims]);
   $rng->ran_rayleigh_tail($x,$sigma,$output_ndarray);
```

### ran\_rayleigh\_tail\_var

Similar to "ran\_rayleigh\_tail" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_rayleigh_tail_var($a_ndarray, $sigma_ndarray);
```

### ran\_tdist

Fills output ndarray with random variates from the t-distribution (AKA Student's t-distribution) with `$nu` degrees of freedom.

Usage:

```
   $ndarray = $rng->ran_tdist($nu,[list of integers = output ndarray dims]);
   $rng->ran_tdist($nu,$output_ndarray);
```

### ran\_tdist\_var

Similar to "ran\_tdist" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_tdist_var($nu_ndarray);
```

### ran\_ugaussian\_tail

Fills output ndarray with random variates from the upper tail of a Gaussian distribution with `"standard deviation = 1"` (AKA unit Gaussian distribution).

Usage:

```
   $ndarray = $rng->ran_ugaussian_tail($tail,[list of integers = output ndarray dims]);
   $rng->ran_ugaussian_tail($tail,$output_ndarray);
```

### ran\_ugaussian\_tail\_var

Similar to "ran\_ugaussian\_tail" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_ugaussian_tail_var($tail_ndarray);
```

### ran\_weibull

Fills output ndarray with random variates from the Weibull distribution with scale `$pa` and exponent `$pb`. (Some literature uses `"lambda"` for `$pa` and `"k"` for `$pb`.)

Usage:

```
   $ndarray = $rng->ran_weibull($pa,$pb,[list of integers = output ndarray dims]);
   $rng->ran_weibull($pa,$pb,$output_ndarray);
```

### ran\_weibull\_var

Similar to "ran\_weibull" except that it takes the distribution parameters as an ndarray and returns an ndarray of equal dimensions.

Usage:

```
   $ndarray = $rng->ran_weibull_var($a_ndarray, $b_ndarray);
```

### ran\_dir

Returns `$n` random vectors in `$ndim` dimensions.

Usage:

```
   $ndarray = $rng->ran_dir($ndim,$n);
```

Example:

```
   $o = $rng->ran_dir($ndim,$n);
```

### ran\_discrete\_preproc

This method returns a handle that must be used when calling "ran\_discrete". You specify the probability of the integer number that are returned by "ran\_discrete".

Usage:

```
   $discrete_dist_handle = $rng->ran_discrete_preproc($double_ndarray_prob);
```

Example:

```
   $prob = pdl [0.1,0.3,0.6];
   $ddh = $rng->ran_discrete_preproc($prob);
   $o = $rng->ran_discrete($discrete_dist_handle,100);
```

### ran\_discrete

Is used to get the desired samples once a proper handle has been enstablished (see **ran\_discrete\_preproc()**).

Usage:

```
   $ndarray = $rng->ran_discrete($discrete_dist_handle,$num);
```

Example:

```
   $prob = pdl [0.1,0.3,0.6];
   $ddh = $rng->ran_discrete_preproc($prob);
   $o = $rng->ran_discrete($discrete_dist_handle,100);
```

### ran\_ver

Returns an ndarray with `$n` values generated by the Verhulst map from `$x0` and parameter `$r`.

Usage:

```
   $rng->ran_ver($x0, $r, $n);
```

### ran\_caos

Returns values from Verhuls map with `"$r=4.0"` and randomly chosen `$x0`. The values are scaled by `$m`.

Usage:

```
   $rng->ran_caos($m,$n);
```

## BUGS

Feedback is welcome. Log bugs in the PDL bug database (the database is always linked from \<http://pdl.perl.org/\>).

## SEE ALSO

PDL

The GSL documentation for random number distributions is online at \<https://www.gnu.org/software/gsl/doc/html/randist.html\>

## AUTHOR

This file copyright (C) 1999 Christian Pellegrin \<chri@infis.univ.trieste.it\> Docs mangled by C. Soeller. All rights reserved. There is no warranty. You are allowed to redistribute this software / documentation under certain conditions. For details, see the file COPYING in the PDL distribution. If this file is separated from the PDL distribution, the copyright notice should be included in the file.

The GSL RNG and randist modules were written by James Theiler.