Univariate Continuous Distribution APIs#

Univariate Continuous Distribution Functions#

randbeta()#

void SRANDBETA(rng_int_t *n, float *a, float *b, rng_int_t *state, float *x, rng_int_t *info)#
void DRANDBETA(rng_int_t *n, double *a, double *b, rng_int_t *state, double *x, rng_int_t *info)#
void srandbeta_(rng_int_t *n, float *a, float *b, rng_int_t *state, float *x, rng_int_t *info)#
void drandbeta_(rng_int_t *n, double *a, double *b, rng_int_t *state, double *x, rng_int_t *info)#
void srandbeta(rng_int_t n, float a, float b, rng_int_t *state, float *x, rng_int_t *info)#
void drandbeta(rng_int_t n, double a, double b, rng_int_t *state, double *x, rng_int_t *info)#

Returns a vector of double precision pseudo-random numbers from beta distribution.

Parameters:
  • n – [in] Number of values to return, n >= 0

  • a – [in] First parameter of the distribution, a > 0

  • b – [in] Second parameter of the distribution, b > 0

  • state – [out] On Entry: Current state of the base generator being used. state must have first been initialized with a call to drandinitialize On Exit: State of generator after n- values are generated

  • x – [out] Vector of n values from the beta distribution, x(n)

  • info – [out]

    Error code

    0 = Everything OK

    -1 to -4 = Error in parameter, abs(info)

randcauchy()#

void SRANDCAUCHY(rng_int_t *n, float *a, float *b, rng_int_t *state, float *x, rng_int_t *info)#
void DRANDCAUCHY(rng_int_t *n, double *a, double *b, rng_int_t *state, double *x, rng_int_t *info)#
void srandcauchy_(rng_int_t *n, float *a, float *b, rng_int_t *state, float *x, rng_int_t *info)#
void drandcauchy_(rng_int_t *n, double *a, double *b, rng_int_t *state, double *x, rng_int_t *info)#
void srandcauchy(rng_int_t n, float a, float b, rng_int_t *state, float *x, rng_int_t *info)#
void drandcauchy(rng_int_t n, double a, double b, rng_int_t *state, double *x, rng_int_t *info)#

Returns a vector of double precision pseudo-random numbers from cauchy distribution.

Parameters:
  • n – [in] Number of values to return, n > 0

  • a – [in] Median

  • b – [in] Semi-quartile range, b >= 0.0

  • state – [inout] On Entry: Current state of the base generator being used. state must have first been initialized with a call to drandinitialize On Exit: State of generator after n- values are generated

  • x – [out] Vector of n- values from the cauchy distribution, x(n)

  • info – [out]

    Error code

    0 = Everything OK

    -1 to -4 = Error in parameter, abs(info)

randchisquared()#

void SRANDCHISQUARED(rng_int_t *n, rng_int_t *df, rng_int_t *state, float *x, rng_int_t *info)#
void DRANDCHISQUARED(rng_int_t *n, rng_int_t *df, rng_int_t *state, double *x, rng_int_t *info)#
void srandchisquared_(rng_int_t *n, rng_int_t *df, rng_int_t *state, float *x, rng_int_t *info)#
void drandchisquared_(rng_int_t *n, rng_int_t *df, rng_int_t *state, double *x, rng_int_t *info)#
void srandchisquared(rng_int_t n, rng_int_t df, rng_int_t *state, float *x, rng_int_t *info)#
void drandchisquared(rng_int_t n, rng_int_t df, rng_int_t *state, double *x, rng_int_t *info)#

Returns a vector of double precision pseudo-random numbers from chi-squared distribution.

Parameters:
  • n – [in] Number of values to return, n > 0

  • df – [in] Degrees of freedom, df > 0

  • state – [inout] On Entry: Current state of the base generator being used. state must have first been initialized with a call to drandinitialize On Exit: State of generator after n- values are generated

  • x – [out] Vector of n- values from the chi-squared distribution, x(n)

  • info – [out]

    Error code

    0 = Everything OK

    -1 to -3 = Error in parameter, abs(info)

randexponential()#

void SRANDEXPONENTIAL(rng_int_t *n, float *a, rng_int_t *state, float *x, rng_int_t *info)#
void DRANDEXPONENTIAL(rng_int_t *n, double *a, rng_int_t *state, double *x, rng_int_t *info)#
void srandexponential_(rng_int_t *n, float *a, rng_int_t *state, float *x, rng_int_t *info)#
void drandexponential_(rng_int_t *n, double *a, rng_int_t *state, double *x, rng_int_t *info)#
void srandexponential(rng_int_t n, float a, rng_int_t *state, float *x, rng_int_t *info)#
void drandexponential(rng_int_t n, double a, rng_int_t *state, double *x, rng_int_t *info)#

