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_brs_evaluate(coco_problem_t *self, const double *x, double *y) { size_t i; double factor; transform_vars_brs_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) { /* 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) 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); }
/** * 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); }
static void transform_vars_shift_evaluate(coco_problem_t *self, const double *x, double *y) { size_t i; transform_vars_shift_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) { data->shifted_x[i] = x[i] - data->offset[i]; } coco_evaluate_function(inner_problem, data->shifted_x, y); assert(y[0] >= self->best_value[0]); }
static void transform_vars_scale_evaluate(coco_problem_t *self, const double *x, double *y) { size_t i; transform_vars_scale_data_t *data; coco_problem_t *inner_problem; data = coco_transformed_get_data(self); inner_problem = coco_transformed_get_inner_problem(self); do { const double factor = data->factor; for (i = 0; i < self->number_of_variables; ++i) { data->x[i] = factor * x[i]; } coco_evaluate_function(inner_problem, data->x, y); assert(y[0] >= self->best_value[0]); } while (0); }
static void transform_vars_conditioning_evaluate(coco_problem_t *self, const double *x, double *y) { size_t i; transform_vars_conditioning_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) { /* 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) self->number_of_variables - 1.0)) * x[i]; } coco_evaluate_function(inner_problem, data->x, y); }
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); }
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); }
static void transform_obj_shift_evaluate(coco_problem_t *self, const double *x, double *y) { transform_obj_shift_data_t *data; data = coco_transformed_get_data(self); coco_evaluate_function(coco_transformed_get_inner_problem(self), x, y); y[0] += data->offset; /* FIXME: shifts only the first objective */ }