Module: Numo::GSL::Ran

Included in:

Rng

Defined in:

ext/numo/gsl/rng/gsl_rng.c,
ext/numo/gsl/ran/gsl_ran.c

Defined Under Namespace

Classes: Discrete

Instance Method Summary

• #bernoulli(p, [shape]) ⇒ Integer or UInt

  This function returns either 0 or 1, the result of a Bernoulli trial with probability p.

• #beta(a, b, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the beta distribution.

• #binomial(p, n, [shape]) ⇒ Integer or UInt

  This function returns a random integer from the binomial distribution, the number of successes in n independent trials with probability p.

• #bivariate_gaussian(sigma_x, sigma_y, rho, [shape]) ⇒ Object

  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.

• #cauchy(a, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the Cauchy distribution with scale parameter a.

• #chisq(nu, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the chi-squared distribution with nu degrees of freedom.

• #dir_2d([shape]) ⇒ Object

  This function returns a random direction vector v = (x,y) in two dimensions.

• #dir_2d_trig_method([shape]) ⇒ Object

  This function returns a random direction vector v = (x,y) in two dimensions.

• #dir_3d([shape]) ⇒ Array

  This function returns a random direction vector v = (x,y,z) in three dimensions.

• #dirichlet(alpha[]) ⇒ DFloat

  This function returns an array of K random variates from a Dirichlet distribution of order K-1.

• #exponential(mu, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the exponential distribution with mean mu.

• #exppow(a, b, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the exponential power distribution with scale parameter a and exponent b.

• #fdist(nu1, nu2, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the F-distribution with degrees of freedom nu1 and nu2.

• #flat(a, b, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the flat (uniform) distribution from a to b.

• #gamma(a, b, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the gamma distribution.

• #gamma_knuth(a, b, [shape]) ⇒ Float or DFloat

  This function returns a gamma variate using the algorithms from Knuth (vol 2).

• #gaussian(sigma, [shape]) ⇒ Float or DFloat

  This function returns a Gaussian random variate, with mean zero and standard deviation sigma.

• #gaussian_ratio_method(sigma, [shape]) ⇒ Float or DFloat

  This function computes a Gaussian random variate using the alternative Marsaglia-Tsang ziggurat and Kinderman-Monahan-Leva ratio methods.

• #gaussian_tail(a, sigma, [shape]) ⇒ Float or DFloat

  This function provides random variates from the upper tail of a Gaussian distribution with standard deviation sigma.

• #gaussian_ziggurat(sigma, [shape]) ⇒ Float or DFloat

  This function computes a Gaussian random variate using the alternative Marsaglia-Tsang ziggurat and Kinderman-Monahan-Leva ratio methods.

• #geometric(p, [shape]) ⇒ Integer or UInt

  This function returns a random integer from the geometric distribution, the number of independent trials with probability p until the first success.

• #gumbel1(a, b, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the Type-1 Gumbel distribution.

• #gumbel2(a, b, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the Type-2 Gumbel distribution.

• #hypergeometric(n1, n2, t, [shape]) ⇒ Integer or UInt

  This function returns a random integer from the hypergeometric distribution.

• #landau([shape]) ⇒ Float or DFloat

  This function returns a random variate from the Landau distribution.

• #laplace(a, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the Laplace distribution with width a.

• #levy(c, alpha, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the Levy symmetric stable distribution with scale c and exponent alpha.

• #logarithmic(p, [shape]) ⇒ Integer or UInt

  This function returns a random integer from the logarithmic distribution.

• #logistic(a, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the logistic distribution.

• #lognormal(zeta, sigma, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the lognormal distribution.

• #multinomial(N, p[]) ⇒ UInt

  This function computes a random sample n[] from the multinomial distribution formed by N trials from an underlying distribution p[K].

• #pareto(a, b, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the Pareto distribution of order a.

• #pascal(p, n, [shape]) ⇒ Integer or UInt

  This function returns a random integer from the Pascal distribution.

• #poisson(mu, [shape]) ⇒ Integer or UInt

  This function returns a random integer from the Poisson distribution with mean mu.

• #rayleigh(sigma, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the Rayleigh distribution with scale parameter sigma.

• #rayleigh_tail(a, sigma, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the tail of the Rayleigh distribution with scale parameter sigma and a lower limit of a.

• #tdist(nu, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the t-distribution.

• #ugaussian([shape]) ⇒ Float or DFloat

  These functions compute results for the unit Gaussian distribution.

• #ugaussian_ratio_method([shape]) ⇒ Float or DFloat

  These functions compute results for the unit Gaussian distribution.

• #ugaussian_tail(a, [shape]) ⇒ Float or DFloat

  These functions compute results for the tail of a unit Gaussian distribution.

