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.

type bitgen_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.

double random_standard_uniform(bitgen_t *bitgen_state)#

void random_standard_uniform_fill(bitgen_t *bitgen_state, npy_intp cnt, double *out)#

double random_standard_exponential(bitgen_t *bitgen_state)#

void random_standard_exponential_fill(bitgen_t *bitgen_state, npy_intp cnt, double *out)#

void random_standard_exponential_inv_fill(bitgen_t *bitgen_state, npy_intp cnt, double *out)#

double random_standard_normal(bitgen_t *bitgen_state)#

void random_standard_normal_fill(bitgen_t *bitgen_state, npy_intp count, double *out)#

void random_standard_normal_fill_f(bitgen_t *bitgen_state, npy_intp count, float *out)#

double random_standard_gamma(bitgen_t *bitgen_state, double shape)#

float random_standard_uniform_f(bitgen_t *bitgen_state)#

void random_standard_uniform_fill_f(bitgen_t *bitgen_state, npy_intp cnt, float *out)#

float random_standard_exponential_f(bitgen_t *bitgen_state)#

void random_standard_exponential_fill_f(bitgen_t *bitgen_state, npy_intp cnt, float *out)#

void random_standard_exponential_inv_fill_f(bitgen_t *bitgen_state, npy_intp cnt, float *out)#

float random_standard_normal_f(bitgen_t *bitgen_state)#

float random_standard_gamma_f(bitgen_t *bitgen_state, float shape)#

double random_normal(bitgen_t *bitgen_state, double loc, double scale)#

double random_gamma(bitgen_t *bitgen_state, double shape, double scale)#

float random_gamma_f(bitgen_t *bitgen_state, float shape, float scale)#

double random_exponential(bitgen_t *bitgen_state, double scale)#

double random_uniform(bitgen_t *bitgen_state, double lower, double range)#

double random_beta(bitgen_t *bitgen_state, double a, double b)#

double random_chisquare(bitgen_t *bitgen_state, double df)#

double random_f(bitgen_t *bitgen_state, double dfnum, double dfden)#

double random_standard_cauchy(bitgen_t *bitgen_state)#

double random_pareto(bitgen_t *bitgen_state, double a)#

double random_weibull(bitgen_t *bitgen_state, double a)#

double random_power(bitgen_t *bitgen_state, double a)#

double random_laplace(bitgen_t *bitgen_state, double loc, double scale)#

double random_gumbel(bitgen_t *bitgen_state, double loc, double scale)#

double random_logistic(bitgen_t *bitgen_state, double loc, double scale)#

double random_lognormal(bitgen_t *bitgen_state, double mean, double sigma)#

double random_rayleigh(bitgen_t *bitgen_state, double mode)#

double random_standard_t(bitgen_t *bitgen_state, double df)#

double random_noncentral_chisquare(bitgen_t *bitgen_state, double df, double nonc)#

double random_noncentral_f(bitgen_t *bitgen_state, double dfnum, double dfden, double nonc)#

double random_wald(bitgen_t *bitgen_state, double mean, double scale)#

double random_vonmises(bitgen_t *bitgen_state, double mu, double kappa)#

double random_triangular(bitgen_t *bitgen_state, double left, double mode, double right)#

npy_int64 random_poisson(bitgen_t *bitgen_state, double lam)#

npy_int64 random_negative_binomial(bitgen_t *bitgen_state, double n, double p)#

type binomial_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_int64 random_binomial(bitgen_t *bitgen_state, double p, npy_int64 n, binomial_t *binomial)#

npy_int64 random_logseries(bitgen_t *bitgen_state, double p)#

npy_int64 random_geometric_search(bitgen_t *bitgen_state, double p)#

npy_int64 random_geometric_inversion(bitgen_t *bitgen_state, double p)#

npy_int64 random_geometric(bitgen_t *bitgen_state, double p)#

npy_int64 random_zipf(bitgen_t *bitgen_state, double a)#

npy_int64 random_hypergeometric(bitgen_t *bitgen_state, npy_int64 good, npy_int64 bad, npy_int64 sample)#

npy_uint64 random_interval(bitgen_t *bitgen_state, npy_uint64 max)#

void random_multinomial(bitgen_t *bitgen_state, npy_int64 n, npy_int64 *mnix, double *pix, npy_intp d, binomial_t *binomial)#

int random_multivariate_hypergeometric_count(bitgen_t *bitgen_state, npy_int64 total, size_t num_colors, npy_int64 *colors, npy_int64 nsample, size_t num_variates, npy_int64 *variates)#

void random_multivariate_hypergeometric_marginals(bitgen_t *bitgen_state, npy_int64 total, size_t num_colors, npy_int64 *colors, npy_int64 nsample, size_t num_variates, npy_int64 *variates)#

Generate a single integer

npy_int64 random_positive_int64(bitgen_t *bitgen_state)#

npy_int32 random_positive_int32(bitgen_t *bitgen_state)#

npy_int64 random_positive_int(bitgen_t *bitgen_state)#

npy_uint64 random_uint(bitgen_t *bitgen_state)#

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

npy_uint64 random_bounded_uint64(bitgen_t *bitgen_state, npy_uint64 off, npy_uint64 rng, npy_uint64 mask, bool use_masked)#