static nlopt_result optimize_rect(double *r, params *p)
{
int i, n = p->n;
double *lb = p->work, *ub = lb + n;
double *x = r + 3, *c = x + n, *w = c + n;
double t = nlopt_seconds();
double minf;
nlopt_stopping *stop = p->stop;
nlopt_result ret;
if (stop->maxeval > 0 &&
stop->nevals >= stop->maxeval) return NLOPT_MAXEVAL_REACHED;
if (stop->maxtime > 0 &&
t - stop->start >= stop->maxtime) return NLOPT_MAXTIME_REACHED;
for (i = 0; i < n; ++i) {
lb[i] = c[i] - 0.5 * w[i];
ub[i] = c[i] + 0.5 * w[i];
}
ret = nlopt_minimize(p->local_alg, n, fcount, p,
lb, ub, x, &minf,
stop->minf_max, stop->ftol_rel, stop->ftol_abs,
stop->xtol_rel, stop->xtol_abs,
p->local_maxeval > 0 ?
MIN(p->local_maxeval,
stop->maxeval - stop->nevals)
: stop->maxeval - stop->nevals,
stop->maxtime - (t - stop->start));
r[1] = -minf;
if (ret > 0) {
if (minf < p->minf) {
p->minf = minf;
memcpy(p->xmin, x, sizeof(double) * n);
if (ret == NLOPT_MINF_MAX_REACHED) return ret;
}
return NLOPT_SUCCESS;
}
return ret;
}
nlopt_result mma_minimize(unsigned n, nlopt_func f, void *f_data,
unsigned m, nlopt_constraint *fc,
const double *lb, const double *ub, /* bounds */
double *x, /* in: initial guess, out: minimizer */
double *minf,
nlopt_stopping *stop,
nlopt_opt dual_opt)
{
nlopt_result ret = NLOPT_SUCCESS;
double *xcur, rho, *sigma, *dfdx, *dfdx_cur, *xprev, *xprevprev, fcur;
double *dfcdx, *dfcdx_cur;
double *fcval, *fcval_cur, *rhoc, *gcval, *y, *dual_lb, *dual_ub;
unsigned i, ifc, j, k = 0;
dual_data dd;
int feasible;
double infeasibility;
unsigned mfc;
m = nlopt_count_constraints(mfc = m, fc);
if (nlopt_get_dimension(dual_opt) != m) return NLOPT_INVALID_ARGS;
sigma = (double *) malloc(sizeof(double) * (6*n + 2*m*n + m*7));
if (!sigma) return NLOPT_OUT_OF_MEMORY;
dfdx = sigma + n;
dfdx_cur = dfdx + n;
xcur = dfdx_cur + n;
xprev = xcur + n;
xprevprev = xprev + n;
fcval = xprevprev + n;
fcval_cur = fcval + m;
rhoc = fcval_cur + m;
gcval = rhoc + m;
dual_lb = gcval + m;
dual_ub = dual_lb + m;
y = dual_ub + m;
dfcdx = y + m;
dfcdx_cur = dfcdx + m*n;
dd.n = n;
dd.x = x;
dd.lb = lb;
dd.ub = ub;
dd.sigma = sigma;
dd.dfdx = dfdx;
dd.dfcdx = dfcdx;
dd.fcval = fcval;
dd.rhoc = rhoc;
dd.xcur = xcur;
dd.gcval = gcval;
for (j = 0; j < n; ++j) {
if (nlopt_isinf(ub[j]) || nlopt_isinf(lb[j]))
sigma[j] = 1.0; /* arbitrary default */
else
sigma[j] = 0.5 * (ub[j] - lb[j]);
}
rho = 1.0;
for (i = 0; i < m; ++i) {
rhoc[i] = 1.0;
dual_lb[i] = y[i] = 0.0;
dual_ub[i] = HUGE_VAL;
}
dd.fval = fcur = *minf = f(n, x, dfdx, f_data);
stop->nevals++;
memcpy(xcur, x, sizeof(double) * n);
if (nlopt_stop_forced(stop)) { ret = NLOPT_FORCED_STOP; goto done; }
feasible = 1; infeasibility = 0;
for (i = ifc = 0; ifc < mfc; ++ifc) {
nlopt_eval_constraint(fcval + i, dfcdx + i*n,
fc + ifc, n, x);
i += fc[ifc].m;
if (nlopt_stop_forced(stop)) { ret = NLOPT_FORCED_STOP; goto done; }
}
for (i = 0; i < m; ++i) {
feasible = feasible && (fcval[i] <= 0 || isnan(fcval[i]));
if (fcval[i] > infeasibility) infeasibility = fcval[i];
}
/* For non-feasible initial points, set a finite (large)
upper-bound on the dual variables. What this means is that,
if no feasible solution is found from the dual problem, it
will minimize the dual objective with the unfeasible
constraint weighted by 1e40 -- basically, minimizing the
unfeasible constraint until it becomes feasible or until we at
least obtain a step towards a feasible point.
Svanberg suggested a different approach in his 1987 paper, basically
introducing additional penalty variables for unfeasible constraints,
but this is easier to implement and at least as efficient. */
if (!feasible)
for (i = 0; i < m; ++i) dual_ub[i] = 1e40;
nlopt_set_min_objective(dual_opt, dual_func, &dd);
nlopt_set_lower_bounds(dual_opt, dual_lb);
nlopt_set_upper_bounds(dual_opt, dual_ub);
nlopt_set_stopval(dual_opt, -HUGE_VAL);
nlopt_remove_inequality_constraints(dual_opt);
nlopt_remove_equality_constraints(dual_opt);
while (1) { /* outer iterations */
double fprev = fcur;
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;
else if (feasible && *minf < stop->minf_max)
ret = NLOPT_MINF_MAX_REACHED;
if (ret != NLOPT_SUCCESS) goto done;
if (++k > 1) memcpy(xprevprev, xprev, sizeof(double) * n);
memcpy(xprev, xcur, sizeof(double) * n);
while (1) { /* inner iterations */
double min_dual, infeasibility_cur;
int feasible_cur, inner_done;
unsigned save_verbose;
int new_infeasible_constraint;
nlopt_result reti;
/* solve dual problem */
dd.rho = rho; dd.count = 0;
save_verbose = mma_verbose;
mma_verbose = 0; /* no recursive verbosity */
reti = nlopt_optimize_limited(dual_opt, y, &min_dual,
0,
stop->maxtime - (nlopt_seconds()
- stop->start));
mma_verbose = save_verbose;
if (reti < 0 || reti == NLOPT_MAXTIME_REACHED) {
ret = reti;
goto done;
}
dual_func(m, y, NULL, &dd); /* evaluate final xcur etc. */
if (mma_verbose) {
printf("MMA dual converged in %d iterations to g=%g:\n",
dd.count, dd.gval);
for (i = 0; i < MIN(mma_verbose, m); ++i)
printf(" MMA y[%d]=%g, gc[%d]=%g\n",
i, y[i], i, dd.gcval[i]);
}
fcur = f(n, xcur, dfdx_cur, f_data);
stop->nevals++;
if (nlopt_stop_forced(stop)) {
ret = NLOPT_FORCED_STOP; goto done; }
feasible_cur = 1; infeasibility_cur = 0;
new_infeasible_constraint = 0;
inner_done = dd.gval >= fcur;
for (i = ifc = 0; ifc < mfc; ++ifc) {
nlopt_eval_constraint(fcval_cur + i, dfcdx_cur + i*n,
fc + ifc, n, xcur);
i += fc[ifc].m;
if (nlopt_stop_forced(stop)) {
ret = NLOPT_FORCED_STOP; goto done; }
}
for (i = ifc = 0; ifc < mfc; ++ifc) {
unsigned i0 = i, inext = i + fc[ifc].m;
for (; i < inext; ++i)
if (!isnan(fcval_cur[i])) {
feasible_cur = feasible_cur
&& (fcval_cur[i] <= fc[ifc].tol[i-i0]);
if (!isnan(fcval[i]))
inner_done = inner_done &&
(dd.gcval[i] >= fcval_cur[i]);
else if (fcval_cur[i] > 0)
new_infeasible_constraint = 1;
if (fcval_cur[i] > infeasibility_cur)
infeasibility_cur = fcval_cur[i];
}
}
if ((fcur < *minf && (inner_done || feasible_cur || !feasible))
|| (!feasible && infeasibility_cur < infeasibility)) {
if (mma_verbose && !feasible_cur)
printf("MMA - using infeasible point?\n");
dd.fval = *minf = fcur;
infeasibility = infeasibility_cur;
memcpy(fcval, fcval_cur, sizeof(double)*m);
memcpy(x, xcur, sizeof(double)*n);
memcpy(dfdx, dfdx_cur, sizeof(double)*n);
memcpy(dfcdx, dfcdx_cur, sizeof(double)*n*m);
/* once we have reached a feasible solution, the
algorithm should never make the solution infeasible
again (if inner_done), although the constraints may
be violated slightly by rounding errors etc. so we
must be a little careful about checking feasibility */
if (infeasibility_cur == 0) {
if (!feasible) { /* reset upper bounds to infin. */
for (i = 0; i < m; ++i) dual_ub[i] = HUGE_VAL;
nlopt_set_upper_bounds(dual_opt, dual_ub);
}
feasible = 1;
}
else if (new_infeasible_constraint) feasible = 0;
}
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;
else if (feasible && *minf < stop->minf_max)
ret = NLOPT_MINF_MAX_REACHED;
if (ret != NLOPT_SUCCESS) goto done;
if (inner_done) break;
if (fcur > dd.gval)
rho = MIN(10*rho, 1.1 * (rho + (fcur-dd.gval) / dd.wval));
for (i = 0; i < m; ++i)
if (!isnan(fcval_cur[i]) && fcval_cur[i] > dd.gcval[i])
rhoc[i] =
MIN(10*rhoc[i],
1.1 * (rhoc[i] + (fcval_cur[i]-dd.gcval[i])
/ dd.wval));
if (mma_verbose)
printf("MMA inner iteration: rho -> %g\n", rho);
for (i = 0; i < MIN(mma_verbose, m); ++i)
printf(" MMA rhoc[%d] -> %g\n", i,rhoc[i]);
}
if (nlopt_stop_ftol(stop, fcur, fprev))
ret = NLOPT_FTOL_REACHED;
if (nlopt_stop_x(stop, xcur, xprev))
ret = NLOPT_XTOL_REACHED;
if (ret != NLOPT_SUCCESS) goto done;
/* update rho and sigma for iteration k+1 */
rho = MAX(0.1 * rho, MMA_RHOMIN);
if (mma_verbose)
printf("MMA outer iteration: rho -> %g\n", rho);
for (i = 0; i < m; ++i)
rhoc[i] = MAX(0.1 * rhoc[i], MMA_RHOMIN);
for (i = 0; i < MIN(mma_verbose, m); ++i)
printf(" MMA rhoc[%d] -> %g\n", i, rhoc[i]);
if (k > 1) {
for (j = 0; j < n; ++j) {
double dx2 = (xcur[j]-xprev[j]) * (xprev[j]-xprevprev[j]);
double gam = dx2 < 0 ? 0.7 : (dx2 > 0 ? 1.2 : 1);
sigma[j] *= gam;
if (!nlopt_isinf(ub[j]) && !nlopt_isinf(lb[j])) {
sigma[j] = MIN(sigma[j], 10*(ub[j]-lb[j]));
sigma[j] = MAX(sigma[j], 0.01*(ub[j]-lb[j]));
}
}
for (j = 0; j < MIN(mma_verbose, n); ++j)
printf(" MMA sigma[%d] -> %g\n",
j, sigma[j]);
}
}
done:
free(sigma);
return ret;
}
nlopt_result auglag_minimize(int n, nlopt_func f, void *f_data,
int m, nlopt_constraint *fc,
int p, nlopt_constraint *h,
const double *lb, const double *ub, /* bounds */
double *x, /* in: initial guess, out: minimizer */
double *minf,
nlopt_stopping *stop,
nlopt_opt sub_opt, int sub_has_fc)
{
auglag_data d;
nlopt_result ret = NLOPT_SUCCESS;
double ICM = HUGE_VAL, minf_penalty = HUGE_VAL, penalty;
double *xcur = NULL, fcur;
int i, ii, feasible, minf_feasible = 0;
unsigned int k;
int auglag_iters = 0;
int max_constraint_dim;
/* magic parameters from Birgin & Martinez */
const double tau = 0.5, gam = 10;
const double lam_min = -1e20, lam_max = 1e20, mu_max = 1e20;
d.f = f; d.f_data = f_data;
d.m = m; d.fc = fc;
d.p = p; d.h = h;
d.stop = stop;
/* whether we handle inequality constraints via the augmented
Lagrangian penalty function, or directly in the sub-algorithm */
if (sub_has_fc)
d.m = 0;
else
m = 0;
max_constraint_dim = MAX(nlopt_max_constraint_dim(d.m, fc),
nlopt_max_constraint_dim(d.p, h));
d.mm = nlopt_count_constraints(d.m, fc);
d.pp = nlopt_count_constraints(d.p, h);
ret = nlopt_set_min_objective(sub_opt, auglag, &d); if (ret<0) return ret;
ret = nlopt_set_lower_bounds(sub_opt, lb); if (ret<0) return ret;
ret = nlopt_set_upper_bounds(sub_opt, ub); if (ret<0) return ret;
ret = nlopt_set_stopval(sub_opt,
d.m==0 && d.p==0 ? stop->minf_max : -HUGE_VAL);
if (ret<0) return ret;
ret = nlopt_remove_inequality_constraints(sub_opt); if (ret<0) return ret;
ret = nlopt_remove_equality_constraints(sub_opt); if (ret<0) return ret;
for (i = 0; i < m; ++i) {
if (fc[i].f)
ret = nlopt_add_inequality_constraint(sub_opt,
fc[i].f, fc[i].f_data,
fc[i].tol[0]);
else
ret = nlopt_add_inequality_mconstraint(sub_opt, fc[i].m,
fc[i].mf, fc[i].f_data,
fc[i].tol);
if (ret < 0) return ret;
}
xcur = (double *) malloc(sizeof(double) * (n
+ max_constraint_dim * (1 + n)
+ d.pp + d.mm));
if (!xcur) return NLOPT_OUT_OF_MEMORY;
memcpy(xcur, x, sizeof(double) * n);
d.restmp = xcur + n;
d.gradtmp = d.restmp + max_constraint_dim;
memset(d.gradtmp, 0, sizeof(double) * (n*max_constraint_dim + d.pp+d.mm));
d.lambda = d.gradtmp + n * max_constraint_dim;
d.mu = d.lambda + d.pp;
*minf = HUGE_VAL;
/* starting rho suggested by B & M */
if (d.p > 0 || d.m > 0) {
double con2 = 0;
++ *(d.stop->nevals_p);
fcur = f(n, xcur, NULL, f_data);
if (nlopt_stop_forced(stop)) {
ret = NLOPT_FORCED_STOP; goto done; }
penalty = 0;
feasible = 1;
for (i = 0; i < d.p; ++i) {
nlopt_eval_constraint(d.restmp, NULL, d.h + i, n, xcur);
if (nlopt_stop_forced(stop)) {
ret = NLOPT_FORCED_STOP; goto done; }
for (k = 0; k < d.h[i].m; ++k) {
double hi = d.restmp[k];
penalty += fabs(hi);
feasible = feasible && fabs(hi) <= h[i].tol[k];
con2 += hi * hi;
}
}
for (i = 0; i < d.m; ++i) {
nlopt_eval_constraint(d.restmp, NULL, d.fc + i, n, xcur);
if (nlopt_stop_forced(stop)) {
ret = NLOPT_FORCED_STOP; goto done; }
for (k = 0; k < d.fc[i].m; ++k) {
double fci = d.restmp[k];
penalty += fci > 0 ? fci : 0;
feasible = feasible && fci <= fc[i].tol[k];
if (fci > 0) con2 += fci * fci;
}
}
*minf = fcur;
minf_penalty = penalty;
minf_feasible = feasible;
d.rho = MAX(1e-6, MIN(10, 2 * fabs(*minf) / con2));
}
else
d.rho = 1; /* whatever, doesn't matter */
if (auglag_verbose) {
printf("auglag: initial rho=%g\nauglag initial lambda=", d.rho);
for (i = 0; i < d.pp; ++i) printf(" %g", d.lambda[i]);
printf("\nauglag initial mu = ");
for (i = 0; i < d.mm; ++i) printf(" %g", d.mu[i]);
printf("\n");
}
do {
double prev_ICM = ICM;
ret = nlopt_optimize_limited(sub_opt, xcur, &fcur,
stop->maxeval - *(stop->nevals_p),
stop->maxtime - (nlopt_seconds()
- stop->start));
if (auglag_verbose)
printf("auglag: subopt return code %d\n", ret);
if (ret < 0) break;
++ *(d.stop->nevals_p);
fcur = f(n, xcur, NULL, f_data);
if (nlopt_stop_forced(stop)) {
ret = NLOPT_FORCED_STOP; goto done; }
if (auglag_verbose)
printf("auglag: fcur = %g\n", fcur);
ICM = 0;
penalty = 0;
feasible = 1;
for (i = ii = 0; i < d.p; ++i) {
nlopt_eval_constraint(d.restmp, NULL, d.h + i, n, xcur);
if (nlopt_stop_forced(stop)) {
ret = NLOPT_FORCED_STOP; goto done; }
for (k = 0; k < d.h[i].m; ++k) {
double hi = d.restmp[k];
double newlam = d.lambda[ii] + d.rho * hi;
penalty += fabs(hi);
feasible = feasible && fabs(hi) <= h[i].tol[k];
ICM = MAX(ICM, fabs(hi));
d.lambda[ii++] = MIN(MAX(lam_min, newlam), lam_max);
}
}
for (i = ii = 0; i < d.m; ++i) {
nlopt_eval_constraint(d.restmp, NULL, d.fc + i, n, xcur);
if (nlopt_stop_forced(stop)) {
ret = NLOPT_FORCED_STOP; goto done; }
for (k = 0; k < d.fc[i].m; ++k) {
double fci = d.restmp[k];
double newmu = d.mu[ii] + d.rho * fci;
penalty += fci > 0 ? fci : 0;
feasible = feasible && fci <= fc[i].tol[k];
ICM = MAX(ICM, fabs(MAX(fci, -d.mu[ii] / d.rho)));
d.mu[ii++] = MIN(MAX(0.0, newmu), mu_max);
}
}
if (ICM > tau * prev_ICM) {
d.rho *= gam;
}
auglag_iters++;
if (auglag_verbose) {
printf("auglag %d: ICM=%g (%sfeasible), rho=%g\nauglag lambda=",
auglag_iters, ICM, feasible ? "" : "not ", d.rho);
for (i = 0; i < d.pp; ++i) printf(" %g", d.lambda[i]);
printf("\nauglag %d: mu = ", auglag_iters);
for (i = 0; i < d.mm; ++i) printf(" %g", d.mu[i]);
printf("\n");
}
if ((feasible && (!minf_feasible || penalty < minf_penalty
|| fcur < *minf)) ||
(!minf_feasible && penalty < minf_penalty)) {
ret = NLOPT_SUCCESS;
if (feasible) {
if (fcur < stop->minf_max)
ret = NLOPT_MINF_MAX_REACHED;
else if (nlopt_stop_ftol(stop, fcur, *minf))
ret = NLOPT_FTOL_REACHED;
else if (nlopt_stop_x(stop, xcur, x))
ret = NLOPT_XTOL_REACHED;
}
*minf = fcur;
minf_penalty = penalty;
minf_feasible = feasible;
memcpy(x, xcur, sizeof(double) * n);
if (ret != NLOPT_SUCCESS) break;
}
if (nlopt_stop_forced(stop)) {ret = NLOPT_FORCED_STOP; break;}
if (nlopt_stop_evals(stop)) {ret = NLOPT_MAXEVAL_REACHED; break;}
if (nlopt_stop_time(stop)) {ret = NLOPT_MAXTIME_REACHED; break;}
/* TODO: use some other stopping criterion on ICM? */
/* The paper uses ICM <= epsilon and DFM <= epsilon, where
DFM is a measure of the size of the Lagrangian gradient.
Besides the fact that these kinds of absolute tolerances
(non-scale-invariant) are unsatisfying and it is not
clear how the user should specify it, the ICM <= epsilon
condition seems not too different from requiring feasibility,
especially now that the user can provide constraint-specific
tolerances analogous to epsilon. */
if (ICM == 0) {ret = NLOPT_FTOL_REACHED; break;}
} while (1);
done:
free(xcur);
return ret;
}
int nlopt_stop_time_(double start, double maxtime)
{
return (maxtime > 0 && nlopt_seconds() - start >= maxtime);
}
nlopt_result mlsl_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,
nlopt_opt local_opt,
int Nsamples, /* #samples/iteration (0=default) */
int lds) /* random or low-discrepancy seq. (lds) */
{
nlopt_result ret = NLOPT_SUCCESS;
mlsl_data d;
int i;
pt *p;
if (!Nsamples)
d.N = 4; /* FIXME: what is good number of samples per iteration? */
else
d.N = Nsamples;
if (d.N < 1) return NLOPT_INVALID_ARGS;
d.n = n;
d.lb = lb; d.ub = ub;
d.stop = stop;
d.f = f; d.f_data = f_data;
rb_tree_init(&d.pts, pt_compare);
rb_tree_init(&d.lms, lm_compare);
d.s = lds ? nlopt_sobol_create((unsigned) n) : NULL;
nlopt_set_min_objective(local_opt, fcount, &d);
nlopt_set_lower_bounds(local_opt, lb);
nlopt_set_upper_bounds(local_opt, ub);
nlopt_set_stopval(local_opt, stop->minf_max);
d.gamma = MLSL_GAMMA;
d.R_prefactor = sqrt(2./K2PI) * pow(gam(n) * MLSL_SIGMA, 1.0/n);
for (i = 0; i < n; ++i)
d.R_prefactor *= pow(ub[i] - lb[i], 1.0/n);
/* MLSL also suggests setting some minimum distance from points
to previous local minimiza and to the boundaries; I don't know
how to choose this as a fixed number, so I set it proportional
to R; see also the comments at top. dlm and dbound are the
proportionality constants. */
d.dlm = 1.0; /* min distance/R to local minima (FIXME: good value?) */
d.dbound = 1e-6; /* min distance/R to ub/lb boundaries (good value?) */
p = alloc_pt(n);
if (!p) { ret = NLOPT_OUT_OF_MEMORY; goto done; }
/* FIXME: how many sobol points to skip, if any? */
nlopt_sobol_skip(d.s, (unsigned) (10*n+d.N), p->x);
memcpy(p->x, x, n * sizeof(double));
p->f = f(n, x, NULL, f_data);
stop->nevals++;
if (!rb_tree_insert(&d.pts, (rb_key) p)) {
free(p); ret = NLOPT_OUT_OF_MEMORY;
}
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;
else if (p->f < stop->minf_max) ret = NLOPT_MINF_MAX_REACHED;
while (ret == NLOPT_SUCCESS) {
rb_node *node;
double R;
get_minf(&d, minf, x);
/* sampling phase: add random/quasi-random points */
for (i = 0; i < d.N && ret == NLOPT_SUCCESS; ++i) {
p = alloc_pt(n);
if (!p) { ret = NLOPT_OUT_OF_MEMORY; goto done; }
if (d.s) nlopt_sobol_next(d.s, p->x, lb, ub);
else { /* use random points instead of LDS */
int j;
for (j = 0; j < n; ++j) p->x[j] = nlopt_urand(lb[j],ub[j]);
}
p->f = f(n, p->x, NULL, f_data);
stop->nevals++;
if (!rb_tree_insert(&d.pts, (rb_key) p)) {
free(p); ret = NLOPT_OUT_OF_MEMORY;
}
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;
else if (p->f < stop->minf_max) ret = NLOPT_MINF_MAX_REACHED;
else {
find_closest_pt(n, &d.pts, p);
find_closest_lm(n, &d.lms, p);
pts_update_newpt(n, &d.pts, p);
}
}
/* distance threshhold parameter R in MLSL */
R = d.R_prefactor
* pow(log((double) d.pts.N) / d.pts.N, 1.0 / n);
/* local search phase: do local opt. for promising points */
node = rb_tree_min(&d.pts);
for (i = (int) (ceil(d.gamma * d.pts.N) + 0.5);
node && i > 0 && ret == NLOPT_SUCCESS; --i) {
p = (pt *) node->k;
if (is_potential_minimizer(&d, p,
R, d.dlm*R, d.dbound*R)) {
nlopt_result lret;
double *lm;
double t = nlopt_seconds();
if (nlopt_stop_forced(stop)) {
ret = NLOPT_FORCED_STOP; break;
}
if (nlopt_stop_evals(stop)) {
ret = NLOPT_MAXEVAL_REACHED; break;
}
if (stop->maxtime > 0 &&
t - stop->start >= stop->maxtime) {
ret = NLOPT_MAXTIME_REACHED; break;
}
lm = (double *) malloc(sizeof(double) * (n+1));
if (!lm) { ret = NLOPT_OUT_OF_MEMORY; goto done; }
memcpy(lm+1, p->x, sizeof(double) * n);
lret = nlopt_optimize_limited(local_opt, lm+1, lm,
stop->maxeval - stop->nevals,
stop->maxtime -
(t - stop->start));
p->minimized = 1;
if (lret < 0) { free(lm); ret = lret; goto done; }
if (!rb_tree_insert(&d.lms, lm)) {
free(lm); ret = NLOPT_OUT_OF_MEMORY;
}
else if (nlopt_stop_forced(stop)) ret = NLOPT_FORCED_STOP;
else if (*lm < stop->minf_max)
ret = NLOPT_MINF_MAX_REACHED;
else if (nlopt_stop_evals(stop))
ret = NLOPT_MAXEVAL_REACHED;
else if (nlopt_stop_time(stop))
ret = NLOPT_MAXTIME_REACHED;
else
pts_update_newlm(n, &d.pts, lm);
}
/* TODO: additional stopping criteria based
e.g. on improvement in function values, etc? */
node = rb_tree_succ(node);
}
}
get_minf(&d, minf, x);
done:
nlopt_sobol_destroy(d.s);
rb_tree_destroy_with_keys(&d.lms);
rb_tree_destroy_with_keys(&d.pts);
return ret;
}
static int test_function(int ifunc)
{
testfunc func;
int i, iter;
double *x, minf, minf_max, f0, *xtabs, *lb, *ub;
nlopt_result ret;
double start = nlopt_seconds();
int total_count = 0, max_count = 0, min_count = 1<<30;
double total_err = 0, max_err = 0;
bounds_wrap_data bw;
if (ifunc < 0 || ifunc >= NTESTFUNCS) {
fprintf(stderr, "testopt: invalid function %d\n", ifunc);
listfuncs(stderr);
return 0;
}
func = testfuncs[ifunc];
x = (double *) malloc(sizeof(double) * func.n * 5);
if (!x) { fprintf(stderr, "testopt: Out of memory!\n"); return 0; }
lb = x + func.n * 3;
ub = lb + func.n;
xtabs = x + func.n * 2;
bw.lb = lb;
bw.ub = ub;
bw.f = func.f;
bw.f_data = func.f_data;
for (i = 0; i < func.n; ++i) xtabs[i] = xtol_abs;
minf_max = minf_max_delta > (-HUGE_VAL) ? minf_max_delta + func.minf : (-HUGE_VAL);
printf("-----------------------------------------------------------\n");
printf("Optimizing %s (%d dims) using %s algorithm\n",
func.name, func.n, nlopt_algorithm_name(algorithm));
printf("lower bounds at lb = [");
for (i = 0; i < func.n; ++i) printf(" %g", func.lb[i]);
printf("]\n");
printf("upper bounds at ub = [");
for (i = 0; i < func.n; ++i) printf(" %g", func.ub[i]);
printf("]\n");
memcpy(lb, func.lb, func.n * sizeof(double));
memcpy(ub, func.ub, func.n * sizeof(double));
for (i = 0; i < func.n; ++i) if (fix_bounds[i]) {
printf("fixing bounds for dim[%d] to xmin[%d]=%g\n",
i, i, func.xmin[i]);
lb[i] = ub[i] = func.xmin[i];
}
if (force_constraints) {
for (i = 0; i < func.n; ++i) {
if (nlopt_iurand(2) == 0)
ub[i] = nlopt_urand(lb[i], func.xmin[i]);
else
lb[i] = nlopt_urand(func.xmin[i], ub[i]);
}
printf("adjusted lower bounds at lb = [");
for (i = 0; i < func.n; ++i) printf(" %g", lb[i]);
printf("]\n");
printf("adjusted upper bounds at ub = [");
for (i = 0; i < func.n; ++i) printf(" %g", ub[i]);
printf("]\n");
}
if (fabs(func.f(func.n, func.xmin, 0, func.f_data) - func.minf) > 1e-8) {
fprintf(stderr, "BUG: function does not achieve given lower bound!\n");
fprintf(stderr, "f(%g", func.xmin[0]);
for (i = 1; i < func.n; ++i) fprintf(stderr, ", %g", func.xmin[i]);
fprintf(stderr, ") = %0.16g instead of %0.16g, |diff| = %g\n",
func.f(func.n, func.xmin, 0, func.f_data), func.minf,
fabs(func.f(func.n, func.xmin, 0, func.f_data) - func.minf));
return 0;
}
for (iter = 0; iter < iterations; ++iter) {
double val;
testfuncs_counter = 0;
printf("Starting guess x = [");
for (i = 0; i < func.n; ++i) {
if (center_start)
x[i] = (ub[i] + lb[i]) * 0.5;
else if (xinit_tol < 0) { /* random starting point near center of box */
double dx = (ub[i] - lb[i]) * 0.25;
double xm = 0.5 * (ub[i] + lb[i]);
x[i] = nlopt_urand(xm - dx, xm + dx);
}
else {
x[i] = nlopt_urand(-xinit_tol, xinit_tol)
+ (1 + nlopt_urand(-xinit_tol, xinit_tol)) * func.xmin[i];
if (x[i] > ub[i]) x[i] = ub[i];
else if (x[i] < lb[i]) x[i] = lb[i];
}
printf(" %g", x[i]);
}
printf("]\n");
f0 = func.f(func.n, x, x + func.n, func.f_data);
printf("Starting function value = %g\n", f0);
if (iter == 0 && testfuncs_verbose && func.has_gradient) {
printf("checking gradient:\n");
for (i = 0; i < func.n; ++i) {
double f;
x[i] *= 1 + 1e-6;
f = func.f(func.n, x, NULL, func.f_data);
x[i] /= 1 + 1e-6;
printf(" grad[%d] = %g vs. numerical derivative %g\n",
i, x[i + func.n], (f - f0) / (x[i] * 1e-6));
}
}
testfuncs_counter = 0;
ret = nlopt_minimize(algorithm,
func.n, bounds_wrap_func, &bw,
lb, ub,
x, &minf,
minf_max, ftol_rel, ftol_abs, xtol_rel, xtabs,
maxeval, maxtime);
printf("finished after %g seconds.\n", nlopt_seconds() - start);
printf("return code %d from nlopt_minimize\n", ret);
if (ret < 0 && ret != NLOPT_ROUNDOFF_LIMITED
&& ret != NLOPT_FORCED_STOP) {
fprintf(stderr, "testopt: error in nlopt_minimize\n");
free(x);
return 0;
}
printf("Found minimum f = %g after %d evaluations.\n",
minf, testfuncs_counter);
total_count += testfuncs_counter;
if (testfuncs_counter > max_count) max_count = testfuncs_counter;
if (testfuncs_counter < min_count) min_count = testfuncs_counter;
printf("Minimum at x = [");
for (i = 0; i < func.n; ++i) printf(" %g", x[i]);
printf("]\n");
if (func.minf == 0)
printf("|f - minf| = %g\n", fabs(minf - func.minf));
else
printf("|f - minf| = %g, |f - minf| / |minf| = %e\n",
fabs(minf - func.minf), fabs(minf - func.minf) / fabs(func.minf));
total_err += fabs(minf - func.minf);
if (fabs(minf - func.minf) > max_err)
max_err = fabs(minf - func.minf);
printf("vs. global minimum f = %g at x = [", func.minf);
for (i = 0; i < func.n; ++i) printf(" %g", func.xmin[i]);
printf("]\n");
val = func.f(func.n, x, NULL, func.f_data);
if (val != minf) {
fprintf(stderr, "Mismatch %g between returned minf=%g and f(x) = %g\n",
minf - val, minf, val);
free(x);
return 0;
}
}
if (iterations > 1)
printf("average #evaluations = %g (%d-%d)\naverage |f-minf| = %g, max |f-minf| = %g\n", total_count * 1.0 / iterations, min_count, max_count, total_err / iterations, max_err);
free(x);
return 1;
}
/* unlike nlopt_optimize() below, only handles minimization case */
static nlopt_result nlopt_optimize_(nlopt_opt opt, double *x, double *minf)
{
const double *lb, *ub;
nlopt_algorithm algorithm;
nlopt_func f; void *f_data;
unsigned n, i;
int ni;
nlopt_stopping stop;
if (!opt || !x || !minf || !opt->f
|| opt->maximize) return NLOPT_INVALID_ARGS;
/* reset stopping flag */
nlopt_set_force_stop(opt, 0);
opt->force_stop_child = NULL;
/* copy a few params to local vars for convenience */
n = opt->n;
ni = (int) n; /* most of the subroutines take "int" arg */
lb = opt->lb; ub = opt->ub;
algorithm = opt->algorithm;
f = opt->f; f_data = opt->f_data;
if (n == 0) { /* trivial case: no degrees of freedom */
*minf = opt->f(n, x, NULL, opt->f_data);
return NLOPT_SUCCESS;
}
*minf = HUGE_VAL;
/* make sure rand generator is inited */
nlopt_srand_time_default(); /* default is non-deterministic */
/* check bound constraints */
for (i = 0; i < n; ++i)
if (lb[i] > ub[i] || x[i] < lb[i] || x[i] > ub[i])
return NLOPT_INVALID_ARGS;
stop.n = n;
stop.minf_max = opt->stopval;
stop.ftol_rel = opt->ftol_rel;
stop.ftol_abs = opt->ftol_abs;
stop.xtol_rel = opt->xtol_rel;
stop.xtol_abs = opt->xtol_abs;
stop.nevals = 0;
stop.maxeval = opt->maxeval;
stop.maxtime = opt->maxtime;
stop.start = nlopt_seconds();
stop.force_stop = &(opt->force_stop);
switch (algorithm) {
case NLOPT_GN_DIRECT:
case NLOPT_GN_DIRECT_L:
case NLOPT_GN_DIRECT_L_RAND:
if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
return cdirect(ni, f, f_data,
lb, ub, x, minf, &stop, 0.0,
(algorithm != NLOPT_GN_DIRECT)
+ 3 * (algorithm == NLOPT_GN_DIRECT_L_RAND
? 2 : (algorithm != NLOPT_GN_DIRECT))
+ 9 * (algorithm == NLOPT_GN_DIRECT_L_RAND
? 1 : (algorithm != NLOPT_GN_DIRECT)));
case NLOPT_GN_DIRECT_NOSCAL:
case NLOPT_GN_DIRECT_L_NOSCAL:
case NLOPT_GN_DIRECT_L_RAND_NOSCAL:
if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
return cdirect_unscaled(ni, f, f_data, lb, ub, x, minf,
&stop, 0.0,
(algorithm != NLOPT_GN_DIRECT)
+ 3 * (algorithm == NLOPT_GN_DIRECT_L_RAND ? 2 : (algorithm != NLOPT_GN_DIRECT))
+ 9 * (algorithm == NLOPT_GN_DIRECT_L_RAND ? 1 : (algorithm != NLOPT_GN_DIRECT)));
case NLOPT_GN_ORIG_DIRECT:
case NLOPT_GN_ORIG_DIRECT_L: {
direct_return_code dret;
if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
opt->work = malloc(sizeof(double) *
nlopt_max_constraint_dim(opt->m,
opt->fc));
if (!opt->work) return NLOPT_OUT_OF_MEMORY;
dret = direct_optimize(f_direct, opt, ni, lb, ub, x, minf,
stop.maxeval, -1,
stop.start, stop.maxtime,
0.0, 0.0,
pow(stop.xtol_rel, (double) n), -1.0,
stop.force_stop,
stop.minf_max, 0.0,
NULL,
algorithm == NLOPT_GN_ORIG_DIRECT
? DIRECT_ORIGINAL
: DIRECT_GABLONSKY);
free(opt->work); opt->work = NULL;
switch (dret) {
case DIRECT_INVALID_BOUNDS:
case DIRECT_MAXFEVAL_TOOBIG:
case DIRECT_INVALID_ARGS:
return NLOPT_INVALID_ARGS;
case DIRECT_INIT_FAILED:
case DIRECT_SAMPLEPOINTS_FAILED:
case DIRECT_SAMPLE_FAILED:
return NLOPT_FAILURE;
case DIRECT_MAXFEVAL_EXCEEDED:
case DIRECT_MAXITER_EXCEEDED:
return NLOPT_MAXEVAL_REACHED;
case DIRECT_MAXTIME_EXCEEDED:
return NLOPT_MAXTIME_REACHED;
case DIRECT_GLOBAL_FOUND:
return NLOPT_MINF_MAX_REACHED;
case DIRECT_VOLTOL:
case DIRECT_SIGMATOL:
return NLOPT_XTOL_REACHED;
case DIRECT_OUT_OF_MEMORY:
return NLOPT_OUT_OF_MEMORY;
case DIRECT_FORCED_STOP:
return NLOPT_FORCED_STOP;
}
break;
}
case NLOPT_GD_STOGO:
case NLOPT_GD_STOGO_RAND:
#ifdef WITH_CXX
if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
if (!stogo_minimize(ni, f, f_data, x, minf, lb, ub, &stop,
algorithm == NLOPT_GD_STOGO
? 0 : (int) POP(2*n)))
return NLOPT_FAILURE;
break;
#else
return NLOPT_INVALID_ARGS;
#endif
#if 0
/* lacking a free/open-source license, we no longer use
Rowan's code, and instead use by "sbplx" re-implementation */
case NLOPT_LN_SUBPLEX: {
int iret, freedx = 0;
if (!opt->dx) {
freedx = 1;
if (nlopt_set_default_initial_step(opt, x) != NLOPT_SUCCESS)
return NLOPT_OUT_OF_MEMORY;
}
iret = nlopt_subplex(f_bound, minf, x, n, opt, &stop, opt->dx);
if (freedx) { free(opt->dx); opt->dx = NULL; }
switch (iret) {
case -2: return NLOPT_INVALID_ARGS;
case -20: return NLOPT_FORCED_STOP;
case -10: return NLOPT_MAXTIME_REACHED;
case -1: return NLOPT_MAXEVAL_REACHED;
case 0: return NLOPT_XTOL_REACHED;
case 1: return NLOPT_SUCCESS;
case 2: return NLOPT_MINF_MAX_REACHED;
case 20: return NLOPT_FTOL_REACHED;
case -200: return NLOPT_OUT_OF_MEMORY;
default: return NLOPT_FAILURE; /* unknown return code */
}
break;
}
#endif
case NLOPT_LN_PRAXIS: {
double step;
if (initial_step(opt, x, &step) != NLOPT_SUCCESS)
return NLOPT_OUT_OF_MEMORY;
return praxis_(0.0, DBL_EPSILON,
step, ni, x, f_bound, opt, &stop, minf);
}
case NLOPT_LD_LBFGS:
return luksan_plis(ni, f, f_data, lb, ub, x, minf,
&stop, opt->vector_storage);
case NLOPT_LD_VAR1:
case NLOPT_LD_VAR2:
return luksan_plip(ni, f, f_data, lb, ub, x, minf,
&stop, opt->vector_storage,
algorithm == NLOPT_LD_VAR1 ? 1 : 2);
case NLOPT_LD_TNEWTON:
case NLOPT_LD_TNEWTON_RESTART:
case NLOPT_LD_TNEWTON_PRECOND:
case NLOPT_LD_TNEWTON_PRECOND_RESTART:
return luksan_pnet(ni, f, f_data, lb, ub, x, minf,
&stop, opt->vector_storage,
1 + (algorithm - NLOPT_LD_TNEWTON) % 2,
1 + (algorithm - NLOPT_LD_TNEWTON) / 2);
case NLOPT_GN_CRS2_LM:
if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
return crs_minimize(ni, f, f_data, lb, ub, x, minf, &stop,
(int) POP(0), 0);
case NLOPT_G_MLSL:
case NLOPT_G_MLSL_LDS:
case NLOPT_GN_MLSL:
case NLOPT_GD_MLSL:
case NLOPT_GN_MLSL_LDS:
case NLOPT_GD_MLSL_LDS: {
nlopt_opt local_opt = opt->local_opt;
nlopt_result ret;
if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
if (!local_opt && (algorithm == NLOPT_G_MLSL
|| algorithm == NLOPT_G_MLSL_LDS))
return NLOPT_INVALID_ARGS;
if (!local_opt) { /* default */
nlopt_algorithm local_alg = (algorithm == NLOPT_GN_MLSL ||
algorithm == NLOPT_GN_MLSL_LDS)
? nlopt_local_search_alg_nonderiv
: nlopt_local_search_alg_deriv;
/* don't call MLSL recursively! */
if (local_alg >= NLOPT_GN_MLSL
&& local_alg <= NLOPT_GD_MLSL_LDS)
local_alg = (algorithm == NLOPT_GN_MLSL ||
algorithm == NLOPT_GN_MLSL_LDS)
? NLOPT_LN_COBYLA : NLOPT_LD_MMA;
local_opt = nlopt_create(local_alg, n);
if (!local_opt) return NLOPT_FAILURE;
nlopt_set_ftol_rel(local_opt, opt->ftol_rel);
nlopt_set_ftol_abs(local_opt, opt->ftol_abs);
nlopt_set_xtol_rel(local_opt, opt->xtol_rel);
nlopt_set_xtol_abs(local_opt, opt->xtol_abs);
nlopt_set_maxeval(local_opt, nlopt_local_search_maxeval);
}
if (opt->dx) nlopt_set_initial_step(local_opt, opt->dx);
for (i = 0; i < n && stop.xtol_abs[i] > 0; ++i) ;
if (local_opt->ftol_rel <= 0 && local_opt->ftol_abs <= 0 &&
local_opt->xtol_rel <= 0 && i < n) {
/* it is not sensible to call MLSL without *some*
nonzero tolerance for the local search */
nlopt_set_ftol_rel(local_opt, 1e-15);
nlopt_set_xtol_rel(local_opt, 1e-7);
}
opt->force_stop_child = local_opt;
ret = mlsl_minimize(ni, f, f_data, lb, ub, x, minf, &stop,
local_opt, (int) POP(0),
algorithm >= NLOPT_GN_MLSL_LDS &&
algorithm != NLOPT_G_MLSL);
opt->force_stop_child = NULL;
if (!opt->local_opt) nlopt_destroy(local_opt);
return ret;
}
case NLOPT_LD_MMA: case NLOPT_LD_CCSAQ: {
nlopt_opt dual_opt;
nlopt_result ret;
#define LO(param, def) (opt->local_opt ? opt->local_opt->param : (def))
dual_opt = nlopt_create(LO(algorithm,
nlopt_local_search_alg_deriv),
nlopt_count_constraints(opt->m,
opt->fc));
if (!dual_opt) return NLOPT_FAILURE;
nlopt_set_ftol_rel(dual_opt, LO(ftol_rel, 1e-14));
nlopt_set_ftol_abs(dual_opt, LO(ftol_abs, 0.0));
nlopt_set_maxeval(dual_opt, LO(maxeval, 100000));
#undef LO
if (algorithm == NLOPT_LD_MMA)
ret = mma_minimize(n, f, f_data, opt->m, opt->fc,
lb, ub, x, minf, &stop, dual_opt);
else
ret = ccsa_quadratic_minimize(
n, f, f_data, opt->m, opt->fc, opt->pre,
lb, ub, x, minf, &stop, dual_opt);
nlopt_destroy(dual_opt);
return ret;
}
case NLOPT_LN_COBYLA: {
nlopt_result ret;
int freedx = 0;
if (!opt->dx) {
freedx = 1;
if (nlopt_set_default_initial_step(opt, x) != NLOPT_SUCCESS)
return NLOPT_OUT_OF_MEMORY;
}
return cobyla_minimize(n, f, f_data,
opt->m, opt->fc,
opt->p, opt->h,
lb, ub, x, minf, &stop,
opt->dx);
if (freedx) { free(opt->dx); opt->dx = NULL; }
return ret;
}
case NLOPT_LN_NEWUOA: {
double step;
if (initial_step(opt, x, &step) != NLOPT_SUCCESS)
return NLOPT_OUT_OF_MEMORY;
return newuoa(ni, 2*n+1, x, 0, 0, step,
&stop, minf, f_noderiv, opt);
}
case NLOPT_LN_NEWUOA_BOUND: {
double step;
if (initial_step(opt, x, &step) != NLOPT_SUCCESS)
return NLOPT_OUT_OF_MEMORY;
return newuoa(ni, 2*n+1, x, lb, ub, step,
&stop, minf, f_noderiv, opt);
}
case NLOPT_LN_BOBYQA: {
nlopt_result ret;
int freedx = 0;
if (!opt->dx) {
freedx = 1;
if (nlopt_set_default_initial_step(opt, x) != NLOPT_SUCCESS)
return NLOPT_OUT_OF_MEMORY;
}
ret = bobyqa(ni, 2*n+1, x, lb, ub, opt->dx,
&stop, minf, opt->f, opt->f_data);
if (freedx) { free(opt->dx); opt->dx = NULL; }
return ret;
}
case NLOPT_LN_NELDERMEAD:
case NLOPT_LN_SBPLX:
{
nlopt_result ret;
int freedx = 0;
if (!opt->dx) {
freedx = 1;
if (nlopt_set_default_initial_step(opt, x) != NLOPT_SUCCESS)
return NLOPT_OUT_OF_MEMORY;
}
if (algorithm == NLOPT_LN_NELDERMEAD)
ret= nldrmd_minimize(ni,f,f_data,lb,ub,x,minf,opt->dx,&stop);
else
ret= sbplx_minimize(ni,f,f_data,lb,ub,x,minf,opt->dx,&stop);
if (freedx) { free(opt->dx); opt->dx = NULL; }
return ret;
}
case NLOPT_AUGLAG:
case NLOPT_AUGLAG_EQ:
case NLOPT_LN_AUGLAG:
case NLOPT_LN_AUGLAG_EQ:
case NLOPT_LD_AUGLAG:
case NLOPT_LD_AUGLAG_EQ: {
nlopt_opt local_opt = opt->local_opt;
nlopt_result ret;
if ((algorithm == NLOPT_AUGLAG || algorithm == NLOPT_AUGLAG_EQ)
&& !local_opt)
return NLOPT_INVALID_ARGS;
if (!local_opt) { /* default */
local_opt = nlopt_create(
algorithm == NLOPT_LN_AUGLAG ||
algorithm == NLOPT_LN_AUGLAG_EQ
? nlopt_local_search_alg_nonderiv
: nlopt_local_search_alg_deriv, n);
if (!local_opt) return NLOPT_FAILURE;
nlopt_set_ftol_rel(local_opt, opt->ftol_rel);
nlopt_set_ftol_abs(local_opt, opt->ftol_abs);
nlopt_set_xtol_rel(local_opt, opt->xtol_rel);
nlopt_set_xtol_abs(local_opt, opt->xtol_abs);
nlopt_set_maxeval(local_opt, nlopt_local_search_maxeval);
}
if (opt->dx) nlopt_set_initial_step(local_opt, opt->dx);
opt->force_stop_child = local_opt;
ret = auglag_minimize(ni, f, f_data,
opt->m, opt->fc,
opt->p, opt->h,
lb, ub, x, minf, &stop,
local_opt,
algorithm == NLOPT_AUGLAG_EQ
|| algorithm == NLOPT_LN_AUGLAG_EQ
|| algorithm == NLOPT_LD_AUGLAG_EQ);
opt->force_stop_child = NULL;
if (!opt->local_opt) nlopt_destroy(local_opt);
return ret;
}
case NLOPT_GN_ISRES:
if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
return isres_minimize(ni, f, f_data,
(int) (opt->m), opt->fc,
(int) (opt->p), opt->h,
lb, ub, x, minf, &stop,
(int) POP(0));
// case NLOPT_GN_ESCH:
// if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
// return chevolutionarystrategy(n, f, f_data,
// lb, ub, x, minf, &stop,
// (unsigned) POP(0),
// (unsigned) (POP(0)*1.5));
case NLOPT_LD_SLSQP:
return nlopt_slsqp(n, f, f_data,
opt->m, opt->fc,
opt->p, opt->h,
lb, ub, x, minf, &stop);
default:
return NLOPT_INVALID_ARGS;
}
return NLOPT_SUCCESS; /* never reached */
}