• #weibull(a, b, [shape]) ⇒ Float or DFloat

  This function returns a random variate from the Weibull distribution.

Instance Method Details

#bernoulli(p, [shape]) ⇒ Integer or UInt

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 p(1) = p

Parameters:

• p (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Integer or UInt) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 4352

static VALUE
ran_bernoulli(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    unsigned int *ptr;
    
    VALUE v0;
    
    double a0;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "11" , &v0, &vshape);
    a0 = NUM2DBL(v0);
    
    if (nargs == 1) {
        return rb_float_new(gsl_ran_bernoulli(r , a0));
    } else {
        vna = create_new_narray(cUInt,vshape);
        ptr = (unsigned int*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_bernoulli(r , a0);
        }
        return vna;
    }
}

#beta(a, b, [shape]) ⇒ Float or DFloat

This function returns a random variate from the beta distribution. The distribution function is,

p(x) dx = [\Gamma(a+b) \over \Gamma(a) \Gamma(b)] x^[a-1] (1-x)^[b-1] dx

for $0 \le x \le 1$ 0 <= x <= 1.

Parameters:

• a (Float)
• b (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3776

static VALUE
ran_beta(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    VALUE v1;
    
    double a0;
    double a1;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "21" , &v0, &v1, &vshape);
    a0 = NUM2DBL(v0);
    a1 = NUM2DBL(v1);
    
    if (nargs == 2) {
        return rb_float_new(gsl_ran_beta(r , a0, a1));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_beta(r , a0, a1);
        }
        return vna;
    }
}

#binomial(p, n, [shape]) ⇒ Integer or UInt

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! \over k! (n-k)! ] p^k (1-p)^[n-k]

for $0 \le k \le n$ 0 <= k <= n.

Parameters:

• p (Float)
• n (Integer)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Integer or UInt) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 4402

static VALUE
ran_binomial(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    unsigned int *ptr;
    
    VALUE v0;
    VALUE v1;
    
    double a0;
    unsigned int a1;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "21" , &v0, &v1, &vshape);
    a0 = NUM2DBL(v0);
    a1 = NUM2UINT(v1);
    
    if (nargs == 2) {
        return rb_float_new(gsl_ran_binomial(r , a0, a1));
    } else {
        vna = create_new_narray(cUInt,vshape);
        ptr = (unsigned int*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_binomial(r , a0, a1);
        }
        return vna;
    }
}

#bivariate_gaussian(sigma_x, sigma_y, rho, [shape]) ⇒ Object

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 probability distribution for bivariate Gaussian random variates is,

p(x,y) dx dy = [1 \over 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 -\infty to +\infty. The correlation coefficient rho should lie between 1 and -1.

Parameters:

• sigma_x (Float)
• sigma_y (Float)
• rho (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• [] returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 2952

static VALUE
ran_bivariate_gaussian(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vx, vy;
    size_t i, size;
    int nargs;
    double x, y;
    double *px, *py;
    
    VALUE v0;
    VALUE v1;
    VALUE v2;
    
    double a0;
    double a1;
    double a2;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "31" , &v0, &v1, &v2, &vshape);
    
    a0 = NUM2DBL(v0);
    a1 = NUM2DBL(v1);
    a2 = NUM2DBL(v2);
    if (nargs == 3) {
        gsl_ran_bivariate_gaussian(r , a0, a1, a2, &x, &y);
        return rb_assoc_new(DBL2NUM(x),DBL2NUM(y));
    } else {
        vx = create_new_narray(cDF,vshape);
        vy = create_new_narray(cDF,vshape);
        px = (double*)na_get_pointer_for_write(vx);
        py = (double*)na_get_pointer_for_write(vy);
        size = RNARRAY_SIZE(vx);
        for (i=0; i<size; i++) {
            gsl_ran_bivariate_gaussian(r , a0, a1, a2, px, py);
            px++; py++;
        }
        return rb_assoc_new(vx,vy);
    }
}

#cauchy(a, [shape]) ⇒ Float or DFloat

This function returns a random variate from the Cauchy distribution with scale parameter a. The probability distribution for Cauchy random variates is,

p(x) dx = [1 \over a\pi (1 + (x/a)^2) ] dx

for x in the range -\infty to +\infty. The Cauchy distribution is also known as the Lorentz distribution.

Parameters:

• a (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3162

static VALUE
ran_cauchy(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    
    double a0;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "11" , &v0, &vshape);
    a0 = NUM2DBL(v0);
    
    if (nargs == 1) {
        return rb_float_new(gsl_ran_cauchy(r , a0));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_cauchy(r , a0);
        }
        return vna;
    }
}

#chisq(nu, [shape]) ⇒ Float or DFloat