Returns a vector of double precision pseudo-random numbers from exponential distribution.

Parameters:
  • n – [in] Number of values to return, n > 0

  • a – [in] Expontential parameter, a >= 0.0

  • state – [inout] On Entry: Current state of the base generator being used. state must have first been initialized with a call to drandinitialize On Exit: State of generator after n- values are generated

  • x – [out] Vector of n- values from the exponential distribution, x(n)

  • info – [out]

    Error code

    0 = Everything OK

    -1 to -3 = Error in parameter, abs(info)

randf()#

void SRANDF(rng_int_t *n, rng_int_t *df1, rng_int_t *df2, rng_int_t *state, float *x, rng_int_t *info)#
void DRANDF(rng_int_t *n, rng_int_t *df1, rng_int_t *df2, rng_int_t *state, double *x, rng_int_t *info)#
void srandf_(rng_int_t *n, rng_int_t *df1, rng_int_t *df2, rng_int_t *state, float *x, rng_int_t *info)#
void drandf_(rng_int_t *n, rng_int_t *df1, rng_int_t *df2, rng_int_t *state, double *x, rng_int_t *info)#
void srandf(rng_int_t n, rng_int_t df1, rng_int_t df2, rng_int_t *state, float *x, rng_int_t *info)#
void drandf(rng_int_t n, rng_int_t df1, rng_int_t df2, rng_int_t *state, double *x, rng_int_t *info)#

Returns a vector of double precision pseudo-random numbers from F- distribution.

Parameters:
  • n – [in] Number of values to return, n > 0

  • df1 – [in] First degrees of freedom, df1 > 0

  • df2 – [in] Second degrees of freedom, df2 > 0

  • state – [inout] On Entry: Current state of the base generator being used. state must have first been initialized with a call to drandinitialize On Exit: State of generator after n- values are generated

  • x – [out] Vector of n- values from the F- distribution, x(n)

  • info – [out]

    Error code

    0 = Everything OK

    -1 to -4 = Error in parameter, abs(info)

randgamma()#

void SRANDGAMMA(rng_int_t *n, float *a, float *b, rng_int_t *state, float *x, rng_int_t *info)#
void DRANDGAMMA(rng_int_t *n, double *a, double *b, rng_int_t *state, double *x, rng_int_t *info)#
void srandgamma_(rng_int_t *n, float *a, float *b, rng_int_t *state, float *x, rng_int_t *info)#
void drandgamma_(rng_int_t *n, double *a, double *b, rng_int_t *state, double *x, rng_int_t *info)#
void srandgamma(rng_int_t n, float a, float b, rng_int_t *state, float *x, rng_int_t *info)#
void drandgamma(rng_int_t n, double a, double b, rng_int_t *state, double *x, rng_int_t *info)#

Returns a vector of double precision pseudo-random numbers from exponential distribution.

Parameters:
  • n – [in] Number of values to return, n > 0

  • a – [in] First parameter of the distribution, a > 0

  • b – [in] Second parameter of the distribution, b > 0

  • state – [inout] On Entry: Current state of the base generator being used. state must have first been initialized with a call to drandinitialize On Exit: State of generator after n- values are generated

  • x – [out] Vector of n- values from the gamma distribution, x(n)

  • info – [out]

    Error code

    0 = Everything OK

    -1 to - 4 = Error in parameter, abs(info)

randgaussian()#

void SRANDGAUSSIAN(rng_int_t *n, float *xmu, float *var, rng_int_t *state, float *x, rng_int_t *info)#
void DRANDGAUSSIAN(rng_int_t *n, double *xmu, double *var, rng_int_t *state, double *x, rng_int_t *info)#
void srandgaussian_(rng_int_t *n, float *xmu, float *var, rng_int_t *state, float *x, rng_int_t *info)#
void drandgaussian_(rng_int_t *n, double *xmu, double *var, rng_int_t *state, double *x, rng_int_t *info)#
void srandgaussian(rng_int_t n, float xmu, float var, rng_int_t *state, float *x, rng_int_t *info)#
void drandgaussian(rng_int_t n, double xmu, double var, rng_int_t *state, double *x, rng_int_t *info)#

Returns a vector of double precision pseudo-random numbers from gaussian (or normal) distribution.

Parameters:
  • n – [in] Number of values return, n > 0

  • xmu – [in] Mean of distribution

  • var – [in] Variance of distribution, var >= 0.0

  • state – [inout] On Entry: Current state of the base generator being used. state must have first been initialized with a call to drandinitialize On Exit: State of generator after n- values are generated

  • x – [out] Vector of n- values from the gaussian distribution, x(n)

  • info – [out]

    Error code

    0 = Everything OK

    -1 to -4 = Error in parameter, abs(info)

randlogistic()#

