/**
* @brief Evaluates the transformation.
*/
static void transform_vars_oscillate_evaluate(coco_problem_t *problem, 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 = (transform_vars_oscillate_data_t *) coco_problem_transformed_get_data(problem);
oscillated_x = data->oscillated_x; /* short cut to make code more readable */
inner_problem = coco_problem_transformed_get_inner_problem(problem);
for (i = 0; i < problem->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 >= problem->best_value[0]);
}
/**
* @brief Evaluates the transformation.
*/
static void transform_vars_asymmetric_evaluate(coco_problem_t *problem, const double *x, double *y) {
size_t i;
double exponent;
transform_vars_asymmetric_data_t *data;
coco_problem_t *inner_problem;
if (coco_vector_contains_nan(x, coco_problem_get_dimension(problem))) {
coco_vector_set_to_nan(y, coco_problem_get_number_of_objectives(problem));
return;
}
data = (transform_vars_asymmetric_data_t *) coco_problem_transformed_get_data(problem);
inner_problem = coco_problem_transformed_get_inner_problem(problem);
for (i = 0; i < problem->number_of_variables; ++i) {
if (x[i] > 0.0) {
exponent = 1.0
+ (data->beta * (double) (long) i) / ((double) (long) problem->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);
assert(y[0] + 1e-13 >= problem->best_value[0]);
}
static void transform_vars_permblockdiag_evaluate(coco_problem_t *problem, const double *x, double *y) {
size_t i, j, current_blocksize, first_non_zero_ind;
transform_vars_permblockdiag_t *data;
coco_problem_t *inner_problem;
if (coco_vector_contains_nan(x, coco_problem_get_dimension(problem))) {
coco_vector_set_to_nan(y, coco_problem_get_number_of_objectives(problem));
return;
}
data = (transform_vars_permblockdiag_t *) coco_problem_transformed_get_data(problem);
inner_problem = coco_problem_transformed_get_inner_problem(problem);
for (i = 0; i < inner_problem->number_of_variables; ++i) {
current_blocksize = data->block_size_map[data->P2[i]];/*the block_size is that of the permuted line*/
first_non_zero_ind = data->first_non_zero_map[data->P2[i]];
data->x[i] = 0;
/*compute data->x[i] = < B[P2[i]] , x[P1] > */
for (j = first_non_zero_ind; j < first_non_zero_ind + current_blocksize; ++j) {/*blocksize[P2[i]]*/
data->x[i] += data->B[data->P2[i]][j - first_non_zero_ind] * x[data->P1[j]];/*all B lines start at 0*/
}
if (data->x[i] > 100 || data->x[i] < -100 || 1) {
}
}
coco_evaluate_function(inner_problem, data->x, y);
assert(y[0] + 1e-13 >= problem->best_value[0]);
}
/**
* @brief Evaluates the transformation.
*/
static void transform_vars_brs_evaluate(coco_problem_t *problem, const double *x, double *y) {
size_t i;
double factor;
transform_vars_brs_data_t *data;
coco_problem_t *inner_problem;
data = (transform_vars_brs_data_t *) coco_problem_transformed_get_data(problem);
inner_problem = coco_problem_transformed_get_inner_problem(problem);
for (i = 0; i < problem->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) problem->number_of_variables - 1.0));
/* Documentation specifies odd indices and starts indexing
* from 1, we use all even indices 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);
assert(y[0] + 1e-13 >= problem->best_value[0]);
}
/**
* @brief Evaluates the transformation.
*/
static void transform_obj_power_evaluate(coco_problem_t *problem, const double *x, double *y) {
transform_obj_power_data_t *data;
size_t i;
data = (transform_obj_power_data_t *) coco_problem_transformed_get_data(problem);
coco_evaluate_function(coco_problem_transformed_get_inner_problem(problem), x, y);
for (i = 0; i < problem->number_of_objectives; i++) {
y[i] = pow(y[i], data->exponent);
}
assert(y[0] + 1e-13 >= problem->best_value[0]);
}
/**
* @brief Evaluates the transformation.
*/
static void transform_vars_shift_evaluate(coco_problem_t *problem, const double *x, double *y) {
size_t i;
transform_vars_shift_data_t *data;
coco_problem_t *inner_problem;
data = (transform_vars_shift_data_t *) coco_problem_transformed_get_data(problem);
inner_problem = coco_problem_transformed_get_inner_problem(problem);
for (i = 0; i < problem->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] + 1e-13 >= problem->best_value[0]);
}
/**
* @brief Evaluates the transformation.
*/
static void transform_vars_z_hat_evaluate(coco_problem_t *problem, const double *x, double *y) {
size_t i;
transform_vars_z_hat_data_t *data;
coco_problem_t *inner_problem;
data = (transform_vars_z_hat_data_t *) coco_problem_transformed_get_data(problem);
inner_problem = coco_problem_transformed_get_inner_problem(problem);
data->z[0] = x[0];
for (i = 1; i < problem->number_of_variables; ++i) {
data->z[i] = x[i] + 0.25 * (x[i - 1] - 2.0 * fabs(data->xopt[i - 1]));
}
coco_evaluate_function(inner_problem, data->z, y);
assert(y[0] + 1e-13 >= problem->best_value[0]);
}
/**
* @brief Evaluates the transformation.
*/
static void transform_vars_scale_evaluate(coco_problem_t *problem, const double *x, double *y) {
size_t i;
transform_vars_scale_data_t *data;
coco_problem_t *inner_problem;
data = (transform_vars_scale_data_t *) coco_problem_transformed_get_data(problem);
inner_problem = coco_problem_transformed_get_inner_problem(problem);
do {
const double factor = data->factor;
for (i = 0; i < problem->number_of_variables; ++i) {
data->x[i] = factor * x[i];
}
coco_evaluate_function(inner_problem, data->x, y);
assert(y[0] + 1e-13 >= problem->best_value[0]);
} while (0);
}
/**
* @brief Evaluates the transformation.
*/
static void transform_vars_conditioning_evaluate(coco_problem_t *problem, const double *x, double *y) {
size_t i;
transform_vars_conditioning_data_t *data;
coco_problem_t *inner_problem;
data = (transform_vars_conditioning_data_t *) coco_problem_transformed_get_data(problem);
inner_problem = coco_problem_transformed_get_inner_problem(problem);
for (i = 0; i < problem->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) problem->number_of_variables - 1.0))
* x[i];
}
coco_evaluate_function(inner_problem, data->x, y);
assert(y[0] + 1e-13 >= problem->best_value[0]);
}
/**
* @brief Evaluates the transformation.
*/
static void transform_vars_shift_evaluate(coco_problem_t *problem, const double *x, double *y) {
size_t i;
transform_vars_shift_data_t *data;
coco_problem_t *inner_problem;
if (coco_vector_contains_nan(x, coco_problem_get_dimension(problem))) {
coco_vector_set_to_nan(y, coco_problem_get_number_of_objectives(problem));
return;
}
data = (transform_vars_shift_data_t *) coco_problem_transformed_get_data(problem);
inner_problem = coco_problem_transformed_get_inner_problem(problem);
for (i = 0; i < problem->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] + 1e-13 >= problem->best_value[0]);
}
/**
* @brief Evaluates the transformation.
*/
static void transform_vars_z_hat_evaluate(coco_problem_t *problem, const double *x, double *y) {
size_t i;
transform_vars_z_hat_data_t *data;
coco_problem_t *inner_problem;
if (coco_vector_contains_nan(x, coco_problem_get_dimension(problem))) {
coco_vector_set_to_nan(y, coco_problem_get_number_of_objectives(problem));
return;
}
data = (transform_vars_z_hat_data_t *) coco_problem_transformed_get_data(problem);
inner_problem = coco_problem_transformed_get_inner_problem(problem);
data->z[0] = x[0];
for (i = 1; i < problem->number_of_variables; ++i) {
data->z[i] = x[i] + 0.25 * (x[i - 1] - 2.0 * fabs(data->xopt[i - 1]));
}
coco_evaluate_function(inner_problem, data->z, y);
assert(y[0] + 1e-13 >= problem->best_value[0]);
}
/**
* @brief Evaluates the transformation.
*/
static void transform_obj_penalize_evaluate(coco_problem_t *problem, const double *x, double *y) {
transform_obj_penalize_data_t *data = (transform_obj_penalize_data_t *) coco_problem_transformed_get_data(problem);
const double *lower_bounds = problem->smallest_values_of_interest;
const double *upper_bounds = problem->largest_values_of_interest;
double penalty = 0.0;
size_t i;
for (i = 0; i < problem->number_of_variables; ++i) {
const double c1 = x[i] - upper_bounds[i];
const double c2 = lower_bounds[i] - x[i];
assert(lower_bounds[i] < upper_bounds[i]);
if (c1 > 0.0) {
penalty += c1 * c1;
} else if (c2 > 0.0) {
penalty += c2 * c2;
}
}
assert(coco_problem_transformed_get_inner_problem(problem) != NULL);
coco_evaluate_function(coco_problem_transformed_get_inner_problem(problem), x, y);
for (i = 0; i < problem->number_of_objectives; ++i) {
y[i] += data->factor * penalty;
}
assert(y[0] + 1e-13 >= problem->best_value[0]);
}
/**
* @brief Evaluates the transformation.
*/
static void transform_vars_affine_evaluate(coco_problem_t *problem, const double *x, double *y) {
size_t i, j;
transform_vars_affine_data_t *data;
coco_problem_t *inner_problem;
if (coco_vector_contains_nan(x, coco_problem_get_dimension(problem))) {
coco_vector_set_to_nan(y, coco_problem_get_number_of_objectives(problem));
return;
}
data = (transform_vars_affine_data_t *) coco_problem_transformed_get_data(problem);
inner_problem = coco_problem_transformed_get_inner_problem(problem);
for (i = 0; i < inner_problem->number_of_variables; ++i) {
/* data->M has problem->number_of_variables columns and inner_problem->number_of_variables rows. */
const double *current_row = data->M + i * problem->number_of_variables;
data->x[i] = data->b[i];
for (j = 0; j < problem->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 >= problem->best_value[0]);
}
/**
* @brief Evaluates the function, increases the number of evaluations and outputs information based on the
* observer options.
*/
static void logger_biobj_evaluate(coco_problem_t *problem, const double *x, double *y) {
logger_biobj_data_t *logger;
logger_biobj_avl_item_t *node_item;
logger_biobj_indicator_t *indicator;
avl_node_t *solution;
int update_performed;
size_t i;
logger = (logger_biobj_data_t *) coco_problem_transformed_get_data(problem);
/* Evaluate function */
coco_evaluate_function(coco_problem_transformed_get_inner_problem(problem), x, y);
logger->number_of_evaluations++;
/* Update the archive with the new solution, if it is not dominated by or equal to existing solutions in
* the archive */
node_item = logger_biobj_node_create(x, y, logger->number_of_evaluations, logger->number_of_variables,
logger->number_of_objectives);
update_performed = logger_biobj_tree_update(logger, coco_problem_transformed_get_inner_problem(problem),
node_item);
/* If the archive was updated and you need to log all nondominated solutions, output the new solution to
* nondom_file */
if (update_performed && (logger->log_nondom_mode == LOG_NONDOM_ALL)) {
logger_biobj_tree_output(logger->archive_file, logger->buffer_tree, logger->number_of_variables,
logger->number_of_objectives, logger->log_vars, logger->precision_x, logger->precision_f);
avl_tree_purge(logger->buffer_tree);
/* Flush output so that impatient users can see progress. */
fflush(logger->archive_file);
}
/* Perform output to the:
* - dat file, if the archive was updated and a new target was reached for an indicator;
* - tdat file, if the number of evaluations matches one of the predefined numbers.
*
* Note that a target is reached when the (best_value - current_value) <= relative_target_value
* The relative_target_value is a target for indicator difference, not indicator value!
*/
if (logger->compute_indicators) {
for (i = 0; i < OBSERVER_BIOBJ_NUMBER_OF_INDICATORS; i++) {
indicator = logger->indicators[i];
indicator->target_hit = 0;
/* If the update was performed, update the overall indicator value */
if (update_performed) {
/* Compute the overall_value of an indicator */
if (strcmp(indicator->name, "hyp") == 0) {
if (indicator->current_value == 0) {
/* The additional penalty for hypervolume is the minimal distance from the nondominated set to the ROI */
indicator->additional_penalty = DBL_MAX;
if (logger->archive_tree->tail) {
solution = logger->archive_tree->head;
while (solution != NULL) {
double distance = mo_get_distance_to_ROI(((logger_biobj_avl_item_t*) solution->item)->y,
problem->best_value, problem->nadir_value, problem->number_of_objectives);
indicator->additional_penalty = coco_double_min(indicator->additional_penalty, distance);
solution = solution->next;
}
}
assert(indicator->additional_penalty >= 0);
} else {
indicator->additional_penalty = 0;
}
indicator->overall_value = indicator->best_value - indicator->current_value
+ indicator->additional_penalty;
} else {
coco_error("logger_biobj_evaluate(): Indicator computation not implemented yet for indicator %s",
indicator->name);
}
/* Check whether a target was hit */
while ((indicator->next_target_id < MO_NUMBER_OF_TARGETS)
&& (indicator->overall_value <= mo_relateive_target_values[indicator->next_target_id])) {
/* A target was hit */
indicator->target_hit = 1;
if (indicator->next_target_id + 1 < MO_NUMBER_OF_TARGETS)
indicator->next_target_id++;
else
break;
}
}
/* Log to the dat file if a target was hit */
if (indicator->target_hit) {
fprintf(indicator->dat_file, "%lu\t%.*e\t%.*e\n", logger->number_of_evaluations, logger->precision_f,
indicator->overall_value, logger->precision_f,
mo_relateive_target_values[indicator->next_target_id - 1]);
}
/* Log to the tdat file if the number of evaluations matches one of the predefined numbers */
if (coco_observer_evaluation_to_log(logger->number_of_evaluations, logger->number_of_variables)) {
fprintf(indicator->tdat_file, "%lu\t%.*e\n", logger->number_of_evaluations, logger->precision_f,
indicator->overall_value);
}
}
}
}
