void DPCostsInsideExpectation::sampleOnceGradientFD
(double const * const coefsJkp1Ref,
int const * const * const refTableJkp1Ref,
double const * const stateKRef,
double const * const controlKRef,
gsl_rng* generator, double * const grad)
{
/* Note we assume the generator is already initialized with the
* appropriate seed when passed into this function. */
static gsl_rng_type const * rngType = gsl_rng_ranlxs0;
static gsl_rng* generatorRef = gsl_rng_alloc(rngType);
gsl_rng_memcpy(generatorRef, generator);
/* Initializations. */
double perturb(0.0), fp(0.0), fm(0.0);
static double* controlKPert = new double[primary.nControlsDim];
for (int i = 0; i < primary.nControlsDim; i++)
controlKPert[i] = controlKRef[i];
for (int i = 0; i < primary.nControlsDim; i++)
{
/* Reset previous perturbation. */
if (i > 0)
controlKPert[i - 1] = controlKRef[i - 1];
/* Positive perturbation. */
perturb = max<double>(fabs(controlKRef[i]), 1.0) * sqrt(EPS);
controlKPert[i] = controlKRef[i] + perturb;
fp = 0.0;
gsl_rng_memcpy(generator, generatorRef);
fp = sampleOnce(coefsJkp1Ref, refTableJkp1Ref,
stateKRef, controlKPert, generator);
/* Negative perturbation. */
controlKPert[i] = controlKRef[i] - perturb;
fm = 0.0;
gsl_rng_memcpy(generator, generatorRef);
fm = sampleOnce(coefsJkp1Ref, refTableJkp1Ref,
stateKRef, controlKPert, generator);
/* Compute gradient component. */
grad[i] = (fp - fm) / (2.0 * perturb);
}
}
static VALUE rb_gsl_rng_memcpy(VALUE obj, VALUE dst, VALUE org)
{
gsl_rng *dest, *src;
CHECK_RNG(dst); CHECK_RNG(org);
Data_Get_Struct(dst, gsl_rng, dest);
Data_Get_Struct(org, gsl_rng, src);
gsl_rng_memcpy(dest, src);
return dst;
}
void
rng_state_test (const gsl_rng_type * T)
{
unsigned long int test_a[N], test_b[N];
int i;
gsl_rng *r = gsl_rng_alloc (T);
gsl_rng *r_save = gsl_rng_alloc (T);
for (i = 0; i < N; ++i)
{
gsl_rng_get (r); /* throw away N iterations */
}
gsl_rng_memcpy (r_save, r); /* save the intermediate state */
for (i = 0; i < N; ++i)
{
test_a[i] = gsl_rng_get (r);
}
gsl_rng_memcpy (r, r_save); /* restore the intermediate state */
gsl_rng_free (r_save);
for (i = 0; i < N; ++i)
{
test_b[i] = gsl_rng_get (r);
}
{
int status = 0;
for (i = 0; i < N; ++i)
{
status |= (test_b[i] != test_a[i]);
}
/*gsl_test (status, "%s, random number state consistency",*/
/*gsl_rng_name (r));*/
}
gsl_rng_free (r);
}
void
rng_parallel_state_test (const gsl_rng_type * T)
{
unsigned long int test_a[N], test_b[N];
unsigned long int test_c[N], test_d[N];
double test_e[N], test_f[N];
int i;
gsl_rng *r1 = gsl_rng_alloc (T);
gsl_rng *r2 = gsl_rng_alloc (T);
for (i = 0; i < N; ++i)
{
gsl_rng_get (r1); /* throw away N iterations */
}
gsl_rng_memcpy (r2, r1); /* save the intermediate state */
for (i = 0; i < N; ++i)
{
/* check that there is no hidden state intermixed between r1 and r2 */
test_a[i] = gsl_rng_get (r1);
test_b[i] = gsl_rng_get (r2);
test_c[i] = gsl_rng_uniform_int (r1, 1234);
test_d[i] = gsl_rng_uniform_int (r2, 1234);
test_e[i] = gsl_rng_uniform (r1);
test_f[i] = gsl_rng_uniform (r2);
}
{
int status = 0;
for (i = 0; i < N; ++i)
{
status |= (test_b[i] != test_a[i]);
status |= (test_c[i] != test_d[i]);
status |= (test_e[i] != test_f[i]);
}
/*gsl_test (status, "%s, parallel random number state
* consistency",*/
/*gsl_rng_name (r1));*/
}
gsl_rng_free (r1);
gsl_rng_free (r2);
}
void restore_state(void *state)
{
gsl_rng_memcpy(rnd(), (gsl_rng *) state);
}
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;
}