This function returns a random variate from the chi-squared distribution with nu degrees of freedom. The distribution function is,

p(x) dx = [1 \over 2 \Gamma(\nu/2) ] (x/2)^[\nu/2 - 1] \exp(-x/2) dx

for $x \ge 0$ x >= 0.

Parameters:

• nu (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3624

static VALUE
ran_chisq(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    
    double a0;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "11" , &v0, &vshape);
    a0 = NUM2DBL(v0);
    
    if (nargs == 1) {
        return rb_float_new(gsl_ran_chisq(r , a0));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_chisq(r , a0);
        }
        return vna;
    }
}

#dir_2d([shape]) ⇒ Object

This function returns a random direction vector v = (x,y) in two dimensions. The vector is normalized such that |v|^2 = x^2 + y^2 = 1. The obvious way to do this is to take a uniform random number between 0 and 2\pi and let x and y be the sine and cosine respectively. Two trig functions would have been expensive in the old days, but with modern hardware implementations, this is sometimes the fastest way to go. This is the case for the Pentium (but not the case for the Sun Sparcstation). One can avoid the trig evaluations by choosing x and y in the interior of a unit circle (choose them at random from the interior of the enclosing square, and then reject those that are outside the unit circle), and then dividing by $\sqrt+ y^2$ \sqrt[x^2 + y^2]. A much cleverer approach, attributed to von Neumann (See Knuth, v2, 3rd ed, p140, exercise 23), requires neither trig nor a square root. In this approach, u and v are chosen at random from the interior of a unit circle, and then x=(u^2-v^2)/(u^2+v^2) and y=2uv/(u^2+v^2).

Parameters:

• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• [] returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3936

static VALUE
ran_dir_2d(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vx, vy;
    size_t i, size;
    int nargs;
    double x, y;
    double *px, *py;
    
    
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "01" , &vshape);
    
    if (nargs == 0) {
        gsl_ran_dir_2d(r , &x, &y);
        return rb_assoc_new(DBL2NUM(x),DBL2NUM(y));
    } else {
        vx = create_new_narray(cDF,vshape);
        vy = create_new_narray(cDF,vshape);
        px = (double*)na_get_pointer_for_write(vx);
        py = (double*)na_get_pointer_for_write(vy);
        size = RNARRAY_SIZE(vx);
        for (i=0; i<size; i++) {
            gsl_ran_dir_2d(r , px, py);
            px++; py++;
        }
        return rb_assoc_new(vx,vy);
    }
}

#dir_2d_trig_method([shape]) ⇒ Object

This function returns a random direction vector v = (x,y) in two dimensions. The vector is normalized such that |v|^2 = x^2 + y^2 = 1. The obvious way to do this is to take a uniform random number between 0 and 2\pi and let x and y be the sine and cosine respectively. Two trig functions would have been expensive in the old days, but with modern hardware implementations, this is sometimes the fastest way to go. This is the case for the Pentium (but not the case for the Sun Sparcstation). One can avoid the trig evaluations by choosing x and y in the interior of a unit circle (choose them at random from the interior of the enclosing square, and then reject those that are outside the unit circle), and then dividing by $\sqrt+ y^2$ \sqrt[x^2 + y^2]. A much cleverer approach, attributed to von Neumann (See Knuth, v2, 3rd ed, p140, exercise 23), requires neither trig nor a square root. In this approach, u and v are chosen at random from the interior of a unit circle, and then x=(u^2-v^2)/(u^2+v^2) and y=2uv/(u^2+v^2).

Parameters:

• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• [] returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3996

static VALUE
ran_dir_2d_trig_method(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vx, vy;
    size_t i, size;
    int nargs;
    double x, y;
    double *px, *py;
    
    
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "01" , &vshape);
    
    if (nargs == 0) {
        gsl_ran_dir_2d_trig_method(r , &x, &y);
        return rb_assoc_new(DBL2NUM(x),DBL2NUM(y));
    } else {
        vx = create_new_narray(cDF,vshape);
        vy = create_new_narray(cDF,vshape);
        px = (double*)na_get_pointer_for_write(vx);
        py = (double*)na_get_pointer_for_write(vy);
        size = RNARRAY_SIZE(vx);
        for (i=0; i<size; i++) {
            gsl_ran_dir_2d_trig_method(r , px, py);
            px++; py++;
        }
        return rb_assoc_new(vx,vy);
    }
}

#dir_3d([shape]) ⇒ Array

This function returns 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).

Parameters:

• shape (Array or Integer) —

  (optional) shape for result Numo::NArray

Returns:

• (Array) —

  returns array of [x,y,z], where x,y,z are Float or Numo::DFloat

