static coco_problem_t *f_weierstrass_bbob_problem_allocate(const size_t function,
const size_t dimension,
const size_t instance,
const long rseed,
const char *problem_id_template,
const char *problem_name_template) {
double *xopt, fopt;
coco_problem_t *problem = NULL;
size_t i, j, k;
double *M = coco_allocate_vector(dimension * dimension);
double *b = coco_allocate_vector(dimension);
double *current_row, **rot1, **rot2;
const double condition = 100.0;
const double penalty_factor = 10.0 / (double) dimension;
xopt = coco_allocate_vector(dimension);
fopt = bbob2009_compute_fopt(function, instance);
bbob2009_compute_xopt(xopt, rseed, dimension);
rot1 = bbob2009_allocate_matrix(dimension, dimension);
rot2 = bbob2009_allocate_matrix(dimension, dimension);
bbob2009_compute_rotation(rot1, rseed + 1000000, dimension);
bbob2009_compute_rotation(rot2, rseed, dimension);
for (i = 0; i < dimension; ++i) {
b[i] = 0.0;
current_row = M + i * dimension;
for (j = 0; j < dimension; ++j) {
current_row[j] = 0.0;
for (k = 0; k < dimension; ++k) {
const double base = 1.0 / sqrt(condition);
const double exponent = 1.0 * (int) k / ((double) (long) dimension - 1.0);
current_row[j] += rot1[i][k] * pow(base, exponent) * rot2[k][j];
}
}
}
problem = f_weierstrass_allocate(dimension);
problem = f_transform_obj_shift(problem, fopt);
problem = f_transform_vars_affine(problem, M, b, dimension);
problem = f_transform_vars_oscillate(problem);
bbob2009_copy_rotation_matrix(rot1, M, b, dimension);
problem = f_transform_vars_affine(problem, M, b, dimension);
problem = f_transform_vars_shift(problem, xopt, 0);
problem = f_transform_obj_penalize(problem, penalty_factor);
bbob2009_free_matrix(rot1, dimension);
bbob2009_free_matrix(rot2, dimension);
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, "4-multi-modal");
coco_free_memory(M);
coco_free_memory(b);
coco_free_memory(xopt);
return problem;
}
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;
}