nlopt_result crs_minimize(int n, nlopt_func f, void *f_data,
const double *lb, const double *ub, /* bounds */
double *x, /* in: initial guess, out: minimizer */
double *minf,
nlopt_stopping *stop,
int population, /* initial population (0=default) */
int lds) /* random or low-discrepancy seq. (lds) */
{
nlopt_result ret;
crs_data d;
rb_node *best;
ret = crs_init(&d, n, x, lb, ub, stop, f, f_data, population, lds);
if (ret < 0) return ret;
best = rb_tree_min(&d.t);
*minf = best->k[0];
memcpy(x, best->k + 1, sizeof(double) * n);
while (ret == NLOPT_SUCCESS) {
if (NLOPT_SUCCESS == (ret = crs_trial(&d))) {
best = rb_tree_min(&d.t);
if (best->k[0] < *minf) {
if (best->k[0] < stop->minf_max)
ret = NLOPT_MINF_MAX_REACHED;
else if (nlopt_stop_f(stop, best->k[0], *minf))
ret = NLOPT_FTOL_REACHED;
else if (nlopt_stop_x(stop, best->k + 1, x))
ret = NLOPT_XTOL_REACHED;
*minf = best->k[0];
memcpy(x, best->k + 1, sizeof(double) * n);
}
if (ret != NLOPT_SUCCESS) {
if (nlopt_stop_evals(stop))
ret = NLOPT_MAXEVAL_REACHED;
else if (nlopt_stop_time(stop))
ret = NLOPT_MAXTIME_REACHED;
}
}
}
crs_destroy(&d);
return ret;
}
nlopt_result cdirect_unscaled(int n, nlopt_func f, void *f_data,
const double *lb, const double *ub,
double *x,
double *minf,
nlopt_stopping *stop,
double magic_eps, int which_alg)
{
params p;
int i;
double *rnew;
nlopt_result ret = NLOPT_OUT_OF_MEMORY;
p.magic_eps = magic_eps;
p.which_diam = which_alg % 3;
p.which_div = (which_alg / 3) % 3;
p.which_opt = (which_alg / (3*3)) % 3;
p.lb = lb; p.ub = ub;
p.stop = stop;
p.n = n;
p.L = 2*n+3;
p.f = f;
p.f_data = f_data;
p.xmin = x;
p.minf = HUGE_VAL;
p.work = 0;
p.iwork = 0;
p.hull = 0;
p.age = 0;
rb_tree_init(&p.rtree, cdirect_hyperrect_compare);
p.work = (double *) malloc(sizeof(double) * (2*n));
if (!p.work) goto done;
p.iwork = (int *) malloc(sizeof(int) * n);
if (!p.iwork) goto done;
p.hull_len = 128; /* start with a reasonable number */
p.hull = (double **) malloc(sizeof(double *) * p.hull_len);
if (!p.hull) goto done;
if (!(rnew = (double *) malloc(sizeof(double) * p.L))) goto done;
for (i = 0; i < n; ++i) {
rnew[3+i] = 0.5 * (lb[i] + ub[i]);
rnew[3+n+i] = ub[i] - lb[i];
}
rnew[0] = rect_diameter(n, rnew+3+n, &p);
rnew[1] = function_eval(rnew+3, &p);
rnew[2] = p.age++;
if (!rb_tree_insert(&p.rtree, rnew)) {
free(rnew);
goto done;
}
ret = divide_rect(rnew, &p);
if (ret != NLOPT_SUCCESS) goto done;
while (1) {
double minf0 = p.minf;
ret = divide_good_rects(&p);
if (ret != NLOPT_SUCCESS) goto done;
if (p.minf < minf0 && nlopt_stop_f(p.stop, p.minf, minf0)) {
ret = NLOPT_FTOL_REACHED;
goto done;
}
}
done:
rb_tree_destroy_with_keys(&p.rtree);
free(p.hull);
free(p.iwork);
free(p.work);
*minf = p.minf;
return ret;
}
static nlopt_result divide_largest(params *p)
{
int L = p->L;
int n = p->n;
rb_node *node = rb_tree_max(&p->rtree); /* just using it as a heap */
double minf_start = p->minf;
double *r = node->k, *rnew = NULL;
double *x = r + 3, *c = x + n, *w = c + n;
const double *lb = p->lb, *ub = p->ub;
int i, idiv;
double wmax;
nlopt_result ret;
/* printf("rect:, %d, %g, %g, %g, %g\n", p->stop->nevals, c[0], c[1], w[0], w[1]); */
/* check xtol */
for (i = 0; i < n; ++i)
if (w[i] > p->stop->xtol_rel * (ub[i] - lb[i])
&& w[i] > p->stop->xtol_abs[i])
break;
if (i == n) return NLOPT_XTOL_REACHED;
if (p->randomized_div) { /* randomly pick among ~largest sides */
int nlongest = 0;
wmax = longest(n, w);
for (i = 0; i < n; ++i)
if (wmax - w[i] < EQUAL_SIDE_TOL * wmax) ++nlongest;
i = 1 + nlopt_iurand(nlongest);
for (idiv = 0; idiv < n; ++idiv) {
if (wmax - w[idiv] < EQUAL_SIDE_TOL * wmax) --i;
if (!i) break;
}
}
else { /* just pick first largest side */
wmax = w[idiv = 0];
for (i = 1; i < n; ++i) if (w[i] > wmax) wmax = w[idiv = i];
}
if (fabs(x[idiv] - c[idiv]) > (0.5 * THIRD) * w[idiv]) { /* bisect */
double deltac = (x[idiv] > c[idiv] ? 0.25 : -0.25) * w[idiv];
w[idiv] *= 0.5;
c[idiv] += deltac;
r[0] = longest(n, w); /* new diameter */
/* r[1] unchanged since still contains local optimum x */
r[2] = p->age--;
node = rb_tree_resort(&p->rtree, node);
rnew = (double *) malloc(sizeof(double) * L);
if (!rnew) return NLOPT_OUT_OF_MEMORY;
memcpy(rnew, r, sizeof(double) * L);
rnew[2] = p->age--;
rnew[3+n+idiv] -= deltac*2;
if (p->randomized_div)
randomize_x(n, rnew);
else
memcpy(rnew+3, rnew+3+n, sizeof(double) * n); /* x = c */
ret = optimize_rect(rnew, p);
if (ret != NLOPT_SUCCESS) { free(rnew); return ret; }
if (!rb_tree_insert(&p->rtree, rnew)) {
free(rnew); return NLOPT_OUT_OF_MEMORY;
}
}
else { /* trisect */
w[idiv] *= THIRD;
r[0] = longest(n, w);
/* r[1] unchanged since still contains local optimum x */
r[2] = p->age--;
node = rb_tree_resort(&p->rtree, node);
for (i = -1; i <= +1; i += 2) {
rnew = (double *) malloc(sizeof(double) * L);
if (!rnew) return NLOPT_OUT_OF_MEMORY;
memcpy(rnew, r, sizeof(double) * L);
rnew[2] = p->age--;
rnew[3+n+idiv] += w[i] * i;
if (p->randomized_div)
randomize_x(n, rnew);
else
memcpy(rnew+3, rnew+3+n, sizeof(double) * n); /* x = c */
ret = optimize_rect(rnew, p);
if (ret != NLOPT_SUCCESS) { free(rnew); return ret; }
if (!rb_tree_insert(&p->rtree, rnew)) {
free(rnew); return NLOPT_OUT_OF_MEMORY;
}
}
}
if (p->minf < minf_start && nlopt_stop_f(p->stop, p->minf, minf_start))
return NLOPT_FTOL_REACHED;
return NLOPT_SUCCESS;
}
nlopt_result isres_minimize(int n, nlopt_func f, void *f_data,
int m, nlopt_constraint *fc, /* fc <= 0 */
int p, nlopt_constraint *h, /* h == 0 */
const double *lb, const double *ub, /* bounds */
double *x, /* in: initial guess, out: minimizer */
double *minf,
nlopt_stopping *stop,
int population) /* pop. size (= 0 for default) */
{
const double ALPHA = 0.2; /* smoothing factor from paper */
const double GAMMA = 0.85; /* step-reduction factor from paper */
const double PHI = 1.0; /* expected rate of convergence, from paper */
const double PF = 0.45; /* fitness probability, from paper */
const double SURVIVOR = 1.0/7.0; /* survivor fraction, from paper */
int survivors;
nlopt_result ret = NLOPT_SUCCESS;
double *sigmas = 0, *xs; /* population-by-n arrays (row-major) */
double *fval; /* population array of function vals */
double *penalty; /* population array of penalty vals */
double *x0;
int *irank = 0;
int k, i, j, c;
int mp = m + p;
double minf_penalty = HUGE_VAL, minf_gpenalty = HUGE_VAL;
double taup, tau;
double *results = 0; /* scratch space for mconstraint results */
unsigned ires;
*minf = HUGE_VAL;
if (!population) population = 20 * (n + 1);
if (population < 1) return NLOPT_INVALID_ARGS;
survivors = ceil(population * SURVIVOR);
taup = PHI / sqrt((double) 2*n);
tau = PHI / sqrt((double) 2*sqrt((double) n));
/* we don't handle unbounded search regions */
for (j = 0; j < n; ++j) if (nlopt_isinf(lb[j]) || nlopt_isinf(ub[j]))
return NLOPT_INVALID_ARGS;
ires = imax2(nlopt_max_constraint_dim(m, fc),
nlopt_max_constraint_dim(p, h));
results = (double *) malloc(ires * sizeof(double));
if (ires > 0 && !results) return NLOPT_OUT_OF_MEMORY;
sigmas = (double*) malloc(sizeof(double) * (population*n*2
+ population
+ population
+ n));
if (!sigmas) { free(results); return NLOPT_OUT_OF_MEMORY; }
xs = sigmas + population*n;
fval = xs + population*n;
penalty = fval + population;
x0 = penalty + population;
irank = (int*) malloc(sizeof(int) * population);
if (!irank) { ret = NLOPT_OUT_OF_MEMORY; goto done; }
for (k = 0; k < population; ++k) {
for (j = 0; j < n; ++j) {
sigmas[k*n+j] = (ub[j] - lb[j]) / sqrt((double) n);
xs[k*n+j] = nlopt_urand(lb[j], ub[j]);
}
}
memcpy(xs, x, sizeof(double) * n); /* use input x for xs_0 */
while (1) { /* each loop body = one generation */
int all_feasible = 1;
/* evaluate f and constraint violations for whole population */
for (k = 0; k < population; ++k) {
int feasible = 1;
double gpenalty;
stop->nevals++;
fval[k] = f(n, xs + k*n, NULL, f_data);
if (nlopt_stop_forced(stop)) {
ret = NLOPT_FORCED_STOP; goto done; }
penalty[k] = 0;
for (c = 0; c < m; ++c) { /* inequality constraints */
nlopt_eval_constraint(results, NULL,
fc + c, n, xs + k*n);
if (nlopt_stop_forced(stop)) {
ret = NLOPT_FORCED_STOP; goto done; }
for (ires = 0; ires < fc[c].m; ++ires) {
double gval = results[ires];
if (gval > fc[c].tol[ires]) feasible = 0;
if (gval < 0) gval = 0;
penalty[k] += gval*gval;
}
}
gpenalty = penalty[k];
for (c = m; c < mp; ++c) { /* equality constraints */
nlopt_eval_constraint(results, NULL,
h + (c-m), n, xs + k*n);
if (nlopt_stop_forced(stop)) {
ret = NLOPT_FORCED_STOP; goto done; }
for (ires = 0; ires < h[c-m].m; ++ires) {
double hval = results[ires];
if (fabs(hval) > h[c-m].tol[ires]) feasible = 0;
penalty[k] += hval*hval;
}
}
if (penalty[k] > 0) all_feasible = 0;
/* convergence criteria (FIXME: improve?) */
/* FIXME: with equality constraints, how do
we decide which solution is the "best" so far?
... need some total order on the solutions? */
if ((penalty[k] <= minf_penalty || feasible)
&& (fval[k] <= *minf || minf_gpenalty > 0)
&& ((feasible ? 0 : penalty[k]) != minf_penalty
|| fval[k] != *minf)) {
if (fval[k] < stop->minf_max && feasible)
ret = NLOPT_MINF_MAX_REACHED;
else if (!nlopt_isinf(*minf)) {
if (nlopt_stop_f(stop, fval[k], *minf)
&& nlopt_stop_f(stop, feasible ? 0 : penalty[k],
minf_penalty))
ret = NLOPT_FTOL_REACHED;
else if (nlopt_stop_x(stop, xs+k*n, x))
ret = NLOPT_XTOL_REACHED;
}
memcpy(x, xs+k*n, sizeof(double)*n);
*minf = fval[k];
minf_penalty = feasible ? 0 : penalty[k];
minf_gpenalty = feasible ? 0 : gpenalty;
if (ret != NLOPT_SUCCESS) goto done;
}
if (nlopt_stop_forced(stop)) ret = NLOPT_FORCED_STOP;
else if (nlopt_stop_evals(stop)) ret = NLOPT_MAXEVAL_REACHED;
else if (nlopt_stop_time(stop)) ret = NLOPT_MAXTIME_REACHED;
if (ret != NLOPT_SUCCESS) goto done;
}
/* "selection" step: rank the population */
for (k = 0; k < population; ++k) irank[k] = k;
if (all_feasible) /* special case: rank by objective function */
nlopt_qsort_r(irank, population, sizeof(int), fval,key_compare);
else {
/* Runarsson & Yao's stochastic ranking of the population */
for (i = 0; i < population; ++i) {
int swapped = 0;
for (j = 0; j < population-1; ++j) {
double u = nlopt_urand(0,1);
if (u < PF || (penalty[irank[j]] == 0
&& penalty[irank[j+1]] == 0)) {
if (fval[irank[j]] > fval[irank[j+1]]) {
int irankj = irank[j];
irank[j] = irank[j+1];
irank[j+1] = irankj;
swapped = 1;
}
}
else if (penalty[irank[j]] > penalty[irank[j+1]]) {
int irankj = irank[j];
irank[j] = irank[j+1];
irank[j+1] = irankj;
swapped = 1;
}
}
if (!swapped) break;
}
}
/* evolve the population:
differential evolution for the best survivors,
and standard mutation of the best survivors for the rest: */
for (k = survivors; k < population; ++k) { /* standard mutation */
double taup_rand = taup * nlopt_nrand(0,1);
int rk = irank[k], ri;
i = k % survivors;
ri = irank[i];
for (j = 0; j < n; ++j) {
double sigmamax = (ub[j] - lb[j]) / sqrt((double) n);
sigmas[rk*n+j] = sigmas[ri*n+j]
* exp(taup_rand + tau*nlopt_nrand(0,1));
if (sigmas[rk*n+j] > sigmamax)
sigmas[rk*n+j] = sigmamax;
do {
xs[rk*n+j] = xs[ri*n+j]
+ sigmas[rk*n+j] * nlopt_nrand(0,1);
} while (xs[rk*n+j] < lb[j] || xs[rk*n+j] > ub[j]);
sigmas[rk*n+j] = sigmas[ri*n+j] + ALPHA*(sigmas[rk*n+j]
- sigmas[ri*n+j]);
}
}
memcpy(x0, xs, n * sizeof(double));
for (k = 0; k < survivors; ++k) { /* differential variation */
double taup_rand = taup * nlopt_nrand(0,1);
int rk = irank[k];
for (j = 0; j < n; ++j) {
double xi = xs[rk*n+j];
if (k+1 < survivors)
xs[rk*n+j] += GAMMA * (x0[j] - xs[(k+1)*n+j]);
if (k+1 == survivors
|| xs[rk*n+j] < lb[j] || xs[rk*n+j] > ub[j]) {
/* standard mutation for last survivor and
for any survivor components that are now
outside the bounds */
double sigmamax = (ub[j] - lb[j]) / sqrt((double) n);
double sigi = sigmas[rk*n+j];
sigmas[rk*n+j] *= exp(taup_rand
+ tau*nlopt_nrand(0,1));
if (sigmas[rk*n+j] > sigmamax)
sigmas[rk*n+j] = sigmamax;
do {
xs[rk*n+j] = xi
+ sigmas[rk*n+j] * nlopt_nrand(0,1);
} while (xs[rk*n+j] < lb[j] || xs[rk*n+j] > ub[j]);
sigmas[rk*n+j] = sigi
+ ALPHA * (sigmas[rk*n+j] - sigi);
}
}
}
}
done:
if (irank) free(irank);
if (sigmas) free(sigmas);
if (results) free(results);
return ret;
}