# File 'ext/numo/gsl/rng/gsl_rng.c', line 4045

static VALUE
ran_dir_3d(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape;
    VALUE v[3];
    size_t i, size;
    int nargs;
    double x, y, z;
    double *px, *py, *pz;
    
    
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "01" , &vshape);
    
    if (nargs == 0) {
        gsl_ran_dir_3d(r , &x, &y, &z);
        v[0] = DBL2NUM(x);
        v[1] = DBL2NUM(y);
        v[2] = DBL2NUM(z);
        return rb_ary_new4(3,v);
    } else {
        v[0] = create_new_narray(cDF,vshape);
        v[1] = create_new_narray(cDF,vshape);
        v[2] = create_new_narray(cDF,vshape);
        px = (double*)na_get_pointer_for_write(v[0]);
        py = (double*)na_get_pointer_for_write(v[1]);
        pz = (double*)na_get_pointer_for_write(v[2]);
        size = RNARRAY_SIZE(v[0]);
        for (i=0; i<size; i++) {
            gsl_ran_dir_3d(r , px, py, pz);
            px++; py++; pz++;
        }
        return rb_ary_new4(3,v);
    }
}

#dirichlet(alpha[]) ⇒ DFloat

This function returns an array of K 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 \ge 0$ theta_i >= 0 and $\alpha_i > 0$ 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$ a=alpha_i, b=1, and renormalizing. See A.M. Law, W.D. Kelton, Simulation Modeling and Analysis (1991).

Parameters:

• alpha[] (DFloat)

Returns:

• (DFloat) —

  theta[]

# File 'ext/numo/gsl/rng/gsl_rng.c', line 4266

static VALUE
ran_dirichlet(VALUE self, VALUE valpha)
{
    VALUE   vtheta;
    double *alpha, *theta;
    narray_t *na;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    valpha = cast_1d_contiguous(valpha, cDF);
    GetNArray(valpha,na);
    vtheta = rb_narray_new(cDF,na->ndim,na->shape);
    theta = (double*)na_get_pointer_for_write(vtheta);
    alpha = (double*)na_get_pointer_for_read(valpha);

    gsl_ran_dirichlet(r, na->size, alpha, theta);
    RB_GC_GUARD(valpha);
    return vtheta;
}

#exponential(mu, [shape]) ⇒ Float or DFloat

This function returns a random variate from the exponential distribution with mean mu. The distribution is,

p(x) dx = [1 \over \mu] \exp(-x/\mu) dx

for $x \ge 0$ x >= 0.

Parameters:

• mu (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3011

static VALUE
ran_exponential(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    
    double a0;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "11" , &v0, &vshape);
    a0 = NUM2DBL(v0);
    
    if (nargs == 1) {
        return rb_float_new(gsl_ran_exponential(r , a0));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_exponential(r , a0);
        }
        return vna;
    }
}

#exppow(a, b, [shape]) ⇒ Float or DFloat

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 \over 2 a \Gamma(1+1/b)] \exp(-

x/a

^b) dx

for $x \ge 0$ 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 = \sqrt2 \sigma$ a = \sqrt[2] \sigma.

Parameters:

• a (Float)
• b (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3110

static VALUE
ran_exppow(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    VALUE v1;
    
    double a0;
    double a1;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "21" , &v0, &v1, &vshape);
    a0 = NUM2DBL(v0);
    a1 = NUM2DBL(v1);
    
    if (nargs == 2) {
        return rb_float_new(gsl_ran_exppow(r , a0, a1));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_exppow(r , a0, a1);
        }
        return vna;
    }
}

#fdist(nu1, nu2, [shape]) ⇒ Float or DFloat

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) \over \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 \ge 0$ x >= 0.

Parameters:

• nu1 (Float)
• nu2 (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3676

static VALUE
ran_fdist(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    VALUE v1;
    
    double a0;
    double a1;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "21" , &v0, &v1, &vshape);
    a0 = NUM2DBL(v0);
    a1 = NUM2DBL(v1);
    
    if (nargs == 2) {
        return rb_float_new(gsl_ran_fdist(r , a0, a1));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_fdist(r , a0, a1);
        }
        return vna;
    }
}

#flat(a, b, [shape]) ⇒ Float or DFloat

This function returns a random variate from the flat (uniform) distribution from a to b. The distribution is,

p(x) dx = [1 \over (b-a)] dx

if $a \le x < b$ a <= x < b and 0 otherwise.

Parameters:

• a (Float)
• b (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3522

static VALUE
ran_flat(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    VALUE v1;
    
    double a0;
    double a1;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "21" , &v0, &v1, &vshape);
    a0 = NUM2DBL(v0);
    a1 = NUM2DBL(v1);
    
    if (nargs == 2) {
        return rb_float_new(gsl_ran_flat(r , a0, a1));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_flat(r , a0, a1);
        }
        return vna;
    }
}

