/**
* @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;
}
/**
* 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);
}
/**
* 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;
}
static coco_problem_t *f_weierstrass_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) {
double *xopt, fopt;
coco_problem_t *problem = NULL;
size_t i, j, k;
double *M = coco_allocate_vector(dimension * dimension);
double *b = coco_allocate_vector(dimension);
double *current_row, **rot1, **rot2;
const double condition = 100.0;
const double penalty_factor = 10.0 / (double) dimension;
xopt = coco_allocate_vector(dimension);
fopt = bbob2009_compute_fopt(function, instance);
bbob2009_compute_xopt(xopt, rseed, dimension);
rot1 = bbob2009_allocate_matrix(dimension, dimension);
rot2 = bbob2009_allocate_matrix(dimension, dimension);
bbob2009_compute_rotation(rot1, rseed + 1000000, dimension);
bbob2009_compute_rotation(rot2, rseed, dimension);
for (i = 0; i < dimension; ++i) {
b[i] = 0.0;
current_row = M + i * dimension;
for (j = 0; j < dimension; ++j) {
current_row[j] = 0.0;
for (k = 0; k < dimension; ++k) {
const double base = 1.0 / sqrt(condition);
const double exponent = 1.0 * (int) k / ((double) (long) dimension - 1.0);
current_row[j] += rot1[i][k] * pow(base, exponent) * rot2[k][j];
}
}
}
problem = f_weierstrass_allocate(dimension);
problem = f_transform_obj_shift(problem, fopt);
problem = f_transform_vars_affine(problem, M, b, dimension);
problem = f_transform_vars_oscillate(problem);
bbob2009_copy_rotation_matrix(rot1, M, b, dimension);
problem = f_transform_vars_affine(problem, M, b, dimension);
problem = f_transform_vars_shift(problem, xopt, 0);
problem = f_transform_obj_penalize(problem, penalty_factor);
bbob2009_free_matrix(rot1, dimension);
bbob2009_free_matrix(rot2, dimension);
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, "4-multi-modal");
coco_free_memory(M);
coco_free_memory(b);
coco_free_memory(xopt);
return problem;
}
/**
* @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;
}
/**
* @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;
}
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;
}
/*
* Class: CocoJNI
* Method: cocoEvaluateConstraint
* Signature: (J[D)[D
*/
JNIEXPORT jdoubleArray JNICALL Java_org_moeaframework_problem_BBOB2016_CocoJNI_cocoEvaluateConstraint
(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 cocoEvaluateConstraint\n");
}
problem = (coco_problem_t *) jproblem_pointer;
number_of_objectives = (int) coco_problem_get_number_of_objectives(problem);
/* Call coco_evaluate_constraint */
x = (*jenv)->GetDoubleArrayElements(jenv, jx, NULL);
y = coco_allocate_vector(number_of_objectives);
coco_evaluate_constraint(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;
}
/**
* @brief Creates the BBOB Rastrigin problem.
*/
static coco_problem_t *f_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) {
double *xopt, fopt;
coco_problem_t *problem = NULL;
xopt = coco_allocate_vector(dimension);
fopt = bbob2009_compute_fopt(function, instance);
bbob2009_compute_xopt(xopt, rseed, dimension);
problem = f_rastrigin_allocate(dimension);
problem = transform_vars_conditioning(problem, 10.0);
problem = transform_vars_asymmetric(problem, 0.2);
problem = transform_vars_oscillate(problem);
problem = transform_vars_shift(problem, xopt, 0);
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, "1-separable");
coco_free_memory(xopt);
return problem;
}
/**
* @brief Creates a rounded normalized version of the given solution w.r.t. the given ROI.
*
* If the solution seems to be better than the extremes it is corrected (2 objectives are assumed).
* The caller is responsible for freeing the allocated memory using coco_free_memory().
*/
static double *mo_normalize(const double *y, const double *ideal, const double *nadir, const size_t num_obj) {
size_t i;
double *normalized_y = coco_allocate_vector(num_obj);
for (i = 0; i < num_obj; i++) {
assert((nadir[i] - ideal[i]) > mo_discretization);
normalized_y[i] = (y[i] - ideal[i]) / (nadir[i] - ideal[i]);
normalized_y[i] = coco_double_round(normalized_y[i] / mo_discretization) * mo_discretization;
if (normalized_y[i] < 0) {
coco_debug("Adjusting %.15e to %.15e", y[i], ideal[i]);
normalized_y[i] = 0;
}
}
for (i = 0; i < num_obj; i++) {
assert(num_obj == 2);
if (coco_double_almost_equal(normalized_y[i], 0, mo_precision) && (normalized_y[1-i] < 1)) {
coco_debug("Adjusting %.15e to %.15e", y[1-i], nadir[1-i]);
normalized_y[1-i] = 1;
}
}
return normalized_y;
}
/**
* @brief Creates the BBOB Griewank-Rosenbrock problem.
*/
static coco_problem_t *f_griewank_rosenbrock_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) {
double fopt;
coco_problem_t *problem = NULL;
size_t i, j;
double *M = coco_allocate_vector(dimension * dimension);
double *b = coco_allocate_vector(dimension);
double *shift = coco_allocate_vector(dimension);
double scales, **rot1;
fopt = bbob2009_compute_fopt(function, instance);
for (i = 0; i < dimension; ++i) {
shift[i] = -0.5;
}
rot1 = bbob2009_allocate_matrix(dimension, dimension);
bbob2009_compute_rotation(rot1, rseed, dimension);
scales = coco_double_max(1., sqrt((double) dimension) / 8.);
for (i = 0; i < dimension; ++i) {
for (j = 0; j < dimension; ++j) {
rot1[i][j] *= scales;
}
}
problem = f_griewank_rosenbrock_allocate(dimension);
problem = transform_obj_shift(problem, fopt);
problem = transform_vars_shift(problem, shift, 0);
bbob2009_copy_rotation_matrix(rot1, M, b, dimension);
problem = transform_vars_affine(problem, M, b, dimension);
bbob2009_free_matrix(rot1, dimension);
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, "4-multi-modal");
coco_free_memory(M);
coco_free_memory(b);
coco_free_memory(shift);
return problem;
}
/**
* @brief Implements the Lunacek bi-Rastrigin function without connections to any COCO structures.
*/
static double f_lunacek_bi_rastrigin_raw(const double *x,
const size_t number_of_variables,
f_lunacek_bi_rastrigin_data_t *data) {
double result;
static const double condition = 100.;
size_t i, j;
double penalty = 0.0;
static const double mu0 = 2.5;
static const double d = 1.;
const double s = 1. - 0.5 / (sqrt((double) (number_of_variables + 20)) - 4.1);
const double mu1 = -sqrt((mu0 * mu0 - d) / s);
double *tmpvect, sum1 = 0., sum2 = 0., sum3 = 0.;
assert(number_of_variables > 1);
for (i = 0; i < number_of_variables; ++i) {
double tmp;
tmp = fabs(x[i]) - 5.0;
if (tmp > 0.0)
penalty += tmp * tmp;
}
/* x_hat */
for (i = 0; i < number_of_variables; ++i) {
data->x_hat[i] = 2. * x[i];
if (data->xopt[i] < 0.) {
data->x_hat[i] *= -1.;
}
}
tmpvect = coco_allocate_vector(number_of_variables);
/* affine transformation */
for (i = 0; i < number_of_variables; ++i) {
double c1;
tmpvect[i] = 0.0;
c1 = pow(sqrt(condition), ((double) i) / (double) (number_of_variables - 1));
for (j = 0; j < number_of_variables; ++j) {
tmpvect[i] += c1 * data->rot2[i][j] * (data->x_hat[j] - mu0);
}
}
for (i = 0; i < number_of_variables; ++i) {
data->z[i] = 0;
for (j = 0; j < number_of_variables; ++j) {
data->z[i] += data->rot1[i][j] * tmpvect[j];
}
}
/* Computation core */
for (i = 0; i < number_of_variables; ++i) {
sum1 += (data->x_hat[i] - mu0) * (data->x_hat[i] - mu0);
sum2 += (data->x_hat[i] - mu1) * (data->x_hat[i] - mu1);
sum3 += cos(2 * coco_pi * data->z[i]);
}
result = coco_double_min(sum1, d * (double) number_of_variables + s * sum2)
+ 10. * ((double) number_of_variables - sum3) + 1e4 * penalty;
coco_free_memory(tmpvect);
return result;
}
/**
* @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_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;
}
/**
* 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;
}
/**
* @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;
}
/**
* 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_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;
}
static double f_gallagher_raw(const double *x, const size_t number_of_variables, f_gallagher_data_t *data) {
size_t i, j; /* Loop over dim */
double *tmx;
double a = 0.1;
double tmp2, f = 0., Fadd, tmp, Fpen = 0., Ftrue = 0.;
double fac;
double result;
fac = -0.5 / (double) number_of_variables;
/* Boundary handling */
for (i = 0; i < number_of_variables; ++i) {
tmp = fabs(x[i]) - 5.;
if (tmp > 0.) {
Fpen += tmp * tmp;
}
}
Fadd = Fpen;
/* Transformation in search space */
/* TODO: this should rather be done in f_gallagher */
tmx = coco_allocate_vector(number_of_variables);
for (i = 0; i < number_of_variables; i++) {
tmx[i] = 0;
for (j = 0; j < number_of_variables; ++j) {
tmx[i] += data->rotation[i][j] * x[j];
}
}
/* Computation core*/
for (i = 0; i < data->number_of_peaks; ++i) {
tmp2 = 0.;
for (j = 0; j < number_of_variables; ++j) {
tmp = (tmx[j] - data->x_local[j][i]);
tmp2 += data->arr_scales[i][j] * tmp * tmp;
}
tmp2 = data->peak_values[i] * exp(fac * tmp2);
f = coco_max_double(f, tmp2);
}
f = 10. - f;
if (f > 0) {
Ftrue = log(f) / a;
Ftrue = pow(exp(Ftrue + 0.49 * (sin(Ftrue) + sin(0.79 * Ftrue))), a);
} else if (f < 0) {
Ftrue = log(-f) / a;
Ftrue = -pow(exp(Ftrue + 0.49 * (sin(0.55 * Ftrue) + sin(0.31 * Ftrue))), a);
} else
Ftrue = f;
Ftrue *= Ftrue;
Ftrue += Fadd;
result = Ftrue;
coco_free_memory(tmx);
return result;
}
/**
* @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_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;
}
/*
* Shift all variables of ${inner_problem} by ${offset}.
*/
static coco_problem_t *f_transform_vars_shift(coco_problem_t *inner_problem,
const double *offset,
const int shift_bounds) {
transform_vars_shift_data_t *data;
coco_problem_t *self;
if (shift_bounds)
coco_error("shift_bounds not implemented.");
data = 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);
self = coco_transformed_allocate(inner_problem, data, transform_vars_shift_free);
self->evaluate_function = transform_vars_shift_evaluate;
return self;
}
static coco_problem_t *logger_bbob2009(coco_problem_t *inner_problem, const char *alg_name) {
logger_bbob2009_t *data;
coco_problem_t *self;
data = coco_allocate_memory(sizeof(*data));
data->alg_name = coco_strdup(alg_name);
if (bbob2009_logger_is_open)
coco_error("The current bbob2009_logger (observer) must be closed before a new one is opened");
/* This is the name of the folder which happens to be the algName */
data->path = coco_strdup(alg_name);
data->index_file = NULL;
data->fdata_file = NULL;
data->tdata_file = NULL;
data->rdata_file = NULL;
data->number_of_variables = inner_problem->number_of_variables;
if (inner_problem->best_value == NULL) {
/* coco_error("Optimal f value must be defined for each problem in order for the logger to work properly"); */
/* Setting the value to 0 results in the assertion y>=optimal_fvalue being susceptible to failure */
coco_warning("undefined optimal f value. Set to 0");
data->optimal_fvalue = 0;
} else {
data->optimal_fvalue = *(inner_problem->best_value);
}
bbob2009_raisedOptValWarning = 0;
data->idx_f_trigger = INT_MAX;
data->idx_t_trigger = 0;
data->idx_tdim_trigger = 0;
data->f_trigger = DBL_MAX;
data->t_trigger = 0;
data->number_of_evaluations = 0;
data->best_solution = coco_allocate_vector(inner_problem->number_of_variables);
/* TODO: the following inits are just to be in the safe side and
* should eventually be removed. Some fields of the bbob2009_logger struct
* might be useless
*/
data->function_id = coco_problem_get_suite_dep_function_id(inner_problem);
data->instance_id = coco_problem_get_suite_dep_instance_id(inner_problem);
data->written_last_eval = 1;
data->last_fvalue = DBL_MAX;
data->is_initialized = 0;
self = coco_transformed_allocate(inner_problem, data, logger_bbob2009_free);
self->evaluate_function = logger_bbob2009_evaluate;
bbob2009_logger_is_open = 1;
return self;
}
/*
* Perform an affine transformation of the variable vector:
*
* x |-> Mx + b
*
* The matrix M is stored in row-major format.
*/
static coco_problem_t *f_transform_vars_affine(coco_problem_t *inner_problem,
const double *M,
const double *b,
const size_t number_of_variables) {
coco_problem_t *self;
transform_vars_affine_data_t *data;
size_t entries_in_M;
entries_in_M = inner_problem->number_of_variables * number_of_variables;
data = 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);
self = coco_transformed_allocate(inner_problem, data, transform_vars_affine_free);
self->evaluate_function = transform_vars_affine_evaluate;
return self;
}
/**
* @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 Returns f1 and f2 in a vector of two doubles. Memory needs to be freed by the caller.
*/
static double *coco_archive_node_item_get_vector(coco_archive_avl_item_t *item) {
double *result = coco_allocate_vector(2);
result[0] = item->f1;
result[1] = item->f2;
return result;
}