void SRANDLOGISTIC(rng_int_t *n, float *a, float *b, rng_int_t *state, float *x, rng_int_t *info)#
void DRANDLOGISTIC(rng_int_t *n, double *a, double *b, rng_int_t *state, double *x, rng_int_t *info)#
void srandlogistic_(rng_int_t *n, float *a, float *b, rng_int_t *state, float *x, rng_int_t *info)#
void drandlogistic_(rng_int_t *n, double *a, double *b, rng_int_t *state, double *x, rng_int_t *info)#
void srandlogistic(rng_int_t n, float a, float b, rng_int_t *state, float *x, rng_int_t *info)#
void drandlogistic(rng_int_t n, double a, double b, rng_int_t *state, double *x, rng_int_t *info)#

Returns a vector of double precision pseudo-random numbers from logistic distribution.

Parameters:
  • n – [in] Number of values to return, n > 0

  • a – [in] Mean of distribution

  • b – [in] Spread of distribution, b = sqrt(3)/PI * standard deviation, b > 0.0

  • state – [inout] On Entry: Current state of the base generator being used. state must have first been initialized with a call to drandinitialize On Exit: State of generator after n- values are generated

  • x – [out] Vector of n- values from the logistic distribution, x(n)

  • info – [out]

    Error code

    0 = Everything OK

    -1 to -4 = Error in parameter, abs(info)

randlognormal()#

void SRANDLOGNORMAL(rng_int_t *n, float *xmu, float *var, rng_int_t *state, float *x, rng_int_t *info)#
void DRANDLOGNORMAL(rng_int_t *n, double *xmu, double *var, rng_int_t *state, double *x, rng_int_t *info)#
void srandlognormal_(rng_int_t *n, float *xmu, float *var, rng_int_t *state, float *x, rng_int_t *info)#
void drandlognormal_(rng_int_t *n, double *xmu, double *var, rng_int_t *state, double *x, rng_int_t *info)#
void srandlognormal(rng_int_t n, float xmu, float var, rng_int_t *state, float *x, rng_int_t *info)#
void drandlognormal(rng_int_t n, double xmu, double var, rng_int_t *state, double *x, rng_int_t *info)#

Returns a vector of double precision pseudo-random numbers from log-normal distribution based on underlying normal distribution of n(xmu,var)

Parameters:
  • n – [in] Number of values to return, n > 0

  • xmu – [in] Mean of the underlying normal distribution

  • var – [in] Variance of the underlying normal distribution, var >= 0.0

  • state – [inout] On Entry: Current state of the base generator being used. state must have first been initialized with a call to drandinitialize On Exit: State of generator after n- values are generated

  • x – [out] Vector of n- values from the log-normal distribution, x(n)

  • info – [out]

    Error code

    0 = Everything OK

    -1 to -4 = Error in parameter, abs(info)

randstudentst()#

void SRANDSTUDENTST(rng_int_t *n, rng_int_t *df, rng_int_t *state, float *x, rng_int_t *info)#
void DRANDSTUDENTST(rng_int_t *n, rng_int_t *df, rng_int_t *state, double *x, rng_int_t *info)#
void srandstudentst_(rng_int_t *n, rng_int_t *df, rng_int_t *state, float *x, rng_int_t *info)#
void drandstudentst_(rng_int_t *n, rng_int_t *df, rng_int_t *state, double *x, rng_int_t *info)#
void srandstudentst(rng_int_t n, rng_int_t df, rng_int_t *state, float *x, rng_int_t *info)#
void drandstudentst(rng_int_t n, rng_int_t df, rng_int_t *state, double *x, rng_int_t *info)#

Returns a vector of double precision pseudo-random numbers from students t distribution.

Parameters:
  • n – [in] Number of values to return, n > 0

  • df – [in] Degrees of freedom, df > 0

  • state – [inout] On Entry: Current state of the base generator being used. state must have first been initialized with a call to drandinitialize On Exit: State of generator after n- values are generated

  • x – [out] Vector of n- values from the von mises distribution, x(n)

  • info – [out]

    Error code

    0 = Everything OK

    -1 to -3 = Error in parameter, abs(info)

randtriangular()#

void SRANDTRIANGULAR(rng_int_t *n, float *xmin, float *xmed, float *xmax, rng_int_t *state, float *x, rng_int_t *info)#
void DRANDTRIANGULAR(rng_int_t *n, double *xmin, double *xmed, double *xmax, rng_int_t *state, double *x, rng_int_t *info)#
void srandtriangular_(rng_int_t *n, float *xmin, float *xmed, float *xmax, rng_int_t *state, float *x, rng_int_t *info)#
void drandtriangular_(rng_int_t *n, double *xmin, double *xmed, double *xmax, rng_int_t *state, double *x, rng_int_t *info)#
void srandtriangular(rng_int_t n, float xmin, float xmed, float xmax, rng_int_t *state, float *x, rng_int_t *info)#
void drandtriangular(rng_int_t n, double xmin, double xmed, double xmax, rng_int_t *state, double *x, rng_int_t *info)#

