api/optimize.c

   1 /* Copyright (c) 2007-2010 Massachusetts Institute of Technology
   2  *
   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:
  10  *
  11  * The above copyright notice and this permission notice shall be
  12  * included in all copies or substantial portions of the Software.
  13  *
  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.
  21  */
  22
  23 #include <stdlib.h>
  24 #include <math.h>
  25 #include <float.h>
  26
  27 #include "nlopt-internal.h"
  28
  29 /*********************************************************************/
  30
  31 #ifndef HAVE_ISNAN
  32 static int my_isnan(double x) { return x != x; }
  33 #  define isnan my_isnan
  34 #endif
  35
  36 /*********************************************************************/
  37
  38 #include "praxis.h"
  39 #include "direct.h"
  40
  41 #ifdef WITH_CXX
  42 #  include "stogo.h"
  43 #endif
  44
  45 #include "cdirect.h"
  46
  47 #ifdef WITH_NOCEDAL
  48 #  include "l-bfgs-b.h"
  49 #endif
  50
  51 #include "luksan.h"
  52
  53 #include "crs.h"
  54
  55 #include "mlsl.h"
  56 #include "mma.h"
  57 #include "cobyla.h"
  58 #include "newuoa.h"
  59 #include "neldermead.h"
  60 #include "auglag.h"
  61 #include "bobyqa.h"
  62 #include "isres.h"
  63 #include "slsqp.h"
  64
  65 /*********************************************************************/
  66
  67 static double f_bound(int n, const double *x, void *data_)
  68 {
  69      int i;
  70      nlopt_opt data = (nlopt_opt) data_;
  71      double f;
  72
  73      /* some methods do not support bound constraints, but support
  74         discontinuous objectives so we can just return Inf for invalid x */
  75      for (i = 0; i < n; ++i)
  76           if (x[i] < data->lb[i] || x[i] > data->ub[i])
  77                return HUGE_VAL;
  78
  79      f = data->f((unsigned) n, x, NULL, data->f_data);
  80      return (isnan(f) || nlopt_isinf(f) ? HUGE_VAL : f);
  81 }
  82
  83 static double f_noderiv(int n, const double *x, void *data_)
  84 {
  85      nlopt_opt data = (nlopt_opt) data_;
  86      return data->f((unsigned) n, x, NULL, data->f_data);
  87 }
  88
  89 static double f_direct(int n, const double *x, int *undefined, void *data_)
  90 {
  91      nlopt_opt data = (nlopt_opt) data_;
  92      double f;
  93      unsigned i, j;
  94      f = data->f((unsigned) n, x, NULL, data->f_data);
  95      *undefined = isnan(f) || nlopt_isinf(f);
  96      if (nlopt_get_force_stop(data)) return f;
  97      for (i = 0; i < data->m && !*undefined; ++i) {
  98           nlopt_eval_constraint(data->work, NULL, data->fc+i, (unsigned) n, x);
  99           if (nlopt_get_force_stop(data)) return f;
 100           for (j = 0; j < data->fc[i].m; ++j)
 101                if (data->work[j] > 0)
 102                     *undefined = 1;
 103      }
 104      return f;
 105 }
 106
 107 /*********************************************************************/
 108
 109 /* get min(dx) for algorithms requiring a scalar initial step size */
 110 static nlopt_result initial_step(nlopt_opt opt, const double *x, double *step)
 111 {
 112      unsigned freedx = 0, i;
 113
 114      if (!opt->dx) {
 115           freedx = 1;
 116           if (nlopt_set_default_initial_step(opt, x) != NLOPT_SUCCESS)
 117                return NLOPT_OUT_OF_MEMORY;
 118      }
 119
 120      *step = HUGE_VAL;
 121      for (i = 0; i < opt->n; ++i)
 122           if (*step > fabs(opt->dx[i]))
 123                *step = fabs(opt->dx[i]);
 124
 125      if (freedx) { free(opt->dx); opt->dx = NULL; }
 126      return NLOPT_SUCCESS;
 127 }
 128
 129 /*********************************************************************/
 130
 131 /* return true if [lb,ub] is finite in every dimension (n dimensions) */
 132 static int finite_domain(unsigned n, const double *lb, const double *ub)
 133 {
 134      unsigned i;
 135      for (i = 0; i < n; ++i)
 136           if (nlopt_isinf(ub[i] - lb[i])) return 0;
 137      return 1;
 138 }
 139
 140 /*********************************************************************/
 141
 142 #define POP(defaultpop) (opt->stochastic_population > 0 ?               \
 143                          opt->stochastic_population :                   \
 144                          (nlopt_stochastic_population > 0 ?             \
 145                           nlopt_stochastic_population : (defaultpop)))
 146
 147 /* unlike nlopt_optimize() below, only handles minimization case */
 148 static nlopt_result nlopt_optimize_(nlopt_opt opt, double *x, double *minf)
 149 {
 150      const double *lb, *ub;
 151      nlopt_algorithm algorithm;
 152      nlopt_func f; void *f_data;
 153      unsigned n, i;
 154      int ni;
 155      nlopt_stopping stop;
 156
 157      if (!opt || !x || !minf || !opt->f
 158          || opt->maximize) return NLOPT_INVALID_ARGS;
 159
 160      /* reset stopping flag */
 161      nlopt_set_force_stop(opt, 0);
 162      opt->force_stop_child = NULL;
 163
 164      /* copy a few params to local vars for convenience */
 165      n = opt->n;
 166      ni = (int) n; /* most of the subroutines take "int" arg */
 167      lb = opt->lb; ub = opt->ub;
 168      algorithm = opt->algorithm;
 169      f = opt->f; f_data = opt->f_data;
 170
 171      if (n == 0) { /* trivial case: no degrees of freedom */
 172           *minf = opt->f(n, x, NULL, opt->f_data);
 173           return NLOPT_SUCCESS;
 174      }
 175
 176      *minf = HUGE_VAL;
 177
 178      /* make sure rand generator is inited */
 179      nlopt_srand_time_default(); /* default is non-deterministic */
 180
 181      /* check bound constraints */
 182      for (i = 0; i < n; ++i)
 183           if (lb[i] > ub[i] || x[i] < lb[i] || x[i] > ub[i])
 184                return NLOPT_INVALID_ARGS;
 185
 186      stop.n = n;
 187      stop.minf_max = opt->stopval;
 188      stop.ftol_rel = opt->ftol_rel;
 189      stop.ftol_abs = opt->ftol_abs;
 190      stop.xtol_rel = opt->xtol_rel;
 191      stop.xtol_abs = opt->xtol_abs;
 192      stop.nevals = 0;
 193      stop.maxeval = opt->maxeval;
 194      stop.maxtime = opt->maxtime;
 195      stop.start = nlopt_seconds();
 196      stop.force_stop = &(opt->force_stop);
 197
 198      switch (algorithm) {
 199          case NLOPT_GN_DIRECT:
 200          case NLOPT_GN_DIRECT_L:
 201          case NLOPT_GN_DIRECT_L_RAND:
 202               if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
 203               return cdirect(ni, f, f_data,
 204                              lb, ub, x, minf, &stop, 0.0,
 205                              (algorithm != NLOPT_GN_DIRECT)
 206                              + 3 * (algorithm == NLOPT_GN_DIRECT_L_RAND
 207                                     ? 2 : (algorithm != NLOPT_GN_DIRECT))
 208                              + 9 * (algorithm == NLOPT_GN_DIRECT_L_RAND
 209                                     ? 1 : (algorithm != NLOPT_GN_DIRECT)));
 210
 211          case NLOPT_GN_DIRECT_NOSCAL:
 212          case NLOPT_GN_DIRECT_L_NOSCAL:
 213          case NLOPT_GN_DIRECT_L_RAND_NOSCAL:
 214               if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
 215               return cdirect_unscaled(ni, f, f_data, lb, ub, x, minf,
 216                                       &stop, 0.0,
 217                                       (algorithm != NLOPT_GN_DIRECT)
 218                                       + 3 * (algorithm == NLOPT_GN_DIRECT_L_RAND ? 2 : (algorithm != NLOPT_GN_DIRECT))
 219                                       + 9 * (algorithm == NLOPT_GN_DIRECT_L_RAND ? 1 : (algorithm != NLOPT_GN_DIRECT)));
 220
 221          case NLOPT_GN_ORIG_DIRECT:
 222          case NLOPT_GN_ORIG_DIRECT_L: {
 223               direct_return_code dret;
 224               if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
 225               opt->work = (double*) malloc(sizeof(double) *
 226                                            nlopt_max_constraint_dim(opt->m,
 227                                                                     opt->fc));
 228               if (!opt->work) return NLOPT_OUT_OF_MEMORY;
 229               dret = direct_optimize(f_direct, opt, ni, lb, ub, x, minf,
 230                                      stop.maxeval, -1,
 231                                      stop.start, stop.maxtime,
 232                                      0.0, 0.0,
 233                                      pow(stop.xtol_rel, (double) n), -1.0,
 234                                      stop.force_stop,
 235                                      stop.minf_max, 0.0,
 236                                      NULL,
 237                                      algorithm == NLOPT_GN_ORIG_DIRECT
 238                                      ? DIRECT_ORIGINAL
 239                                      : DIRECT_GABLONSKY);
 240               free(opt->work); opt->work = NULL;
 241               switch (dret) {
 242                   case DIRECT_INVALID_BOUNDS:
 243                   case DIRECT_MAXFEVAL_TOOBIG:
 244                   case DIRECT_INVALID_ARGS:
 245                        return NLOPT_INVALID_ARGS;
 246                   case DIRECT_INIT_FAILED:
 247                   case DIRECT_SAMPLEPOINTS_FAILED:
 248                   case DIRECT_SAMPLE_FAILED:
 249                        return NLOPT_FAILURE;
 250                   case DIRECT_MAXFEVAL_EXCEEDED:
 251                   case DIRECT_MAXITER_EXCEEDED:
 252                        return NLOPT_MAXEVAL_REACHED;
 253                   case DIRECT_MAXTIME_EXCEEDED:
 254                        return NLOPT_MAXTIME_REACHED;
 255                   case DIRECT_GLOBAL_FOUND:
 256                        return NLOPT_MINF_MAX_REACHED;
 257                   case DIRECT_VOLTOL:
 258                   case DIRECT_SIGMATOL:
 259                        return NLOPT_XTOL_REACHED;
 260                   case DIRECT_OUT_OF_MEMORY:
 261                        return NLOPT_OUT_OF_MEMORY;
 262                   case DIRECT_FORCED_STOP:
 263                        return NLOPT_FORCED_STOP;
 264               }
 265               break;
 266          }
 267
 268          case NLOPT_GD_STOGO:
 269          case NLOPT_GD_STOGO_RAND:
 270 #ifdef WITH_CXX
 271               if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
 272               if (!stogo_minimize(ni, f, f_data, x, minf, lb, ub, &stop,
 273                                   algorithm == NLOPT_GD_STOGO
 274                                   ? 0 : (int) POP(2*n)))
 275                    return NLOPT_FAILURE;
 276               break;
 277 #else
 278               return NLOPT_INVALID_ARGS;
 279 #endif
 280
 281 #if 0
 282               /* lacking a free/open-source license, we no longer use
 283                  Rowan's code, and instead use by "sbplx" re-implementation */
 284          case NLOPT_LN_SUBPLEX: {
 285               int iret, freedx = 0;
 286               if (!opt->dx) {
 287                    freedx = 1;
 288                    if (nlopt_set_default_initial_step(opt, x) != NLOPT_SUCCESS)
 289                         return NLOPT_OUT_OF_MEMORY;
 290               }
 291               iret = nlopt_subplex(f_bound, minf, x, n, opt, &stop, opt->dx);
 292               if (freedx) { free(opt->dx); opt->dx = NULL; }
 293               switch (iret) {
 294                   case -2: return NLOPT_INVALID_ARGS;
 295                   case -20: return NLOPT_FORCED_STOP;
 296                   case -10: return NLOPT_MAXTIME_REACHED;
 297                   case -1: return NLOPT_MAXEVAL_REACHED;
 298                   case 0: return NLOPT_XTOL_REACHED;
 299                   case 1: return NLOPT_SUCCESS;
 300                   case 2: return NLOPT_MINF_MAX_REACHED;
 301                   case 20: return NLOPT_FTOL_REACHED;
 302                   case -200: return NLOPT_OUT_OF_MEMORY;
 303                   default: return NLOPT_FAILURE; /* unknown return code */
 304               }
 305               break;
 306          }
 307 #endif
 308
 309          case NLOPT_LN_PRAXIS: {
 310               double step;
 311               if (initial_step(opt, x, &step) != NLOPT_SUCCESS)
 312                    return NLOPT_OUT_OF_MEMORY;
 313               return praxis_(0.0, DBL_EPSILON,
 314                              step, ni, x, f_bound, opt, &stop, minf);
 315          }
 316
 317 #ifdef WITH_NOCEDAL
 318          case NLOPT_LD_LBFGS_NOCEDAL: {
 319               int iret, *nbd = (int *) malloc(sizeof(int) * n);
 320               if (!nbd) return NLOPT_OUT_OF_MEMORY;
 321               for (i = 0; i < n; ++i) {
 322                    int linf = nlopt_isinf(lb[i]) && lb[i] < 0;
 323                    int uinf = nlopt_isinf(ub[i]) && ub[i] > 0;
 324                    nbd[i] = linf && uinf ? 0 : (uinf ? 1 : (linf ? 3 : 2));
 325               }
 326               iret = lbfgsb_minimize(ni, f, f_data, x, nbd, lb, ub,
 327                                      ni < 5 ? ni : 5, 0.0, stop.ftol_rel,
 328                                      stop.xtol_abs[0] > 0 ? stop.xtol_abs[0]
 329                                      : stop.xtol_rel,
 330                                      stop.maxeval);
 331               free(nbd);
 332               if (iret <= 0) {
 333                    switch (iret) {
 334                        case -1: return NLOPT_INVALID_ARGS;
 335                        case -2: default: return NLOPT_FAILURE;
 336                    }
 337               }
 338               else {
 339                    *minf = f(n, x, NULL, f_data);
 340                    switch (iret) {
 341                        case 5: return NLOPT_MAXEVAL_REACHED;
 342                        case 2: return NLOPT_XTOL_REACHED;
 343                        case 1: return NLOPT_FTOL_REACHED;
 344                        default: return NLOPT_SUCCESS;
 345                    }
 346               }
 347               break;
 348          }
 349 #endif
 350
 351          case NLOPT_LD_LBFGS:
 352               return luksan_plis(ni, f, f_data, lb, ub, x, minf,
 353                                  &stop, opt->subspace_dim);
 354
 355          case NLOPT_LD_VAR1:
 356          case NLOPT_LD_VAR2:
 357               return luksan_plip(ni, f, f_data, lb, ub, x, minf,
 358                                  &stop, opt->subspace_dim,
 359                                  algorithm == NLOPT_LD_VAR1 ? 1 : 2);
 360
 361          case NLOPT_LD_TNEWTON:
 362          case NLOPT_LD_TNEWTON_RESTART:
 363          case NLOPT_LD_TNEWTON_PRECOND:
 364          case NLOPT_LD_TNEWTON_PRECOND_RESTART:
 365               return luksan_pnet(ni, f, f_data, lb, ub, x, minf,
 366                                  &stop, opt->subspace_dim,
 367                                  1 + (algorithm - NLOPT_LD_TNEWTON) % 2,
 368                                  1 + (algorithm - NLOPT_LD_TNEWTON) / 2);
 369
 370          case NLOPT_GN_CRS2_LM:
 371               if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
 372               return crs_minimize(ni, f, f_data, lb, ub, x, minf, &stop,
 373                                   (int) POP(0), 0);
 374
 375          case NLOPT_G_MLSL:
 376          case NLOPT_G_MLSL_LDS:
 377          case NLOPT_GN_MLSL:
 378          case NLOPT_GD_MLSL:
 379          case NLOPT_GN_MLSL_LDS:
 380          case NLOPT_GD_MLSL_LDS: {
 381               nlopt_opt local_opt = opt->local_opt;
 382               nlopt_result ret;
 383               if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
 384               if (!local_opt && (algorithm == NLOPT_G_MLSL
 385                                  || algorithm == NLOPT_G_MLSL_LDS))
 386                    return NLOPT_INVALID_ARGS;
 387               if (!local_opt) { /* default */
 388                    nlopt_algorithm local_alg = (algorithm == NLOPT_GN_MLSL ||
 389                                                 algorithm == NLOPT_GN_MLSL_LDS)
 390                         ? nlopt_local_search_alg_nonderiv
 391                         : nlopt_local_search_alg_deriv;
 392                    /* don't call MLSL recursively! */
 393                    if (local_alg >= NLOPT_GN_MLSL
 394                        && local_alg <= NLOPT_GD_MLSL_LDS)
 395                         local_alg = (algorithm == NLOPT_GN_MLSL ||
 396                                      algorithm == NLOPT_GN_MLSL_LDS)
 397                              ? NLOPT_LN_COBYLA : NLOPT_LD_MMA;
 398                    local_opt = nlopt_create(local_alg, n);
 399                    if (!local_opt) return NLOPT_FAILURE;
 400                    nlopt_set_ftol_rel(local_opt, opt->ftol_rel);
 401                    nlopt_set_ftol_abs(local_opt, opt->ftol_abs);
 402                    nlopt_set_xtol_rel(local_opt, opt->xtol_rel);
 403                    nlopt_set_xtol_abs(local_opt, opt->xtol_abs);
 404                    nlopt_set_maxeval(local_opt, nlopt_local_search_maxeval);
 405               }
 406               if (opt->dx) nlopt_set_initial_step(local_opt, opt->dx);
 407               for (i = 0; i < n && stop.xtol_abs[i] > 0; ++i) ;
 408               if (local_opt->ftol_rel <= 0 && local_opt->ftol_abs <= 0 &&
 409                   local_opt->xtol_rel <= 0 && i < n) {
 410                    /* it is not sensible to call MLSL without *some*
 411                       nonzero tolerance for the local search */
 412                    nlopt_set_ftol_rel(local_opt, 1e-15);
 413                    nlopt_set_xtol_rel(local_opt, 1e-7);
 414               }
 415               opt->force_stop_child = local_opt;
 416               ret = mlsl_minimize(ni, f, f_data, lb, ub, x, minf, &stop,
 417                                   local_opt, (int) POP(0),
 418                                   algorithm >= NLOPT_GN_MLSL_LDS &&
 419                                   algorithm != NLOPT_G_MLSL);
 420               opt->force_stop_child = NULL;
 421               if (!opt->local_opt) nlopt_destroy(local_opt);
 422               return ret;
 423          }
 424
 425          case NLOPT_LD_MMA: {
 426               nlopt_opt dual_opt;
 427               nlopt_result ret;
 428 #define LO(param, def) (opt->local_opt ? opt->local_opt->param : (def))
 429               dual_opt = nlopt_create(LO(algorithm,
 430                                          nlopt_local_search_alg_deriv),
 431                                       nlopt_count_constraints(opt->m,
 432                                                               opt->fc));
 433               if (!dual_opt) return NLOPT_FAILURE;
 434               nlopt_set_ftol_rel(dual_opt, LO(ftol_rel, 1e-12));
 435               nlopt_set_ftol_abs(dual_opt, LO(ftol_abs, 0.0));
 436               nlopt_set_maxeval(dual_opt, LO(maxeval, 100000));
 437 #undef LO
 438
 439               ret = mma_minimize(n, f, f_data, opt->m, opt->fc,
 440                                  lb, ub, x, minf, &stop, dual_opt);
 441               nlopt_destroy(dual_opt);
 442               return ret;
 443          }
 444
 445          case NLOPT_LN_COBYLA: {
 446               nlopt_result ret;
 447               int freedx = 0;
 448               if (!opt->dx) {
 449                    freedx = 1;
 450                    if (nlopt_set_default_initial_step(opt, x) != NLOPT_SUCCESS)
 451                         return NLOPT_OUT_OF_MEMORY;
 452               }
 453               return cobyla_minimize(n, f, f_data,
 454                                      opt->m, opt->fc,
 455                                      opt->p, opt->h,
 456                                      lb, ub, x, minf, &stop,
 457                                      opt->dx);
 458               if (freedx) { free(opt->dx); opt->dx = NULL; }
 459               return ret;
 460          }
 461
 462          case NLOPT_LN_NEWUOA: {
 463               double step;
 464               if (initial_step(opt, x, &step) != NLOPT_SUCCESS)
 465                    return NLOPT_OUT_OF_MEMORY;
 466               return newuoa(ni, 2*n+1, x, 0, 0, step,
 467                             &stop, minf, f_noderiv, opt);
 468          }
 469
 470          case NLOPT_LN_NEWUOA_BOUND: {
 471               double step;
 472               if (initial_step(opt, x, &step) != NLOPT_SUCCESS)
 473                    return NLOPT_OUT_OF_MEMORY;
 474               return newuoa(ni, 2*n+1, x, lb, ub, step,
 475                             &stop, minf, f_noderiv, opt);
 476          }
 477
 478          case NLOPT_LN_BOBYQA: {
 479               nlopt_result ret;
 480               int freedx = 0;
 481               if (!opt->dx) {
 482                    freedx = 1;
 483                    if (nlopt_set_default_initial_step(opt, x) != NLOPT_SUCCESS)
 484                         return NLOPT_OUT_OF_MEMORY;
 485               }
 486               ret = bobyqa(ni, 2*n+1, x, lb, ub, opt->dx,
 487                            &stop, minf, opt->f, opt->f_data);
 488               if (freedx) { free(opt->dx); opt->dx = NULL; }
 489               return ret;
 490          }
 491
 492          case NLOPT_LN_NELDERMEAD:
 493          case NLOPT_LN_SBPLX:
 494          {
 495               nlopt_result ret;
 496               int freedx = 0;
 497               if (!opt->dx) {
 498                    freedx = 1;
 499                    if (nlopt_set_default_initial_step(opt, x) != NLOPT_SUCCESS)
 500                         return NLOPT_OUT_OF_MEMORY;
 501               }
 502               if (algorithm == NLOPT_LN_NELDERMEAD)
 503                    ret= nldrmd_minimize(ni,f,f_data,lb,ub,x,minf,opt->dx,&stop);
 504               else
 505                    ret= sbplx_minimize(ni,f,f_data,lb,ub,x,minf,opt->dx,&stop);
 506               if (freedx) { free(opt->dx); opt->dx = NULL; }
 507               return ret;
 508          }
 509
 510          case NLOPT_AUGLAG:
 511          case NLOPT_AUGLAG_EQ:
 512          case NLOPT_LN_AUGLAG:
 513          case NLOPT_LN_AUGLAG_EQ:
 514          case NLOPT_LD_AUGLAG:
 515          case NLOPT_LD_AUGLAG_EQ: {
 516               nlopt_opt local_opt = opt->local_opt;
 517               nlopt_result ret;
 518               if ((algorithm == NLOPT_AUGLAG || algorithm == NLOPT_AUGLAG_EQ)
 519                   && !local_opt)
 520                    return NLOPT_INVALID_ARGS;
 521               if (!local_opt) { /* default */
 522                    local_opt = nlopt_create(
 523                         algorithm == NLOPT_LN_AUGLAG ||
 524                         algorithm == NLOPT_LN_AUGLAG_EQ
 525                         ? nlopt_local_search_alg_nonderiv
 526                         : nlopt_local_search_alg_deriv, n);
 527                    if (!local_opt) return NLOPT_FAILURE;
 528                    nlopt_set_ftol_rel(local_opt, opt->ftol_rel);
 529                    nlopt_set_ftol_abs(local_opt, opt->ftol_abs);
 530                    nlopt_set_xtol_rel(local_opt, opt->xtol_rel);
 531                    nlopt_set_xtol_abs(local_opt, opt->xtol_abs);
 532                    nlopt_set_maxeval(local_opt, nlopt_local_search_maxeval);
 533               }
 534               if (opt->dx) nlopt_set_initial_step(local_opt, opt->dx);
 535               opt->force_stop_child = local_opt;
 536               ret = auglag_minimize(ni, f, f_data,
 537                                     opt->m, opt->fc,
 538                                     opt->p, opt->h,
 539                                     lb, ub, x, minf, &stop,
 540                                     local_opt,
 541                                     algorithm == NLOPT_AUGLAG_EQ
 542                                     || algorithm == NLOPT_LN_AUGLAG_EQ
 543                                     || algorithm == NLOPT_LD_AUGLAG_EQ);
 544               opt->force_stop_child = NULL;
 545               if (!opt->local_opt) nlopt_destroy(local_opt);
 546               return ret;
 547          }
 548
 549          case NLOPT_GN_ISRES:
 550               if (!finite_domain(n, lb, ub)) return NLOPT_INVALID_ARGS;
 551               return isres_minimize(ni, f, f_data,
 552                                     (int) (opt->m), opt->fc,
 553                                     (int) (opt->p), opt->h,
 554                                     lb, ub, x, minf, &stop,
 555                                     (int) POP(0));
 556
 557          case NLOPT_LD_SLSQP:
 558               return nlopt_slsqp(n, f, f_data,
 559                                  opt->m, opt->fc,
 560                                  opt->p, opt->h,
 561                                  lb, ub, x, minf, &stop);
 562
 563          default:
 564               return NLOPT_INVALID_ARGS;
 565      }
 566
 567      return NLOPT_SUCCESS; /* never reached */
 568 }
 569
 570 /*********************************************************************/
 571
 572 typedef struct {
 573      nlopt_func f;
 574      void *f_data;
 575 } f_max_data;
 576
 577 /* wrapper for maximizing: just flip the sign of f and grad */
 578 static double f_max(unsigned n, const double *x, double *grad, void *data)
 579 {
 580      f_max_data *d = (f_max_data *) data;
 581      double val = d->f(n, x, grad, d->f_data);
 582      if (grad) {
 583           unsigned i;
 584           for (i = 0; i < n; ++i)
 585                grad[i] = -grad[i];
 586      }
 587      return -val;
 588 }
 589
 590 nlopt_result
 591 NLOPT_STDCALL nlopt_optimize(nlopt_opt opt, double *x, double *opt_f)
 592 {
 593      nlopt_func f; void *f_data;
 594      f_max_data fmd;
 595      int maximize;
 596      nlopt_result ret;
 597
 598      if (!opt || !opt_f || !opt->f) return NLOPT_INVALID_ARGS;
 599      f = opt->f; f_data = opt->f_data;
 600
 601      /* for maximizing, just minimize the f_max wrapper, which
 602         flips the sign of everything */
 603      if ((maximize = opt->maximize)) {
 604           fmd.f = f; fmd.f_data = f_data;
 605           opt->f = f_max; opt->f_data = &fmd;
 606           opt->stopval = -opt->stopval;
 607           opt->maximize = 0;
 608      }
 609
 610      ret = nlopt_optimize_(opt, x, opt_f);
 611
 612      if (maximize) { /* restore original signs */
 613           opt->maximize = maximize;
 614           opt->stopval = -opt->stopval;
 615           opt->f = f; opt->f_data = f_data;
 616           *opt_f = -*opt_f;
 617      }
 618
 619      return ret;
 620 }
 621
 622 /*********************************************************************/
 623
 624 nlopt_result nlopt_optimize_limited(nlopt_opt opt, double *x, double *minf,
 625                                     int maxeval, double maxtime)
 626 {
 627      int save_maxeval;
 628      double save_maxtime;
 629      nlopt_result ret;
 630
 631      if (!opt) return NLOPT_INVALID_ARGS;
 632
 633      save_maxeval = nlopt_get_maxeval(opt);
 634      save_maxtime = nlopt_get_maxtime(opt);
 635
 636      /* override opt limits if maxeval and/or maxtime are more stringent */
 637      if (save_maxeval <= 0 || (maxeval > 0 && maxeval < save_maxeval))
 638           nlopt_set_maxeval(opt, maxeval);
 639      if (save_maxtime <= 0 || (maxtime > 0 && maxtime < save_maxtime))
 640           nlopt_set_maxtime(opt, maxtime);
 641
 642      ret = nlopt_optimize(opt, x, minf);
 643
 644      nlopt_set_maxeval(opt, save_maxeval);
 645      nlopt_set_maxtime(opt, save_maxtime);
 646
 647      return ret;
 648 }
 649
 650 /*********************************************************************/