static coco_problem_t *f_weierstrass_allocate(const size_t number_of_variables) {
f_weierstrass_data_t *data;
size_t i;
double *non_unique_best_value;
coco_problem_t *problem = coco_problem_allocate_from_scalars("Weierstrass function",
f_weierstrass_evaluate, NULL, number_of_variables, -5.0, 5.0, NAN);
coco_problem_set_id(problem, "%s_d%02lu", "weierstrass", number_of_variables);
data = coco_allocate_memory(sizeof(*data));
data->f0 = 0.0;
for (i = 0; i < WEIERSTRASS_SUMMANDS; ++i) {
data->ak[i] = pow(0.5, (double) i);
data->bk[i] = pow(3., (double) i);
data->f0 += data->ak[i] * cos(2 * coco_pi * data->bk[i] * 0.5);
}
problem->data = data;
/* Compute best solution */
non_unique_best_value = coco_allocate_vector(number_of_variables);
for (i = 0; i < number_of_variables; i++)
non_unique_best_value[i] = 0.0;
f_weierstrass_evaluate(problem, non_unique_best_value, problem->best_value);
coco_free_memory(non_unique_best_value);
return problem;
}
/**
* @brief Creates the BBOB Rastrigin problem.
*/
static coco_problem_t *f_rastrigin_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;
xopt = coco_allocate_vector(dimension);
fopt = bbob2009_compute_fopt(function, instance);
bbob2009_compute_xopt(xopt, rseed, dimension);
problem = f_rastrigin_allocate(dimension);
problem = transform_vars_conditioning(problem, 10.0);
problem = transform_vars_asymmetric(problem, 0.2);
problem = transform_vars_oscillate(problem);
problem = transform_vars_shift(problem, xopt, 0);
problem = 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, "1-separable");
coco_free_memory(xopt);
return problem;
}
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;
}
/**
* @brief Allocates the basic Rastrigin problem.
*/
static coco_problem_t *f_rastrigin_allocate(const size_t number_of_variables) {
coco_problem_t *problem = coco_problem_allocate_from_scalars("Rastrigin function",
f_rastrigin_evaluate, NULL, number_of_variables, -5.0, 5.0, 0.0);
coco_problem_set_id(problem, "%s_d%02lu", "rastrigin", number_of_variables);
/* Compute best solution */
f_rastrigin_evaluate(problem, problem->best_parameter, problem->best_value);
return problem;
}
/**
* @brief Allocates the basic Griewank-Rosenbrock problem.
*/
static coco_problem_t *f_griewank_rosenbrock_allocate(const size_t number_of_variables) {
coco_problem_t *problem = coco_problem_allocate_from_scalars("Griewank Rosenbrock function",
f_griewank_rosenbrock_evaluate, NULL, number_of_variables, -5.0, 5.0, 1);
coco_problem_set_id(problem, "%s_d%02lu", "griewank_rosenbrock", number_of_variables);
/* Compute best solution */
f_griewank_rosenbrock_evaluate(problem, problem->best_parameter, problem->best_value);
return problem;
}
/**
* @brief Creates the BBOB Lunacek bi-Rastrigin problem.
*
* @note There is no separate basic allocate function.
*/
static coco_problem_t *f_lunacek_bi_rastrigin_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) {
f_lunacek_bi_rastrigin_data_t *data;
coco_problem_t *problem = coco_problem_allocate_from_scalars("Lunacek's bi-Rastrigin function",
f_lunacek_bi_rastrigin_evaluate, f_lunacek_bi_rastrigin_free, dimension, -5.0, 5.0, 0.0);
const double mu0 = 2.5;
double fopt, *tmpvect;
size_t i;
data = (f_lunacek_bi_rastrigin_data_t *) coco_allocate_memory(sizeof(*data));
/* Allocate temporary storage and space for the rotation matrices */
data->x_hat = coco_allocate_vector(dimension);
data->z = coco_allocate_vector(dimension);
data->xopt = coco_allocate_vector(dimension);
data->rot1 = bbob2009_allocate_matrix(dimension, dimension);
data->rot2 = bbob2009_allocate_matrix(dimension, dimension);
data->rseed = rseed;
data->fopt = bbob2009_compute_fopt(24, instance);
bbob2009_compute_xopt(data->xopt, rseed, dimension);
bbob2009_compute_rotation(data->rot1, rseed + 1000000, dimension);
bbob2009_compute_rotation(data->rot2, rseed, dimension);
problem->data = data;
/* Compute best solution */
tmpvect = coco_allocate_vector(dimension);
bbob2009_gauss(tmpvect, dimension, rseed);
for (i = 0; i < dimension; ++i) {
data->xopt[i] = 0.5 * mu0;
if (tmpvect[i] < 0.0) {
data->xopt[i] *= -1.0;
}
problem->best_parameter[i] = data->xopt[i];
}
coco_free_memory(tmpvect);
f_lunacek_bi_rastrigin_evaluate(problem, problem->best_parameter, problem->best_value);
fopt = bbob2009_compute_fopt(function, instance);
problem = 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;
}
/**
* @brief Creates the BBOB Griewank-Rosenbrock problem.
*/
static coco_problem_t *f_griewank_rosenbrock_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 fopt;
coco_problem_t *problem = NULL;
size_t i, j;
double *M = coco_allocate_vector(dimension * dimension);
double *b = coco_allocate_vector(dimension);
double *shift = coco_allocate_vector(dimension);
double scales, **rot1;
fopt = bbob2009_compute_fopt(function, instance);
for (i = 0; i < dimension; ++i) {
shift[i] = -0.5;
}
rot1 = bbob2009_allocate_matrix(dimension, dimension);
bbob2009_compute_rotation(rot1, rseed, dimension);
scales = coco_double_max(1., sqrt((double) dimension) / 8.);
for (i = 0; i < dimension; ++i) {
for (j = 0; j < dimension; ++j) {
rot1[i][j] *= scales;
}
}
problem = f_griewank_rosenbrock_allocate(dimension);
problem = transform_obj_shift(problem, fopt);
problem = transform_vars_shift(problem, shift, 0);
bbob2009_copy_rotation_matrix(rot1, M, b, dimension);
problem = transform_vars_affine(problem, M, b, dimension);
bbob2009_free_matrix(rot1, 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(shift);
return problem;
}
/**
* @brief Returns the problem from the bbob-biobj suite that corresponds to the given parameters.
*
* Creates the bi-objective problem by constructing it from two single-objective problems from the bbob
* suite. If the invoked instance number is not in suite_biobj_instances, the function uses the following
* formula to construct a new appropriate instance:
*
* problem1_instance = 2 * biobj_instance + 1
*
* problem2_instance = problem1_instance + 1
*
* If needed, problem2_instance is increased (see also the explanation of suite_biobj_get_new_instance).
*
* @param suite The COCO suite.
* @param function_idx Index of the function (starting from 0).
* @param dimension_idx Index of the dimension (starting from 0).
* @param instance_idx Index of the instance (starting from 0).
* @return The problem that corresponds to the given parameters.
*/
static coco_problem_t *suite_biobj_get_problem(coco_suite_t *suite,
const size_t function_idx,
const size_t dimension_idx,
const size_t instance_idx) {
const size_t num_bbob_functions = 10;
/* Functions from the bbob suite that are used to construct the bi-objective problem. */
const size_t bbob_functions[] = { 1, 2, 6, 8, 13, 14, 15, 17, 20, 21 };
coco_problem_t *problem1, *problem2, *problem = NULL;
size_t function1_idx, function2_idx;
size_t instance1 = 0, instance2 = 0;
const size_t function = suite->functions[function_idx];
const size_t dimension = suite->dimensions[dimension_idx];
const size_t instance = suite->instances[instance_idx];
suite_biobj_t *data = (suite_biobj_t *) suite->data;
size_t i, j;
const size_t num_existing_instances = sizeof(suite_biobj_instances) / sizeof(suite_biobj_instances[0]);
int instance_found = 0;
/* A "magic" formula to compute the BBOB function index from the bi-objective function index */
function1_idx = num_bbob_functions
- coco_double_to_size_t(
floor(-0.5 + sqrt(0.25 + 2.0 * (double) (suite->number_of_functions - function_idx - 1)))) - 1;
function2_idx = function_idx - (function1_idx * num_bbob_functions) +
(function1_idx * (function1_idx + 1)) / 2;
/* First search for instance in suite_biobj_instances */
for (i = 0; i < num_existing_instances; i++) {
if (suite_biobj_instances[i][0] == instance) {
/* The instance has been found in suite_biobj_instances */
instance1 = suite_biobj_instances[i][1];
instance2 = suite_biobj_instances[i][2];
instance_found = 1;
break;
}
}
if ((!instance_found) && (data)) {
/* Next, search for instance in new_instances */
for (i = 0; i < data->max_new_instances; i++) {
if (data->new_instances[i][0] == 0)
break;
if (data->new_instances[i][0] == instance) {
/* The instance has been found in new_instances */
instance1 = data->new_instances[i][1];
instance2 = data->new_instances[i][2];
instance_found = 1;
break;
}
}
}
if (!instance_found) {
/* Finally, if the instance is not found, create a new one */
if (!data) {
/* Allocate space needed for saving new instances */
data = (suite_biobj_t *) coco_allocate_memory(sizeof(*data));
/* Most often the actual number of new instances will be lower than max_new_instances, because
* some of them are already in suite_biobj_instances. However, in order to avoid iterating over
* suite_biobj_instances, the allocation uses max_new_instances. */
data->max_new_instances = suite->number_of_instances;
data->new_instances = (size_t **) coco_allocate_memory(data->max_new_instances * sizeof(size_t *));
for (i = 0; i < data->max_new_instances; i++) {
data->new_instances[i] = (size_t *) malloc(3 * sizeof(size_t));
for (j = 0; j < 3; j++) {
data->new_instances[i][j] = 0;
}
}
suite->data_free_function = suite_biobj_free;
suite->data = data;
}
/* A simple formula to set the first instance */
instance1 = 2 * instance + 1;
instance2 = suite_biobj_get_new_instance(suite, instance, instance1, num_bbob_functions, bbob_functions);
}
problem1 = coco_get_bbob_problem(bbob_functions[function1_idx], dimension, instance1);
problem2 = coco_get_bbob_problem(bbob_functions[function2_idx], dimension, instance2);
problem = coco_problem_stacked_allocate(problem1, problem2);
problem->suite_dep_function = function;
problem->suite_dep_instance = instance;
problem->suite_dep_index = coco_suite_encode_problem_index(suite, function_idx, dimension_idx, instance_idx);
/* Use the standard stacked problem_id as problem_name and construct a new suite-specific problem_id */
coco_problem_set_name(problem, problem->problem_id);
coco_problem_set_id(problem, "bbob-biobj_f%02d_i%02ld_d%02d", function, instance, dimension);
/* Construct problem type */
coco_problem_set_type(problem, "%s_%s", problem1->problem_type, problem2->problem_type);
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;
}