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; }
/** * @brief Allocates the basic Rastrigin problem. */ static coco_problem_t *f_rastrigin_allocate(const size_t number_of_variables) { coco_problem_t *problem = coco_problem_allocate_from_scalars("Rastrigin function", f_rastrigin_evaluate, NULL, number_of_variables, -5.0, 5.0, 0.0); coco_problem_set_id(problem, "%s_d%02lu", "rastrigin", number_of_variables); /* Compute best solution */ f_rastrigin_evaluate(problem, problem->best_parameter, problem->best_value); return problem; }
/** * @brief Allocates the basic Griewank-Rosenbrock problem. */ static coco_problem_t *f_griewank_rosenbrock_allocate(const size_t number_of_variables) { coco_problem_t *problem = coco_problem_allocate_from_scalars("Griewank Rosenbrock function", f_griewank_rosenbrock_evaluate, NULL, number_of_variables, -5.0, 5.0, 1); coco_problem_set_id(problem, "%s_d%02lu", "griewank_rosenbrock", number_of_variables); /* Compute best solution */ f_griewank_rosenbrock_evaluate(problem, problem->best_parameter, problem->best_value); 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; }
static coco_problem_t *f_gallagher_bbob_problem_allocate(const size_t function, const size_t dimension, const size_t instance, const long rseed, const size_t number_of_peaks, const char *problem_id_template, const char *problem_name_template) { f_gallagher_data_t *data; /* problem_name and best_parameter will be overwritten below */ coco_problem_t *problem = coco_problem_allocate_from_scalars("Gallagher function", f_gallagher_evaluate, f_gallagher_free, dimension, -5.0, 5.0, 0.0); const size_t peaks_21 = 21; const size_t peaks_101 = 101; double fopt; size_t i, j, k, *rperm; double maxcondition = 1000.; /* maxcondition1 satisfies the old code and the doc but seems wrong in that it is, with very high * probability, not the largest condition level!!! */ double maxcondition1 = 1000.; double *arrCondition; double fitvalues[2] = { 1.1, 9.1 }; /* Parameters for generating local optima. In the old code, they are different in f21 and f22 */ double b, c; data = coco_allocate_memory(sizeof(*data)); /* Allocate temporary storage and space for the rotation matrices */ data->number_of_peaks = number_of_peaks; data->xopt = coco_allocate_vector(dimension); data->rotation = bbob2009_allocate_matrix(dimension, dimension); data->x_local = bbob2009_allocate_matrix(dimension, number_of_peaks); data->arr_scales = bbob2009_allocate_matrix(number_of_peaks, dimension); if (number_of_peaks == peaks_101) { if (gallagher_peaks != NULL) coco_free_memory(gallagher_peaks); gallagher_peaks = coco_allocate_vector(peaks_101 * dimension); maxcondition1 = sqrt(maxcondition1); b = 10.; c = 5.; } else if (number_of_peaks == peaks_21) { if (gallagher_peaks != NULL) coco_free_memory(gallagher_peaks); gallagher_peaks = coco_allocate_vector(peaks_21 * dimension); b = 9.8; c = 4.9; } else { coco_error("f_gallagher(): '%lu' is a bad number of peaks", number_of_peaks); } data->rseed = rseed; bbob2009_compute_rotation(data->rotation, rseed, dimension); /* Initialize all the data of the inner problem */ bbob2009_unif(gallagher_peaks, number_of_peaks - 1, data->rseed); rperm = (size_t *) coco_allocate_memory((number_of_peaks - 1) * sizeof(size_t)); for (i = 0; i < number_of_peaks - 1; ++i) rperm[i] = i; qsort(rperm, number_of_peaks - 1, sizeof(size_t), f_gallagher_compare_doubles); /* Random permutation */ arrCondition = coco_allocate_vector(number_of_peaks); arrCondition[0] = maxcondition1; data->peak_values = coco_allocate_vector(number_of_peaks); data->peak_values[0] = 10; for (i = 1; i < number_of_peaks; ++i) { arrCondition[i] = pow(maxcondition, (double) (rperm[i - 1]) / ((double) (number_of_peaks - 2))); data->peak_values[i] = (double) (i - 1) / (double) (number_of_peaks - 2) * (fitvalues[1] - fitvalues[0]) + fitvalues[0]; } coco_free_memory(rperm); rperm = (size_t *) coco_allocate_memory(dimension * sizeof(size_t)); for (i = 0; i < number_of_peaks; ++i) { bbob2009_unif(gallagher_peaks, dimension, data->rseed + (long) (1000 * i)); for (j = 0; j < dimension; ++j) rperm[j] = j; qsort(rperm, dimension, sizeof(size_t), f_gallagher_compare_doubles); for (j = 0; j < dimension; ++j) { data->arr_scales[i][j] = pow(arrCondition[i], ((double) rperm[j]) / ((double) (dimension - 1)) - 0.5); } } coco_free_memory(rperm); bbob2009_unif(gallagher_peaks, dimension * number_of_peaks, data->rseed); for (i = 0; i < dimension; ++i) { data->xopt[i] = 0.8 * (b * gallagher_peaks[i] - c); problem->best_parameter[i] = 0.8 * (b * gallagher_peaks[i] - c); for (j = 0; j < number_of_peaks; ++j) { data->x_local[i][j] = 0.; for (k = 0; k < dimension; ++k) { data->x_local[i][j] += data->rotation[i][k] * (b * gallagher_peaks[j * dimension + k] - c); } if (j == 0) { data->x_local[i][j] *= 0.8; } } } coco_free_memory(arrCondition); problem->data = data; /* Compute best solution */ f_gallagher_evaluate(problem, problem->best_parameter, problem->best_value); fopt = bbob2009_compute_fopt(function, instance); problem = f_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; }