/**
* @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;
}
/**
* Formatted printing of a problem ID, mimicking
* sprintf(coco_problem_get_id(problem), id, ...) while taking care
* of memory (de-)allocations.
*
*/
void coco_problem_set_id(coco_problem_t *problem, const char *id, ...) {
va_list args;
va_start(args, id);
coco_free_memory(problem->problem_id);
problem->problem_id = coco_vstrdupf(id, args);
va_end(args);
if (!coco_problem_id_is_fine(problem->problem_id)) {
coco_error("Problem id should only contain standard chars, not like '%s'", coco_problem_get_id(problem));
}
}
/**
* 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);
}
/*
* Class: CocoJNI
* Method: cocoProblemGetId
* Signature: (J)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_org_moeaframework_problem_BBOB2016_CocoJNI_cocoProblemGetId
(JNIEnv *jenv, jclass interface_cls, jlong jproblem_pointer) {
coco_problem_t *problem = NULL;
const char *result;
jstring jresult;
/* 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 cocoProblemGetId\n");
}
problem = (coco_problem_t *) jproblem_pointer;
result = coco_problem_get_id(problem);
jresult = (*jenv)->NewStringUTF(jenv, result);
return jresult;
}
/**
* Initializes the toy logger.
*/
static coco_problem_t *logger_toy(coco_observer_t *observer, coco_problem_t *problem) {
logger_toy_t *logger;
coco_problem_t *self;
FILE *output_file;
if (problem->number_of_objectives != 1) {
coco_warning("logger_toy(): The toy logger shouldn't be used to log a problem with %d objectives", problem->number_of_objectives);
}
logger = coco_allocate_memory(sizeof(*logger));
logger->observer = observer;
logger->next_target = 0;
logger->number_of_evaluations = 0;
output_file = ((observer_toy_t *) logger->observer->data)->log_file;
fprintf(output_file, "\n%s, %s\n", coco_problem_get_id(problem), coco_problem_get_name(problem));
self = coco_transformed_allocate(problem, logger, NULL);
self->evaluate_function = logger_toy_evaluate;
return self;
}
/**
* 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;
}
int main(int argc, char **argv) {
int header_shown = 0, number_of_failures = 0, shown_failures = 0;
size_t number_of_testvectors = 0, i, j;
int number_of_testcases = 0;
testvector_t *testvectors = NULL;
long previous_problem_index = -1;
size_t problem_index_old, problem_index;
int testvector_id, ret;
coco_problem_t *problem = NULL;
char suit_name[128];
FILE *testfile = NULL;
coco_suite_t *suite;
if (argc != 2) {
usage(argv[0]);
goto err;
}
testfile = fopen(argv[1], "r");
if (testfile == NULL) {
fprintf(stderr, "Failed to open testcases file %s.\n", argv[1]);
goto err;
}
ret = fscanf(testfile, "%127s", suit_name);
if (ret != 1) {
fprintf(stderr, "Failed to read suite name from testcases file.\n");
goto err;
}
ret = fscanf(testfile, "%30lu", &number_of_testvectors);
if (ret != 1) {
fprintf(stderr,
"Failed to read number of test vectors from testcases file.\n");
goto err;
}
testvectors = malloc(number_of_testvectors * sizeof(*testvectors));
if (NULL == testvectors) {
fprintf(stderr, "Failed to allocate memory for testvectors.\n");
goto err;
}
for (i = 0; i < number_of_testvectors; ++i) {
for (j = 0; j < 40; ++j) {
ret = fscanf(testfile, "%30lf", &testvectors[i].x[j]);
if (ret != 1) {
fprintf(stderr, "ERROR: Failed to parse testvector %lu element %lu.\n",
(unsigned long) i + 1, (unsigned long) j + 1);
}
}
}
suite = coco_suite("bbob", "instances: 1-15", NULL);
while (1) {
double expected_value, *x, y;
ret = fscanf(testfile, "%30lu\t%30lu\t%30i\t%30lf", &problem_index_old, &problem_index, &testvector_id,
&expected_value);
if (ret != 4)
break;
++number_of_testcases;
/* We cache the problem object to save time. Instantiating
* some functions is expensive because we have to generate
* large rotation matrices.
*/
if (previous_problem_index != (long) problem_index) {
if (NULL != problem)
coco_problem_free(problem);
if (problem_index > coco_suite_get_number_of_problems(suite) - 1) {
fprintf(stdout, "problem index = %lu, maximum index = %lu \n", (unsigned long) problem_index,
(unsigned long) coco_suite_get_number_of_problems(suite) - 1);
}
problem = coco_suite_get_problem(suite, problem_index);
previous_problem_index = (long) problem_index;
}
x = testvectors[testvector_id].x;
coco_evaluate_function(problem, x, &y);
if (!about_equal(expected_value, y)) {
++number_of_failures;
if (!header_shown) {
fprintf(stdout, "Problem Testcase Status Message\n");
header_shown = 1;
}
if (shown_failures < 100) {
fprintf(stdout,
"%8lu %8i FAILED expected=%.8e observed=%.8e problem_id=%s\n",
problem_index, testvector_id, expected_value, y,
coco_problem_get_id(problem));
fflush(stdout);
++shown_failures;
} else if (shown_failures == 100) {
fprintf(stdout, "... further failed tests suppressed ...\n");
fflush(stdout);
++shown_failures;
}
}
}
fclose(testfile);
/* Output summary statistics */
fprintf(stderr, "%i of %i tests passed (failure rate %.2f%%)\n",
number_of_testcases - number_of_failures, (int)number_of_testcases,
(100.0 * number_of_failures) / number_of_testcases);
/* Free any remaining allocated memory */
if (NULL != problem)
coco_problem_free(problem);
free(testvectors);
coco_suite_free(suite);
return number_of_failures == 0 ? 0 : 1;
err:
if (testfile != NULL)
fclose(testfile);
if (testvectors != NULL)
free(testvectors);
return 2;
}
