/** * @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; }