Returns a vector of double precision pseudo-random numbers from triangular distribution.

Parameters:
  • n – [in] Number of values to return, n > 0

  • xmin – [in] Minimum of distribution

  • xmed – [in] Median of distribution, xmin <= xmed <= xmax

  • xmax – [in] Maximum of distribution

  • state – [inout] On Entry: Current state of the base generator being used. state must have first been initialized with a call to drandinitialize On Exit: State of generator after n- values are generated

  • x – [out] Vector of n- values from the triangular distribution, x(n)

  • info – [out]

    Error code

    0 = Everything OK

    -1 to -5 = Error in parameter, abs(info)

randuniform()#

void SRANDUNIFORM(rng_int_t *n, float *a, float *b, rng_int_t *state, float *x, rng_int_t *info)#
void DRANDUNIFORM(rng_int_t *n, double *a, double *b, rng_int_t *state, double *x, rng_int_t *info)#
void sranduniform_(rng_int_t *n, float *a, float *b, rng_int_t *state, float *x, rng_int_t *info)#
void dranduniform_(rng_int_t *n, double *a, double *b, rng_int_t *state, double *x, rng_int_t *info)#
void sranduniform(rng_int_t n, float a, float b, rng_int_t *state, float *x, rng_int_t *info)#
void dranduniform(rng_int_t n, double a, double b, rng_int_t *state, double *x, rng_int_t *info)#

Returns a vector of double precision pseudo-random numbers uniformly distributed between a and b

Parameters:
  • n – [in] Number of values to generate, n >= 0

  • a – [in] Lower limit for distribution

  • b – [in] Upper limit for distribution

  • state – [inout] On Entry: Current state of the base generator being used. state must have first been initialized with a call to drandinitialize On Exit: State of generator after n- values are generated

  • x – [out] Vector of values, x(n)

  • info – [out]

    Error code

    0 = Everything OK

    -1 to -4 = Error in parameter, abs(info)

randvonmises()#

void SRANDVONMISES(rng_int_t *n, float *vk, rng_int_t *state, float *x, rng_int_t *info)#
void DRANDVONMISES(rng_int_t *n, double *vk, rng_int_t *state, double *x, rng_int_t *info)#
void srandvonmises_(rng_int_t *n, float *vk, rng_int_t *state, float *x, rng_int_t *info)#
void drandvonmises_(rng_int_t *n, double *vk, rng_int_t *state, double *x, rng_int_t *info)#
void srandvonmises(rng_int_t n, float vk, rng_int_t *state, float *x, rng_int_t *info)#
void drandvonmises(rng_int_t n, double vk, rng_int_t *state, double *x, rng_int_t *info)#

Returns a vector of double precision pseudo-random numbers from von-mises distribution.

Parameters:
  • n – [in] Number of values to return, n > 0

  • vk – [in] Concentration parameter, vk > 0

  • state – [inout] On Entry: Current state of the base generator being used. state must have first been initialized with a call to drandinitialize On Exit: State of generator after n- values are generated

  • x – [out] Vector of n- values from the Von-Mises distribution, x(n)

  • info – [out]

    Error code

    0 = Everything OK

    -1 to -3 = Error in parameter, abs(info)

randweibull()#

void SRANDWEIBULL(rng_int_t *n, float *a, float *b, rng_int_t *state, float *x, rng_int_t *info)#
void DRANDWEIBULL(rng_int_t *n, double *a, double *b, rng_int_t *state, double *x, rng_int_t *info)#
void srandweibull_(rng_int_t *n, float *a, float *b, rng_int_t *state, float *x, rng_int_t *info)#
void drandweibull_(rng_int_t *n, double *a, double *b, rng_int_t *state, double *x, rng_int_t *info)#
void srandweibull(rng_int_t n, float a, float b, rng_int_t *state, float *x, rng_int_t *info)#
void drandweibull(rng_int_t n, double a, double b, rng_int_t *state, double *x, rng_int_t *info)#

Returns a vector of double precision pseudo-random numbers from weibull distribution.

Parameters:
  • n – [in] Number of values to generate, n > 0

  • a – [in] Shape parameter, a > 0.0

  • b – [in] Scale parameter, b > 0.0

  • state – [inout] On Entry: Current state of the base generator being used. state must have first been initialized with a call to drandinitialize On Exit: State of generator after n- values are generated

  • x – [out] Vector of n- values from the weibull distribution, x(n)

  • info – [out]

    Error code

    0 = Everything OK

    -1 to -4 = Error in parameter, abs(info)