/**
* @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;
}
static void coco_stacked_problem_evaluate(coco_problem_t *self, const double *x, double *y) {
coco_stacked_problem_data_t* data = (coco_stacked_problem_data_t *) self->data;
assert(
coco_problem_get_number_of_objectives(self)
== coco_problem_get_number_of_objectives(data->problem1)
+ coco_problem_get_number_of_objectives(data->problem2));
coco_evaluate_function(data->problem1, x, &y[0]);
coco_evaluate_function(data->problem2, x, &y[coco_problem_get_number_of_objectives(data->problem1)]);
}
/*
* Class: CocoJNI
* Method: cocoEvaluateFunction
* Signature: (J[D)[D
*/
JNIEXPORT jdoubleArray JNICALL Java_org_moeaframework_problem_BBOB2016_CocoJNI_cocoEvaluateFunction
(JNIEnv *jenv, jclass interface_cls, jlong jproblem_pointer, jdoubleArray jx) {
coco_problem_t *problem = NULL;
double *y = NULL;
double *x = NULL;
int number_of_objectives;
jdoubleArray jy;
/* This test is both to prevent warning because interface_cls was not used and to check for exceptions */
if (interface_cls == NULL) {
jclass Exception = (*jenv)->FindClass(jenv, "java/lang/Exception");
(*jenv)->ThrowNew(jenv, Exception, "Exception in cocoEvaluateFunction\n");
}
problem = (coco_problem_t *) jproblem_pointer;
number_of_objectives = (int) coco_problem_get_number_of_objectives(problem);
/* Call coco_evaluate_function */
x = (*jenv)->GetDoubleArrayElements(jenv, jx, NULL);
y = coco_allocate_vector(number_of_objectives);
coco_evaluate_function(problem, x, y);
/* Prepare the return value */
jy = (*jenv)->NewDoubleArray(jenv, number_of_objectives);
(*jenv)->SetDoubleArrayRegion(jenv, jy, 0, number_of_objectives, y);
/* Free resources */
coco_free_memory(y);
(*jenv)->ReleaseDoubleArrayElements(jenv, jx, x, JNI_ABORT);
return jy;
}
/**
* A random search optimizer.
*/
void my_optimizer(coco_problem_t *problem) {
const size_t budget = 2;
coco_random_state_t *rng = coco_random_new(0xdeadbeef);
const double *lbounds = coco_problem_get_smallest_values_of_interest(problem);
const double *ubounds = coco_problem_get_largest_values_of_interest(problem);
size_t dimension = coco_problem_get_dimension(problem);
size_t number_of_objectives = coco_problem_get_number_of_objectives(problem);
double *x = coco_allocate_vector(dimension);
double *y = coco_allocate_vector(number_of_objectives);
double range;
size_t i, j;
for (i = 0; i < budget; ++i) {
for (j = 0; j < dimension; ++j) {
range = ubounds[j] - lbounds[j];
x[j] = lbounds[j] + coco_random_uniform(rng) * range;
}
coco_evaluate_function(problem, x, y);
}
coco_random_free(rng);
coco_free_memory(x);
coco_free_memory(y);
}
static void transform_vars_oscillate_evaluate(coco_problem_t *self, 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 = coco_transformed_get_data(self);
oscillated_x = data->oscillated_x; /* short cut to make code more readable */
inner_problem = coco_transformed_get_inner_problem(self);
for (i = 0; i < self->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 >= self->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_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]);
}
/**
* @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;
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_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]);
}
/* The gateway function */
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
size_t *ref;
mxArray *problem_prop;
coco_problem_t *problem = NULL;
/* const char *class_name = NULL; */
int nb_objectives;
double *x;
double *y;
/* check for proper number of arguments */
if(nrhs!=2) {
mexErrMsgIdAndTxt("cocoEvaluateFunction:nrhs","Two inputs required.");
}
/* get the problem */
ref = (mwSize *) mxGetData(prhs[0]);
problem = (coco_problem_t *)(*ref);
/* make sure the second input argument is array of doubles */
if(!mxIsDouble(prhs[1])) {
mexErrMsgIdAndTxt("cocoEvaluateFunction:notDoubleArray","Input x must be an array of doubles.");
}
/* get the x vector */
x = mxGetPr(prhs[1]);
/* prepare the return value */
nb_objectives = coco_problem_get_number_of_objectives(problem);
plhs[0] = mxCreateDoubleMatrix(1, (size_t)nb_objectives, mxREAL);
y = mxGetPr(plhs[0]);
/* call coco_evaluate_function(...) */
coco_evaluate_function(problem, x, y);
}
/**
* @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]);
}
static void _brs_evaluate_function(coco_problem_t *self, const double *x, double *y) {
size_t i;
double factor;
_brs_data_t *data;
coco_problem_t *inner_problem;
data = coco_get_transform_data(self);
inner_problem = coco_get_transform_inner_problem(self);
for (i = 0; i < self->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), i / (self->number_of_variables - 1.0));
/* Documentation specifies odd indexes and starts indexing
* from 1, we use all even indexes 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);
}
static void transformed_evaluate_function(coco_problem_t *self, const double *x, double *y) {
coco_transformed_data_t *data;
assert(self != NULL);
assert(self->data != NULL);
data = self->data;
assert(data->inner_problem != NULL);
coco_evaluate_function(data->inner_problem, x, y);
}
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 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]);
}
/**
* Layer added to the transformed-problem evaluate_function by the logger
*/
static void logger_bbob2009_evaluate(coco_problem_t *self, const double *x, double *y) {
logger_bbob2009_t *data = coco_transformed_get_data(self);
coco_problem_t * inner_problem = coco_transformed_get_inner_problem(self);
if (!data->is_initialized) {
logger_bbob2009_initialize(data, inner_problem);
}
if (bbob2009_logger_verbosity > 2 && data->number_of_evaluations == 0) {
if (inner_problem->suite_dep_index >= 0) {
printf("%4ld: ", inner_problem->suite_dep_index);
}
printf("on problem %s ... ", coco_problem_get_id(inner_problem));
}
coco_evaluate_function(inner_problem, x, y);
data->last_fvalue = y[0];
data->written_last_eval = 0;
if (data->number_of_evaluations == 0 || y[0] < data->best_fvalue) {
size_t i;
data->best_fvalue = y[0];
for (i = 0; i < self->number_of_variables; i++)
data->best_solution[i] = x[i];
}
data->number_of_evaluations++;
/* Add sanity check for optimal f value */
/* assert(y[0] >= data->optimal_fvalue); */
if (!bbob2009_raisedOptValWarning && y[0] < data->optimal_fvalue) {
coco_warning("Observed fitness is smaller than supposed optimal fitness.");
bbob2009_raisedOptValWarning = 1;
}
/* Add a line in the .dat file for each logging target reached. */
if (y[0] - data->optimal_fvalue <= data->f_trigger) {
logger_bbob2009_write_data(data->fdata_file, data->number_of_evaluations, y[0], data->best_fvalue,
data->optimal_fvalue, x, self->number_of_variables);
logger_bbob2009_update_f_trigger(data, y[0]);
}
/* Add a line in the .tdat file each time an fevals trigger is reached. */
if (data->number_of_evaluations >= data->t_trigger) {
data->written_last_eval = 1;
logger_bbob2009_write_data(data->tdata_file, data->number_of_evaluations, y[0], data->best_fvalue,
data->optimal_fvalue, x, self->number_of_variables);
logger_bbob2009_update_t_trigger(data, self->number_of_variables);
}
/* Flush output so that impatient users can see progress. */
fflush(data->fdata_file);
}
/**
* @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_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_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]);
}
static void transform_obj_oscillate_evaluate(coco_problem_t *self, const double *x, double *y) {
static const double factor = 0.1;
size_t i;
coco_evaluate_function(coco_transformed_get_inner_problem(self), x, y);
for (i = 0; i < self->number_of_objectives; i++) {
if (y[i] != 0) {
double log_y;
log_y = log(fabs(y[i])) / factor;
if (y[i] > 0) {
y[i] = pow(exp(log_y + 0.49 * (sin(log_y) + sin(0.79 * log_y))), factor);
} else {
y[i] = -pow(exp(log_y + 0.49 * (sin(0.55 * log_y) + sin(0.31 * log_y))), factor);
}
}
}
}
static void _cv_evaluate_function(coco_problem_t *self, const double *x, double *y) {
size_t i;
_cv_data_t *data;
coco_problem_t *inner_problem;
data = coco_get_transform_data(self);
inner_problem = coco_get_transform_inner_problem(self);
for (i = 0; i < self->number_of_variables; ++i) {
/* OME: We could precalculate the scaling coefficients if we
* really wanted to.
*/
data->x[i] =
pow(data->alpha, 0.5 * i / (self->number_of_variables - 1.0)) * x[i];
}
coco_evaluate_function(inner_problem, data->x, y);
}
/**
* @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]);
}
static void transform_vars_asymmetric_evaluate(coco_problem_t *self, const double *x, double *y) {
size_t i;
double exponent;
transform_vars_asymmetric_data_t *data;
coco_problem_t *inner_problem;
data = coco_transformed_get_data(self);
inner_problem = coco_transformed_get_inner_problem(self);
for (i = 0; i < self->number_of_variables; ++i) {
if (x[i] > 0.0) {
exponent = 1.0
+ (data->beta * (double) (long) i) / ((double) (long) self->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);
}
/**
* @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]);
}
static void transform_vars_affine_evaluate(coco_problem_t *self, const double *x, double *y) {
size_t i, j;
transform_vars_affine_data_t *data;
coco_problem_t *inner_problem;
data = coco_transformed_get_data(self);
inner_problem = coco_transformed_get_inner_problem(self);
for (i = 0; i < inner_problem->number_of_variables; ++i) {
/* data->M has self->number_of_variables columns and
* problem->inner_problem->number_of_variables rows.
*/
const double *current_row = data->M + i * self->number_of_variables;
data->x[i] = data->b[i];
for (j = 0; j < self->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 >= self->best_value[0]);
}
/**
* Evaluates the function, increases the number of evaluations and outputs information based on the targets
* that have been hit.
*/
static void logger_toy_evaluate(coco_problem_t *self, const double *x, double *y) {
logger_toy_t *logger;
observer_toy_t *observer_toy;
double *targets;
logger = coco_transformed_get_data(self);
observer_toy = (observer_toy_t *) logger->observer->data;
targets = observer_toy->targets;
coco_evaluate_function(coco_transformed_get_inner_problem(self), x, y);
logger->number_of_evaluations++;
/* Add a line for each target that has been hit */
while (y[0] <= targets[logger->next_target] && logger->next_target < observer_toy->number_of_targets) {
fprintf(observer_toy->log_file, "%e\t%5ld\t%.5f\n", targets[logger->next_target],
logger->number_of_evaluations, y[0]);
logger->next_target++;
}
/* Flush output so that impatient users can see the progress */
fflush(observer_toy->log_file);
}
/**
* @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]);
}
void my_optimizer(coco_problem_t *problem) {
static const int budget = 102; /* 100000;*/
coco_random_state_t *rng = coco_new_random(0xdeadbeef);
double *x = (double *)malloc(problem->number_of_parameters * sizeof(double));
double y;
for (int i = 1; i < budget; ++i) {
bbob2009_unif(x, problem->number_of_parameters, i);
for (int j = 0; j < problem->number_of_parameters; ++j) {
/*const double range = problem->upper_bounds[j] -
problem->lower_bounds[j];
x[j] = problem->lower_bounds[j] + coco_uniform_random(rng) * range;*/
x[j] = 20. * x[j] - 10.;
}
/*if ( i % 100==0 ){
printf("%d: [ %f,", i, x[0]);
printf(" %f ]\n",x[1]);
}*/
coco_evaluate_function(problem, x, &y);
}
coco_free_random(rng);
free(x);
printf("%s\n", problem->problem_name);
printf("%s\n", problem->problem_id);
}
/**
* @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);
}
}
}
}
