fix some compiler warnings

diff --git a/api/options.c b/api/options.c
index ba2a1b8f064795bd23c0c3f4ace981d1b809ff4b..06776349231b1afe2cde0669cf6be8f5a90660f9 100644 (file)
--- a/api/options.c
+++ b/api/options.c
@@ -271,7 +271,7 @@ NLOPT_STDCALL nlopt_set_lower_bounds(nlopt_opt opt, const double *lb)
 {
      nlopt_unset_errmsg(opt);
      if (opt && (opt->n == 0 || lb)) {
-          int i;
+         unsigned int i;
          memcpy(opt->lb, lb, sizeof(double) * (opt->n));
          for (i = 0; i < opt->n; ++i)
               if (opt->lb[i] < opt->ub[i] && nlopt_istiny(opt->ub[i] - opt->lb[i]))
@@ -313,7 +313,7 @@ NLOPT_STDCALL nlopt_set_upper_bounds(nlopt_opt opt, const double *ub)
 {
      nlopt_unset_errmsg(opt);
      if (opt && (opt->n == 0 || ub)) {
-          int i;
+         unsigned int i;
          memcpy(opt->ub, ub, sizeof(double) * (opt->n));
          for (i = 0; i < opt->n; ++i)
               if (opt->lb[i] < opt->ub[i] && nlopt_istiny(opt->ub[i] - opt->lb[i]))

diff --git a/auglag/auglag.c b/auglag/auglag.c
index f18cfece6f21816b576a7f92a8f81320626626d3..0092484d3bfc13c212db43ff9e92afc5ef40aa5f 100644 (file)
--- a/auglag/auglag.c
+++ b/auglag/auglag.c
@@ -79,7 +79,8 @@ nlopt_result auglag_minimize(int n, nlopt_func f, void *f_data,
      nlopt_result ret = NLOPT_SUCCESS;
      double ICM = HUGE_VAL, minf_penalty = HUGE_VAL, penalty;
      double *xcur = NULL, fcur;
-     int i, ii, k, feasible, minf_feasible = 0;
+     int i, ii, feasible, minf_feasible = 0;
+     unsigned int k;
      int auglag_iters = 0;
      int max_constraint_dim;
 

diff --git a/isres/isres.c b/isres/isres.c
index 0e40106db27b7b190953930cfabc8de83da3f8b7..c6de700933e00007f57fcd8202690c82c7513f1f 100644 (file)
--- a/isres/isres.c
+++ b/isres/isres.c
@@ -90,7 +90,7 @@ nlopt_result isres_minimize(int n, nlopt_func f, void *f_data,
          nlopt_stop_msg(stop, "population %d is too small", population);
          return NLOPT_INVALID_ARGS;
      }
-     survivors = ceil(population * SURVIVOR);
+     survivors = (int) ceil(population * SURVIVOR);
 
      taup = PHI / sqrt(2*n);
      tau = PHI / sqrt(2*sqrt(n));

diff --git a/mma/ccsa_quadratic.c b/mma/ccsa_quadratic.c
index ddbf77e13147744773354880acf3bae26f90ed5d..01f2413fa2762f9dde1235d1da926a7b76ad179f 100644 (file)
--- a/mma/ccsa_quadratic.c
+++ b/mma/ccsa_quadratic.c
@@ -436,7 +436,7 @@ nlopt_result ccsa_quadratic_minimize(
                    printf("CCSA dual converged in %d iters to g=%g:\n",
                           dd.count, dd.gval);
                    for (i = 0; i < MIN(ccsa_verbose, m); ++i)
-                        printf("    CCSA y[%d]=%g, gc[%d]=%g\n",
+                        printf("    CCSA y[%u]=%g, gc[%u]=%g\n",
                                i, y[i], i, dd.gcval[i]);
               }
 
@@ -511,7 +511,7 @@ nlopt_result ccsa_quadratic_minimize(
               if (ccsa_verbose)
                    printf("CCSA inner iteration: rho -> %g\n", rho);
               for (i = 0; i < MIN(ccsa_verbose, m); ++i)
-                   printf("                CCSA rhoc[%d] -> %g\n", i,rhoc[i]);
+                   printf("                CCSA rhoc[%u] -> %g\n", i,rhoc[i]);
          }
 
          if (nlopt_stop_ftol(stop, fcur, fprev))
@@ -527,7 +527,7 @@ nlopt_result ccsa_quadratic_minimize(
          for (i = 0; i < m; ++i)
               rhoc[i] = MAX(0.1 * rhoc[i], CCSA_RHOMIN);
          for (i = 0; i < MIN(ccsa_verbose, m); ++i)
-              printf("                 CCSA rhoc[%d] -> %g\n", i, rhoc[i]);
+              printf("                 CCSA rhoc[%u] -> %g\n", i, rhoc[i]);
          if (k > 1) {
               for (j = 0; j < n; ++j) {
                    double dx2 = (xcur[j]-xprev[j]) * (xprev[j]-xprevprev[j]);
@@ -541,7 +541,7 @@ nlopt_result ccsa_quadratic_minimize(
                    }
               }
               for (j = 0; j < MIN(ccsa_verbose, n); ++j)
-                   printf("                 CCSA sigma[%d] -> %g\n", 
+                   printf("                 CCSA sigma[%u] -> %g\n", 
                           j, sigma[j]);
          }
      }

diff --git a/mma/mma.c b/mma/mma.c
index afaa024f3ddbf65dc34c6d6fe22bfc72cf715335..7f14375bd2b00251c1c5115540e7b7d9d5d6a8bd 100644 (file)
--- a/mma/mma.c
+++ b/mma/mma.c
@@ -282,7 +282,7 @@ nlopt_result mma_minimize(unsigned n, nlopt_func f, void *f_data,
                    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",
+                        printf("    MMA y[%u]=%g, gc[%u]=%g\n",
                                i, y[i], i, dd.gcval[i]);
               }
 
@@ -363,7 +363,7 @@ nlopt_result mma_minimize(unsigned n, nlopt_func f, void *f_data,
               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]);
+                   printf("                 MMA rhoc[%u] -> %g\n", i,rhoc[i]);
          }
 
          if (nlopt_stop_ftol(stop, fcur, fprev))
@@ -379,7 +379,7 @@ nlopt_result mma_minimize(unsigned n, nlopt_func f, void *f_data,
          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]);
+              printf("                 MMA rhoc[%u] -> %g\n", i, rhoc[i]);
          if (k > 1) {
               for (j = 0; j < n; ++j) {
                    double dx2 = (xcur[j]-xprev[j]) * (xprev[j]-xprevprev[j]);
@@ -391,7 +391,7 @@ nlopt_result mma_minimize(unsigned n, nlopt_func f, void *f_data,
                    }
               }
               for (j = 0; j < MIN(mma_verbose, n); ++j)
-                   printf("                 MMA sigma[%d] -> %g\n", 
+                   printf("                 MMA sigma[%u] -> %g\n", 
                           j, sigma[j]);
          }
      }

diff --git a/test/testfuncs.c b/test/testfuncs.c
index 74237a2b2b66b14796db9d76619e121cc384c091..7e498fe27abdca25a54a374ce35407f9eadc17f1 100644 (file)
--- a/test/testfuncs.c
+++ b/test/testfuncs.c
@@ -72,7 +72,7 @@ static double boxbetts_f(unsigned n, const double *x, double *grad, void *data)
      for (i = 1; i <= 10; ++i) {
          double e0 = exp(-0.1*i*x[0]);
          double e1 = exp(-0.1*i*x[1]);
-         double e2 = exp(-0.1*i) - exp((double) -i);
+         double e2 = exp(-0.1*i) - exp(-1.0*i);
          double g = e0 - e1 - e2 * x[2];
          f += sqr(g);
          if (grad) {
@@ -140,12 +140,12 @@ static const double grosenbrock_xmin[30] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 static double goldsteinprice_f(unsigned n, const double *x, double *grad, void *data)
 {
      double x0, x1, a1, a12, a2, b1, b12, b2;
-     UNUSED(data);
      x0 = x[0]; x1 = x[1];
      a1 = x0+x1+1; a12 = sqr(a1);
      a2 = 19 - 14*x0 + 3*x0*x0 - 14*x1 + 6*x0*x1 + 3*x1*x1;
      b1 = 2*x0-3*x1; b12 = sqr(b1);
      b2 = 18 - 32*x0 + 12*x0*x0 + 48*x1 - 36*x0*x1 + 27*x1*x1;
+     UNUSED(data);
      if (grad) {
          grad[0] = (1 + a12 * a2) * (2 * b1 * 2 * b2
                                      + b12 * (-32 + 24*x0 - 36*x1))
@@ -177,8 +177,8 @@ static double shekel_f(unsigned n, const double *x, double *grad, void *data)
      static const double c[10] = {.1,.2,.2,.4,.4,.6,.3,.7,.5,.5};
      unsigned i;
      double f = 0;
-     if (grad) for (i = 0; i < n; ++i) grad[i] = 0;
      unsigned m = *((unsigned *) data);
+     if (grad) for (i = 0; i < n; ++i) grad[i] = 0;
      for (i = 0; i < m; ++i) {
          double fi = 1.0 / (c[i]
                             + sqr(x[0]-A[i][0])
@@ -206,10 +206,10 @@ static const double shekel2_xmin[4] = {4.000746531,4.000592935,3.999663399,3.999
 /****************************************************************************/
 static double levy_f(unsigned n, const double *x, double *grad, void *data)
 {
-     UNUSED(data);
      unsigned i;
      double a = x[n-1] - 1, b = 1 + sqr(sin(PI2*x[n-1]));
      double f = sqr(sin(PI3*x[0])) + a * b;
+     UNUSED(data);
      if (grad) {
          for (i = 0; i < n; ++i) grad[i] = 0;
          grad[0] = 2 * PI3 * sin(PI3*x[0]) * cos(PI3*x[0]);
@@ -310,9 +310,9 @@ static const double branin_xmin[2] = {1,0};
 /****************************************************************************/
 static double shubert_f(unsigned n, const double *x, double *grad, void *data)
 {
-     UNUSED(data);
      unsigned i, j;
      double f = 0;
+     UNUSED(data);
      for (j = 1; j <= 5; ++j)
          for (i = 0; i < n; ++i)
               f -= j * sin((j+1) * x[i] + j);
@@ -373,10 +373,10 @@ static const double osc1d_xmin[1] = {1.23456789};
 /****************************************************************************/
 static double corner4d_f(unsigned n, const double *x, double *grad, void *data)
 {
-     UNUSED(data);
-     UNUSED(n);
      double u = x[0] + x[1] * x[2] * sin(2 * x[3]);
      double v = x[0] + 2*sin(u);
+     UNUSED(data);
+     UNUSED(n);
      if (grad) {
          grad[0] = 2*v * (1 + 2*cos(u));
          grad[1] = 2*v * 2*cos(u) * x[2] * sin(2*x[3]) + 0.1;
@@ -393,10 +393,10 @@ static const double corner4d_xmin[4] = {0,0,0,0};
 /****************************************************************************/
 static double side4d_f(unsigned n, const double *x, double *grad, void *data)
 {
-     UNUSED(data);
-     UNUSED(n);
      double x0, x1, x2, x3, d0,d1,d2,d3;
      const double w0 = 0.1, w1 = 0.2, w2 = 0.3, w3 = 0.4;
+     UNUSED(data);
+     UNUSED(n);
      x0 = +0.4977 * x[0] - 0.3153 * x[1] - 0.5066 * x[2] - 0.4391 * x[3];
      x1 = -0.3153 * x[0] + 0.3248 * x[1] - 0.4382 * x[2] - 0.4096 * x[3];
      x2 = -0.5066 * x[0] - 0.4382 * x[1] + 0.3807 * x[2] - 0.4543 * x[3];

diff --git a/util/redblack_test.c b/util/redblack_test.c
index 2d06fd4445cccff7c323fbf39e053a15e1d77b30..6f1b35b2f4fed2d546c6420f6944e7ac30a69627 100644 (file)
--- a/util/redblack_test.c
+++ b/util/redblack_test.c
@@ -149,12 +149,13 @@ int main(int argc, char **argv)
          
      for (i = 0; i < N; ++i) {
          rb_node *le, *gt;
+         double lek, gtk;
          kd = 0.01 * (rand() % (N * 150) - N*25);
          le = rb_tree_find_le(&t, &kd);
          gt = rb_tree_find_gt(&t, &kd);
          n = rb_tree_min(&t);
-         double lek = le ? le->k[0] : -HUGE_VAL;
-         double gtk = gt ? gt->k[0] : +HUGE_VAL;
+         lek = le ? le->k[0] : -HUGE_VAL;
+         gtk = gt ? gt->k[0] : +HUGE_VAL;
          printf("%g <= %g < %g\n", lek, kd, gtk);
          if (n->k[0] > kd) {
               if (le) {