static void transform_vars_brs_evaluate(coco_problem_t *self, const double *x, double *y) {
size_t i;
double factor;
transform_vars_brs_data_t *data;
coco_problem_t *inner_problem;
data = coco_transformed_get_data(self);
inner_problem = coco_transformed_get_inner_problem(self);
for (i = 0; i < self->number_of_variables; ++i) {
/* Function documentation says we should compute 10^(0.5 *
* (i-1)/(D-1)). Instead we compute the equivalent
* sqrt(10)^((i-1)/(D-1)) just like the legacy code.
*/
factor = pow(sqrt(10.0), (double) (long) i / ((double) (long) self->number_of_variables - 1.0));
/* Documentation specifies odd indexes and starts indexing
* from 1, we use all even indexes since C starts indexing
* with 0.
*/
if (x[i] > 0.0 && i % 2 == 0) {
factor *= 10.0;
}
data->x[i] = factor * x[i];
}
coco_evaluate_function(inner_problem, data->x, y);
}
static void transform_vars_oscillate_evaluate(coco_problem_t *self, const double *x, double *y) {
static const double alpha = 0.1;
double tmp, base, *oscillated_x;
size_t i;
transform_vars_oscillate_data_t *data;
coco_problem_t *inner_problem;
data = coco_transformed_get_data(self);
oscillated_x = data->oscillated_x; /* short cut to make code more readable */
inner_problem = coco_transformed_get_inner_problem(self);
for (i = 0; i < self->number_of_variables; ++i) {
if (x[i] > 0.0) {
tmp = log(x[i]) / alpha;
base = exp(tmp + 0.49 * (sin(tmp) + sin(0.79 * tmp)));
oscillated_x[i] = pow(base, alpha);
} else if (x[i] < 0.0) {
tmp = log(-x[i]) / alpha;
base = exp(tmp + 0.49 * (sin(0.55 * tmp) + sin(0.31 * tmp)));
oscillated_x[i] = -pow(base, alpha);
} else {
oscillated_x[i] = 0.0;
}
}
coco_evaluate_function(inner_problem, oscillated_x, y);
assert(y[0] + 1e-13 >= self->best_value[0]);
}
/**
* Layer added to the transformed-problem evaluate_function by the logger
*/
static void logger_bbob2009_evaluate(coco_problem_t *self, const double *x, double *y) {
logger_bbob2009_t *data = coco_transformed_get_data(self);
coco_problem_t * inner_problem = coco_transformed_get_inner_problem(self);
if (!data->is_initialized) {
logger_bbob2009_initialize(data, inner_problem);
}
if (bbob2009_logger_verbosity > 2 && data->number_of_evaluations == 0) {
if (inner_problem->suite_dep_index >= 0) {
printf("%4ld: ", inner_problem->suite_dep_index);
}
printf("on problem %s ... ", coco_problem_get_id(inner_problem));
}
coco_evaluate_function(inner_problem, x, y);
data->last_fvalue = y[0];
data->written_last_eval = 0;
if (data->number_of_evaluations == 0 || y[0] < data->best_fvalue) {
size_t i;
data->best_fvalue = y[0];
for (i = 0; i < self->number_of_variables; i++)
data->best_solution[i] = x[i];
}
data->number_of_evaluations++;
/* Add sanity check for optimal f value */
/* assert(y[0] >= data->optimal_fvalue); */
if (!bbob2009_raisedOptValWarning && y[0] < data->optimal_fvalue) {
coco_warning("Observed fitness is smaller than supposed optimal fitness.");
bbob2009_raisedOptValWarning = 1;
}
/* Add a line in the .dat file for each logging target reached. */
if (y[0] - data->optimal_fvalue <= data->f_trigger) {
logger_bbob2009_write_data(data->fdata_file, data->number_of_evaluations, y[0], data->best_fvalue,
data->optimal_fvalue, x, self->number_of_variables);
logger_bbob2009_update_f_trigger(data, y[0]);
}
/* Add a line in the .tdat file each time an fevals trigger is reached. */
if (data->number_of_evaluations >= data->t_trigger) {
data->written_last_eval = 1;
logger_bbob2009_write_data(data->tdata_file, data->number_of_evaluations, y[0], data->best_fvalue,
data->optimal_fvalue, x, self->number_of_variables);
logger_bbob2009_update_t_trigger(data, self->number_of_variables);
}
/* Flush output so that impatient users can see progress. */
fflush(data->fdata_file);
}
static void transform_vars_shift_evaluate(coco_problem_t *self, const double *x, double *y) {
size_t i;
transform_vars_shift_data_t *data;
coco_problem_t *inner_problem;
data = coco_transformed_get_data(self);
inner_problem = coco_transformed_get_inner_problem(self);
for (i = 0; i < self->number_of_variables; ++i) {
data->shifted_x[i] = x[i] - data->offset[i];
}
coco_evaluate_function(inner_problem, data->shifted_x, y);
assert(y[0] >= self->best_value[0]);
}
static void transform_obj_oscillate_evaluate(coco_problem_t *self, const double *x, double *y) {
static const double factor = 0.1;
size_t i;
coco_evaluate_function(coco_transformed_get_inner_problem(self), x, y);
for (i = 0; i < self->number_of_objectives; i++) {
if (y[i] != 0) {
double log_y;
log_y = log(fabs(y[i])) / factor;
if (y[i] > 0) {
y[i] = pow(exp(log_y + 0.49 * (sin(log_y) + sin(0.79 * log_y))), factor);
} else {
y[i] = -pow(exp(log_y + 0.49 * (sin(0.55 * log_y) + sin(0.31 * log_y))), factor);
}
}
}
}
static void transform_vars_scale_evaluate(coco_problem_t *self, const double *x, double *y) {
size_t i;
transform_vars_scale_data_t *data;
coco_problem_t *inner_problem;
data = coco_transformed_get_data(self);
inner_problem = coco_transformed_get_inner_problem(self);
do {
const double factor = data->factor;
for (i = 0; i < self->number_of_variables; ++i) {
data->x[i] = factor * x[i];
}
coco_evaluate_function(inner_problem, data->x, y);
assert(y[0] >= self->best_value[0]);
} while (0);
}
static void transform_vars_conditioning_evaluate(coco_problem_t *self, const double *x, double *y) {
size_t i;
transform_vars_conditioning_data_t *data;
coco_problem_t *inner_problem;
data = coco_transformed_get_data(self);
inner_problem = coco_transformed_get_inner_problem(self);
for (i = 0; i < self->number_of_variables; ++i) {
/* OME: We could precalculate the scaling coefficients if we
* really wanted to.
*/
data->x[i] = pow(data->alpha, 0.5 * (double) (long) i / ((double) (long) self->number_of_variables - 1.0))
* x[i];
}
coco_evaluate_function(inner_problem, data->x, y);
}
static void transform_vars_asymmetric_evaluate(coco_problem_t *self, const double *x, double *y) {
size_t i;
double exponent;
transform_vars_asymmetric_data_t *data;
coco_problem_t *inner_problem;
data = coco_transformed_get_data(self);
inner_problem = coco_transformed_get_inner_problem(self);
for (i = 0; i < self->number_of_variables; ++i) {
if (x[i] > 0.0) {
exponent = 1.0
+ (data->beta * (double) (long) i) / ((double) (long) self->number_of_variables - 1.0) * sqrt(x[i]);
data->x[i] = pow(x[i], exponent);
} else {
data->x[i] = x[i];
}
}
coco_evaluate_function(inner_problem, data->x, y);
}
static void transform_vars_affine_evaluate(coco_problem_t *self, const double *x, double *y) {
size_t i, j;
transform_vars_affine_data_t *data;
coco_problem_t *inner_problem;
data = coco_transformed_get_data(self);
inner_problem = coco_transformed_get_inner_problem(self);
for (i = 0; i < inner_problem->number_of_variables; ++i) {
/* data->M has self->number_of_variables columns and
* problem->inner_problem->number_of_variables rows.
*/
const double *current_row = data->M + i * self->number_of_variables;
data->x[i] = data->b[i];
for (j = 0; j < self->number_of_variables; ++j) {
data->x[i] += x[j] * current_row[j];
}
}
coco_evaluate_function(inner_problem, data->x, y);
assert(y[0] + 1e-13 >= self->best_value[0]);
}
/**
* Evaluates the function, increases the number of evaluations and outputs information based on the targets
* that have been hit.
*/
static void logger_toy_evaluate(coco_problem_t *self, const double *x, double *y) {
logger_toy_t *logger;
observer_toy_t *observer_toy;
double *targets;
logger = coco_transformed_get_data(self);
observer_toy = (observer_toy_t *) logger->observer->data;
targets = observer_toy->targets;
coco_evaluate_function(coco_transformed_get_inner_problem(self), x, y);
logger->number_of_evaluations++;
/* Add a line for each target that has been hit */
while (y[0] <= targets[logger->next_target] && logger->next_target < observer_toy->number_of_targets) {
fprintf(observer_toy->log_file, "%e\t%5ld\t%.5f\n", targets[logger->next_target],
logger->number_of_evaluations, y[0]);
logger->next_target++;
}
/* Flush output so that impatient users can see the progress */
fflush(observer_toy->log_file);
}
static void transform_obj_shift_evaluate(coco_problem_t *self, const double *x, double *y) {
transform_obj_shift_data_t *data;
data = coco_transformed_get_data(self);
coco_evaluate_function(coco_transformed_get_inner_problem(self), x, y);
y[0] += data->offset; /* FIXME: shifts only the first objective */
}
