/** * 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; }
/** * Oscillate the objective value of the inner problem. * * Caveat: this can change best_parameter and best_value. */ static coco_problem_t *f_transform_obj_oscillate(coco_problem_t *inner_problem) { coco_problem_t *self; self = coco_transformed_allocate(inner_problem, NULL, NULL); self->evaluate_function = transform_obj_oscillate_evaluate; /* Compute best value */ /* Maybe not the most efficient solution */ transform_obj_oscillate_evaluate(self, self->best_parameter, self->best_value); return self; }
/** * Perform monotone oscillation(?) transformation on input variables. */ static coco_problem_t *f_transform_vars_conditioning(coco_problem_t *inner_problem, const double alpha) { transform_vars_conditioning_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_transformed_allocate(inner_problem, data, transform_vars_conditioning_free); self->evaluate_function = transform_vars_conditioning_evaluate; return self; }
/** * 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; }
/** * Shift the objective value of the inner problem by offset. */ static coco_problem_t *f_transform_obj_shift(coco_problem_t *inner_problem, const double offset) { coco_problem_t *self; transform_obj_shift_data_t *data; data = coco_allocate_memory(sizeof(*data)); data->offset = offset; self = coco_transformed_allocate(inner_problem, data, NULL); self->evaluate_function = transform_obj_shift_evaluate; self->best_value[0] += offset; /* FIXME: shifts only the first objective */ return self; }
/* * 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; }
/** * 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; }