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