/**
* @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 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;
}
