Add nlopt_get_numevals (#160)

* Add nlopt_get_numevals

We reuse stop.nevals which becomes stop.nevals_p, a pointer to opt.numevals, an int that we can return to the user.

* Add doc

diff --git a/api/f77funcs_.h b/api/f77funcs_.h
index a8534fd200793662e82fddb80d234443111fa63c..1f10ba279629bf99d46b45f5beac97df3362a9b7 100644 (file)
--- a/api/f77funcs_.h
+++ b/api/f77funcs_.h
@@ -148,6 +148,7 @@ F77_GETSET(ftol_abs, FTOL_ABS, double)
 F77_GETSET(xtol_rel, XTOL_REL, double)
 F77_GETSETA(xtol_abs, XTOL_ABS, double)
 F77_GETSET(maxeval, MAXEVAL, int)
+F77_GET(numevals, NUMEVALS, int)
 F77_GETSET(maxtime, MAXTIME, double)
 
 F77_GETSET(force_stop, FORCE_STOP, int)

diff --git a/api/nlopt-in.hpp b/api/nlopt-in.hpp
index 582c676fd9704e7dd073d6e8a043356f4ae9bf2a..d742c0ad651b2493f3b62a9ed2785a11052a7055 100644 (file)
--- a/api/nlopt-in.hpp
+++ b/api/nlopt-in.hpp
@@ -463,6 +463,12 @@ namespace nlopt {
     NLOPT_GETSET(double, xtol_rel)
     NLOPT_GETSET_VEC(xtol_abs)
     NLOPT_GETSET(int, maxeval)
+
+    int get_numevals() const {
+      if (!o) throw std::runtime_error("uninitialized nlopt::opt");
+      return nlopt_get_numevals(o);
+    }
+
     NLOPT_GETSET(double, maxtime)
 
     NLOPT_GETSET(int, force_stop)

diff --git a/api/nlopt-internal.h b/api/nlopt-internal.h
index c4d13d11d20abd870eaf0191fdf969fa264d49ee..b1aa318be60cdc62d381b26d38e417efcb21c59d 100644 (file)
--- a/api/nlopt-internal.h
+++ b/api/nlopt-internal.h
@@ -58,6 +58,7 @@ struct nlopt_opt_s {
      double ftol_rel, ftol_abs; /* relative/absolute f tolerances */
      double xtol_rel, *xtol_abs; /* rel/abs x tolerances */
      int maxeval; /* max # evaluations */
+     int numevals; /* number of evaluations */
      double maxtime; /* max time (seconds) */
 
      int force_stop; /* if nonzero, force a halt the next time we

diff --git a/api/nlopt.h b/api/nlopt.h
index a0e6b384b1f9f65c23ea086e82bffd31aa408ab5..328b6d09fbee4fc1587acaa56c96e43996093c7e 100644 (file)
--- a/api/nlopt.h
+++ b/api/nlopt.h
@@ -272,6 +272,8 @@ NLOPT_EXTERN(nlopt_result) nlopt_get_xtol_abs(const nlopt_opt opt,
 NLOPT_EXTERN(nlopt_result) nlopt_set_maxeval(nlopt_opt opt, int maxeval);
 NLOPT_EXTERN(int) nlopt_get_maxeval(const nlopt_opt opt);
 
+NLOPT_EXTERN(int) nlopt_get_numevals(const nlopt_opt opt);
+
 NLOPT_EXTERN(nlopt_result) nlopt_set_maxtime(nlopt_opt opt, double maxtime);
 NLOPT_EXTERN(double) nlopt_get_maxtime(const nlopt_opt opt);
 

diff --git a/api/optimize.c b/api/optimize.c
index d9e78b73f2e915fe901bef71a6c8560140d78c1a..2c8bbdd307b34ca78c9300af416d337b844deed7 100644 (file)
--- a/api/optimize.c
+++ b/api/optimize.c
@@ -411,7 +411,7 @@ static nlopt_result nlopt_optimize_(nlopt_opt opt, double *x, double *minf)
      stop.ftol_abs = opt->ftol_abs;
      stop.xtol_rel = opt->xtol_rel;
      stop.xtol_abs = opt->xtol_abs;
-     stop.nevals = 0;
+     stop.nevals_p = &(opt->numevals);
      stop.maxeval = opt->maxeval;
      stop.maxtime = opt->maxtime;
      stop.start = nlopt_seconds();

diff --git a/api/options.c b/api/options.c
index b3f7470932d857d5f04371e8716b4789c6702a04..632eb388ba3bb39dec2ddc4f64cd1a107aa071d0 100644 (file)
--- a/api/options.c
+++ b/api/options.c
@@ -86,6 +86,7 @@ nlopt_opt NLOPT_STDCALL nlopt_create(nlopt_algorithm algorithm, unsigned n)
          opt->ftol_rel = opt->ftol_abs = 0;
          opt->xtol_rel = 0; opt->xtol_abs = NULL;
          opt->maxeval = 0;
+    opt->numevals = 0;
          opt->maxtime = 0;
          opt->force_stop = 0;
          opt->force_stop_child = NULL;
@@ -627,6 +628,8 @@ NLOPT_STDCALL nlopt_get_xtol_abs(const nlopt_opt opt, double *xtol_abs)
 
 GETSET(maxeval, int, maxeval)
 
+GETSET(numevals, int, numevals)
+
 GETSET(maxtime, double, maxtime)
 
 /*************************************************************************/

diff --git a/auglag/auglag.c b/auglag/auglag.c
index 0092484d3bfc13c212db43ff9e92afc5ef40aa5f..384194afc99ab11f452c81cdf04baf14d6dd0800 100644 (file)
--- a/auglag/auglag.c
+++ b/auglag/auglag.c
@@ -34,7 +34,7 @@ static double auglag(unsigned n, const double *x, double *grad, void *data)
      unsigned j, k;
 
      L = d->f(n, x, grad, d->f_data);
-     d->stop->nevals++;
+     ++ *(d->stop->nevals_p);
      if (nlopt_stop_forced(d->stop)) return L;
 
      for (ii = i = 0; i < d->p; ++i) {
@@ -143,7 +143,7 @@ nlopt_result auglag_minimize(int n, nlopt_func f, void *f_data,
      /* starting rho suggested by B & M */
      if (d.p > 0 || d.m > 0) {
          double con2 = 0;
-         d.stop->nevals++;
+         ++ *(d.stop->nevals_p);
          fcur = f(n, xcur, NULL, f_data);
          if (nlopt_stop_forced(stop)) {
               ret = NLOPT_FORCED_STOP; goto done; }
@@ -191,14 +191,14 @@ nlopt_result auglag_minimize(int n, nlopt_func f, void *f_data,
          double prev_ICM = ICM;
          
          ret = nlopt_optimize_limited(sub_opt, xcur, &fcur,
-                                      stop->maxeval - stop->nevals,
+                                      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++;
+         ++ *(d.stop->nevals_p);
          fcur = f(n, xcur, NULL, f_data);
          if (nlopt_stop_forced(stop)) {
               ret = NLOPT_FORCED_STOP; goto done; }

diff --git a/bobyqa/bobyqa.c b/bobyqa/bobyqa.c
index 2ef46a30e20784191c978d25dc4aaaedc3323353..e51b0a2b68986c6bacaa8e54b3ae08469b5fe763 100644 (file)
--- a/bobyqa/bobyqa.c
+++ b/bobyqa/bobyqa.c
@@ -675,7 +675,7 @@ L260:
 /* L290: */
        }
 
-       stop->nevals++;
+       ++ *(stop->nevals_p);
        f = calfun(*n, &w[1], calfun_data);
        fval[kpt] = f;
        if (f < fval[*kopt]) {
@@ -1877,7 +1877,7 @@ L50:
        }
 /* L60: */
     }
-    stop->nevals++;
+    ++ *(stop->nevals_p);
     f = calfun(*n, &x[1], calfun_data);
     fval[nf] = f;
     if (nf == 1) {
@@ -2098,12 +2098,12 @@ static nlopt_result bobyqb_(int *n, int *npt, double *x,
 
     rho = *rhobeg;
     delta = rho;
-    nresc = stop->nevals;
+    nresc = *(stop->nevals_p);
     ntrits = 0;
     diffa = zero;
     diffb = zero;
     itest = 0;
-    nfsav = stop->nevals;
+    nfsav = *(stop->nevals_p);
 
 /*     Update GOPT if necessary before the first iteration and after each */
 /*     call of RESCUE that makes a call of CALFUN. */
@@ -2123,7 +2123,7 @@ L20:
                gopt[i__] += hq[ih] * xopt[j];
            }
        }
-       if (stop->nevals > *npt) {
+       if (*(stop->nevals_p) > *npt) {
            i__2 = *npt;
            for (k = 1; k <= i__2; ++k) {
                temp = zero;
@@ -2161,7 +2161,7 @@ L60:
 /* Computing 2nd power */
        d__1 = ten * rho;
        distsq = d__1 * d__1;
-       if (stop->nevals <= nfsav + 2) {
+       if (*(stop->nevals_p) <= nfsav + 2) {
            goto L650;
        }
 
@@ -2331,7 +2331,7 @@ L90:
 /*     useful safeguard, but is not invoked in most applications of BOBYQA. */
 
 L190:
-    nfsav = stop->nevals;
+    nfsav = *(stop->nevals_p);
     kbase = kopt;
     rc2 = rescue_(n, npt, &xl[1], &xu[1], 
                  stop, calfun, calfun_data,
@@ -2359,9 +2359,9 @@ L190:
       rc = rc2;
       goto L720; 
     }
-    nresc = stop->nevals;
-    if (nfsav < stop->nevals) {
-       nfsav = stop->nevals;
+    nresc = *(stop->nevals_p);
+    if (nfsav < *(stop->nevals_p)) {
+       nfsav = *(stop->nevals_p);
        goto L20;
     }
     if (ntrits > 0) {
@@ -2477,7 +2477,7 @@ L230:
 /* Computing 2nd power */
        d__1 = vlag[knew];
        if (denom <= half * (d__1 * d__1)) {
-           if (stop->nevals > nresc) {
+           if (*(stop->nevals_p) > nresc) {
                goto L190;
            }
            /* Return from BOBYQA because of much cancellation in a
@@ -2540,7 +2540,7 @@ L350:
            ;
        }
        if (scaden <= half * biglsq) {
-           if (stop->nevals > nresc) {
+           if (*(stop->nevals_p) > nresc) {
                goto L190;
            }
            /* Return from BOBYQA because of much cancellation in a
@@ -2579,7 +2579,7 @@ L360:
     else if (nlopt_stop_time(stop)) rc = NLOPT_MAXTIME_REACHED;
     if (rc != NLOPT_SUCCESS) goto L720;
 
-    stop->nevals++;
+    ++ *(stop->nevals_p);
     f = calfun(*n, &x[1], calfun_data);
     if (ntrits == -1) {
        fsave = f;
@@ -2625,7 +2625,7 @@ L360:
     diffb = diffa;
     diffa = fabs(diff);
     if (dnorm > rho) {
-       nfsav = stop->nevals;
+       nfsav = *(stop->nevals_p);
     }
 
 /*     Pick the next value of DELTA after a trust region step. */
@@ -3015,7 +3015,7 @@ L680:
        }
        delta = MAX2(delta,rho);
        ntrits = 0;
-       nfsav = stop->nevals;
+       nfsav = *(stop->nevals_p);
        goto L60;
     }
 

diff --git a/cdirect/cdirect.c b/cdirect/cdirect.c
index 165f8e8dff24dcf20596ee70828549dd7a428023..d4d1cd50481f703be6163ea0deb37b6298add47a 100644 (file)
--- a/cdirect/cdirect.c
+++ b/cdirect/cdirect.c
@@ -139,7 +139,7 @@ static double function_eval(const double *x, params *p) {
          p->minf = f;
          memcpy(p->xmin, x, sizeof(double) * p->n);
      }
-     p->stop->nevals++;
+     ++ *(p->stop->nevals_p);
      return f;
 }
 #define FUNCTION_EVAL(fv,x,p,freeonerr) fv = function_eval(x, p); if (nlopt_stop_forced((p)->stop)) { free(freeonerr); return NLOPT_FORCED_STOP; } else if (p->minf < p->stop->minf_max) { free(freeonerr); return NLOPT_MINF_MAX_REACHED; } else if (nlopt_stop_evals((p)->stop)) { free(freeonerr); return NLOPT_MAXEVAL_REACHED; } else if (nlopt_stop_time((p)->stop)) { free(freeonerr); return NLOPT_MAXTIME_REACHED; }

diff --git a/cdirect/hybrid.c b/cdirect/hybrid.c
index 97103ba2cd9105666a9702208fb0c68868fac94d..9179313b6567c9e62f827ca09fcc45f579dec6aa 100644 (file)
--- a/cdirect/hybrid.c
+++ b/cdirect/hybrid.c
@@ -65,7 +65,7 @@ typedef struct {
 static double fcount(int n, const double *x, double *grad, void *p_)
 {
      params *p = (params *) p_;
-     p->stop->nevals++;
+     ++ *(p->stop->nevals_p);
      return p->f(n, x, grad, p->f_data);
 }
 
@@ -80,7 +80,7 @@ static nlopt_result optimize_rect(double *r, params *p)
      nlopt_result ret;
      
      if (stop->maxeval > 0 &&
-        stop->nevals >= stop->maxeval) return NLOPT_MAXEVAL_REACHED;
+        *(stop->nevals_p) >= stop->maxeval) return NLOPT_MAXEVAL_REACHED;
      if (stop->maxtime > 0 &&
         t - stop->start >= stop->maxtime) return NLOPT_MAXTIME_REACHED;
 
@@ -94,8 +94,8 @@ static nlopt_result optimize_rect(double *r, params *p)
                          stop->xtol_rel, stop->xtol_abs,
                          p->local_maxeval > 0 ?
                          MIN(p->local_maxeval, 
-                             stop->maxeval - stop->nevals)
-                         : stop->maxeval - stop->nevals,
+                             stop->maxeval - *(stop->nevals_p))
+                         : stop->maxeval - *(stop->nevals_p),
                          stop->maxtime - (t - stop->start));
      r[1] = -minf;
      if (ret > 0) {
@@ -144,7 +144,7 @@ static nlopt_result divide_largest(params *p)
      double wmax;
      nlopt_result ret;
 
-     /* printf("rect:, %d, %g, %g, %g, %g\n", p->stop->nevals, c[0], c[1], w[0], w[1]); */
+     /* printf("rect:, %d, %g, %g, %g, %g\n", p->stop->nevals_p, c[0], c[1], w[0], w[1]); */
 
      /* check xtol */
      for (i = 0; i < n; ++i)

diff --git a/cobyla/cobyla.c b/cobyla/cobyla.c
index 2e7a81c56a84c69d97e41901979a8108da3c2e3b..17fd70bbe028e5837718a3985287ca5cbfadff5b 100644 (file)
--- a/cobyla/cobyla.c
+++ b/cobyla/cobyla.c
@@ -383,7 +383,7 @@ nlopt_result cobyla(int n, int m, double *x, double *minf, double rhobeg, double
  * for the main calculation.
  */
 
-  stop->nevals = 0;
+  *(stop->nevals_p) = 0;
 
   if (n == 0)
   {
@@ -568,13 +568,13 @@ static nlopt_result cobylb(int *n, int *m, int *mpp,
 
 L40:
   if (nlopt_stop_forced(stop)) rc = NLOPT_FORCED_STOP;
-  else if (stop->nevals > 0) {
+  else if (*(stop->nevals_p) > 0) {
        if (nlopt_stop_evals(stop)) rc = NLOPT_MAXEVAL_REACHED;
        else if (nlopt_stop_time(stop)) rc = NLOPT_MAXTIME_REACHED;
   }
   if (rc != NLOPT_SUCCESS) goto L600;
 
-  stop->nevals++;
+  ++ *(stop->nevals_p);
   if (calcfc(*n, *m, &x[1], &f, &con[1], state))
   {
     if (*iprint >= 1) {
@@ -602,9 +602,9 @@ L40:
        goto L620; /* not L600 because we want to use current x, f, resmax */
   }
 
-  if (stop->nevals == *iprint - 1 || *iprint == 3) {
+  if (*(stop->nevals_p) == *iprint - 1 || *iprint == 3) {
     fprintf(stderr, "cobyla: NFVALS = %4d, F =%13.6E, MAXCV =%13.6E\n",
-           stop->nevals, f, resmax);
+           *(stop->nevals_p), f, resmax);
     i__1 = iptem;
     fprintf(stderr, "cobyla: X =");
     for (i__ = 1; i__ <= i__1; ++i__) {
@@ -636,7 +636,7 @@ L40:
   for (k = 1; k <= i__1; ++k) {
     datmat[k + jdrop * datmat_dim1] = con[k];
   }
-  if (stop->nevals > np) {
+  if (*(stop->nevals_p) > np) {
     goto L130;
   }
 
@@ -671,8 +671,8 @@ L40:
       }
     }
   }
-  if (stop->nevals <= *n) { /* evaluating initial simplex */
-    jdrop = stop->nevals;
+  if (*(stop->nevals_p) <= *n) { /* evaluating initial simplex */
+    jdrop = *(stop->nevals_p);
     /* SGJ: was += rho, but using sim[jdrop,jdrop] enforces consistency
             if we change the stepsize above to stay in [lb,ub]. */
     x[jdrop] += sim[jdrop + jdrop * sim_dim1];
@@ -1179,7 +1179,7 @@ L550:
     }
     if (*iprint == 2) {
       fprintf(stderr, "cobyla: NFVALS = %4d, F =%13.6E, MAXCV =%13.6E\n",
-        stop->nevals, datmat[mp + np * datmat_dim1], datmat[*mpp + np * datmat_dim1]);
+        *(stop->nevals_p), datmat[mp + np * datmat_dim1], datmat[*mpp + np * datmat_dim1]);
 
       fprintf(stderr, "cobyla: X =");
       i__1 = iptem;
@@ -1220,7 +1220,7 @@ L620:
   *minf = f;
   if (*iprint >= 1) {
     fprintf(stderr, "cobyla: NFVALS = %4d, F =%13.6E, MAXCV =%13.6E\n",
-           stop->nevals, f, resmax);
+           *(stop->nevals_p), f, resmax);
     i__1 = iptem;
     fprintf(stderr, "cobyla: X =");
     for (i__ = 1; i__ <= i__1; ++i__) {

diff --git a/cquad/cquad.c b/cquad/cquad.c
index b2dc27cc5118fb0fb0c573d3a63f6075666b3cbb..e20ff986442f082091db65ac7cd519931b288f0c 100644 (file)
--- a/cquad/cquad.c
+++ b/cquad/cquad.c
@@ -303,7 +303,7 @@ nlopt_result cquad_minimize(int n, nlopt_func f, void *f_data,
          model.model.q0 = f(n, x0, NULL, f_data);
          memcpy(X + (iM++ * n), x0, n * sizeof(double));
          memset(model.model.Q, 0, sizeof(double) * n*n);
-         stop->nevals++;
+         *(stop->nevals_p)++;
          feasible_cur = 1;
          for (i = 0; i < m; ++i) {
               modelc[i].model.q0 = fc(n, x0, NULL, fc_data + fc_datum_size*i);
@@ -330,7 +330,7 @@ nlopt_result cquad_minimize(int n, nlopt_func f, void *f_data,
                    xcur[j] = x0[j] + (2*s - 1) * dx[j];
                    fmp[s] = fcur = f(n, xcur, NULL, f_data);
                    memcpy(X + (iM++ * n), xcur, n * sizeof(double));
-                   stop->nevals++;
+                   *(stop->nevals_p)++;
                    feasible_cur = 1;
                    for (i = 0; i < m; ++i) {
                         fcmp[s][i] = fcval_cur[i] = 
@@ -416,7 +416,7 @@ nlopt_result cquad_minimize(int n, nlopt_func f, void *f_data,
                    gcval[i] = cmodel_func(n, xcur, NULL, modelc + i);
 
               fcur = f(n, xcur, NULL, f_data);
-              stop->nevals++;
+              *(stop->nevals_p)++;
               feasible_cur = 1;
               inner_done = gval >= fcur;
               for (i = 0; i < m; ++i) {

diff --git a/crs/crs.c b/crs/crs.c
index 16f4ad5e63556fe1bbd09dde79531fe629c4bdbe..ce27f6481a152e8493fb0cab87b75d233a69e925 100644 (file)
--- a/crs/crs.c
+++ b/crs/crs.c
@@ -131,7 +131,7 @@ static nlopt_result crs_trial(crs_data *d)
      random_trial(d, d->p + 1, best);
      do {
          d->p[0] = d->f(n, d->p + 1, NULL, d->f_data);
-         d->stop->nevals++;
+         ++ *(d->stop->nevals_p);
          if (nlopt_stop_forced(d->stop)) return NLOPT_FORCED_STOP;
          if (d->p[0] < worst->k[0]) break;
          if (nlopt_stop_evals(d->stop)) return NLOPT_MAXEVAL_REACHED;
@@ -203,7 +203,7 @@ static nlopt_result crs_init(crs_data *d, int n, const double *x,
      /* generate initial points randomly, plus starting guess x */
      memcpy(d->ps + 1, x, sizeof(double) * n);
      d->ps[0] = f(n, x, NULL, f_data);
-     stop->nevals++;
+     ++ *(stop->nevals_p);
      if (!rb_tree_insert(&d->t, d->ps)) return NLOPT_OUT_OF_MEMORY;
      if (d->ps[0] < stop->minf_max) return NLOPT_MINF_MAX_REACHED;
      if (nlopt_stop_evals(stop)) return NLOPT_MAXEVAL_REACHED;
@@ -218,7 +218,7 @@ static nlopt_result crs_init(crs_data *d, int n, const double *x,
                    k[1 + j] = nlopt_urand(lb[j], ub[j]);
          }
          k[0] = f(n, k + 1, NULL, f_data);
-         stop->nevals++;
+         ++ *(stop->nevals_p);
          if (!rb_tree_insert(&d->t, k)) return NLOPT_OUT_OF_MEMORY;
          if (k[0] < stop->minf_max) return NLOPT_MINF_MAX_REACHED;
          if (nlopt_stop_evals(stop)) return NLOPT_MAXEVAL_REACHED;

diff --git a/doc/docs/NLopt_C-plus-plus_Reference.md b/doc/docs/NLopt_C-plus-plus_Reference.md
index f511d429a8f5d7d47105650e5342a02f2b4adf8a..463deb36986045036b9ce8cca78c87692bb269ea 100644 (file)
--- a/doc/docs/NLopt_C-plus-plus_Reference.md
+++ b/doc/docs/NLopt_C-plus-plus_Reference.md
@@ -229,6 +229,13 @@ double nlopt::opt::get_maxtime() const;
 
 Stop when the optimization time (in seconds) exceeds `maxtime`.
 
+```
+int nlopt::opt::get_numevals() const;
+```
+
+
+Request the number of evaluations.
+
 ### Forced termination
 
 In certain cases, the caller may wish to *force* the optimization to halt, for some reason unknown to NLopt. For example, if the user presses Ctrl-C, or there is an error of some sort in the objective function. You can do this by throwing *any* exception inside your objective/constraint functions: the exception will be caught, the optimization will be halted gracefully, and another exception (possibly not the same one) will be rethrown. See [Exceptions](#Exceptions.md), below. The C++ equivalent of `nlopt_forced_stop` from the [C API](NLopt_Reference#Forced_termination.md) is to throw an `nlopt::forced_stop` exception.

diff --git a/doc/docs/NLopt_Fortran_Reference.md b/doc/docs/NLopt_Fortran_Reference.md
index 559d42c74103397d76c434e42c7e9913c943d3e1..295e89c6773c3202ee035f46fc42d185aec442b5 100644 (file)
--- a/doc/docs/NLopt_Fortran_Reference.md
+++ b/doc/docs/NLopt_Fortran_Reference.md
@@ -256,8 +256,16 @@ call nlo_get_maxeval(maxeval, opt)
 ```
 
 
+
 Stop when the number of function evaluations exceeds the `integer` `maxeval`. (Zero or negative for no limit.)
 
+```
+call nlo_get_numevals(nevals, opt)
+```
+
+Request the number of evaluations.
+
+
 ```
 call nlo_set_maxtime(ires, opt, maxtime)
 call nlo_get_maxtime(maxtime, opt)

diff --git a/doc/docs/NLopt_Guile_Reference.md b/doc/docs/NLopt_Guile_Reference.md
index de396645ddc8cda755f351a525a1a2bd4f8c7fe7..11b875d7269c724c5a32154801e3ff567c7660a1 100644 (file)
--- a/doc/docs/NLopt_Guile_Reference.md
+++ b/doc/docs/NLopt_Guile_Reference.md
@@ -186,6 +186,14 @@ Set absolute tolerances on optimization parameters. The `tol` input must be a ve
 
 Stop when the number of function evaluations exceeds `maxeval`. (0 or negative for no limit.)
 
+```
+(nlopt-opt-get-nevals opt)
+```
+
+
+Request the number of evaluations.
+
+
 ```
 (nlopt-opt-set-maxtime opt maxtime)
 (nlopt-opt-get-maxtime opt)

diff --git a/doc/docs/NLopt_Python_Reference.md b/doc/docs/NLopt_Python_Reference.md
index 8728f6a7518f23e9607d25b80506b92c269c4adf..5bdc8a71ce7ee95a37fdcdfb8f4fca32748cb7ea 100644 (file)
--- a/doc/docs/NLopt_Python_Reference.md
+++ b/doc/docs/NLopt_Python_Reference.md
@@ -239,6 +239,17 @@ opt.get_maxtime()
 
 Stop when the optimization time (in seconds) exceeds `maxtime`. (0 or negative for no limit.)
 
+
+
+```
+opt.get_numevals()
+```
+
+
+Request the number of evaluations.
+
+
+
 ### Forced termination
 
 In certain cases, the caller may wish to *force* the optimization to halt, for some reason unknown to NLopt. For example, if the user presses Ctrl-C, or there is an error of some sort in the objective function. You can do this by raise *any* exception inside your objective/constraint functions:the optimization will be halted gracefully, and the same exception will be raised to the caller. See [Exceptions](#Exceptions.md), below. The Python equivalent of `nlopt_forced_stop` from the [C API](NLopt_Reference#Forced_termination.md) is to throw an `nlopt.ForcedStop` exception.

diff --git a/doc/docs/NLopt_Reference.md b/doc/docs/NLopt_Reference.md
index ae0eaeed6155074457674a187e5d33384c717be9..e59a09c6e8f2162ae964ab6ffad694bb05c4d740 100644 (file)
--- a/doc/docs/NLopt_Reference.md
+++ b/doc/docs/NLopt_Reference.md
@@ -272,6 +272,14 @@ double nlopt_get_maxtime(nlopt_opt opt);
 
 Stop when the optimization time (in seconds) exceeds `maxtime`. (This is not a strict maximum: the time may exceed maxtime slightly, depending upon the algorithm and on how slow your function evaluation is.) Criterion is disabled if `maxtime` is non-positive.
 
+```
+int nlopt_get_numevals(nlopt_opt opt);
+```
+
+
+Request the number of evaluations.
+
+
 ### Forced termination
 
 In certain cases, the caller may wish to *force* the optimization to halt, for some reason unknown to NLopt. For example, if the user presses Ctrl-C, or there is an error of some sort in the objective function. (This is used to implement exception handling in the NLopt wrappers for C++ and other languages.) In this case, it is possible to tell NLopt to halt the optimization gracefully, returning the best point found so far, by calling the following function from *within* your objective or constraint functions:

diff --git a/doc/docs/NLopt_release_notes.md b/doc/docs/NLopt_release_notes.md
index c46801af583a2536faa5df6b6919e0ee4f780bef..8d3e8675af604d9bf9f4048b34579c1ab47e9333 100644 (file)
--- a/doc/docs/NLopt_release_notes.md
+++ b/doc/docs/NLopt_release_notes.md
@@ -10,6 +10,7 @@ NLopt 2.5.0
 <small>TBA</small>
 
 -   Using CMake build system instead of autotools
+-   Add int nlopt_get_numevals() function
 
 NLopt 2.4.2
 -----------

diff --git a/esch/esch.c b/esch/esch.c
index 6fd5ecb65e4f642af6c60c6608bb663a62c26b3a..ef16ee4e3db528551ba98f663cb182b2305cc216 100644 (file)
--- a/esch/esch.c
+++ b/esch/esch.c
@@ -165,7 +165,7 @@ nlopt_result chevolutionarystrategy(
          esparents[id].fitness =
               f(nparameters, esparents[id].parameters, NULL, data_f);
          estotal[id].fitness = esparents[id].fitness;
-         stop->nevals++;
+         ++ *(stop->nevals_p);
          if (*minf > esparents[id].fitness) {
               *minf = esparents[id].fitness;
               memcpy(x, esparents[id].parameters,
@@ -218,7 +218,7 @@ nlopt_result chevolutionarystrategy(
               /*esoffsprings[id].fitness = (double)fitness(esoffsprings[id].parameters, nparameters,fittype);*/
               esoffsprings[id].fitness = f(nparameters, esoffsprings[id].parameters, NULL, data_f);
               estotal[id+np].fitness = esoffsprings[id].fitness;
-              stop->nevals++;
+              ++ *(stop->nevals_p);
               if (*minf > esoffsprings[id].fitness) {
                    *minf = esoffsprings[id].fitness;
                    memcpy(x, esoffsprings[id].parameters,

diff --git a/isres/isres.c b/isres/isres.c
index c6de700933e00007f57fcd8202690c82c7513f1f..ad5fc25dbf8f3b4a1a20a044a46016715e80310b 100644 (file)
--- a/isres/isres.c
+++ b/isres/isres.c
@@ -134,7 +134,7 @@ nlopt_result isres_minimize(int n, nlopt_func f, void *f_data,
          for (k = 0; k < population; ++k) {
               int feasible = 1;
               double gpenalty;
-              stop->nevals++;
+              ++ *(stop->nevals_p);
               fval[k] = f(n, xs + k*n, NULL, f_data);
               if (nlopt_stop_forced(stop)) { 
                    ret = NLOPT_FORCED_STOP; goto done; }

diff --git a/luksan/luksan.h b/luksan/luksan.h
index 01ac07ba29b6da5e3db2b81f5dc0b59aa952ecbb..214fb92f6c76f172e7a7fe812bd8edbc97012ada 100644 (file)
--- a/luksan/luksan.h
+++ b/luksan/luksan.h
@@ -136,7 +136,7 @@ void luksan_pnint1__(double *rl, double *ru, double *fl,
 /* Common Block Declarations */
 typedef struct {
      int nres, ndec, nin, nit;
-     /* int nfv;   -- now stored in stop->nevals */
+     /* int nfv;   -- now stored in stop->nevals_p */
      int nfg, nfh;
 } stat_common;
 

diff --git a/luksan/plip.c b/luksan/plip.c
index 8bce79ee1d9c134022c96056e984dc562f7b813a..efc3fd027feb9da9faf9d7468a7cbb9378e4ac7f 100644 (file)
--- a/luksan/plip.c
+++ b/luksan/plip.c
@@ -279,7 +279,7 @@ static void plip_(int *nf, int *nb, double *x, int *
        goto L11190;
     }
     *f = objgrad(*nf, &x[1], &gf[1], objgrad_data);
-    ++stop->nevals;
+    ++*(stop->nevals_p);
     ++stat_1->nfg;
     if (nlopt_stop_time(stop)) { *iterm = 100; goto L11190; }
 L11120:
@@ -384,7 +384,7 @@ L11170:
     luksan_mxudir__(nf, &r__, &s[1], &xo[1], &x[1], &ix[1], &kbf);
     luksan_pcbs04__(nf, &x[1], &ix[1], &xl[1], &xu[1], &eps9, &kbf);
     *f = objgrad(*nf, &x[1], &gf[1], objgrad_data);
-    ++stop->nevals;
+    ++*(stop->nevals_p);
     ++stat_1->nfg;
     p = luksan_mxudot__(nf, &gf[1], &s[1], &ix[1], &kbf);
     goto L11170;

diff --git a/luksan/plis.c b/luksan/plis.c
index 11d371f209560912a864404b08e6276e47462c47..8bd7bb365dcb1df5bb621452a830be6424128a8b 100644 (file)
--- a/luksan/plis.c
+++ b/luksan/plis.c
@@ -261,7 +261,7 @@ static void plis_(int *nf, int *nb, double *x, int *
        goto L11190;
     }
     *f = objgrad(*nf, &x[1], &gf[1], objgrad_data);
-    ++stop->nevals;
+    ++*(stop->nevals_p);
     ++stat_1->nfg;
     if (nlopt_stop_time(stop)) { *iterm = 100; goto L11190; }
 L11120:
@@ -391,7 +391,7 @@ L11170:
     luksan_mxudir__(nf, &r__, &s[1], &xo[1], &x[1], &ix[1], &kbf);
     luksan_pcbs04__(nf, &x[1], &ix[1], &xl[1], &xu[1], &eps9, &kbf);
     *f = objgrad(*nf, &x[1], &gf[1], objgrad_data);
-    ++stop->nevals;
+    ++*(stop->nevals_p);
     ++stat_1->nfg;
     p = luksan_mxudot__(nf, &gf[1], &s[1], &ix[1], &kbf);
     goto L11170;

diff --git a/luksan/pnet.c b/luksan/pnet.c
index 3e25634314ceae8cb8b8f9c0fc8f9f7e1c51c872..f2e324b4d56c545795a01a418f629c12c1ecd635 100644 (file)
--- a/luksan/pnet.c
+++ b/luksan/pnet.c
@@ -300,7 +300,7 @@ static void pnet_(int *nf, int *nb, double *x, int *
        luksan_pyadc0__(nf, &n, &x[1], &ix[1], &xl[1], &xu[1], &inew);
     }
     *f = objgrad(*nf, &x[1], &gf[1], objgrad_data);
-    ++stop->nevals;
+    ++(*stop->nevals_p);
     ++stat_1->nfg;
     if (nlopt_stop_time(stop)) { *iterm = 100; goto L11080; }
     ld = kd;
@@ -398,7 +398,7 @@ L12520:
     ld = 0;
     luksan_mxudir__(nf, &pp, &xs[1], &xo[1], &x[1], &ix[1], &kbf);
     objgrad(*nf, &x[1], &gf[1], objgrad_data);
-    ++stop->nevals;
+    ++*(stop->nevals_p);
     ++stat_1->nfg;
     ld = kd;
     luksan_mxvdif__(nf, &gf[1], &gn[1], &go[1]);
@@ -526,7 +526,7 @@ L11060:
     luksan_mxudir__(nf, &r__, &s[1], &xo[1], &x[1], &ix[1], &kbf);
     luksan_pcbs04__(nf, &x[1], &ix[1], &xl[1], &xu[1], &eps9, &kbf);
     *f = objgrad(*nf, &x[1], &gf[1], objgrad_data);
-    ++stop->nevals;
+    ++*(stop->nevals_p);
     ++stat_1->nfg;
     ld = kd;
     p = luksan_mxudot__(nf, &gf[1], &s[1], &ix[1], &kbf);

diff --git a/mlsl/mlsl.c b/mlsl/mlsl.c
index b90d690487e08b1fa9323925680809128dfd5172..ff1d517086342dce2136b6c5ecd3301ee342d0ce 100644 (file)
--- a/mlsl/mlsl.c
+++ b/mlsl/mlsl.c
@@ -251,7 +251,7 @@ static pt *alloc_pt(int n)
 static double fcount(unsigned n, const double *x, double *grad, void *p_)
 {
      mlsl_data *p = (mlsl_data *) p_;
-     p->stop->nevals++;
+     ++ *(p->stop->nevals_p);
      return p->f(n, x, grad, p->f_data);
 }
 
@@ -333,7 +333,7 @@ nlopt_result mlsl_minimize(int n, nlopt_func f, void *f_data,
 
      memcpy(p->x, x, n * sizeof(double));
      p->f = f(n, x, NULL, f_data);
-     stop->nevals++;
+     ++ *(stop->nevals_p);
      if (!rb_tree_insert(&d.pts, (rb_key) p)) { 
          free(p); ret = NLOPT_OUT_OF_MEMORY; 
      }
@@ -358,7 +358,7 @@ nlopt_result mlsl_minimize(int n, nlopt_func f, void *f_data,
                    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++;
+              ++ *(stop->nevals_p);
               if (!rb_tree_insert(&d.pts, (rb_key) p)) { 
                    free(p); ret = NLOPT_OUT_OF_MEMORY;
               }
@@ -402,7 +402,7 @@ nlopt_result mlsl_minimize(int n, nlopt_func f, void *f_data,
                    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->maxeval - *(stop->nevals_p),
                                                  stop->maxtime -
                                                  (t - stop->start));
                    p->minimized = 1;

diff --git a/mma/ccsa_quadratic.c b/mma/ccsa_quadratic.c
index 2b34527856cdbd605b1eef1004dbc336cba588b2..23ffbba493e69951623ece841b8a07e212a1e98e 100644 (file)
--- a/mma/ccsa_quadratic.c
+++ b/mma/ccsa_quadratic.c
@@ -333,7 +333,7 @@ nlopt_result ccsa_quadratic_minimize(
      }
 
      dd.fval = fcur = *minf = f(n, x, dfdx, f_data);
-     stop->nevals++;
+     ++ *(stop->nevals_p);
      memcpy(xcur, x, sizeof(double) * n);
      if (nlopt_stop_forced(stop)) { ret = NLOPT_FORCED_STOP; goto done; }
 
@@ -441,7 +441,7 @@ nlopt_result ccsa_quadratic_minimize(
               }
 
               fcur = f(n, xcur, dfdx_cur, f_data);
-              stop->nevals++;
+              ++ *(stop->nevals_p);
               if (nlopt_stop_forced(stop)) { 
                    ret = NLOPT_FORCED_STOP; goto done; }
               feasible_cur = 1; infeasibility_cur = 0;

diff --git a/mma/mma.c b/mma/mma.c
index 7f14375bd2b00251c1c5115540e7b7d9d5d6a8bd..94668bd2888446e23ebb040f7d837e2695006dc1 100644 (file)
--- a/mma/mma.c
+++ b/mma/mma.c
@@ -209,7 +209,7 @@ nlopt_result mma_minimize(unsigned n, nlopt_func f, void *f_data,
      }
 
      dd.fval = fcur = *minf = f(n, x, dfdx, f_data);
-     stop->nevals++;
+     ++ *(stop->nevals_p);
      memcpy(xcur, x, sizeof(double) * n);
      if (nlopt_stop_forced(stop)) { ret = NLOPT_FORCED_STOP; goto done; }
 
@@ -287,7 +287,7 @@ nlopt_result mma_minimize(unsigned n, nlopt_func f, void *f_data,
               }
 
               fcur = f(n, xcur, dfdx_cur, f_data);
-              stop->nevals++;
+              ++ *(stop->nevals_p);
               if (nlopt_stop_forced(stop)) { 
                    ret = NLOPT_FORCED_STOP; goto done; }
               feasible_cur = 1; infeasibility_cur = 0;

diff --git a/neldermead/nldrmd.c b/neldermead/nldrmd.c
index a8e7ee479b079560dc04587c1be3c4b0d2d634dc..f4a8e7e8a90aa97f7d8dd7fb7c961456dc9cd136 100644 (file)
--- a/neldermead/nldrmd.c
+++ b/neldermead/nldrmd.c
@@ -77,7 +77,7 @@ static int reflectpt(int n, double *xnew,
 }
 
 #define CHECK_EVAL(xc,fc)                                                \
- stop->nevals++;                                                         \
+ ++ *(stop->nevals_p);                                                   \
  if (nlopt_stop_forced(stop)) { ret=NLOPT_FORCED_STOP; goto done; }        \
  if ((fc) <= *minf) {                                                    \
    *minf = (fc); memcpy(x, (xc), n * sizeof(double));                    \
@@ -295,7 +295,7 @@ nlopt_result nldrmd_minimize(int n, nlopt_func f, void *f_data,
      double *scratch, fdiff;
 
      *minf = f(n, x, NULL, f_data);
-     stop->nevals++;
+     ++ *(stop->nevals_p);
      if (nlopt_stop_forced(stop)) return NLOPT_FORCED_STOP;
      if (*minf < stop->minf_max) return NLOPT_MINF_MAX_REACHED;
      if (nlopt_stop_evals(stop)) return NLOPT_MAXEVAL_REACHED;

diff --git a/neldermead/sbplx.c b/neldermead/sbplx.c
index f2ad6f373065cc0ec845e2aaad2274ebf771d979..cbad38f0abfa2aad1ce77748c63910497dcf4381 100644 (file)
--- a/neldermead/sbplx.c
+++ b/neldermead/sbplx.c
@@ -78,7 +78,7 @@ nlopt_result sbplx_minimize(int n, nlopt_func f, void *f_data,
      double fprev;
 
      *minf = f(n, x, NULL, f_data);
-     stop->nevals++;
+     ++ *(stop->nevals_p);
      if (nlopt_stop_forced(stop)) return NLOPT_FORCED_STOP;
      if (*minf < stop->minf_max) return NLOPT_MINF_MAX_REACHED;
      if (nlopt_stop_evals(stop)) return NLOPT_MAXEVAL_REACHED;
@@ -107,7 +107,7 @@ nlopt_result sbplx_minimize(int n, nlopt_func f, void *f_data,
          double normi = 0;
          double normdx = 0;
          int ns, nsubs = 0;
-         int nevals = stop->nevals;
+         int nevals = *(stop->nevals_p);
          double fdiff, fdiff_max = 0;
 
          memcpy(xprev, x, n * sizeof(double));
@@ -153,13 +153,13 @@ nlopt_result sbplx_minimize(int n, nlopt_func f, void *f_data,
                    ubs[k-i] = ub[p[k]];
               }
               ++nsubs;
-              nevals = stop->nevals;
+              nevals = *(stop->nevals_p);
               ret = nldrmd_minimize_(ns, subspace_func, &sd, lbs,ubs,xs, minf,
                                      xsstep, stop, psi, scratch, &fdiff);
               if (fdiff > fdiff_max) fdiff_max = fdiff;
               if (sbplx_verbose)
                    printf("%d NM iterations for (%d,%d) subspace\n",
-                          stop->nevals - nevals, sd.is, ns);
+                          *(stop->nevals_p) - nevals, sd.is, ns);
               for (k = i; k < i+ns; ++k) x[p[k]] = xs[k-i];
               if (ret == NLOPT_FAILURE) { ret=NLOPT_XTOL_REACHED; goto done; }
               if (ret != NLOPT_XTOL_REACHED) goto done;
@@ -174,13 +174,13 @@ nlopt_result sbplx_minimize(int n, nlopt_func f, void *f_data,
               ubs[i-sd.is] = ub[p[i]];
          }
          ++nsubs;
-         nevals = stop->nevals;
+         nevals = *(stop->nevals_p);
          ret = nldrmd_minimize_(ns, subspace_func, &sd, lbs,ubs,xs, minf,
                                 xsstep, stop, psi, scratch, &fdiff);
          if (fdiff > fdiff_max) fdiff_max = fdiff;
          if (sbplx_verbose)
               printf("sbplx: %d NM iterations for (%d,%d) subspace\n",
-                     stop->nevals - nevals, sd.is, ns);
+                     *(stop->nevals_p) - nevals, sd.is, ns);
          for (i = sd.is; i < n; ++i) x[p[i]] = xs[i-sd.is];
          if (ret == NLOPT_FAILURE) { ret=NLOPT_XTOL_REACHED; goto done; }
          if (ret != NLOPT_XTOL_REACHED) goto done;

diff --git a/newuoa/newuoa.c b/newuoa/newuoa.c
index a22849e3802ad3e0730c7c0e37a2a18388f2a656..83c1211b6619c7557e7627f2fa9b4f02e8d6cd13 100644 (file)
--- a/newuoa/newuoa.c
+++ b/newuoa/newuoa.c
@@ -2100,13 +2100,13 @@ L290:
     ++nf;
 L310:
     if (nlopt_stop_forced(stop)) rc = NLOPT_FORCED_STOP;
-    else if (stop->nevals > 0) {
+    else if (*(stop->nevals_p) > 0) {
         if (nlopt_stop_evals(stop)) rc = NLOPT_MAXEVAL_REACHED;
         else if (nlopt_stop_time(stop)) rc = NLOPT_MAXTIME_REACHED;
     }
     if (rc != NLOPT_SUCCESS) goto L530;
 
-    stop->nevals++;
+    ++ *(stop->nevals_p);
     f = calfun(*n, &x[1], calfun_data);
     if (f < stop->minf_max) {
        rc = NLOPT_MINF_MAX_REACHED;

diff --git a/praxis/praxis.c b/praxis/praxis.c
index a032904847c185062db1fdf18f4021ab88e6107a..e6ce82e3d235a19881d2c57eee5207adcc0e3e0c 100644 (file)
--- a/praxis/praxis.c
+++ b/praxis/praxis.c
@@ -182,7 +182,7 @@ nlopt_result praxis_(double t0, double machep, double h0,
     prev_fbest = q_1.fbest = global_1.fx = f(n, &x[1], f_data);
     memcpy(q_1.xbest, &x[1], n*sizeof(double));
     memcpy(prev_xbest, &x[1], n*sizeof(double));
-    stop->nevals++;
+    ++ *(stop->nevals_p);
     q_1.stop = stop;
     q_1.qf1 = global_1.fx;
     if (t0 > 0)
@@ -1236,7 +1236,7 @@ L2:
 L4:
     ++(*nf);
     ret_val = f(n, t, f_data);
-    stop->nevals++;
+    ++ *(stop->nevals_p);
     if (ret_val < q_1->fbest) {
         q_1->fbest = ret_val;
         memcpy(q_1->xbest, t, n * sizeof(double));

diff --git a/slsqp/slsqp.c b/slsqp/slsqp.c
index 8a4be2da5cfc319a86d29ea92287af3f291f1f9c..f648f5dc5d46182545308f80df1ec09a90556e70 100644 (file)
--- a/slsqp/slsqp.c
+++ b/slsqp/slsqp.c
@@ -2509,7 +2509,7 @@ nlopt_result nlopt_slsqp(unsigned n, nlopt_func f, void *f_data,
              }
              feasible_cur = 1; infeasibility_cur = 0;
              fcur = f(n, xcur, newgrad, f_data);
-             stop->nevals++;
+             ++ *(stop->nevals_p);
              if (nlopt_stop_forced(stop)) {
                  fcur = HUGE_VAL; ret = NLOPT_FORCED_STOP; goto done; }
              if (nlopt_isfinite(fcur)) {

diff --git a/stogo/local.cc b/stogo/local.cc
index 89802b62f10fec5c463b8b6ddc71486e67c5fd86..f95884b463456ad7445cf383dedc3675a1fcd6c2 100644 (file)
--- a/stogo/local.cc
+++ b/stogo/local.cc
@@ -12,7 +12,7 @@
 #include "tools.h"
 
 #ifdef NLOPT_UTIL_H
-#  define IF_NLOPT_CHECK_EVALS stop->nevals++; \
+#  define IF_NLOPT_CHECK_EVALS ++ *(stop->nevals_p); \
                                if (nlopt_stop_evalstime(stop)) \
                                   return LS_MaxEvalTime
 #else
@@ -44,7 +44,7 @@ static double f_local(int n, const double *x, double *grad, void *data_)
                                   grad?OBJECTIVE_AND_GRADIENT:OBJECTIVE_ONLY);
   if (grad) data->maxgrad = max(data->maxgrad, normInf(gv));
   xv.elements = gv.elements = 0; // prevent deallocation
-  data->stop->nevals++;
+  ++ *(data->stop->nevals_p);
   return f;
 }
 #endif
@@ -98,7 +98,7 @@ int local(Trial &T, TBox &box, TBox &domain, double eps_cl, double *mgr,
                                    stop->minf_max,
                                    stop->ftol_rel, stop->ftol_abs,
                                    stop->xtol_rel, stop->xtol_abs,
-                                   stop->maxeval - stop->nevals,
+                                   stop->maxeval - *(stop->nevals_p),
                                    stop->maxtime - stop->start);
   *mgr = data.maxgrad;
   T.xvals=x ; T.objval=f ;

diff --git a/subplex/subplex.c b/subplex/subplex.c
index 28b9a75f17b0d2c196256895a5f0949461fb33fd..c8c767b8a32b351c11da22df00f317121868b1b0 100644 (file)
--- a/subplex/subplex.c
+++ b/subplex/subplex.c
@@ -1384,7 +1384,7 @@ static int simplx_(D_fp f, void *fdata, integer *n, doublereal *step, integer *
     if (usubc_1.irepl > 0) {
        isubc_1.new__ = FALSE_;
        evalf_((D_fp)f,fdata, ns, &ips[1], &s[s_dim1 + 1], n, &x[1], &fs[1], nfe);
-       stop->nevals++;
+       *(stop->nevals_p)++;
     } else {
        fs[1] = *fx;
     }
@@ -1393,7 +1393,7 @@ static int simplx_(D_fp f, void *fdata, integer *n, doublereal *step, integer *
     for (j = 2; j <= i__1; ++j) {
        evalf_((D_fp)f, fdata,ns, &ips[1], &s[j * s_dim1 + 1], n, &x[1], &fs[j], 
                nfe);
-       stop->nevals++;
+       *(stop->nevals_p)++;
 /* L10: */
     }
     il = 1;
@@ -1415,7 +1415,7 @@ L20:
        goto L40;
     }
     evalf_((D_fp)f,fdata, ns, &ips[1], &s[itemp * s_dim1 + 1], n, &x[1], &fr, nfe);
-    stop->nevals++;
+    *(stop->nevals_p)++;
     if (fr < fs[il]) {
 
 /*         expand */
@@ -1427,7 +1427,7 @@ L20:
            goto L40;
        }
        evalf_((D_fp)f,fdata, ns, &ips[1], &s[ih * s_dim1 + 1], n, &x[1], &fe, nfe);
-       stop->nevals++;
+       *(stop->nevals_p)++;
        if (fe < fr) {
            fs[ih] = fe;
        } else {
@@ -1459,7 +1459,7 @@ L20:
        }
        evalf_((D_fp)f,fdata, ns, &ips[1], &s[itemp * s_dim1 + 1], n, &x[1], &fc, 
                nfe);
-       stop->nevals++;
+       *(stop->nevals_p)++;
 /* Computing MIN */
        d__1 = fr, d__2 = fs[ih];
        if (fc < MIN2(d__1,d__2)) {
@@ -1481,7 +1481,7 @@ L20:
                    }
                    evalf_((D_fp)f,fdata, ns, &ips[1], &s[j * s_dim1 + 1], n, &x[1],
                             &fs[j], nfe);
-                   stop->nevals++;
+                   *(stop->nevals_p)++;
                }
 /* L30: */
            }
@@ -2037,7 +2037,7 @@ static int subplx_(D_fp f, void *fdata, integer *n,
        isubc_1.new__ = TRUE_;
        usubc_1.initx = TRUE_;
        evalf_((D_fp)f, fdata, &c__0, &iwork[1], &dum, n, &x[1], &sfx, nfe);
-       stop->nevals++;
+       *(stop->nevals_p)++;
        usubc_1.initx = FALSE_;
     } else {
 

diff --git a/test/t_python.py b/test/t_python.py
index 8dee3db9848ebfcc87cce33f2a7f87fe4bad36ef..3ce7bdd456366e0b649a9a70d4a38fbaf76dc7da 100644 (file)
--- a/test/t_python.py
+++ b/test/t_python.py
@@ -20,11 +20,12 @@ def myconstraint(x, grad, a, b):
 opt = nlopt.opt(nlopt.LD_MMA, 2)
 opt.set_lower_bounds([-float('inf'), 0])
 opt.set_min_objective(myfunc)
-opt.add_inequality_constraint(lambda x,grad: myconstraint(x,grad,2,0), 1e-8)
-opt.add_inequality_constraint(lambda x,grad: myconstraint(x,grad,-1,1), 1e-8)
+opt.add_inequality_constraint(lambda x, grad: myconstraint(x,grad, 2, 0), 1e-8)
+opt.add_inequality_constraint(lambda x, grad: myconstraint(x,grad, -1, 1), 1e-8)
 opt.set_xtol_rel(1e-4)
 x = opt.optimize([1.234, 5.678])
 minf = opt.last_optimum_value()
-print('optimum at ', x[0],x[1])
+print('optimum at ', x[0], x[1])
 print('minimum value = ', minf)
 print('result code = ', opt.last_optimize_result())
+print('nevals = ', opt.get_numevals())

diff --git a/util/nlopt-util.h b/util/nlopt-util.h
index 89740c4a0ab592bc964b8b70af602733d0ed43e9..437cb67b26c1f2526aee6ef3be85236e5d72842b 100644 (file)
--- a/util/nlopt-util.h
+++ b/util/nlopt-util.h
@@ -82,7 +82,7 @@ typedef struct {
      double ftol_abs;
      double xtol_rel;
      const double *xtol_abs;
-     int nevals, maxeval;
+     int *nevals_p, maxeval;
      double maxtime, start;
      int *force_stop;
      char **stop_msg; /* pointer to msg string to update */

diff --git a/util/stop.c b/util/stop.c
index 7349df154bcb4a83ccad46ebd49aa2b880e7ad0a..b834b55b2d6b5f3bfe8d6996050849a5ac8a4ff7 100644 (file)
--- a/util/stop.c
+++ b/util/stop.c
@@ -87,7 +87,7 @@ int nlopt_stop_xs(const nlopt_stopping *s,
 
 int nlopt_stop_evals(const nlopt_stopping *s)
 {
-     return (s->maxeval > 0 && s->nevals >= s->maxeval);
+     return (s->maxeval > 0 && *(s->nevals_p) >= s->maxeval);
 }
 
 int nlopt_stop_time_(double start, double maxtime)