/**
* @brief Allocates a transformed problem that wraps the inner_problem.
*
* By default all methods will dispatch to the inner_problem. A prefix is prepended to the problem name
* in order to reflect the transformation somewhere.
*/
static coco_problem_t *coco_problem_transformed_allocate(coco_problem_t *inner_problem,
void *user_data,
coco_data_free_function_t data_free_function,
const char *name_prefix) {
coco_problem_transformed_data_t *problem;
coco_problem_t *inner_copy;
char *old_name = coco_strdup(inner_problem->problem_name);
problem = (coco_problem_transformed_data_t *) coco_allocate_memory(sizeof(*problem));
problem->inner_problem = inner_problem;
problem->data = user_data;
problem->data_free_function = data_free_function;
inner_copy = coco_problem_duplicate(inner_problem);
inner_copy->evaluate_function = coco_problem_transformed_evaluate_function;
inner_copy->evaluate_constraint = coco_problem_transformed_evaluate_constraint;
inner_copy->recommend_solution = coco_problem_transformed_recommend_solution;
inner_copy->problem_free_function = coco_problem_transformed_free;
inner_copy->data = problem;
coco_problem_set_name(inner_copy, "%s(%s)", name_prefix, old_name);
coco_free_memory(old_name);
return inner_copy;
}
static coco_problem_t *f_weierstrass_allocate(const size_t number_of_variables) {
f_weierstrass_data_t *data;
size_t i;
double *non_unique_best_value;
coco_problem_t *problem = coco_problem_allocate_from_scalars("Weierstrass function",
f_weierstrass_evaluate, NULL, number_of_variables, -5.0, 5.0, NAN);
coco_problem_set_id(problem, "%s_d%02lu", "weierstrass", number_of_variables);
data = coco_allocate_memory(sizeof(*data));
data->f0 = 0.0;
for (i = 0; i < WEIERSTRASS_SUMMANDS; ++i) {
data->ak[i] = pow(0.5, (double) i);
data->bk[i] = pow(3., (double) i);
data->f0 += data->ak[i] * cos(2 * coco_pi * data->bk[i] * 0.5);
}
problem->data = data;
/* Compute best solution */
non_unique_best_value = coco_allocate_vector(number_of_variables);
for (i = 0; i < number_of_variables; i++)
non_unique_best_value[i] = 0.0;
f_weierstrass_evaluate(problem, non_unique_best_value, problem->best_value);
coco_free_memory(non_unique_best_value);
return problem;
}
/**
* @brief Creates and returns the information on the solution in the form of a node's item in the AVL tree.
*/
static logger_biobj_avl_item_t* logger_biobj_node_create(const double *x,
const double *y,
const size_t time_stamp,
const size_t dim,
const size_t num_obj) {
size_t i;
/* Allocate memory to hold the data structure logger_biobj_node_t */
logger_biobj_avl_item_t *item = (logger_biobj_avl_item_t*) coco_allocate_memory(sizeof(*item));
/* Allocate memory to store the (copied) data of the new node */
item->x = coco_allocate_vector(dim);
item->y = coco_allocate_vector(num_obj);
/* Copy the data */
for (i = 0; i < dim; i++)
item->x[i] = x[i];
for (i = 0; i < num_obj; i++)
item->y[i] = y[i];
item->time_stamp = time_stamp;
for (i = 0; i < OBSERVER_BIOBJ_NUMBER_OF_INDICATORS; i++)
item->indicator_contribution[i] = 0;
item->within_ROI = 0;
return item;
}
/**
* coco_problem_allocate(number_of_variables):
*
* Allocate and pre-populate a new coco_problem_t for a problem with
* ${number_of_variables}.
*/
coco_problem_t *coco_problem_allocate(const size_t number_of_variables,
const size_t number_of_objectives,
const size_t number_of_constraints) {
coco_problem_t *problem;
problem = (coco_problem_t *) coco_allocate_memory(sizeof(*problem));
/* Initialize fields to sane/safe defaults */
problem->initial_solution = NULL;
problem->evaluate_function = NULL;
problem->evaluate_constraint = NULL;
problem->recommend_solutions = NULL;
problem->free_problem = NULL;
problem->number_of_variables = number_of_variables;
problem->number_of_objectives = number_of_objectives;
problem->number_of_constraints = number_of_constraints;
problem->smallest_values_of_interest = coco_allocate_vector(number_of_variables);
problem->largest_values_of_interest = coco_allocate_vector(number_of_variables);
problem->best_parameter = coco_allocate_vector(number_of_variables);
problem->best_value = coco_allocate_vector(number_of_objectives);
problem->problem_name = NULL;
problem->problem_id = NULL;
problem->evaluations = 0;
problem->final_target_delta[0] = 1e-8; /* in case to be modified by the benchmark */
problem->best_observed_fvalue[0] = DBL_MAX;
problem->best_observed_evaluation[0] = 0;
problem->suite_dep_index = 0;
problem->suite_dep_function_id = 0;
problem->suite_dep_instance_id = 0;
problem->data = NULL;
return problem;
}
/**
* @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 Allocates a problem constructed by stacking two COCO problems.
*
* This is particularly useful for generating multi-objective problems, e.g. a bi-objective problem from two
* single-objective problems. The stacked problem must behave like a normal COCO problem accepting the same
* input. The region of interest in the decision space is defined by parameters smallest_values_of_interest
* and largest_values_of_interest, which are two arrays of size equal to the dimensionality of both problems.
*
* @note Regions of interest in the decision space must either agree or at least one of them must be NULL.
* @note Best parameter becomes somewhat meaningless, but the nadir value make sense now.
*/
static coco_problem_t *coco_problem_stacked_allocate(coco_problem_t *problem1,
coco_problem_t *problem2,
const double *smallest_values_of_interest,
const double *largest_values_of_interest) {
const size_t number_of_variables = coco_problem_get_dimension(problem1);
const size_t number_of_objectives = coco_problem_get_number_of_objectives(problem1)
+ coco_problem_get_number_of_objectives(problem2);
const size_t number_of_constraints = coco_problem_get_number_of_constraints(problem1)
+ coco_problem_get_number_of_constraints(problem2);
size_t i;
char *s;
coco_problem_stacked_data_t *data;
coco_problem_t *problem; /* the new coco problem */
assert(coco_problem_get_dimension(problem1) == coco_problem_get_dimension(problem2));
problem = coco_problem_allocate(number_of_variables, number_of_objectives, number_of_constraints);
s = coco_strconcat(coco_problem_get_id(problem1), "__");
problem->problem_id = coco_strconcat(s, coco_problem_get_id(problem2));
coco_free_memory(s);
s = coco_strconcat(coco_problem_get_name(problem1), " + ");
problem->problem_name = coco_strconcat(s, coco_problem_get_name(problem2));
coco_free_memory(s);
problem->evaluate_function = coco_problem_stacked_evaluate_function;
if (number_of_constraints > 0)
problem->evaluate_constraint = coco_problem_stacked_evaluate_constraint;
assert(smallest_values_of_interest);
assert(largest_values_of_interest);
for (i = 0; i < number_of_variables; ++i) {
problem->smallest_values_of_interest[i] = smallest_values_of_interest[i];
problem->largest_values_of_interest[i] = largest_values_of_interest[i];
}
if (problem->best_parameter) /* logger_bbob doesn't work then anymore */
coco_free_memory(problem->best_parameter);
problem->best_parameter = NULL;
/* Compute the ideal and nadir values */
assert(problem->best_value);
assert(problem->nadir_value);
problem->best_value[0] = problem1->best_value[0];
problem->best_value[1] = problem2->best_value[0];
coco_evaluate_function(problem1, problem2->best_parameter, &problem->nadir_value[0]);
coco_evaluate_function(problem2, problem1->best_parameter, &problem->nadir_value[1]);
/* setup data holder */
data = (coco_problem_stacked_data_t *) coco_allocate_memory(sizeof(*data));
data->problem1 = problem1;
data->problem2 = problem2;
problem->data = data;
problem->problem_free_function = coco_problem_stacked_free;
return problem;
}
/**
* Perform monotone oscillation transformation on input variables.
*/
static coco_problem_t *brs_transform(coco_problem_t *inner_problem) {
_brs_data_t *data;
coco_problem_t *self;
data = coco_allocate_memory(sizeof(*data));
data->x = coco_allocate_vector(inner_problem->number_of_variables);
self = coco_allocate_transformed_problem(inner_problem, data, _brs_free_data);
self->evaluate_function = _brs_evaluate_function;
return self;
}
/**
* Perform monotone oscillation transformation on input variables.
*/
static coco_problem_t *f_transform_vars_brs(coco_problem_t *inner_problem) {
transform_vars_brs_data_t *data;
coco_problem_t *self;
data = coco_allocate_memory(sizeof(*data));
data->x = coco_allocate_vector(inner_problem->number_of_variables);
self = coco_transformed_allocate(inner_problem, data, transform_vars_brs_free);
self->evaluate_function = transform_vars_brs_evaluate;
return self;
}
static void lnd_evaluate_function(coco_problem_t *self, const double *x, double *y) {
_log_nondominating_t *data;
data = coco_get_transform_data(self);
coco_evaluate_function(coco_get_transform_inner_problem(self), x, y);
data->number_of_evaluations++;
/* Open logfile if it is not alread open */
if (data->logfile == NULL) {
data->logfile = fopen(data->path, "w");
if (data->logfile == NULL) {
char *buf;
const char *error_format =
"lnd_evaluate_function() failed to open log file '%s'.";
size_t buffer_size = snprintf(NULL, 0, error_format, data->path);
buf = (char *)coco_allocate_memory(buffer_size);
snprintf(buf, buffer_size, error_format, data->path);
coco_error(buf);
coco_free_memory(buf); /* Never reached */
}
fprintf(data->logfile, "# %zu variables | %zu objectives | func eval number\n",
coco_get_number_of_variables(coco_get_transform_inner_problem(self)),
coco_get_number_of_objectives(coco_get_transform_inner_problem(self)));
/*********************************************************************/
/* TODO: Temporary put it here, to check later */
/* Allocate memory for the archive */
mo_archive = (struct mococo_solutions_archive *) malloc(1 * sizeof(struct mococo_solutions_archive));
mococo_allocate_archive(mo_archive, data->max_size_of_archive,
coco_get_number_of_variables(coco_get_transform_inner_problem(self)),
coco_get_number_of_objectives(coco_get_transform_inner_problem(self)), 1);
/*********************************************************************/
}
/********************************************************************************/
/* Finish evaluations of 1 single solution of the pop, with nObj objectives,
* now update the archive with this newly evaluated solution and check its nondomination. */
mococo_push_to_archive(&x, &y, mo_archive, 1, data->number_of_evaluations);
mococo_pareto_filtering(mo_archive); /***** TODO: IMPROVE THIS ROUTINE *****/
mococo_mark_updates(mo_archive, data->number_of_evaluations);
/* Write out a line for this newly evaluated solution if it is nondominated */
// write main info to the log file for pfront
for (size_t i=0; i < mo_archive->updatesize; i++) {
entry = mo_archive->update[i];
for (size_t j=0; j < coco_get_number_of_variables(coco_get_transform_inner_problem(self)); j++) // all decision variables of a solution
fprintf(data->logfile, "%13.10e\t", entry->var[j]);
for (size_t k=0; k < coco_get_number_of_objectives(coco_get_transform_inner_problem(self)); k++) // all objective values of a solution
fprintf(data->logfile, "%13.10e\t", entry->obj[k]);
fprintf(data->logfile, "%zu", entry->birth); // its timestamp (FEval)
fprintf(data->logfile, "\n"); // go to the next line for another solution
}
/********************************************************************************/
/* Flush output so that impatient users can see progress. */
fflush(data->logfile);
}
/**
* @brief Returns a concatenate copy of string1 + string2.
*
* The caller is responsible for freeing the allocated memory using coco_free_memory().
*/
static char *coco_strconcat(const char *s1, const char *s2) {
size_t len1 = strlen(s1);
size_t len2 = strlen(s2);
char *s = (char *) coco_allocate_memory(len1 + len2 + 1);
memcpy(s, s1, len1);
memcpy(&s[len1], s2, len2 + 1);
return s;
}
/**
* @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;
}
/**
* Perform monotone oscillation transformation on input variables.
*/
static coco_problem_t *f_transform_vars_asymmetric(coco_problem_t *inner_problem, const double beta) {
transform_vars_asymmetric_data_t *data;
coco_problem_t *self;
data = coco_allocate_memory(sizeof(*data));
data->x = coco_allocate_vector(inner_problem->number_of_variables);
data->beta = beta;
self = coco_transformed_allocate(inner_problem, data, transform_vars_asymmetric_free);
self->evaluate_function = transform_vars_asymmetric_evaluate;
return self;
}
/**
* @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;
}
/**
* Error when trying to create the file "path"
*/
static void logger_bbob2009_error_io(FILE *path, int errnum) {
char *buf;
const char *error_format = "Error opening file: %s\n ";
/* "bbob2009_logger_prepare() failed to open log file '%s'.";*/
size_t buffer_size = (size_t) snprintf(NULL, 0, error_format, path); /* to silence warning */
buf = (char *) coco_allocate_memory(buffer_size);
snprintf(buf, buffer_size, error_format, strerror(errnum), path);
coco_error(buf);
coco_free_memory(buf);
}
/**
* @brief Creates a duplicate copy of string and returns a pointer to it.
*
* The caller is responsible for freeing the allocated memory using coco_free_memory().
*/
static char *coco_strdup(const char *string) {
size_t len;
char *duplicate;
if (string == NULL)
return NULL;
len = strlen(string);
duplicate = (char *) coco_allocate_memory(len + 1);
memcpy(duplicate, string, len + 1);
return duplicate;
}
/**
* @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;
}
/**
* Perform monotone oscillation transformation on input variables.
*/
static coco_problem_t *condition_variables(coco_problem_t *inner_problem,
const double alpha) {
_cv_data_t *data;
coco_problem_t *self;
data = coco_allocate_memory(sizeof(*data));
data->x = coco_allocate_vector(inner_problem->number_of_variables);
data->alpha = alpha;
self = coco_allocate_transformed_problem(inner_problem, data, _cv_free_data);
self->evaluate_function = _cv_evaluate_function;
return self;
}
/**
* @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;
}
/**
* Shift the objective value of the inner problem by offset.
*/
static coco_problem_t *f_transform_obj_shift(coco_problem_t *inner_problem, const double offset) {
coco_problem_t *self;
transform_obj_shift_data_t *data;
data = coco_allocate_memory(sizeof(*data));
data->offset = offset;
self = coco_transformed_allocate(inner_problem, data, NULL);
self->evaluate_function = transform_obj_shift_evaluate;
self->best_value[0] += offset; /* FIXME: shifts only the first objective */
return self;
}
/**
* @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 and returns the information on the solution in the form of a node's item in the AVL tree.
*/
static coco_archive_avl_item_t* coco_archive_node_item_create(const double f1,
const double f2,
const char *text) {
/* Allocate memory to hold the data structure mo_preprocessing_avl_item_t */
coco_archive_avl_item_t *item = (coco_archive_avl_item_t*) coco_allocate_memory(sizeof(*item));
item->f1 = f1;
item->f2 = f2;
item->text = coco_strdup(text);
return item;
}
/**
* @brief Creates and returns the information on the solution in the form of a node's item in the AVL tree.
*/
static coco_archive_avl_item_t* coco_archive_node_item_create(const double *y,
const double *ideal,
const double *nadir,
const size_t num_obj,
const char *text) {
/* Allocate memory to hold the data structure coco_archive_avl_item_t */
coco_archive_avl_item_t *item = (coco_archive_avl_item_t*) coco_allocate_memory(sizeof(*item));
/* Compute the normalized y */
item->normalized_y = mo_normalize(y, ideal, nadir, num_obj);
item->text = coco_strdup(text);
return item;
}
/**
* @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;
}
static coco_problem_t *weierstrass_problem(const size_t number_of_variables) {
size_t i, problem_id_length;
coco_problem_t *problem = coco_allocate_problem(number_of_variables, 1, 0);
_wss_problem_t *data;
data = coco_allocate_memory(sizeof(*data));
data->f0 = 0.0;
for (i = 0; i < WEIERSTRASS_SUMMANDS; ++i) {
data->ak[i] = pow(0.5, (double)i);
data->bk[i] = pow(3., (double)i);
data->f0 += data->ak[i] * cos(2 * coco_pi * data->bk[i] * 0.5);
}
problem->problem_name = coco_strdup("weierstrass function");
/* Construct a meaningful problem id */
problem_id_length =
snprintf(NULL, 0, "%s_%02i", "weierstrass", (int)number_of_variables);
problem->problem_id = coco_allocate_memory(problem_id_length + 1);
snprintf(problem->problem_id, problem_id_length + 1, "%s_%02d", "weierstrass",
(int)number_of_variables);
problem->number_of_variables = number_of_variables;
problem->number_of_objectives = 1;
problem->number_of_constraints = 0;
problem->evaluate_function = _weierstrass_evaluate;
problem->data = data;
for (i = 0; i < number_of_variables; ++i) {
problem->smallest_values_of_interest[i] = -5.0;
problem->largest_values_of_interest[i] = 5.0;
problem->best_parameter[i] = 0.0;
}
/* Calculate best parameter value */
_weierstrass_evaluate(problem, problem->best_parameter, problem->best_value);
return problem;
}
static coco_problem_t *log_nondominating(coco_problem_t *inner_problem,
const size_t max_size_of_archive,
const char *path) {
_log_nondominating_t *data;
coco_problem_t *self;
data = coco_allocate_memory(sizeof(*data));
data->number_of_evaluations = 0;
data->path = coco_strdup(path);
data->logfile = NULL; /* Open lazily in lht_evaluate_function(). */
data->max_size_of_archive = max_size_of_archive;
self = coco_allocate_transformed_problem(inner_problem, data, _lnd_free_data);
self->evaluate_function = lnd_evaluate_function;
return self;
}
/**
* Initializes the biobjective observer. Possible options:
* - log_nondominated : none (don't log nondominated solutions)
* - log_nondominated : final (log only the final nondominated solutions; default value)
* - log_nondominated : all (log every solution that is nondominated at creation time)
* - log_decision_variables : none (don't output decision variables)
* - log_decision_variables : log_dim (output decision variables only for dimensions lower or equal to 5; default value)
* - log_decision_variables : all (output all decision variables)
* - compute_indicators : 0 / 1 (whether to compute and output performance indicators; default value is 1)
* - produce_all_data: 0 / 1 (whether to produce all data; if set to 1, overwrites other options and is equivalent to
* setting log_nondominated to all, log_decision_variables to log_dim and compute_indicators to 1; if set to 0, it
* does not change the values of other options; default value is 0)
*/
static void observer_biobj(coco_observer_t *self, const char *options) {
observer_biobj_t *data;
char string_value[COCO_PATH_MAX];
data = coco_allocate_memory(sizeof(*data));
data->log_nondom_mode = FINAL;
if (coco_options_read_string(options, "log_nondominated", string_value) > 0) {
if (strcmp(string_value, "none") == 0)
data->log_nondom_mode = NONE;
else if (strcmp(string_value, "all") == 0)
data->log_nondom_mode = ALL;
}
data->log_vars_mode = LOW_DIM;
if (coco_options_read_string(options, "log_decision_variables", string_value) > 0) {
if (strcmp(string_value, "none") == 0)
data->log_vars_mode = NEVER;
else if (strcmp(string_value, "all") == 0)
data->log_vars_mode = ALWAYS;
}
if (coco_options_read_int(options, "compute_indicators", &(data->compute_indicators)) == 0)
data->compute_indicators = 1;
if (coco_options_read_int(options, "produce_all_data", &(data->produce_all_data)) == 0)
data->produce_all_data = 0;
if (data->produce_all_data) {
data->log_vars_mode = LOW_DIM;
data->compute_indicators = 1;
data->log_nondom_mode = ALL;
}
if (data->compute_indicators) {
data->previous_function = -1;
}
self->logger_initialize_function = logger_biobj;
self->data_free_function = NULL;
self->data = data;
if ((data->log_nondom_mode == NONE) && (!data->compute_indicators)) {
/* No logging required */
self->is_active = 0;
}
}
/**
* @brief Initializes the bi-objective observer.
*
* Possible options:
* - log_nondominated : none (don't log nondominated solutions)
* - log_nondominated : final (log only the final nondominated solutions)
* - log_nondominated : all (log every solution that is nondominated at creation time; default value)
* - log_decision_variables : none (don't output decision variables)
* - log_decision_variables : log_dim (output decision variables only for dimensions lower or equal to 5;
* default value)
* - log_decision_variables : all (output all decision variables)
* - compute_indicators : 0 / 1 (whether to compute and output performance indicators; default value is 1)
* - produce_all_data: 0 / 1 (whether to produce all data; if set to 1, overwrites other options and is
* equivalent to setting log_nondominated to all, log_decision_variables to log_dim and compute_indicators
* to 1; if set to 0, it does not change the values of other options; default value is 0)
*/
static void observer_biobj(coco_observer_t *observer, const char *options) {
observer_biobj_data_t *observer_biobj;
char string_value[COCO_PATH_MAX];
observer_biobj = (observer_biobj_data_t *) coco_allocate_memory(sizeof(*observer_biobj));
observer_biobj->log_nondom_mode = LOG_NONDOM_ALL;
if (coco_options_read_string(options, "log_nondominated", string_value) > 0) {
if (strcmp(string_value, "none") == 0)
observer_biobj->log_nondom_mode = LOG_NONDOM_NONE;
else if (strcmp(string_value, "final") == 0)
observer_biobj->log_nondom_mode = LOG_NONDOM_FINAL;
}
observer_biobj->log_vars_mode = LOG_VARS_LOW_DIM;
if (coco_options_read_string(options, "log_decision_variables", string_value) > 0) {
if (strcmp(string_value, "none") == 0)
observer_biobj->log_vars_mode = LOG_VARS_NEVER;
else if (strcmp(string_value, "all") == 0)
observer_biobj->log_vars_mode = LOG_VARS_ALWAYS;
}
if (coco_options_read_int(options, "compute_indicators", &(observer_biobj->compute_indicators)) == 0)
observer_biobj->compute_indicators = 1;
if (coco_options_read_int(options, "produce_all_data", &(observer_biobj->produce_all_data)) == 0)
observer_biobj->produce_all_data = 0;
if (observer_biobj->produce_all_data) {
observer_biobj->log_vars_mode = LOG_VARS_LOW_DIM;
observer_biobj->compute_indicators = 1;
observer_biobj->log_nondom_mode = LOG_NONDOM_ALL;
}
if (observer_biobj->compute_indicators) {
observer_biobj->previous_function = -1;
}
observer->logger_initialize_function = logger_biobj;
observer->data_free_function = NULL;
observer->data = observer_biobj;
if ((observer_biobj->log_nondom_mode == LOG_NONDOM_NONE) && (!observer_biobj->compute_indicators)) {
/* No logging required */
observer->is_active = 0;
}
}