#gamma(a, b, [shape]) ⇒ Float or DFloat

This function returns a random variate from the gamma distribution. The distribution function is,

p(x) dx = [1 \over \Gamma(a) b^a] x^[a-1] e^[-x/b] dx

for x > 0. If X and Y are independent gamma-distributed random variables of order a and b, then X+Y has a gamma distribution of order a+b.

The gamma distribution with an integer parameter a is known as the Erlang distribution.

The variates are computed using the Marsaglia-Tsang fast gamma method. This function for this method was previously called gsl_ran_gamma_mt and can still be accessed using this name.

Parameters:

• a (Float)
• b (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3424

static VALUE
ran_gamma(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    VALUE v1;
    
    double a0;
    double a1;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "21" , &v0, &v1, &vshape);
    a0 = NUM2DBL(v0);
    a1 = NUM2DBL(v1);
    
    if (nargs == 2) {
        return rb_float_new(gsl_ran_gamma(r , a0, a1));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_gamma(r , a0, a1);
        }
        return vna;
    }
}

#gamma_knuth(a, b, [shape]) ⇒ Float or DFloat

This function returns a gamma variate using the algorithms from Knuth (vol 2).

Parameters:

• a (Float)
• b (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3470

static VALUE
ran_gamma_knuth(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    VALUE v1;
    
    double a0;
    double a1;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "21" , &v0, &v1, &vshape);
    a0 = NUM2DBL(v0);
    a1 = NUM2DBL(v1);
    
    if (nargs == 2) {
        return rb_float_new(gsl_ran_gamma_knuth(r , a0, a1));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_gamma_knuth(r , a0, a1);
        }
        return vna;
    }
}

#gaussian(sigma, [shape]) ⇒ Float or DFloat

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 \over \sqrt[2 \pi \sigma^2]] \exp (-x^2 / 2\sigma^2) dx

for x in the range -\infty to +\infty. Use the transformation z = \mu + x on the numbers returned by gsl_ran_gaussian to obtain a Gaussian distribution with mean \mu. This function uses the Box-Muller algorithm which requires two calls to the random number generator r.

Parameters:

• sigma (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 2627

static VALUE
ran_gaussian(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    
    double a0;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "11" , &v0, &vshape);
    a0 = NUM2DBL(v0);
    
    if (nargs == 1) {
        return rb_float_new(gsl_ran_gaussian(r , a0));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_gaussian(r , a0);
        }
        return vna;
    }
}

#gaussian_ratio_method(sigma, [shape]) ⇒ Float or DFloat

This function computes a Gaussian random variate using the alternative Marsaglia-Tsang ziggurat and Kinderman-Monahan-Leva ratio methods. The Ziggurat algorithm is the fastest available algorithm in most cases.

Parameters:

• sigma (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 2715

static VALUE
ran_gaussian_ratio_method(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    
    double a0;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "11" , &v0, &vshape);
    a0 = NUM2DBL(v0);
    
    if (nargs == 1) {
        return rb_float_new(gsl_ran_gaussian_ratio_method(r , a0));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_gaussian_ratio_method(r , a0);
        }
        return vna;
    }
}

#gaussian_tail(a, sigma, [shape]) ⇒ Float or DFloat

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 method is based on Marsaglia’s famous rectangle-wedge-tail algorithm (Ann. Math. Stat. 32, 894–899 (1961)), with this aspect explained in Knuth, v2, 3rd ed, p139,586 (exercise 11).

The probability distribution for Gaussian tail random variates is,

p(x) dx = [1 \over 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)).

Parameters:

• a (Float)
• sigma (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 2852

static VALUE
ran_gaussian_tail(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    VALUE v1;
    
    double a0;
    double a1;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "21" , &v0, &v1, &vshape);
    a0 = NUM2DBL(v0);
    a1 = NUM2DBL(v1);
    
    if (nargs == 2) {
        return rb_float_new(gsl_ran_gaussian_tail(r , a0, a1));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_gaussian_tail(r , a0, a1);
        }
        return vna;
    }
}

#gaussian_ziggurat(sigma, [shape]) ⇒ Float or DFloat

This function computes a Gaussian random variate using the alternative Marsaglia-Tsang ziggurat and Kinderman-Monahan-Leva ratio methods. The Ziggurat algorithm is the fastest available algorithm in most cases.

Parameters:

• sigma (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 2671

static VALUE
ran_gaussian_ziggurat(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    
    double a0;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "11" , &v0, &vshape);
    a0 = NUM2DBL(v0);
    
    if (nargs == 1) {
        return rb_float_new(gsl_ran_gaussian_ziggurat(r , a0));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_gaussian_ziggurat(r , a0);
        }
        return vna;
    }
}

