1 /* Copyright (c) 2007-2008 Massachusetts Institute of Technology
3 * Permission is hereby granted, free of charge, to any person obtaining
4 * a copy of this software and associated documentation files (the
5 * "Software"), to deal in the Software without restriction, including
6 * without limitation the rights to use, copy, modify, merge, publish,
7 * distribute, sublicense, and/or sell copies of the Software, and to
8 * permit persons to whom the Software is furnished to do so, subject to
9 * the following conditions:
11 * The above copyright notice and this permission notice shall be
12 * included in all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
19 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
30 int mma_verbose = 0; /* > 0 for verbose output */
32 #define MIN(a,b) ((a) < (b) ? (a) : (b))
33 #define MAX(a,b) ((a) > (b) ? (a) : (b))
35 /* magic minimum value for rho in MMA ... the 2002 paper says it should
36 be a "fixed, strictly positive `small' number, e.g. 1e-5"
37 ... grrr, I hate these magic numbers, which seem like they
38 should depend on the objective function in some way ... in particular,
39 note that rho is dimensionful (= dimensions of objective function) */
40 #define MMA_RHOMIN 1e-5
42 /***********************************************************************/
43 /* function for MMA's dual solution of the approximate problem */
46 int count; /* evaluation count, incremented each call */
47 int n; /* must be set on input to dimension of x */
48 const double *x, *lb, *ub, *sigma, *dfdx; /* arrays of length n */
49 const double *dfcdx; /* m-by-n array of fc gradients */
50 double fval, rho; /* must be set on input */
51 const double *fcval, *rhoc; /* arrays of length m */
52 double *xcur; /* array of length n, output each time */
53 double gval, wval, *gcval; /* output each time (array length m) */
56 static double sqr(double x) { return x * x; }
58 static double dual_func(int m, const double *y, double *grad, void *d_)
60 dual_data *d = (dual_data *) d_;
62 const double *x = d->x, *lb = d->lb, *ub = d->ub, *sigma = d->sigma,
64 const double *dfcdx = d->dfcdx;
65 double rho = d->rho, fval = d->fval;
66 const double *rhoc = d->rhoc, *fcval = d->fcval;
67 double *xcur = d->xcur;
68 double *gcval = d->gcval;
76 for (i = 0; i < m; ++i) val += y[i] * (gcval[i] = fcval[i]);
78 for (j = 0; j < n; ++j) {
79 double u, v, dx, denominv, c, sigma2, dx2;
81 /* first, compute xcur[j] for y. Because this objective is
82 separable, we can minimize over x analytically, and the minimum
83 dx is given by the solution of a quadratic equation:
84 u dx^2 + 2 v sigma^2 dx + u sigma^2 = 0
85 where u and v are defined by the sums below. Because of
86 the definitions, it is guaranteed that |u/v| <= sigma,
87 and it follows that the only dx solution with |dx| <= sigma
89 (v/u) sigma^2 (-1 + sqrt(1 - (u / v sigma)^2))
90 (which goes to zero as u -> 0). */
93 v = fabs(dfdx[j]) * sigma[j] + 0.5 * rho;
94 for (i = 0; i < m; ++i) {
95 u += dfcdx[i*n + j] * y[i];
96 v += (fabs(dfcdx[i*n + j]) * sigma[j] + 0.5 * rhoc[i]) * y[i];
98 u *= (sigma2 = sqr(sigma[j]));
99 if (fabs(u) < 1e-3 * (v*sigma[j])) { /* Taylor exp. for small u */
100 double a = u / (v*sigma[j]);
101 dx = -sigma[j] * (0.5 * a + 0.125 * a*a*a);
104 dx = (v/u)*sigma2 * (-1 + sqrt(fabs(1 - sqr(u/(v*sigma[j])))));
106 if (xcur[j] > ub[j]) xcur[j] = ub[j];
107 else if (xcur[j] < lb[j]) xcur[j] = lb[j];
108 if (xcur[j] > x[j]+0.9*sigma[j]) xcur[j] = x[j]+0.9*sigma[j];
109 else if (xcur[j] < x[j]-0.9*sigma[j]) xcur[j] = x[j]-0.9*sigma[j];
112 /* function value: */
114 denominv = 1.0 / (sigma2 - dx2);
115 val += (u * dx + v * dx2) * denominv;
117 /* update gval, wval, gcval (approximant functions) */
119 d->gval += (dfdx[j] * c + (fabs(dfdx[j])*sigma[j] + 0.5*rho) * dx2)
121 d->wval += 0.5 * dx2 * denominv;
122 for (i = 0; i < m; ++i)
123 gcval[i] += (dfcdx[i*n+j] * c + (fabs(dfcdx[i*n+j])*sigma[j]
124 + 0.5*rhoc[i]) * dx2)
128 /* gradient is easy to compute: since we are at a minimum x (dval/dx=0),
129 we only need the partial derivative with respect to y, and
130 we negate because we are maximizing: */
131 if (grad) for (i = 0; i < m; ++i) grad[i] = -gcval[i];
135 /***********************************************************************/
137 nlopt_result mma_minimize(int n, nlopt_func f, void *f_data,
138 int m, nlopt_func fc,
139 void *fc_data_, ptrdiff_t fc_datum_size,
140 const double *lb, const double *ub, /* bounds */
141 double *x, /* in: initial guess, out: minimizer */
143 nlopt_stopping *stop,
144 nlopt_algorithm dual_alg,
145 double dual_tolrel, int dual_maxeval)
147 nlopt_result ret = NLOPT_SUCCESS;
148 double *xcur, rho, *sigma, *dfdx, *dfdx_cur, *xprev, *xprevprev, fcur;
149 double *dfcdx, *dfcdx_cur;
150 double *fcval, *fcval_cur, *rhoc, *gcval, *y, *dual_lb, *dual_ub;
152 char *fc_data = (char *) fc_data_;
156 sigma = (double *) malloc(sizeof(double) * (6*n + 2*m*n + m*7));
157 if (!sigma) return NLOPT_OUT_OF_MEMORY;
162 xprevprev = xprev + n;
163 fcval = xprevprev + n;
164 fcval_cur = fcval + m;
165 rhoc = fcval_cur + m;
168 dual_ub = dual_lb + m;
171 dfcdx_cur = dfcdx + m*n;
185 for (j = 0; j < n; ++j) {
186 if (nlopt_isinf(ub[j]) || nlopt_isinf(lb[j]))
187 sigma[j] = 1.0; /* arbitrary default */
189 sigma[j] = 0.5 * (ub[j] - lb[j]);
192 for (i = 0; i < m; ++i) {
194 dual_lb[i] = y[i] = 0.0;
195 dual_ub[i] = HUGE_VAL;
198 dd.fval = fcur = *minf = f(n, x, dfdx, f_data);
200 memcpy(xcur, x, sizeof(double) * n);
203 for (i = 0; i < m; ++i) {
204 fcval[i] = fc(n, x, dfcdx + i*n, fc_data + fc_datum_size * i);
205 feasible = feasible && (fcval[i] <= 0);
207 if (!feasible) { ret = NLOPT_FAILURE; goto done; } /* TODO: handle this */
209 while (1) { /* outer iterations */
211 if (nlopt_stop_evals(stop)) ret = NLOPT_MAXEVAL_REACHED;
212 else if (nlopt_stop_time(stop)) ret = NLOPT_MAXTIME_REACHED;
213 else if (*minf < stop->minf_max) ret = NLOPT_MINF_MAX_REACHED;
214 if (ret != NLOPT_SUCCESS) goto done;
215 if (++k > 1) memcpy(xprevprev, xprev, sizeof(double) * n);
216 memcpy(xprev, xcur, sizeof(double) * n);
218 while (1) { /* inner iterations */
220 int feasible_cur, inner_done, save_verbose;
223 /* solve dual problem */
224 dd.rho = rho; dd.count = 0;
226 save_verbose = mma_verbose;
228 reti = nlopt_minimize(
229 dual_alg, m, dual_func, &dd,
230 dual_lb, dual_ub, y, &min_dual,
231 -HUGE_VAL, dual_tolrel,0., 0.,NULL, dual_maxeval,
232 stop->maxtime - (nlopt_seconds() - stop->start));
233 mma_verbose = save_verbose;
234 if (reti == NLOPT_FAILURE && dual_alg != NLOPT_LD_MMA) {
235 /* LBFGS etc. converge quickly but are sometimes
236 very finicky if there are any rounding errors in
237 the gradient, etcetera; if it fails, try again
238 with MMA called recursively for the dual */
239 dual_alg = NLOPT_LD_MMA;
241 printf("MMA: switching to recursive MMA for dual\n");
244 if (reti < 0 || reti == NLOPT_MAXTIME_REACHED) {
249 dual_func(m, y, NULL, &dd); /* evaluate final xcur etc. */
251 printf("MMA dual converged in %d iterations to g=%g:\n",
253 for (i = 0; i < MIN(mma_verbose, m); ++i)
254 printf(" MMA y[%d]=%g, gc[%d]=%g\n",
255 i, y[i], i, dd.gcval[i]);
258 fcur = f(n, xcur, dfdx_cur, f_data);
261 inner_done = dd.gval >= fcur;
262 for (i = 0; i < m; ++i) {
263 fcval_cur[i] = fc(n, xcur, dfcdx_cur + i*n,
264 fc_data + fc_datum_size * i);
265 feasible_cur = feasible_cur && (fcval_cur[i] <= 0);
266 inner_done = inner_done && (dd.gcval[i] >= fcval_cur[i]);
269 /* once we have reached a feasible solution, the
270 algorithm should never make the solution infeasible
271 again (if inner_done), although the constraints may
272 be violated slightly by rounding errors etc. so we
273 must be a little careful about checking feasibility */
274 if (feasible_cur) feasible = 1;
276 if (fcur < *minf && (inner_done || feasible_cur || !feasible)) {
277 if (mma_verbose && !feasible_cur)
278 printf("MMA - using infeasible point?\n");
279 dd.fval = *minf = fcur;
280 memcpy(fcval, fcval_cur, sizeof(double)*m);
281 memcpy(x, xcur, sizeof(double)*n);
282 memcpy(dfdx, dfdx_cur, sizeof(double)*n);
283 memcpy(dfcdx, dfcdx_cur, sizeof(double)*n*m);
285 if (nlopt_stop_evals(stop)) ret = NLOPT_MAXEVAL_REACHED;
286 else if (nlopt_stop_time(stop)) ret = NLOPT_MAXTIME_REACHED;
287 else if (*minf < stop->minf_max) ret = NLOPT_MINF_MAX_REACHED;
288 if (ret != NLOPT_SUCCESS) goto done;
290 if (inner_done) break;
293 rho = MIN(10*rho, 1.1 * (rho + (fcur-dd.gval) / dd.wval));
294 for (i = 0; i < m; ++i)
295 if (fcval_cur[i] > dd.gcval[i])
298 1.1 * (rhoc[i] + (fcval_cur[i]-dd.gcval[i])
302 printf("MMA inner iteration: rho -> %g\n", rho);
303 for (i = 0; i < MIN(mma_verbose, m); ++i)
304 printf(" MMA rhoc[%d] -> %g\n", i,rhoc[i]);
307 if (nlopt_stop_ftol(stop, fcur, fprev))
308 ret = NLOPT_FTOL_REACHED;
309 if (nlopt_stop_x(stop, xcur, xprev))
310 ret = NLOPT_XTOL_REACHED;
311 if (ret != NLOPT_SUCCESS) goto done;
313 /* update rho and sigma for iteration k+1 */
314 rho = MAX(0.1 * rho, MMA_RHOMIN);
316 printf("MMA outer iteration: rho -> %g\n", rho);
317 for (i = 0; i < m; ++i)
318 rhoc[i] = MAX(0.1 * rhoc[i], MMA_RHOMIN);
319 for (i = 0; i < MIN(mma_verbose, m); ++i)
320 printf(" MMA rhoc[%d] -> %g\n", i, rhoc[i]);
322 for (j = 0; j < n; ++j) {
323 double dx2 = (xcur[j]-xprev[j]) * (xprev[j]-xprevprev[j]);
324 double gam = dx2 < 0 ? 0.7 : (dx2 > 0 ? 1.2 : 1);
326 if (!nlopt_isinf(ub[j]) && !nlopt_isinf(lb[j])) {
327 sigma[j] = MIN(sigma[j], 10*(ub[j]-lb[j]));
328 sigma[j] = MAX(sigma[j], 0.01*(ub[j]-lb[j]));
331 for (j = 0; j < MIN(mma_verbose, n); ++j)
332 printf(" MMA sigma[%d] -> %g\n",