/**
* bbob2009_compute_fopt(function_id, instance_id):
*
* Randomly choose the objective offset for function ${function_id}
* and instance ${instance_id}.
*/
static double bbob2009_compute_fopt(int function_id, long instance_id) {
long rseed, rrseed;
double gval, gval2;
if (function_id == 4)
rseed = 3;
else if (function_id == 18)
rseed = 17;
else if (function_id == 101 || function_id == 102 || function_id == 103 || function_id == 107
|| function_id == 108 || function_id == 109)
rseed = 1;
else if (function_id == 104 || function_id == 105 || function_id == 106 || function_id == 110
|| function_id == 111 || function_id == 112)
rseed = 8;
else if (function_id == 113 || function_id == 114 || function_id == 115)
rseed = 7;
else if (function_id == 116 || function_id == 117 || function_id == 118)
rseed = 10;
else if (function_id == 119 || function_id == 120 || function_id == 121)
rseed = 14;
else if (function_id == 122 || function_id == 123 || function_id == 124)
rseed = 17;
else if (function_id == 125 || function_id == 126 || function_id == 127)
rseed = 19;
else if (function_id == 128 || function_id == 129 || function_id == 130)
rseed = 21;
else
rseed = function_id;
rrseed = rseed + 10000 * instance_id;
bbob2009_gauss(&gval, 1, rrseed);
bbob2009_gauss(&gval2, 1, rrseed + 1);
return bbob2009_fmin(1000., bbob2009_fmax(-1000., bbob2009_round(100. * 100. * gval / gval2) / 100.));
}
/**
* bbob2009_compute_rotation(B, seed, DIM):
*
* Compute a ${DIM}x${DIM} rotation matrix based on ${seed} and store
* it in ${B}.
*/
static void bbob2009_compute_rotation(double **B, long seed, long DIM) {
/* To ensure temporary data fits into gvec */
double prod;
double gvect[2000];
long i, j, k; /* Loop over pairs of column vectors. */
assert(DIM * DIM < 2000);
bbob2009_gauss(gvect, DIM * DIM, seed);
bbob2009_reshape(B, gvect, DIM, DIM);
/*1st coordinate is row, 2nd is column.*/
for (i = 0; i < DIM; i++) {
for (j = 0; j < i; j++) {
prod = 0;
for (k = 0; k < DIM; k++)
prod += B[k][i] * B[k][j];
for (k = 0; k < DIM; k++)
B[k][i] -= prod * B[k][j];
}
prod = 0;
for (k = 0; k < DIM; k++)
prod += B[k][i] * B[k][i];
for (k = 0; k < DIM; k++)
B[k][i] /= sqrt(prod);
}
}
/**
* @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;
}