#geometric(p, [shape]) ⇒ Integer or UInt

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 \ge 1$ 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.

Parameters:

• p (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Integer or UInt) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 4567

static VALUE
ran_geometric(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    unsigned int *ptr;
    
    VALUE v0;
    
    double a0;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "11" , &v0, &vshape);
    a0 = NUM2DBL(v0);
    
    if (nargs == 1) {
        return rb_float_new(gsl_ran_geometric(r , a0));
    } else {
        vna = create_new_narray(cUInt,vshape);
        ptr = (unsigned int*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_geometric(r , a0);
        }
        return vna;
    }
}

#gumbel1(a, b, [shape]) ⇒ Float or DFloat

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.

Parameters:

• a (Float)
• b (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 4153

static VALUE
ran_gumbel1(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    VALUE v1;
    
    double a0;
    double a1;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "21" , &v0, &v1, &vshape);
    a0 = NUM2DBL(v0);
    a1 = NUM2DBL(v1);
    
    if (nargs == 2) {
        return rb_float_new(gsl_ran_gumbel1(r , a0, a1));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_gumbel1(r , a0, a1);
        }
        return vna;
    }
}

#gumbel2(a, b, [shape]) ⇒ Float or DFloat

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.

Parameters:

• a (Float)
• b (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 4204

static VALUE
ran_gumbel2(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    VALUE v1;
    
    double a0;
    double a1;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "21" , &v0, &v1, &vshape);
    a0 = NUM2DBL(v0);
    a1 = NUM2DBL(v1);
    
    if (nargs == 2) {
        return rb_float_new(gsl_ran_gumbel2(r , a0, a1));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_gumbel2(r , a0, a1);
        }
        return vna;
    }
}

#hypergeometric(n1, n2, t, [shape]) ⇒ Integer or UInt

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 \leq n_1 + n_2$ t <= n_1 + n_2. The domain of k is $\hboxmax(0,t-n_2), \ldots, \hboxmin(t,n_1)$ max(0,t-n_2), …, min(t,n_1).

If a population contains n_1 elements of type 1'' and n_2 elements oftype 2’’ then the hypergeometric distribution gives the probability of obtaining k elements of ``type 1’’ in t samples from the population without replacement.

Parameters:

• n1 (Integer)
• n2 (Integer)
• t (Integer)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Integer or UInt) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 4627

static VALUE
ran_hypergeometric(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    unsigned int *ptr;
    
    VALUE v0;
    VALUE v1;
    VALUE v2;
    
    unsigned int a0;
    unsigned int a1;
    unsigned int a2;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "31" , &v0, &v1, &v2, &vshape);
    a0 = NUM2UINT(v0);
    a1 = NUM2UINT(v1);
    a2 = NUM2UINT(v2);
    
    if (nargs == 3) {
        return rb_float_new(gsl_ran_hypergeometric(r , a0, a1, a2));
    } else {
        vna = create_new_narray(cUInt,vshape);
        ptr = (unsigned int*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_hypergeometric(r , a0, a1, a2);
        }
        return vna;
    }
}

#landau([shape]) ⇒ Float or DFloat

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).

Parameters:

• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3310

static VALUE
ran_landau(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "01" , &vshape);
    
    if (nargs == 0) {
        return rb_float_new(gsl_ran_landau(r ));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_landau(r );
        }
        return vna;
    }
}

#laplace(a, [shape]) ⇒ Float or DFloat

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.

Parameters:

• a (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3058

static VALUE
ran_laplace(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    
    double a0;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "11" , &v0, &vshape);
    a0 = NUM2DBL(v0);
    
    if (nargs == 1) {
        return rb_float_new(gsl_ran_laplace(r , a0));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_laplace(r , a0);
        }
        return vna;
    }
}

#levy(c, alpha, [shape]) ⇒ Float or DFloat

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 = \sqrt2 c$ \sigma = \sqrt[2] c. For \alpha < 1 the tails of the distribution become extremely wide.

The algorithm only works for $0 < \alpha \le 2$ 0 < alpha <= 2.

Parameters:

• c (Float)
• alpha (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3364

static VALUE
ran_levy(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    VALUE v1;
    
    double a0;
    double a1;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "21" , &v0, &v1, &vshape);
    a0 = NUM2DBL(v0);
    a1 = NUM2DBL(v1);
    
    if (nargs == 2) {
        return rb_float_new(gsl_ran_levy(r , a0, a1));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_levy(r , a0, a1);
        }
        return vna;
    }
}

