void
generic_rng_test (const gsl_rng_type * T)
{
gsl_rng *r = gsl_rng_alloc (T);
const char *name = gsl_rng_name (r);
unsigned long int kmax = 0, kmin = 1000;
double sigma = 0;
const unsigned long int ran_max = gsl_rng_max (r);
const unsigned long int ran_min = gsl_rng_min (r);
int status = rng_max_test (r, &kmax, ran_max);
/*gsl_test (status,*/
/*"%s, observed vs theoretical maximum (%lu vs %lu)",*/
/*name, kmax, ran_max);*/
status = rng_min_test (r, &kmin, ran_min, ran_max);
/*gsl_test (status,*/
/*"%s, observed vs theoretical minimum (%lu vs %lu)",*/
/*name, kmin, ran_min);*/
status = rng_sum_test (r, &sigma);
/*gsl_test (status,*/
/*"%s, sum test within acceptable sigma (observed %.2g
* sigma)",*/
/*name, sigma);*/
status = rng_bin_test (r, &sigma);
/*gsl_test (status,*/
/*"%s, bin test within acceptable chisq (observed %.2g
* sigma)",*/
/*name, sigma);*/
gsl_rng_set (r, 1); /* set seed to 1 */
status = rng_max_test (r, &kmax, ran_max);
gsl_rng_set (r, 1); /* set seed to 1 */
status |= rng_min_test (r, &kmin, ran_min, ran_max);
gsl_rng_set (r, 1); /* set seed to 1 */
status |= rng_sum_test (r, &sigma);
gsl_rng_set (r, 12345); /* set seed to a "typical" value */
status |= rng_max_test (r, &kmax, ran_max);
gsl_rng_set (r, 12345); /* set seed to a "typical" value */
status |= rng_min_test (r, &kmin, ran_min, ran_max);
gsl_rng_set (r, 12345); /* set seed to a "typical" value */
status |= rng_sum_test (r, &sigma);
/*gsl_test (status, "%s, maximum and sum tests for non-default seeds",
* name);*/
gsl_rng_free (r);
}
int
cmd_sample (struct lexer *lexer, struct dataset *ds)
{
struct sample_trns *trns;
int type;
int a, b;
unsigned frac;
if (!lex_force_num (lexer))
return CMD_FAILURE;
if (!lex_is_integer (lexer))
{
unsigned long min = gsl_rng_min (get_rng ());
unsigned long max = gsl_rng_max (get_rng ());
type = TYPE_FRACTION;
if (lex_tokval (lexer) <= 0 || lex_tokval (lexer) >= 1)
{
msg (SE, _("The sampling factor must be between 0 and 1 "
"exclusive."));
return CMD_FAILURE;
}
frac = lex_tokval (lexer) * (max - min) + min;
a = b = 0;
}
else
{
type = TYPE_A_FROM_B;
a = lex_integer (lexer);
lex_get (lexer);
if (!lex_force_match_id (lexer, "FROM"))
return CMD_FAILURE;
if (!lex_force_int (lexer))
return CMD_FAILURE;
b = lex_integer (lexer);
if (a >= b)
{
msg (SE, _("Cannot sample %d observations from a population of "
"%d."),
a, b);
return CMD_FAILURE;
}
frac = 0;
}
lex_get (lexer);
trns = xmalloc (sizeof *trns);
trns->type = type;
trns->n = a;
trns->N = b;
trns->m = trns->t = 0;
trns->frac = frac;
add_transformation (ds, sample_trns_proc, sample_trns_free, trns);
return CMD_SUCCESS;
}
static unsigned long
gsl_rng_uint32 (gsl_rng *r)
/* the uniform distribution on 0..2^{32}-1 */
{
unsigned long min = gsl_rng_min (r);
unsigned long max = gsl_rng_max (r);
if (min == 0 && max == 4294967295U) { /* we have full 32 bit values */
return gsl_rng_get (r);
} else {
assert (max-min >= 65536); /* make sure we have at least 16 bit */
unsigned long a = (gsl_rng_get (r)-min)&0xFFFF;
unsigned long b = (gsl_rng_get (r)-min)&0xFFFF;
return (a<<16)|b;
}
}
static VALUE rb_gsl_rng_min(VALUE obj, VALUE s)
{
gsl_rng *r = NULL;
Data_Get_Struct(obj, gsl_rng, r);
return UINT2NUM(gsl_rng_min(r));
}
inline unsigned long int GslRandomgen::MinRand() const
{ // get minimum bounding value
assert( defined && me != NULL );
return gsl_rng_min(me);
}
int main(int argc, char **argv){
int i;
gsl_rng *r;
gsl_rng *rcopy;
unsigned long x;
rngRemember(unsigned long save);
rngRemember(unsigned long saved[5]);
double sum = 0.;
(void)argc; (void)argv; /* unused */
/* Silence an unused-parameter warning. */
(void)argc;
r = gsl_rng_alloc(gsl_rng_cbrng);
assert (gsl_rng_min(r) == 0);
assert (gsl_rng_max(r) == 0xffffffffUL); /* Not necessarily ~0UL */
assert (gsl_rng_size(r) > 0);
printf("%s\nulongs from %s in initial state\n", argv[0], gsl_rng_name(r));
for (i = 0; i < 5; i++) {
x = gsl_rng_get(r);
rngRemember(saved[i] = x);
printf("%d: 0x%lx\n", i, x);
assert(x != 0);
}
printf("uniforms from %s\n", gsl_rng_name(r));
for (i = 0; i < 5; i++) {
double z = gsl_rng_uniform(r);
sum += z;
printf("%d: %.4g\n", i, z);
}
assert( sum < 0.9*5 && sum > 0.1*5 && (long)"sum must be reasonably close to 0.5*number of trials");
rngRemember(save =) gsl_rng_get(r);
gsl_rng_set(r, 0xdeadbeef); /* set a non-zero seed */
printf("ulongs from %s after seed\n", gsl_rng_name(r));
for (i = 0; i < 5; i++) {
x = gsl_rng_get(r);
printf("%d: 0x%lx\n", i, x);
assert(x != 0);
}
/* make a copy of the total state */
rcopy = gsl_rng_alloc(gsl_rng_cbrng);
gsl_rng_memcpy(rcopy, r);
printf("uniforms from %s\n", gsl_rng_name(r));
sum = 0.;
for (i = 0; i < 5; i++) {
double x = gsl_rng_uniform(r);
rngRemember(double y = gsl_rng_uniform(rcopy));
printf("%d: %.4g\n", i, x);
sum += x;
assert(x == y);
}
assert(gsl_rng_get(r) != save);
assert( sum < 0.9*5 && sum > 0.1*5 && (long)"sum must be reasonably close to 0.5*number of trials");
/* gsl_rng_set(*, 0) is supposed to recover the default seed */
gsl_rng_set(r, 0);
printf("ulongs from %s after restore to initial\n", gsl_rng_name(r));
for (i = 0; i < 5; i++) {
x = gsl_rng_get(r);
assert( x == saved[i] );
printf("%d: 0x%lx\n", i, x);
assert(x != 0);
}
printf("uniforms from %s\n", gsl_rng_name(r));
for (i = 0; i < 5; i++) {
printf("%d: %.4g\n", i, gsl_rng_uniform(r));
}
gsl_rng_free (rcopy);
gsl_rng_free (r);
printf("ut_gsl: OK\n");
return 0;
}
