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;
}
}
vector<vector<double> > SA::optimize(Mol2* Lig, PARSER* Input, Grid* Grids, gsl_rng* r){
double best_ene, ene, new_ene, p, rnumber;
vector<vector<double> > xyz;
vector<vector<double> > new_xyz;
vector<vector<double> > best_xyz;
double t = Input->sa_start_temp;
ene = this->evaluate_energy(Lig, Lig->xyz, Input, Grids);
best_ene = ene;
xyz = Lig->xyz;
while (t > Input->temp){
for (int i=0; i<Input->sa_steps; i++){
new_xyz = this->take_step(Lig, Input, r, xyz);
new_ene = this->evaluate_energy(Lig, new_xyz, Input, Grids);
if (new_ene <= ene){
ene = new_ene;
xyz = new_xyz;
best_ene = new_ene;
best_xyz = new_xyz;
}
else{
p = this->Boltzmman(ene, new_ene, t);
rnumber = gsl_rng_uniform(r) / (gsl_rng_max(r) + 1.0);
if (p > rnumber){
ene = new_ene;
xyz = new_xyz;
}
}
}
t = t/Input->sa_mu_t;
#ifdef DEBUG
printf("Best Energy: %7.3f @ temperature %7.3f\n", best_ene, t);
#endif
ene = best_ene;
xyz = best_xyz;
}
return(xyz);
}
static VALUE rb_gsl_rng_max(VALUE obj, VALUE s)
{
gsl_rng *r = NULL;
Data_Get_Struct(obj, gsl_rng, r);
return UINT2NUM(gsl_rng_max(r));
}
static void uvag_set (void *vstate, unsigned long int s) {
/* Initialize automaton using specified seed. */
uvag_state_t *state = (uvag_state_t *) vstate;
uint i, array_len = 255 + WORD, tot, seed_seed, tmp8;
unsigned char key[256], *kp, temp;
gsl_rng *seed_rng; /* random number generator used to seed uvag */
/*
* Preload the array with 1-byte integers
*/
for (i=0; i<array_len; i++){
svec[i]=i;
}
/*
* OK, here we have to modify Alex's algorithm. The GSL requires a
* single seed, unsigned long int in type. Alex requires a key string
* 256 characters long (that is, 64 uints long). We therefore have to
* bootstrap off of an existing, deterministic GSL RNG to fill the seed
* string from a single permitted seed. Note that type 12 is the
* mt19937_1999 generator, basically one of the best in the world -- not
* that it matters.
*/
seed_rng = gsl_rng_alloc(dh_rng_types[14]);
seed_seed = s;
gsl_rng_set(seed_rng,seed_seed);
random_max = gsl_rng_max(seed_rng);
rmax = random_max;
rmax_bits = 0;
rmax_mask = 0;
while(rmax){
rmax >>= 1;
rmax_mask = rmax_mask << 1;
rmax_mask++;
rmax_bits++;
}
for(i=0;i<256;i++){
/* if(i%32 == 0) printf("\n"); */
get_rand_bits(&tmp8,sizeof(uint),8,seed_rng);
if(i!=255){
key[i] = tmp8;
} else {
key[i] = 0;
}
/* printf("%02x",key[i]); */
}
/* printf("\n"); */
kp = key;
tot = 0;
for(i=0; i<array_len; i++) { /* shuffle seeds */
tot += *kp++;
tot%=array_len;
temp = svec[tot];
svec[tot] = svec[i];
svec[i] = temp;
/* wrap around key[] */
if(*kp == '\0') {
kp = key;
}
}
/* For debugging of the original load'n'shuffle
printf("svec = ");
for(i=0;i<256;i++){
if(i%32 == 0) printf("\n");
printf("%02x|",svec[i]);
}
printf("\n");
*/
sindex = 0;
rndint = 0;
}
inline unsigned long int GslRandomgen::MaxRand() const
{ // get maximum bounding value
assert( defined && me != NULL );
return gsl_rng_max(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;
}