#logarithmic(p, [shape]) ⇒ Integer or UInt

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 \ge 1$ k >= 1.

Parameters:

• p (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Integer or UInt) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 4682

static VALUE
ran_logarithmic(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    unsigned int *ptr;
    
    VALUE v0;
    
    double a0;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "11" , &v0, &vshape);
    a0 = NUM2DBL(v0);
    
    if (nargs == 1) {
        return rb_float_new(gsl_ran_logarithmic(r , a0));
    } else {
        vna = create_new_narray(cUInt,vshape);
        ptr = (unsigned int*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_logarithmic(r , a0);
        }
        return vna;
    }
}

#logistic(a, [shape]) ⇒ Float or DFloat

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.

Parameters:

• a (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3826

static VALUE
ran_logistic(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    
    double a0;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "11" , &v0, &vshape);
    a0 = NUM2DBL(v0);
    
    if (nargs == 1) {
        return rb_float_new(gsl_ran_logistic(r , a0));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_logistic(r , a0);
        }
        return vna;
    }
}

#lognormal(zeta, sigma, [shape]) ⇒ Float or DFloat

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.

Parameters:

• zeta (Float)
• sigma (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3573

static VALUE
ran_lognormal(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    VALUE v1;
    
    double a0;
    double a1;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "21" , &v0, &v1, &vshape);
    a0 = NUM2DBL(v0);
    a1 = NUM2DBL(v1);
    
    if (nargs == 2) {
        return rb_float_new(gsl_ran_lognormal(r , a0, a1));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_lognormal(r , a0, a1);
        }
        return vna;
    }
}

#multinomial(N, p[]) ⇒ UInt

This function computes 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$, $\ldots$, $n_K$) (n_1, n_2, …, n_K) are nonnegative integers with $\sum_k=1^K n_k =N$ sum_[k=1]^K n_k = N, and $(p_1, p_2, \ldots, p_K)$ (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. The arrays n[] and p[] must both be of length K.

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).

Parameters:

• N (Integer)
• p[] (DFloat)

Returns:

• (UInt) —

  n[]

# File 'ext/numo/gsl/rng/gsl_rng.c', line 4469

static VALUE
ran_multinomial(VALUE self, VALUE vN, VALUE vp)
{
    VALUE vn;
    double *p;
    unsigned int *n;
    unsigned int  N;
    narray_t *na;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    N = NUM2UINT(vN);
    vp = cast_1d_contiguous(vp, cDF);
    GetNArray(vp,na);
    p = (double*)na_get_pointer_for_read(vp);
    vn = rb_narray_new(cUInt,na->ndim,na->shape);
    n = (unsigned int*)na_get_pointer_for_write(vn);

    gsl_ran_multinomial(r, na->size, N, p, n);
    RB_GC_GUARD(vp);
    return vn;
}

#pareto(a, b, [shape]) ⇒ Float or DFloat

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 \ge b$ x >= b.

Parameters:

• a (Float)
• b (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3875

static VALUE
ran_pareto(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    VALUE v1;
    
    double a0;
    double a1;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "21" , &v0, &v1, &vshape);
    a0 = NUM2DBL(v0);
    a1 = NUM2DBL(v1);
    
    if (nargs == 2) {
        return rb_float_new(gsl_ran_pareto(r , a0, a1));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_pareto(r , a0, a1);
        }
        return vna;
    }
}

#pascal(p, n, [shape]) ⇒ Integer or UInt

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)! \over k! (n - 1)! ] p^n (1-p)^k

for $k \ge 0$ k >= 0

Parameters:

• p (Float)
• n (Integer)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Integer or UInt) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 4512

static VALUE
ran_pascal(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    unsigned int *ptr;
    
    VALUE v0;
    VALUE v1;
    
    double a0;
    unsigned int a1;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "21" , &v0, &v1, &vshape);
    a0 = NUM2DBL(v0);
    a1 = NUM2UINT(v1);
    
    if (nargs == 2) {
        return rb_float_new(gsl_ran_pascal(r , a0, a1));
    } else {
        vna = create_new_narray(cUInt,vshape);
        ptr = (unsigned int*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_pascal(r , a0, a1);
        }
        return vna;
    }
}

#poisson(mu, [shape]) ⇒ Integer or UInt

This function returns a random integer from the Poisson distribution with mean mu. The probability distribution for Poisson variates is,

p(k) = [\mu^k \over k!] \exp(-\mu)

for $k \ge 0$ k >= 0.

Parameters:

• mu (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Integer or UInt) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 4304

