coco_problem_t *coco_problem_duplicate(coco_problem_t *other) {
size_t i;
coco_problem_t *problem;
problem = coco_problem_allocate(other->number_of_variables, other->number_of_objectives,
other->number_of_constraints);
problem->evaluate_function = other->evaluate_function;
problem->evaluate_constraint = other->evaluate_constraint;
problem->recommend_solutions = other->recommend_solutions;
problem->free_problem = NULL;
for (i = 0; i < problem->number_of_variables; ++i) {
problem->smallest_values_of_interest[i] = other->smallest_values_of_interest[i];
problem->largest_values_of_interest[i] = other->largest_values_of_interest[i];
if (other->best_parameter)
problem->best_parameter[i] = other->best_parameter[i];
}
if (other->best_value)
for (i = 0; i < problem->number_of_objectives; ++i) {
problem->best_value[i] = other->best_value[i];
}
problem->problem_name = coco_strdup(other->problem_name);
problem->problem_id = coco_strdup(other->problem_id);
problem->suite_dep_index = other->suite_dep_index;
problem->suite_dep_function_id = other->suite_dep_function_id;
problem->suite_dep_instance_id = other->suite_dep_instance_id;
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;
}
/**
* @brief Creates a duplicate of the 'other' problem for all fields except for data, which points to NULL.
*/
static coco_problem_t *coco_problem_duplicate(const coco_problem_t *other) {
size_t i;
coco_problem_t *problem;
problem = coco_problem_allocate(other->number_of_variables, other->number_of_objectives,
other->number_of_constraints);
problem->initial_solution = other->initial_solution;
problem->evaluate_function = other->evaluate_function;
problem->evaluate_constraint = other->evaluate_constraint;
problem->recommend_solution = other->recommend_solution;
problem->problem_free_function = other->problem_free_function;
for (i = 0; i < problem->number_of_variables; ++i) {
problem->smallest_values_of_interest[i] = other->smallest_values_of_interest[i];
problem->largest_values_of_interest[i] = other->largest_values_of_interest[i];
if (other->best_parameter)
problem->best_parameter[i] = other->best_parameter[i];
}
if (other->best_value)
for (i = 0; i < problem->number_of_objectives; ++i) {
problem->best_value[i] = other->best_value[i];
}
if (other->nadir_value)
for (i = 0; i < problem->number_of_objectives; ++i) {
problem->nadir_value[i] = other->nadir_value[i];
}
problem->problem_name = coco_strdup(other->problem_name);
problem->problem_id = coco_strdup(other->problem_id);
problem->problem_type = coco_strdup(other->problem_type);
problem->evaluations = other->evaluations;
problem->final_target_delta[0] = other->final_target_delta[0];
problem->best_observed_fvalue[0] = other->best_observed_fvalue[0];
problem->best_observed_evaluation[0] = other->best_observed_evaluation[0];
problem->suite = other->suite;
problem->suite_dep_index = other->suite_dep_index;
problem->suite_dep_function = other->suite_dep_function;
problem->suite_dep_instance = other->suite_dep_instance;
problem->data = NULL;
return problem;
}
static coco_problem_t *f_schaffers(const size_t number_of_variables) {
size_t i, problem_id_length;
coco_problem_t *problem = coco_problem_allocate(number_of_variables, 1, 0);
problem->problem_name = coco_strdup("schaffers function");
/* Construct a meaningful problem id */
problem_id_length = (size_t) snprintf(NULL, 0, "%s_%02lu", "schaffers", (long) number_of_variables);
problem->problem_id = coco_allocate_memory(problem_id_length + 1);
snprintf(problem->problem_id, problem_id_length + 1, "%s_%02lu", "schaffers", (long) number_of_variables);
problem->number_of_variables = number_of_variables;
problem->number_of_objectives = 1;
problem->number_of_constraints = 0;
problem->evaluate_function = f_schaffers_evaluate;
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 */
f_schaffers_evaluate(problem, problem->best_parameter, problem->best_value);
return problem;
}
/**
* @brief Allocates a problem using scalar values for smallest_value_of_interest, largest_value_of_interest
* and best_parameter.
*/
static coco_problem_t *coco_problem_allocate_from_scalars(const char *problem_name,
coco_evaluate_function_t evaluate_function,
coco_problem_free_function_t problem_free_function,
const size_t number_of_variables,
const double smallest_value_of_interest,
const double largest_value_of_interest,
const double best_parameter) {
size_t i;
coco_problem_t *problem = coco_problem_allocate(number_of_variables, 1, 0);
problem->problem_name = coco_strdup(problem_name);
problem->number_of_variables = number_of_variables;
problem->number_of_objectives = 1;
problem->number_of_constraints = 0;
problem->evaluate_function = evaluate_function;
problem->problem_free_function = problem_free_function;
for (i = 0; i < number_of_variables; ++i) {
problem->smallest_values_of_interest[i] = smallest_value_of_interest;
problem->largest_values_of_interest[i] = largest_value_of_interest;
problem->best_parameter[i] = best_parameter;
}
return problem;
}
/**
* Return a problem that stacks the output of two problems, namely
* of coco_evaluate_function and coco_evaluate_constraint. The accepted
* input remains the same and must be identical for the stacked
* problems.
*
* This is particularly useful to generate multiobjective problems,
* e.g. a biobjective problem from two single objective problems.
*
* Details: regions of interest must either agree or at least one
* of them must be NULL. Best parameter becomes somewhat meaningless.
*/
coco_problem_t *coco_stacked_problem_allocate(coco_problem_t *problem1,
coco_problem_t *problem2,
void *userdata,
coco_stacked_problem_free_data_t free_data) {
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;
const double *smallest, *largest;
coco_stacked_problem_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_stacked_problem_evaluate;
if (number_of_constraints > 0)
problem->evaluate_constraint = coco_stacked_problem_evaluate_constraint;
/* set/copy "boundaries" and best_parameter */
smallest = problem1->smallest_values_of_interest;
if (smallest == NULL)
smallest = problem2->smallest_values_of_interest;
largest = problem1->largest_values_of_interest;
if (largest == NULL)
largest = problem2->largest_values_of_interest;
for (i = 0; i < number_of_variables; ++i) {
if (problem2->smallest_values_of_interest != NULL)
assert(smallest[i] == problem2->smallest_values_of_interest[i]);
if (problem2->largest_values_of_interest != NULL)
assert(largest[i] == problem2->largest_values_of_interest[i]);
if (smallest != NULL)
problem->smallest_values_of_interest[i] = smallest[i];
if (largest != NULL)
problem->largest_values_of_interest[i] = largest[i];
if (problem->best_parameter) /* bbob2009 logger doesn't work then anymore */
coco_free_memory(problem->best_parameter);
problem->best_parameter = NULL;
if (problem->best_value)
coco_free_memory(problem->best_value);
problem->best_value = NULL; /* bbob2009 logger doesn't work */
}
/* setup data holder */
data = coco_allocate_memory(sizeof(*data));
data->problem1 = problem1;
data->problem2 = problem2;
data->data = userdata;
data->free_data = free_data;
problem->data = data;
problem->free_problem = coco_stacked_problem_free; /* free self->data and coco_problem_free(self) */
return problem;
}