inline ssize_t write_(int fd, const void* buf, size_t s) {
CHECK_NON_NEGATIVE(ssize_t, write(fd, buf, s));
}
VALUE rb_create_instance(VALUE rb_obj, ...)
{
VAR_DECLARATIONS
/* initialize ap for use with the va_arg and va_end macros */
va_start(ap, rb_obj);
switch (type(rb_obj)) {
CASE(bernoulli)
VALUE rb_p;
double p;
SET_KLASS(bernoulli);
rb_p = GET_NEXT_ARG(ap);
p = NUM2DBL(rb_p);
CHECK_NUMBER(p);
/* 0 < p < 1 */
CHECK_PROBABILITY_EXCL(p);
/* p parameter correct */
RANDVAR_INIT(bernoulli);
SET_PARAM(bernoulli, p);
CASE_END
CASE(beta)
VALUE rb_alpha, rb_beta;
double alpha, beta;
SET_KLASS(beta);
rb_alpha = GET_NEXT_ARG(ap);
rb_beta = GET_NEXT_ARG(ap);
alpha = NUM2DBL(rb_alpha);
beta = NUM2DBL(rb_beta);
CHECK_NUMBER(alpha);
CHECK_NUMBER(beta);
/* alpha > 0 */
CHECK_POSITIVE(alpha);
/* beta > 0 */
CHECK_POSITIVE(beta);
/* alpha and beta parameters correct */
RANDVAR_INIT(beta);
SET_PARAM(beta, alpha);
SET_PARAM(beta, beta);
CASE_END
CASE(binomial)
VALUE rb_n, rb_p;
long n;
double p;
SET_KLASS(binomial);
rb_n = GET_NEXT_ARG(ap);
rb_p = GET_NEXT_ARG(ap);
CHECK_RB_INTEGER(rb_n, "n");
n = NUM2LONG(rb_n);
p = NUM2DBL(rb_p);
CHECK_NUMBER(p);
/* n >= 0 */
CHECK_NON_NEGATIVE(n);
/* 0 <= p <= 1 */
CHECK_PROBABILITY(p);
/* n and p parameters correct */
RANDVAR_INIT(binomial);
SET_PARAM(binomial, n);
SET_PARAM(binomial, p);
CASE_END
CASE(chi_squared)
VALUE rb_k;
long k;
SET_KLASS(chi_squared);
rb_k = GET_NEXT_ARG(ap);
CHECK_RB_INTEGER(rb_k, "k");
k = NUM2LONG(rb_k);
/* k > 0 */
CHECK_POSITIVE(k);
/* k parameter correct */
RANDVAR_INIT(chi_squared);
SET_PARAM(chi_squared, k);
CASE_END
CASE(continuous_uniform)
VALUE rb_a, rb_b;
double a,b;
SET_KLASS(continuous_uniform);
rb_a = GET_NEXT_ARG(ap);
rb_b = GET_NEXT_ARG(ap);
a = NUM2DBL(rb_a);
b = NUM2DBL(rb_b);
CHECK_NUMBER(a);
CHECK_NUMBER(b);
/* a < b */
CHECK_LESS_THAN(a,b);
/* a and b parameters correct */
RANDVAR_INIT(continuous_uniform);
SET_PARAM(continuous_uniform, a);
SET_PARAM(continuous_uniform, b);
CASE_END
CASE(discrete_uniform)
VALUE rb_a, rb_b;
long a,b;
SET_KLASS(discrete_uniform);
rb_a = GET_NEXT_ARG(ap);
rb_b = GET_NEXT_ARG(ap);
CHECK_RB_INTEGER(rb_a, "a");
CHECK_RB_INTEGER(rb_b, "b");
a = NUM2LONG(rb_a);
b = NUM2LONG(rb_b);
/* a < b */
CHECK_LESS_THAN(a,b);
/* a and b parameters correct */
RANDVAR_INIT(discrete_uniform);
SET_PARAM(discrete_uniform, a);
SET_PARAM(discrete_uniform, b);
CASE_END
CASE(exponential)
VALUE rb_mean;
double mean;
SET_KLASS(exponential);
rb_mean = GET_NEXT_ARG(ap);
mean = NUM2DBL(rb_mean);
CHECK_NUMBER(mean);
/* mean > 0 */
CHECK_POSITIVE(mean);
/* mean parameter correct */
RANDVAR_INIT(exponential);
SET_PARAM(exponential, mean);
CASE_END
CASE(f)
VALUE rb_d1, rb_d2;
double d1, d2;
SET_KLASS(f);
rb_d1 = GET_NEXT_ARG(ap);
rb_d2 = GET_NEXT_ARG(ap);
d1 = NUM2DBL(rb_d1);
d2 = NUM2DBL(rb_d2);
CHECK_NUMBER(d1);
CHECK_NUMBER(d2);
/* d1 > 0 */
/* d2 > 0 */
CHECK_POSITIVE(d1);
CHECK_POSITIVE(d2);
/* d1, d2 parameters correct */
RANDVAR_INIT(f);
SET_PARAM(f, d1);
SET_PARAM(f, d2);
CASE_END
CASE(negative_binomial)
VALUE rb_r, rb_p;
long r;
double p;
SET_KLASS(negative_binomial);
rb_r = GET_NEXT_ARG(ap);
rb_p = GET_NEXT_ARG(ap);
CHECK_RB_INTEGER(rb_r, "r");
r = NUM2LONG(rb_r);
p = NUM2DBL(rb_p);
CHECK_NUMBER(p);
/* r > 0 */
CHECK_POSITIVE(r);
/* 0 < p < 0 */
CHECK_PROBABILITY_EXCL(p);
/* r and p parameters correct */
RANDVAR_INIT(negative_binomial);
SET_PARAM(negative_binomial, r);
SET_PARAM(negative_binomial, p);
CASE_END
CASE(normal)
VALUE rb_mu, rb_sigma;
double mu, sigma;
SET_KLASS(normal);
rb_mu = GET_NEXT_ARG(ap);
rb_sigma = GET_NEXT_ARG(ap);
mu = NUM2DBL(rb_mu);
sigma = NUM2DBL(rb_sigma);
CHECK_NUMBER(mu);
CHECK_NUMBER(sigma);
/* sigma > 0 */
CHECK_POSITIVE(sigma);
/* sigma parameter correct */
RANDVAR_INIT(normal);
SET_PARAM(normal, mu);
SET_PARAM(normal, sigma);
CASE_END
CASE(pareto)
VALUE rb_a, rb_m;
double a, m;
SET_KLASS(pareto);
rb_a = GET_NEXT_ARG(ap);
rb_m = GET_NEXT_ARG(ap);
a = NUM2DBL(rb_a);
m = NUM2DBL(rb_m);
CHECK_NUMBER(a);
CHECK_NUMBER(m);
/* a > 0 */
CHECK_POSITIVE(a);
/* m > 0 */
CHECK_POSITIVE(m);
/* a and m parameters correct */
RANDVAR_INIT(pareto);
SET_PARAM(pareto, a);
SET_PARAM(pareto, m);
CASE_END
CASE(poisson)
VALUE rb_mean;
double mean;
SET_KLASS(poisson);
rb_mean = GET_NEXT_ARG(ap);
mean = NUM2DBL(rb_mean);
CHECK_NUMBER(mean);
/* mean > 0 */
CHECK_POSITIVE(mean);
/* ensure no overflow */
if (mean > LONG_MAX - 0.05 * LONG_MAX)
rb_raise(rb_eArgError, "outcomes may overflow");
/* mean parameter correct */
RANDVAR_INIT(poisson);
SET_PARAM(poisson, mean);
CASE_END
CASE(rademacher)
SET_KLASS(rademacher);
RANDVAR_INIT(rademacher);
CASE_END
CASE(rayleigh)
VALUE rb_sigma;
double sigma;
SET_KLASS(rayleigh);
rb_sigma = GET_NEXT_ARG(ap);
sigma = NUM2DBL(rb_sigma);
CHECK_NUMBER(sigma);
/* sigma > 0 */
CHECK_POSITIVE(sigma);
RANDVAR_INIT(rayleigh);
SET_PARAM(rayleigh, sigma);
CASE_END
CASE(rectangular)
SET_KLASS(rectangular);
RANDVAR_INIT(rectangular);
CASE_END
default:
rb_rv = Qnil;
} /* switch */
va_end(ap);
return rb_rv;
}
inline ssize_t read_(int fd, void* buf, size_t s) {
CHECK_NON_NEGATIVE(ssize_t, read(fd, buf, s));
}