static VALUE
ran_poisson(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    unsigned int *ptr;
    
    VALUE v0;
    
    double a0;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "11" , &v0, &vshape);
    a0 = NUM2DBL(v0);
    
    if (nargs == 1) {
        return rb_float_new(gsl_ran_poisson(r , a0));
    } else {
        vna = create_new_narray(cUInt,vshape);
        ptr = (unsigned int*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_poisson(r , a0);
        }
        return vna;
    }
}

#rayleigh(sigma, [shape]) ⇒ Float or DFloat

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.

Parameters:

• sigma (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3209

static VALUE
ran_rayleigh(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    
    double a0;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "11" , &v0, &vshape);
    a0 = NUM2DBL(v0);
    
    if (nargs == 1) {
        return rb_float_new(gsl_ran_rayleigh(r , a0));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_rayleigh(r , a0);
        }
        return vna;
    }
}

#rayleigh_tail(a, sigma, [shape]) ⇒ Float or DFloat

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.

Parameters:

• a (Float)
• sigma (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3258

static VALUE
ran_rayleigh_tail(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    VALUE v1;
    
    double a0;
    double a1;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "21" , &v0, &v1, &vshape);
    a0 = NUM2DBL(v0);
    a1 = NUM2DBL(v1);
    
    if (nargs == 2) {
        return rb_float_new(gsl_ran_rayleigh_tail(r , a0, a1));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_rayleigh_tail(r , a0, a1);
        }
        return vna;
    }
}

#tdist(nu, [shape]) ⇒ Float or DFloat

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.

Parameters:

• nu (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 3727

static VALUE
ran_tdist(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    
    double a0;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "11" , &v0, &vshape);
    a0 = NUM2DBL(v0);
    
    if (nargs == 1) {
        return rb_float_new(gsl_ran_tdist(r , a0));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_tdist(r , a0);
        }
        return vna;
    }
}

#ugaussian([shape]) ⇒ Float or DFloat

These functions compute results for the unit Gaussian distribution. They are equivalent to the functions above with a standard deviation of one, sigma = 1.

Parameters:

• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 2758

static VALUE
ran_ugaussian(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "01" , &vshape);
    
    if (nargs == 0) {
        return rb_float_new(gsl_ran_ugaussian(r ));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_ugaussian(r );
        }
        return vna;
    }
}

#ugaussian_ratio_method([shape]) ⇒ Float or DFloat

These functions compute results for the unit Gaussian distribution. They are equivalent to the functions above with a standard deviation of one, sigma = 1.

Parameters:

• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 2798

static VALUE
ran_ugaussian_ratio_method(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "01" , &vshape);
    
    if (nargs == 0) {
        return rb_float_new(gsl_ran_ugaussian_ratio_method(r ));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_ugaussian_ratio_method(r );
        }
        return vna;
    }
}

#ugaussian_tail(a, [shape]) ⇒ Float or DFloat

These functions compute results for the tail of a unit Gaussian distribution. They are equivalent to the functions above with a standard deviation of one, sigma = 1.

Parameters:

• a (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 2899

static VALUE
ran_ugaussian_tail(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    
    double a0;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "11" , &v0, &vshape);
    a0 = NUM2DBL(v0);
    
    if (nargs == 1) {
        return rb_float_new(gsl_ran_ugaussian_tail(r , a0));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_ugaussian_tail(r , a0);
        }
        return vna;
    }
}

#weibull(a, b, [shape]) ⇒ Float or DFloat

This function returns a random variate from the Weibull distribution. The distribution function is,

p(x) dx = [b \over a^b] x^[b-1] \exp(-(x/a)^b) dx

for $x \ge 0$ x >= 0.

Parameters:

• a (Float)
• b (Float)
• shape (Array or Integer) —

  (optional) shape for result NArray

Returns:

• (Float or DFloat) —

  returns random number

# File 'ext/numo/gsl/rng/gsl_rng.c', line 4102

static VALUE
ran_weibull(int argc, VALUE *argv, VALUE self)
{
    VALUE vshape, vna;
    size_t i, size;
    int nargs;
    double *ptr;
    
    VALUE v0;
    VALUE v1;
    
    double a0;
    double a1;
    gsl_rng *r;

    TypedData_Get_Struct(self, gsl_rng, &rng_data_type, r);

    nargs = rb_scan_args(argc, argv, "21" , &v0, &v1, &vshape);
    a0 = NUM2DBL(v0);
    a1 = NUM2DBL(v1);
    
    if (nargs == 2) {
        return rb_float_new(gsl_ran_weibull(r , a0, a1));
    } else {
        vna = create_new_narray(cDF,vshape);
        ptr = (double*)na_get_pointer_for_write(vna);
        size = RNARRAY_SIZE(vna);
        for (i=0; i<size; i++) {
            ptr[i] = gsl_ran_weibull(r , a0, a1);
        }
        return vna;
    }
}