/**
* bbob2009_compute_xopt(xopt, seed, DIM):
*
* Randomly compute the location of the global optimum.
*/
static void bbob2009_compute_xopt(double *xopt, long seed, long DIM) {
long i;
bbob2009_unif(xopt, DIM, seed);
for (i = 0; i < DIM; i++) {
xopt[i] = 8 * floor(1e4 * xopt[i]) / 1e4 - 4;
if (xopt[i] == 0.0)
xopt[i] = -1e-5;
}
}
/**
* bbob2009_gauss(g, N, seed)
*
* Generate ${N} Gaussian random numbers using the seed ${seed} and
* store them in ${g}.
*/
static void bbob2009_gauss(double *g, long N, long seed) {
int i;
double uniftmp[6000];
assert(2 * N < 6000);
bbob2009_unif(uniftmp, 2 * N, seed);
for (i = 0; i < N; i++) {
g[i] = sqrt(-2 * log(uniftmp[i])) * cos(2 * coco_pi * uniftmp[N + i]);
if (g[i] == 0.)
g[i] = 1e-99;
}
return;
}
void my_optimizer(coco_problem_t *problem) {
static const int budget = 102; /* 100000;*/
coco_random_state_t *rng = coco_new_random(0xdeadbeef);
double *x = (double *)malloc(problem->number_of_parameters * sizeof(double));
double y;
for (int i = 1; i < budget; ++i) {
bbob2009_unif(x, problem->number_of_parameters, i);
for (int j = 0; j < problem->number_of_parameters; ++j) {
/*const double range = problem->upper_bounds[j] -
problem->lower_bounds[j];
x[j] = problem->lower_bounds[j] + coco_uniform_random(rng) * range;*/
x[j] = 20. * x[j] - 10.;
}
/*if ( i % 100==0 ){
printf("%d: [ %f,", i, x[0]);
printf(" %f ]\n",x[1]);
}*/
coco_evaluate_function(problem, x, &y);
}
coco_free_random(rng);
free(x);
printf("%s\n", problem->problem_name);
printf("%s\n", problem->problem_id);
}
static coco_problem_t *f_gallagher_bbob_problem_allocate(const size_t function,
const size_t dimension,
const size_t instance,
const long rseed,
const size_t number_of_peaks,
const char *problem_id_template,
const char *problem_name_template) {
f_gallagher_data_t *data;
/* problem_name and best_parameter will be overwritten below */
coco_problem_t *problem = coco_problem_allocate_from_scalars("Gallagher function",
f_gallagher_evaluate, f_gallagher_free, dimension, -5.0, 5.0, 0.0);
const size_t peaks_21 = 21;
const size_t peaks_101 = 101;
double fopt;
size_t i, j, k, *rperm;
double maxcondition = 1000.;
/* maxcondition1 satisfies the old code and the doc but seems wrong in that it is, with very high
* probability, not the largest condition level!!! */
double maxcondition1 = 1000.;
double *arrCondition;
double fitvalues[2] = { 1.1, 9.1 };
/* Parameters for generating local optima. In the old code, they are different in f21 and f22 */
double b, c;
data = coco_allocate_memory(sizeof(*data));
/* Allocate temporary storage and space for the rotation matrices */
data->number_of_peaks = number_of_peaks;
data->xopt = coco_allocate_vector(dimension);
data->rotation = bbob2009_allocate_matrix(dimension, dimension);
data->x_local = bbob2009_allocate_matrix(dimension, number_of_peaks);
data->arr_scales = bbob2009_allocate_matrix(number_of_peaks, dimension);
if (number_of_peaks == peaks_101) {
if (gallagher_peaks != NULL)
coco_free_memory(gallagher_peaks);
gallagher_peaks = coco_allocate_vector(peaks_101 * dimension);
maxcondition1 = sqrt(maxcondition1);
b = 10.;
c = 5.;
} else if (number_of_peaks == peaks_21) {
if (gallagher_peaks != NULL)
coco_free_memory(gallagher_peaks);
gallagher_peaks = coco_allocate_vector(peaks_21 * dimension);
b = 9.8;
c = 4.9;
} else {
coco_error("f_gallagher(): '%lu' is a bad number of peaks", number_of_peaks);
}
data->rseed = rseed;
bbob2009_compute_rotation(data->rotation, rseed, dimension);
/* Initialize all the data of the inner problem */
bbob2009_unif(gallagher_peaks, number_of_peaks - 1, data->rseed);
rperm = (size_t *) coco_allocate_memory((number_of_peaks - 1) * sizeof(size_t));
for (i = 0; i < number_of_peaks - 1; ++i)
rperm[i] = i;
qsort(rperm, number_of_peaks - 1, sizeof(size_t), f_gallagher_compare_doubles);
/* Random permutation */
arrCondition = coco_allocate_vector(number_of_peaks);
arrCondition[0] = maxcondition1;
data->peak_values = coco_allocate_vector(number_of_peaks);
data->peak_values[0] = 10;
for (i = 1; i < number_of_peaks; ++i) {
arrCondition[i] = pow(maxcondition, (double) (rperm[i - 1]) / ((double) (number_of_peaks - 2)));
data->peak_values[i] = (double) (i - 1) / (double) (number_of_peaks - 2) * (fitvalues[1] - fitvalues[0])
+ fitvalues[0];
}
coco_free_memory(rperm);
rperm = (size_t *) coco_allocate_memory(dimension * sizeof(size_t));
for (i = 0; i < number_of_peaks; ++i) {
bbob2009_unif(gallagher_peaks, dimension, data->rseed + (long) (1000 * i));
for (j = 0; j < dimension; ++j)
rperm[j] = j;
qsort(rperm, dimension, sizeof(size_t), f_gallagher_compare_doubles);
for (j = 0; j < dimension; ++j) {
data->arr_scales[i][j] = pow(arrCondition[i],
((double) rperm[j]) / ((double) (dimension - 1)) - 0.5);
}
}
coco_free_memory(rperm);
bbob2009_unif(gallagher_peaks, dimension * number_of_peaks, data->rseed);
for (i = 0; i < dimension; ++i) {
data->xopt[i] = 0.8 * (b * gallagher_peaks[i] - c);
problem->best_parameter[i] = 0.8 * (b * gallagher_peaks[i] - c);
for (j = 0; j < number_of_peaks; ++j) {
data->x_local[i][j] = 0.;
for (k = 0; k < dimension; ++k) {
data->x_local[i][j] += data->rotation[i][k] * (b * gallagher_peaks[j * dimension + k] - c);
}
if (j == 0) {
data->x_local[i][j] *= 0.8;
}
}
}
coco_free_memory(arrCondition);
problem->data = data;
/* Compute best solution */
f_gallagher_evaluate(problem, problem->best_parameter, problem->best_value);
fopt = bbob2009_compute_fopt(function, instance);
problem = f_transform_obj_shift(problem, fopt);
coco_problem_set_id(problem, problem_id_template, function, instance, dimension);
coco_problem_set_name(problem, problem_name_template, function, instance, dimension);
coco_problem_set_type(problem, "5-weakly-structured");
return problem;
}