/**
* @brief Creates the transformation.
*/
static coco_problem_t *transform_vars_affine(coco_problem_t *inner_problem,
const double *M,
const double *b,
const size_t number_of_variables) {
/*
* TODO:
* - Calculate new smallest/largest values of interest?
* - Resize bounds vectors if input and output dimensions do not match
*/
coco_problem_t *problem;
transform_vars_affine_data_t *data;
size_t entries_in_M;
entries_in_M = inner_problem->number_of_variables * number_of_variables;
data = (transform_vars_affine_data_t *) coco_allocate_memory(sizeof(*data));
data->M = coco_duplicate_vector(M, entries_in_M);
data->b = coco_duplicate_vector(b, inner_problem->number_of_variables);
data->x = coco_allocate_vector(inner_problem->number_of_variables);
problem = coco_problem_transformed_allocate(inner_problem, data, transform_vars_affine_free, "transform_vars_affine");
problem->evaluate_function = transform_vars_affine_evaluate;
if (coco_problem_best_parameter_not_zero(inner_problem)) {
coco_debug("transform_vars_affine(): 'best_parameter' not updated, set to NAN");
coco_vector_set_to_nan(inner_problem->best_parameter, inner_problem->number_of_variables);
}
return problem;
}
/**
* @brief Creates the transformation.
*/
static coco_problem_t *transform_obj_oscillate(coco_problem_t *inner_problem) {
coco_problem_t *problem;
problem = coco_problem_transformed_allocate(inner_problem, NULL, NULL);
problem->evaluate_function = transform_obj_oscillate_evaluate;
/* Compute best value */
/* Maybe not the most efficient solution */
transform_obj_oscillate_evaluate(problem, problem->best_parameter, problem->best_value);
return problem;
}
/**
* @brief Creates the transformation.
*/
static coco_problem_t *transform_vars_brs(coco_problem_t *inner_problem) {
transform_vars_brs_data_t *data;
coco_problem_t *problem;
data = (transform_vars_brs_data_t *) coco_allocate_memory(sizeof(*data));
data->x = coco_allocate_vector(inner_problem->number_of_variables);
problem = coco_problem_transformed_allocate(inner_problem, data, transform_vars_brs_free, "transform_vars_brs");
problem->evaluate_function = transform_vars_brs_evaluate;
return problem;
}
/**
* @brief Creates the transformation.
*/
static coco_problem_t *transform_vars_conditioning(coco_problem_t *inner_problem, const double alpha) {
transform_vars_conditioning_data_t *data;
coco_problem_t *problem;
data = (transform_vars_conditioning_data_t *) coco_allocate_memory(sizeof(*data));
data->x = coco_allocate_vector(inner_problem->number_of_variables);
data->alpha = alpha;
problem = coco_problem_transformed_allocate(inner_problem, data, transform_vars_conditioning_free);
problem->evaluate_function = transform_vars_conditioning_evaluate;
return problem;
}
/**
* @brief Creates the transformation.
*/
static coco_problem_t *transform_vars_asymmetric(coco_problem_t *inner_problem, const double beta) {
transform_vars_asymmetric_data_t *data;
coco_problem_t *problem;
data = (transform_vars_asymmetric_data_t *) coco_allocate_memory(sizeof(*data));
data->x = coco_allocate_vector(inner_problem->number_of_variables);
data->beta = beta;
problem = coco_problem_transformed_allocate(inner_problem, data, transform_vars_asymmetric_free, "transform_vars_asymmetric");
problem->evaluate_function = transform_vars_asymmetric_evaluate;
return problem;
}
/**
* @brief Creates the transformation.
*/
static coco_problem_t *transform_obj_penalize(coco_problem_t *inner_problem, const double factor) {
coco_problem_t *problem;
transform_obj_penalize_data_t *data;
assert(inner_problem != NULL);
data = (transform_obj_penalize_data_t *) coco_allocate_memory(sizeof(*data));
data->factor = factor;
problem = coco_problem_transformed_allocate(inner_problem, data, NULL);
problem->evaluate_function = transform_obj_penalize_evaluate;
/* No need to update the best value as the best parameter is feasible */
return problem;
}
/**
* @brief Creates the transformation.
*/
static coco_problem_t *transform_vars_z_hat(coco_problem_t *inner_problem, const double *xopt) {
transform_vars_z_hat_data_t *data;
coco_problem_t *problem;
data = (transform_vars_z_hat_data_t *) coco_allocate_memory(sizeof(*data));
data->xopt = coco_duplicate_vector(xopt, inner_problem->number_of_variables);
data->z = coco_allocate_vector(inner_problem->number_of_variables);
problem = coco_problem_transformed_allocate(inner_problem, data, transform_vars_z_hat_free, "transform_vars_z_hat");
problem->evaluate_function = transform_vars_z_hat_evaluate;
return problem;
}
/**
* @brief Creates the transformation.
*/
static coco_problem_t *transform_obj_power(coco_problem_t *inner_problem, const double exponent) {
transform_obj_power_data_t *data;
coco_problem_t *problem;
data = (transform_obj_power_data_t *) coco_allocate_memory(sizeof(*data));
data->exponent = exponent;
problem = coco_problem_transformed_allocate(inner_problem, data, NULL, "transform_obj_power");
problem->evaluate_function = transform_obj_power_evaluate;
/* Compute best value */
transform_obj_power_evaluate(problem, problem->best_parameter, problem->best_value);
return problem;
}
/**
* @brief Creates the transformation.
*/
static coco_problem_t *transform_vars_z_hat(coco_problem_t *inner_problem, const double *xopt) {
transform_vars_z_hat_data_t *data;
coco_problem_t *problem;
data = (transform_vars_z_hat_data_t *) coco_allocate_memory(sizeof(*data));
data->xopt = coco_duplicate_vector(xopt, inner_problem->number_of_variables);
data->z = coco_allocate_vector(inner_problem->number_of_variables);
problem = coco_problem_transformed_allocate(inner_problem, data, transform_vars_z_hat_free, "transform_vars_z_hat");
problem->evaluate_function = transform_vars_z_hat_evaluate;
/* TODO: When should this warning be output?
coco_warning("transform_vars_z_hat(): 'best_parameter' not updated"); */
return problem;
}
/**
* @brief Creates the transformation.
*/
static coco_problem_t *transform_vars_asymmetric(coco_problem_t *inner_problem, const double beta) {
transform_vars_asymmetric_data_t *data;
coco_problem_t *problem;
data = (transform_vars_asymmetric_data_t *) coco_allocate_memory(sizeof(*data));
data->x = coco_allocate_vector(inner_problem->number_of_variables);
data->beta = beta;
problem = coco_problem_transformed_allocate(inner_problem, data, transform_vars_asymmetric_free, "transform_vars_asymmetric");
problem->evaluate_function = transform_vars_asymmetric_evaluate;
if (coco_problem_best_parameter_not_zero(inner_problem)) {
coco_warning("transform_vars_asymmetric(): 'best_parameter' not updated, set to NAN");
coco_vector_set_to_nan(inner_problem->best_parameter, inner_problem->number_of_variables);
}
return problem;
}
/**
* @brief Creates the transformation.
*/
static coco_problem_t *transform_vars_scale(coco_problem_t *inner_problem, const double factor) {
transform_vars_scale_data_t *data;
coco_problem_t *problem;
size_t i;
data = (transform_vars_scale_data_t *) coco_allocate_memory(sizeof(*data));
data->factor = factor;
data->x = coco_allocate_vector(inner_problem->number_of_variables);
problem = coco_problem_transformed_allocate(inner_problem, data, transform_vars_scale_free, "transform_vars_scale");
problem->evaluate_function = transform_vars_scale_evaluate;
/* Compute best parameter */
if (data->factor != 0.) {
for (i = 0; i < problem->number_of_variables; i++) {
problem->best_parameter[i] /= data->factor;
}
} /* else error? */
return problem;
}
/*
* Apply a double permuted orthogonal block-diagonal transfromation matrix to the search space
*
*
* The matrix M is stored in row-major format.
*/
static coco_problem_t *transform_vars_permblockdiag(coco_problem_t *inner_problem,
const double * const *B,
const size_t *P1,
const size_t *P2,
const size_t number_of_variables,
const size_t *block_sizes,
const size_t nb_blocks) {
coco_problem_t *problem;
transform_vars_permblockdiag_t *data;
size_t entries_in_M, idx_blocksize, next_bs_change, current_blocksize;
int i;
entries_in_M = 0;
assert(number_of_variables > 0);/*tmp*/
for (i = 0; i < nb_blocks; i++) {
entries_in_M += block_sizes[i] * block_sizes[i];
}
data = (transform_vars_permblockdiag_t *) coco_allocate_memory(sizeof(*data));
data->B = ls_copy_block_matrix(B, number_of_variables, block_sizes, nb_blocks);
data->x = coco_allocate_vector(inner_problem->number_of_variables);
data->P1 = coco_duplicate_size_t_vector(P1, inner_problem->number_of_variables);
data->P2 = coco_duplicate_size_t_vector(P2, inner_problem->number_of_variables);
data->block_sizes = coco_duplicate_size_t_vector(block_sizes, nb_blocks);
data->nb_blocks = nb_blocks;
data->block_size_map = coco_allocate_vector_size_t(number_of_variables);
data->first_non_zero_map = coco_allocate_vector_size_t(number_of_variables);
idx_blocksize = 0;
next_bs_change = block_sizes[idx_blocksize];
for (i = 0; i < number_of_variables; i++) {
if (i >= next_bs_change) {
idx_blocksize++;
next_bs_change += block_sizes[idx_blocksize];
}
current_blocksize=block_sizes[idx_blocksize];
data->block_size_map[i] = current_blocksize;
data->first_non_zero_map[i] = next_bs_change - current_blocksize;/* next_bs_change serves also as a cumsum for blocksizes*/
}
problem = coco_problem_transformed_allocate(inner_problem, data, transform_vars_permblockdiag_free);
problem->evaluate_function = transform_vars_permblockdiag_evaluate;
return problem;
}
/**
* @brief Creates the transformation.
*/
static coco_problem_t *transform_vars_shift(coco_problem_t *inner_problem,
const double *offset,
const int shift_bounds) {
transform_vars_shift_data_t *data;
coco_problem_t *problem;
size_t i;
if (shift_bounds)
coco_error("shift_bounds not implemented.");
data = (transform_vars_shift_data_t *) coco_allocate_memory(sizeof(*data));
data->offset = coco_duplicate_vector(offset, inner_problem->number_of_variables);
data->shifted_x = coco_allocate_vector(inner_problem->number_of_variables);
problem = coco_problem_transformed_allocate(inner_problem, data, transform_vars_shift_free, "transform_vars_shift");
problem->evaluate_function = transform_vars_shift_evaluate;
/* Compute best parameter */
for (i = 0; i < problem->number_of_variables; i++) {
problem->best_parameter[i] += data->offset[i];
}
return problem;
}
/**
* @brief Initializes the biobjective logger.
*/
static coco_problem_t *logger_biobj(coco_observer_t *observer, coco_problem_t *inner_problem) {
coco_problem_t *problem;
logger_biobj_data_t *logger_biobj;
observer_biobj_data_t *observer_biobj;
const char nondom_folder_name[] = "archive";
char *path_name, *file_name = NULL, *prefix;
size_t i;
if (inner_problem->number_of_objectives != 2) {
coco_error("logger_biobj(): The bi-objective logger cannot log a problem with %d objective(s)", inner_problem->number_of_objectives);
return NULL; /* Never reached. */
}
logger_biobj = (logger_biobj_data_t *) coco_allocate_memory(sizeof(*logger_biobj));
logger_biobj->observer = observer;
logger_biobj->number_of_evaluations = 0;
logger_biobj->number_of_variables = inner_problem->number_of_variables;
logger_biobj->number_of_objectives = inner_problem->number_of_objectives;
logger_biobj->suite_dep_instance = inner_problem->suite_dep_instance;
observer_biobj = (observer_biobj_data_t *) observer->data;
/* Copy values from the observes that you might need even if they do not exist any more */
logger_biobj->log_nondom_mode = observer_biobj->log_nondom_mode;
logger_biobj->compute_indicators = observer_biobj->compute_indicators;
logger_biobj->precision_x = observer->precision_x;
logger_biobj->precision_f = observer->precision_f;
if (((observer_biobj->log_vars_mode == LOG_VARS_LOW_DIM) && (inner_problem->number_of_variables > 5))
|| (observer_biobj->log_vars_mode == LOG_VARS_NEVER))
logger_biobj->log_vars = 0;
else
logger_biobj->log_vars = 1;
/* Initialize logging of nondominated solutions into the archive file */
if (logger_biobj->log_nondom_mode != LOG_NONDOM_NONE) {
/* Create the path to the file */
path_name = coco_allocate_string(COCO_PATH_MAX);
memcpy(path_name, observer->result_folder, strlen(observer->result_folder) + 1);
coco_join_path(path_name, COCO_PATH_MAX, nondom_folder_name, NULL);
coco_create_directory(path_name);
/* Construct file name */
prefix = coco_remove_from_string(inner_problem->problem_id, "_i", "_d");
if (logger_biobj->log_nondom_mode == LOG_NONDOM_ALL)
file_name = coco_strdupf("%s_nondom_all.adat", prefix);
else if (logger_biobj->log_nondom_mode == LOG_NONDOM_FINAL)
file_name = coco_strdupf("%s_nondom_final.adat", prefix);
coco_join_path(path_name, COCO_PATH_MAX, file_name, NULL);
if (logger_biobj->log_nondom_mode != LOG_NONDOM_NONE)
coco_free_memory(file_name);
coco_free_memory(prefix);
/* Open and initialize the archive file */
logger_biobj->archive_file = fopen(path_name, "a");
if (logger_biobj->archive_file == NULL) {
coco_error("logger_biobj() failed to open file '%s'.", path_name);
return NULL; /* Never reached */
}
coco_free_memory(path_name);
/* Output header information */
fprintf(logger_biobj->archive_file, "%% instance = %ld, name = %s\n", inner_problem->suite_dep_instance, inner_problem->problem_name);
if (logger_biobj->log_vars) {
fprintf(logger_biobj->archive_file, "%% function evaluation | %lu objectives | %lu variables\n",
inner_problem->number_of_objectives, inner_problem->number_of_variables);
} else {
fprintf(logger_biobj->archive_file, "%% function evaluation | %lu objectives \n",
inner_problem->number_of_objectives);
}
}
/* Initialize the AVL trees */
logger_biobj->archive_tree = avl_tree_construct((avl_compare_t) avl_tree_compare_by_last_objective,
(avl_free_t) logger_biobj_node_free);
logger_biobj->buffer_tree = avl_tree_construct((avl_compare_t) avl_tree_compare_by_time_stamp, NULL);
problem = coco_problem_transformed_allocate(inner_problem, logger_biobj, logger_biobj_free);
problem->evaluate_function = logger_biobj_evaluate;
/* Initialize the indicators */
if (logger_biobj->compute_indicators) {
for (i = 0; i < OBSERVER_BIOBJ_NUMBER_OF_INDICATORS; i++)
logger_biobj->indicators[i] = logger_biobj_indicator(logger_biobj, inner_problem, observer_biobj_indicators[i]);
observer_biobj->previous_function = (long) inner_problem->suite_dep_function;
}
return problem;
}
