C API for random

Access to various distributions below is available via Cython or C-wrapper libraries like CFFI. All the functions accept a bitgen_t as their first argument. To access these from Cython or C, you must link with the npyrandom static library which is part of the NumPy distribution, located in numpy/random/lib. Note that you must also link with npymath, see Linking against the core math library in an extension.

typebitgen_t

The bitgen_t holds the current state of the BitGenerator and pointers to functions that return standard C types while advancing the state.

struct bitgen:
    void *state
    npy_uint64 (*next_uint64)(void *st) nogil
    uint32_t (*next_uint32)(void *st) nogil
    double (*next_double)(void *st) nogil
    npy_uint64 (*next_raw)(void *st) nogil

ctypedef bitgen bitgen_t

See Extending for examples of using these functions.

The functions are named with the following conventions:

• “standard” refers to the reference values for any parameters. For instance “standard_uniform” means a uniform distribution on the interval 0.0 to 1.0
• “fill” functions will fill the provided out with cnt values.
• The functions without “standard” in their name require additional parameters to describe the distributions.
• Functions with inv in their name are based on the slower inverse method instead of a ziggurat lookup algorithm, which is significantly faster. The non-ziggurat variants are used in corner cases and for legacy compatibility.

doublerandom_standard_uniform(bitgen_t*bitgen_state)

voidrandom_standard_uniform_fill(bitgen_t*bitgen_state, npy_intpcnt, double*out)

doublerandom_standard_exponential(bitgen_t*bitgen_state)

voidrandom_standard_exponential_fill(bitgen_t*bitgen_state, npy_intpcnt, double*out)

voidrandom_standard_exponential_inv_fill(bitgen_t*bitgen_state, npy_intpcnt, double*out)

doublerandom_standard_normal(bitgen_t*bitgen_state)

voidrandom_standard_normal_fill(bitgen_t*bitgen_state, npy_intpcount, double*out)

voidrandom_standard_normal_fill_f(bitgen_t*bitgen_state, npy_intpcount, float*out)

doublerandom_standard_gamma(bitgen_t*bitgen_state, doubleshape)

floatrandom_standard_uniform_f(bitgen_t*bitgen_state)

voidrandom_standard_uniform_fill_f(bitgen_t*bitgen_state, npy_intpcnt, float*out)

floatrandom_standard_exponential_f(bitgen_t*bitgen_state)

voidrandom_standard_exponential_fill_f(bitgen_t*bitgen_state, npy_intpcnt, float*out)

voidrandom_standard_exponential_inv_fill_f(bitgen_t*bitgen_state, npy_intpcnt, float*out)

floatrandom_standard_normal_f(bitgen_t*bitgen_state)

floatrandom_standard_gamma_f(bitgen_t*bitgen_state, floatshape)

doublerandom_normal(bitgen_t*bitgen_state, doubleloc, doublescale)

doublerandom_gamma(bitgen_t*bitgen_state, doubleshape, doublescale)

floatrandom_gamma_f(bitgen_t*bitgen_state, floatshape, floatscale)

doublerandom_exponential(bitgen_t*bitgen_state, doublescale)

doublerandom_uniform(bitgen_t*bitgen_state, doublelower, doublerange)

doublerandom_beta(bitgen_t*bitgen_state, doublea, doubleb)

doublerandom_chisquare(bitgen_t*bitgen_state, doubledf)

doublerandom_f(bitgen_t*bitgen_state, doubledfnum, doubledfden)

doublerandom_standard_cauchy(bitgen_t*bitgen_state)

doublerandom_pareto(bitgen_t*bitgen_state, doublea)

doublerandom_weibull(bitgen_t*bitgen_state, doublea)

doublerandom_power(bitgen_t*bitgen_state, doublea)

doublerandom_laplace(bitgen_t*bitgen_state, doubleloc, doublescale)

doublerandom_gumbel(bitgen_t*bitgen_state, doubleloc, doublescale)

doublerandom_logistic(bitgen_t*bitgen_state, doubleloc, doublescale)

doublerandom_lognormal(bitgen_t*bitgen_state, doublemean, doublesigma)

doublerandom_rayleigh(bitgen_t*bitgen_state, doublemode)

doublerandom_standard_t(bitgen_t*bitgen_state, doubledf)

doublerandom_noncentral_chisquare(bitgen_t*bitgen_state, doubledf, doublenonc)

doublerandom_noncentral_f(bitgen_t*bitgen_state, doubledfnum, doubledfden, doublenonc)

doublerandom_wald(bitgen_t*bitgen_state, doublemean, doublescale)

doublerandom_vonmises(bitgen_t*bitgen_state, doublemu, doublekappa)

doublerandom_triangular(bitgen_t*bitgen_state, doubleleft, doublemode, doubleright)

npy_int64random_poisson(bitgen_t*bitgen_state, doublelam)

npy_int64random_negative_binomial(bitgen_t*bitgen_state, doublen, doublep)

typebinomial_t

typedef struct s_binomial_t {
  int has_binomial; /* !=0: following parameters initialized for binomial */
  double psave;
  RAND_INT_TYPE nsave;
  double r;
  double q;
  double fm;
  RAND_INT_TYPE m;
  double p1;
  double xm;
  double xl;
  double xr;
  double c;
  double laml;
  double lamr;
  double p2;
  double p3;
  double p4;
} binomial_t;

npy_int64random_binomial(bitgen_t*bitgen_state, doublep, npy_int64n, binomial_t*binomial)

npy_int64random_logseries(bitgen_t*bitgen_state, doublep)

npy_int64random_geometric_search(bitgen_t*bitgen_state, doublep)

npy_int64random_geometric_inversion(bitgen_t*bitgen_state, doublep)

npy_int64random_geometric(bitgen_t*bitgen_state, doublep)

npy_int64random_zipf(bitgen_t*bitgen_state, doublea)

npy_int64random_hypergeometric(bitgen_t*bitgen_state, npy_int64good, npy_int64bad, npy_int64sample)

npy_uint64random_interval(bitgen_t*bitgen_state, npy_uint64max)

voidrandom_multinomial(bitgen_t*bitgen_state, npy_int64n, npy_int64*mnix, double*pix, npy_intpd, binomial_t*binomial)

intrandom_multivariate_hypergeometric_count(bitgen_t*bitgen_state, npy_int64total, size_tnum_colors, npy_int64*colors, npy_int64nsample, size_tnum_variates, npy_int64*variates)

voidrandom_multivariate_hypergeometric_marginals(bitgen_t*bitgen_state, npy_int64total, size_tnum_colors, npy_int64*colors, npy_int64nsample, size_tnum_variates, npy_int64*variates)

Generate a single integer

npy_int64random_positive_int64(bitgen_t*bitgen_state)

npy_int32random_positive_int32(bitgen_t*bitgen_state)

npy_int64random_positive_int(bitgen_t*bitgen_state)

npy_uint64random_uint(bitgen_t*bitgen_state)

Generate random uint64 numbers in closed interval [off, off + rng].

npy_uint64random_bounded_uint64(bitgen_t*bitgen_state, npy_uint64off, npy_uint64rng, npy_uint64mask, booluse_masked)