From 3a631907275e96783562e6453e96f433a68e8a69 Mon Sep 17 00:00:00 2001 From: stevenj Date: Fri, 13 Aug 2010 13:35:48 -0400 Subject: [PATCH] max/min macros are already defined(!) by stdlib.h(!) in visual studio; thanks to Benoit Scherrer for the report about the compiler warning darcs-hash:20100813173548-c8de0-f0815042dc233cd3279c81517ffdaf9ef247d7e5.gz --- bobyqa/bobyqa.c | 118 +++++++++++++++++++++++----------------------- cobyla/cobyla.c | 69 +++++++++++++-------------- luksan/mssubs.c | 4 +- luksan/plip.c | 28 +++++------ luksan/plis.c | 34 ++++++------- luksan/pnet.c | 36 +++++++------- luksan/pssubs.c | 66 +++++++++++++------------- newuoa/newuoa.c | 30 ++++++------ slsqp/slsqp.c | 64 ++++++++++++------------- subplex/subplex.c | 57 +++++++++++----------- 10 files changed, 252 insertions(+), 254 deletions(-) diff --git a/bobyqa/bobyqa.c b/bobyqa/bobyqa.c index 9c3a8b7..c4ddaf0 100644 --- a/bobyqa/bobyqa.c +++ b/bobyqa/bobyqa.c @@ -11,9 +11,9 @@ typedef double (*bobyqa_func)(int n, const double *x, void *func_data); -#define min(a,b) ((a) <= (b) ? (a) : (b)) -#define max(a,b) ((a) >= (b) ? (a) : (b)) -#define iabs(x) ((x) < 0 ? -(x) : (x)) +#define MIN2(a,b) ((a) <= (b) ? (a) : (b)) +#define MAX2(a,b) ((a) >= (b) ? (a) : (b)) +#define IABS(x) ((x) < 0 ? -(x) : (x)) static void update_(int *n, int *npt, double *bmat, double *zmat, int *ndim, double *vlag, double *beta, @@ -63,7 +63,7 @@ static void update_(int *n, int *npt, double *bmat, /* L10: */ /* Computing MAX */ d__2 = ztest, d__3 = (d__1 = zmat[k + j * zmat_dim1], fabs(d__1)); - ztest = max(d__2,d__3); + ztest = MAX2(d__2,d__3); } } ztest *= 1e-20; @@ -264,7 +264,7 @@ static nlopt_result rescue_(int *n, int *npt, const double *xl, const double *xu } sumpq += pq[k]; w[*ndim + k] = distsq; - winc = max(winc,distsq); + winc = MAX2(winc,distsq); i__2 = nptm; for (j = 1; j <= i__2; ++j) { /* L20: */ @@ -303,10 +303,10 @@ static nlopt_result rescue_(int *n, int *npt, const double *xl, const double *xu xopt[j] = zero; /* Computing MIN */ d__1 = *delta, d__2 = su[j]; - ptsaux[(j << 1) + 1] = min(d__1,d__2); + ptsaux[(j << 1) + 1] = MIN2(d__1,d__2); /* Computing MAX */ d__1 = -(*delta), d__2 = sl[j]; - ptsaux[(j << 1) + 2] = max(d__1,d__2); + ptsaux[(j << 1) + 2] = MAX2(d__1,d__2); if (ptsaux[(j << 1) + 1] + ptsaux[(j << 1) + 2] < zero) { temp = ptsaux[(j << 1) + 1]; ptsaux[(j << 1) + 1] = ptsaux[(j << 1) + 2]; @@ -571,7 +571,7 @@ L120: /* Computing 2nd power */ d__3 = vlag[k]; d__1 = vlmxsq, d__2 = d__3 * d__3; - vlmxsq = max(d__1,d__2); + vlmxsq = MAX2(d__1,d__2); } if (denom <= vlmxsq * .01) { w[*ndim + knew] = -w[*ndim + knew] - winc; @@ -638,7 +638,7 @@ L260: ihq = (iq + iq * iq) / 2; vquad += xq * (gopt[iq] + half * xq * hq[ihq]); if (ip > 0) { - iw = max(ihp,ihq) - (i__3 = ip - iq, iabs(i__3)); + iw = MAX2(ihp,ihq) - (i__3 = ip - iq, IABS(i__3)); vquad += xp * xq * hq[iw]; } } @@ -664,8 +664,8 @@ L260: /* Computing MIN */ /* Computing MAX */ d__3 = xl[i__], d__4 = xbase[i__] + xpt[kpt + i__ * xpt_dim1]; - d__1 = max(d__3,d__4), d__2 = xu[i__]; - w[i__] = min(d__1,d__2); + d__1 = MAX2(d__3,d__4), d__2 = xu[i__]; + w[i__] = MIN2(d__1,d__2); if (xpt[kpt + i__ * xpt_dim1] == sl[i__]) { w[i__] = xl[i__]; } @@ -725,7 +725,7 @@ L260: /* Computing 2nd power */ d__1 = ptsaux[(iq << 1) + 1]; hq[ihq] += temp * (d__1 * d__1); - iw = max(ihp,ihq) - (i__2 = iq - ip, iabs(i__2)); + iw = MAX2(ihp,ihq) - (i__2 = iq - ip, IABS(i__2)); hq[iw] += temp * ptsaux[(ip << 1) + 1] * ptsaux[(iq << 1) + 1]; } @@ -887,7 +887,7 @@ static void altmov_(int *n, int *npt, double *xpt, slbd = -subd; ilbd = 0; iubd = 0; - sumin = min(one,subd); + sumin = MIN2(one,subd); /* Revise SLBD and SUBD if necessary because of the bounds in SL and SU. */ @@ -902,7 +902,7 @@ static void altmov_(int *n, int *npt, double *xpt, if (subd * temp > su[i__] - xopt[i__]) { /* Computing MAX */ d__1 = sumin, d__2 = (su[i__] - xopt[i__]) / temp; - subd = max(d__1,d__2); + subd = MAX2(d__1,d__2); iubd = i__; } } else if (temp < zero) { @@ -913,7 +913,7 @@ static void altmov_(int *n, int *npt, double *xpt, if (subd * temp < sl[i__] - xopt[i__]) { /* Computing MAX */ d__1 = sumin, d__2 = (sl[i__] - xopt[i__]) / temp; - subd = max(d__1,d__2); + subd = MAX2(d__1,d__2); iubd = -i__; } } @@ -991,8 +991,8 @@ L80: /* Computing MAX */ /* Computing MIN */ d__3 = su[i__]; - d__1 = sl[i__], d__2 = min(d__3,temp); - xnew[i__] = max(d__1,d__2); + d__1 = sl[i__], d__2 = MIN2(d__3,temp); + xnew[i__] = MAX2(d__1,d__2); } if (ibdsav < 0) { xnew[-ibdsav] = sl[-ibdsav]; @@ -1015,10 +1015,10 @@ L100: w[i__] = zero; /* Computing MIN */ d__1 = xopt[i__] - sl[i__], d__2 = glag[i__]; - tempa = min(d__1,d__2); + tempa = MIN2(d__1,d__2); /* Computing MAX */ d__1 = xopt[i__] - su[i__], d__2 = glag[i__]; - tempb = max(d__1,d__2); + tempb = MAX2(d__1,d__2); if (tempa > zero || tempb < zero) { w[i__] = bigstp; /* Computing 2nd power */ @@ -1078,8 +1078,8 @@ L120: /* Computing MAX */ /* Computing MIN */ d__3 = su[i__], d__4 = xopt[i__] + w[i__]; - d__1 = sl[i__], d__2 = min(d__3,d__4); - xalt[i__] = max(d__1,d__2); + d__1 = sl[i__], d__2 = MIN2(d__3,d__4); + xalt[i__] = MAX2(d__1,d__2); } else if (w[i__] == zero) { xalt[i__] = xopt[i__]; } else if (glag[i__] > zero) { @@ -1120,8 +1120,8 @@ L120: /* Computing MAX */ /* Computing MIN */ d__3 = su[i__]; - d__1 = sl[i__], d__2 = min(d__3,temp); - xalt[i__] = max(d__1,d__2); + d__1 = sl[i__], d__2 = MIN2(d__3,temp); + xalt[i__] = MAX2(d__1,d__2); } /* Computing 2nd power */ d__1 = half * gw * scale; @@ -1352,7 +1352,7 @@ L50: if (shs > zero) { /* Computing MIN */ d__1 = blen, d__2 = gredsq / shs; - stplen = min(d__1,d__2); + stplen = MIN2(d__1,d__2); } /* Reduce STPLEN if necessary in order to preserve the simple bounds, */ @@ -1383,7 +1383,7 @@ L50: ++iterc; temp = shs / stepsq; if (iact == 0 && temp > zero) { - *crvmin = min(*crvmin,temp); + *crvmin = MIN2(*crvmin,temp); if (*crvmin == onemin) { *crvmin = temp; } @@ -1403,7 +1403,7 @@ L50: } /* Computing MAX */ d__1 = stplen * (ggsav - half * stplen * shs); - sdec = max(d__1,zero); + sdec = MAX2(d__1,zero); qred += sdec; } @@ -1643,8 +1643,8 @@ L190: /* Computing MAX */ /* Computing MIN */ d__3 = xopt[i__] + d__[i__], d__4 = su[i__]; - d__1 = min(d__3,d__4), d__2 = sl[i__]; - xnew[i__] = max(d__1,d__2); + d__1 = MIN2(d__3,d__4), d__2 = sl[i__]; + xnew[i__] = MAX2(d__1,d__2); if (xbdi[i__] == onemin) { xnew[i__] = sl[i__]; } @@ -1837,12 +1837,12 @@ L50: if (sl[nfx] == zero) { /* Computing MIN */ d__1 = two * *rhobeg, d__2 = su[nfx]; - stepb = min(d__1,d__2); + stepb = MIN2(d__1,d__2); } if (su[nfx] == zero) { /* Computing MAX */ d__1 = -two * *rhobeg, d__2 = sl[nfx]; - stepb = max(d__1,d__2); + stepb = MAX2(d__1,d__2); } xpt[nf + nfx * xpt_dim1] = stepb; } @@ -1867,8 +1867,8 @@ L50: /* Computing MIN */ /* Computing MAX */ d__3 = xl[j], d__4 = xbase[j] + xpt[nf + j * xpt_dim1]; - d__1 = max(d__3,d__4), d__2 = xu[j]; - x[j] = min(d__1,d__2); + d__1 = MAX2(d__3,d__4), d__2 = xu[j]; + x[j] = MIN2(d__1,d__2); if (xpt[nf + j * xpt_dim1] == sl[j]) { x[j] = xl[j]; } @@ -2155,7 +2155,7 @@ L60: &w[np + (*n << 1)], &w[np + *n * 3], &dsq, &crvmin); /* Computing MIN */ d__1 = delta, d__2 = sqrt(dsq); - dnorm = min(d__1,d__2); + dnorm = MIN2(d__1,d__2); if (dnorm < half * rho) { ntrits = -1; /* Computing 2nd power */ @@ -2172,8 +2172,8 @@ L60: /* of likely improvements to the model within distance HALF*RHO of XOPT. */ /* Computing MAX */ - d__1 = max(diffa,diffb); - errbig = max(d__1,diffc); + d__1 = MAX2(diffa,diffb); + errbig = MAX2(d__1,diffc); frhosq = rho * .125 * rho; if (crvmin > zero && errbig > frhosq * crvmin) { goto L650; @@ -2525,7 +2525,7 @@ L230: /* Computing 2nd power */ d__3 = distsq / delsq; d__1 = one, d__2 = d__3 * d__3; - temp = max(d__1,d__2); + temp = MAX2(d__1,d__2); if (temp * den > scaden) { scaden = temp * den; knew = k; @@ -2535,7 +2535,7 @@ L230: /* Computing 2nd power */ d__3 = vlag[k]; d__1 = biglsq, d__2 = temp * (d__3 * d__3); - biglsq = max(d__1,d__2); + biglsq = MAX2(d__1,d__2); L350: ; } @@ -2563,8 +2563,8 @@ L360: /* Computing MIN */ /* Computing MAX */ d__3 = xl[i__], d__4 = xbase[i__] + xnew[i__]; - d__1 = max(d__3,d__4), d__2 = xu[i__]; - x[i__] = min(d__1,d__2); + d__1 = MAX2(d__3,d__4), d__2 = xu[i__]; + x[i__] = MIN2(d__1,d__2); if (xnew[i__] == sl[i__]) { x[i__] = xl[i__]; } @@ -2641,15 +2641,15 @@ L360: if (ratio <= tenth) { /* Computing MIN */ d__1 = half * delta; - delta = min(d__1,dnorm); + delta = MIN2(d__1,dnorm); } else if (ratio <= .7) { /* Computing MAX */ d__1 = half * delta; - delta = max(d__1,dnorm); + delta = MAX2(d__1,dnorm); } else { /* Computing MAX */ d__1 = half * delta, d__2 = dnorm + dnorm; - delta = max(d__1,d__2); + delta = MAX2(d__1,d__2); } if (delta <= rho * 1.5) { delta = rho; @@ -2689,7 +2689,7 @@ L360: /* Computing 2nd power */ d__3 = distsq / delsq; d__1 = one, d__2 = d__3 * d__3; - temp = max(d__1,d__2); + temp = MAX2(d__1,d__2); if (temp * den > scaden) { scaden = temp * den; knew = k; @@ -2700,7 +2700,7 @@ L360: /* Computing 2nd power */ d__3 = vlag[k]; d__1 = biglsq, d__2 = temp * (d__3 * d__3); - biglsq = max(d__1,d__2); + biglsq = MAX2(d__1,d__2); } if (scaden <= half * biglsq) { knew = ksav; @@ -2875,19 +2875,19 @@ L360: /* Computing MIN */ d__2 = zero, d__3 = gopt[i__]; /* Computing 2nd power */ - d__1 = min(d__2,d__3); + d__1 = MIN2(d__2,d__3); gqsq += d__1 * d__1; /* Computing 2nd power */ - d__1 = min(zero,sum); + d__1 = MIN2(zero,sum); gisq += d__1 * d__1; } else if (xopt[i__] == su[i__]) { /* Computing MAX */ d__2 = zero, d__3 = gopt[i__]; /* Computing 2nd power */ - d__1 = max(d__2,d__3); + d__1 = MAX2(d__2,d__3); gqsq += d__1 * d__1; /* Computing 2nd power */ - d__1 = max(zero,sum); + d__1 = MAX2(zero,sum); gisq += d__1 * d__1; } else { /* Computing 2nd power */ @@ -2907,7 +2907,7 @@ L360: itest = 0; } if (itest >= 3) { - i__1 = max(*npt,nh); + i__1 = MAX2(*npt,nh); for (i__ = 1; i__ <= i__1; ++i__) { if (i__ <= *n) { gopt[i__] = vlag[*npt + i__]; @@ -2944,7 +2944,7 @@ L360: /* Computing 2nd power */ d__4 = ten * rho; d__1 = d__3 * d__3, d__2 = d__4 * d__4; - distsq = max(d__1,d__2); + distsq = MAX2(d__1,d__2); L650: knew = 0; i__1 = *npt; @@ -2975,7 +2975,7 @@ L650: if (ntrits == -1) { /* Computing MIN */ d__1 = tenth * delta, d__2 = half * dist; - delta = min(d__1,d__2); + delta = MIN2(d__1,d__2); if (delta <= rho * 1.5) { delta = rho; } @@ -2984,8 +2984,8 @@ L650: /* Computing MAX */ /* Computing MIN */ d__2 = tenth * dist; - d__1 = min(d__2,delta); - adelt = max(d__1,rho); + d__1 = MIN2(d__2,delta); + adelt = MAX2(d__1,rho); dsq = adelt * adelt; goto L90; } @@ -2995,7 +2995,7 @@ L650: if (ratio > zero) { goto L60; } - if (max(delta,dnorm) > rho) { + if (MAX2(delta,dnorm) > rho) { goto L60; } @@ -3013,7 +3013,7 @@ L680: } else { rho = tenth * rho; } - delta = max(delta,rho); + delta = MAX2(delta,rho); ntrits = 0; nfsav = stop->nevals; goto L60; @@ -3038,8 +3038,8 @@ L720: /* Computing MIN */ /* Computing MAX */ d__3 = xl[i__], d__4 = xbase[i__] + xopt[i__]; - d__1 = max(d__3,d__4), d__2 = xu[i__]; - x[i__] = min(d__1,d__2); + d__1 = MAX2(d__3,d__4), d__2 = xu[i__]; + x[i__] = MIN2(d__1,d__2); if (xopt[i__] == sl[i__]) { x[i__] = xl[i__]; } @@ -3230,7 +3230,7 @@ nlopt_result bobyqa(int n, int npt, double *x, w[jsl] = -(rhobeg); /* Computing MAX */ d__1 = xu[j] - x[j]; - w[jsu] = max(d__1,rhobeg); + w[jsu] = MAX2(d__1,rhobeg); } } else if (w[jsu] <= rhobeg) { if (w[jsu] <= zero) { @@ -3241,7 +3241,7 @@ nlopt_result bobyqa(int n, int npt, double *x, x[j] = xu[j] - rhobeg; /* Computing MIN */ d__1 = xl[j] - x[j], d__2 = -(rhobeg); - w[jsl] = min(d__1,d__2); + w[jsl] = MIN2(d__1,d__2); w[jsu] = rhobeg; } } diff --git a/cobyla/cobyla.c b/cobyla/cobyla.c index 71916f0..64c605f 100644 --- a/cobyla/cobyla.c +++ b/cobyla/cobyla.c @@ -54,9 +54,8 @@ static char const rcsid[] = problem */ #define ENFORCE_BOUNDS 1 -#define min(a,b) ((a) <= (b) ? (a) : (b)) -#define max(a,b) ((a) >= (b) ? (a) : (b)) -#define abs(x) ((x) >= 0 ? (x) : -(x)) +#define MIN2(a,b) ((a) <= (b) ? (a) : (b)) +#define MAX2(a,b) ((a) >= (b) ? (a) : (b)) #define U(n) ((unsigned) (n)) @@ -511,7 +510,7 @@ static nlopt_result cobylb(int *n, int *m, int *mpp, --lb; --ub; /* Function Body */ - iptem = min(*n,4); + iptem = MIN2(*n,4); iptemp = iptem + 1; np = *n + 1; mp = *m + 1; @@ -583,7 +582,7 @@ L40: i__1 = *m; for (k = 1; k <= i__1; ++k) { d__1 = resmax, d__2 = -con[k]; - resmax = max(d__1,d__2); + resmax = MAX2(d__1,d__2); if (d__2 > state->con_tol[k-1]) feasible = 0; /* SGJ, 2010 */ } @@ -737,8 +736,8 @@ L140: for (k = 1; k <= i__3; ++k) if (sim[k + j * sim_dim1] != 0) { temp += simi[i__ + k * simi_dim1] * sim[k + j * sim_dim1]; } - d__1 = error, d__2 = abs(temp); - error = max(d__1,d__2); + d__1 = error, d__2 = fabs(temp); + error = MAX2(d__1,d__2); } } if (error > .1) { @@ -843,9 +842,9 @@ L140: if (k < mp) { temp = datmat[k + np * datmat_dim1]; d__1 = cvmaxp, d__2 = -sum - temp; - cvmaxp = max(d__1,d__2); + cvmaxp = MAX2(d__1,d__2); d__1 = cvmaxm, d__2 = sum - temp; - cvmaxm = max(d__1,d__2); + cvmaxm = MAX2(d__1,d__2); } } dxsign = 1.; @@ -951,7 +950,7 @@ L370: sum -= a[i__ + k * a_dim1] * dx[i__]; } if (k < mp) { - resnew = max(resnew,sum); + resnew = MAX2(resnew,sum); } } @@ -1025,7 +1024,7 @@ L440: for (i__ = 1; i__ <= i__2; ++i__) { temp += simi[j + i__ * simi_dim1] * dx[i__]; } - temp = abs(temp); + temp = fabs(temp); if (temp > ratio) { jdrop = j; ratio = temp; @@ -1147,16 +1146,16 @@ L550: i__2 = *n; for (i__ = 1; i__ <= i__2; ++i__) { d__1 = cmin, d__2 = datmat[k + i__ * datmat_dim1]; - cmin = min(d__1,d__2); + cmin = MIN2(d__1,d__2); d__1 = cmax, d__2 = datmat[k + i__ * datmat_dim1]; - cmax = max(d__1,d__2); + cmax = MAX2(d__1,d__2); } if (k <= *m && cmin < cmax * .5) { - temp = max(cmax,0.) - cmin; + temp = MAX2(cmax,0.) - cmin; if (denom <= 0.) { denom = temp; } else { - denom = min(denom,temp); + denom = MIN2(denom,temp); } } } @@ -1406,10 +1405,10 @@ L100: for (i__ = 1; i__ <= i__1; ++i__) { temp = z__[i__ + k * z_dim1] * dxnew[i__]; sp += temp; - spabs += abs(temp); + spabs += fabs(temp); } - acca = spabs + abs(sp) * .1; - accb = spabs + abs(sp) * .2; + acca = spabs + fabs(sp) * .1; + accb = spabs + fabs(sp) * .2; if (spabs >= acca || acca >= accb) { sp = 0.; } @@ -1461,10 +1460,10 @@ L130: for (i__ = 1; i__ <= i__1; ++i__) { temp = z__[i__ + k * z_dim1] * dxnew[i__]; zdotv += temp; - zdvabs += abs(temp); + zdvabs += fabs(temp); } - acca = zdvabs + abs(zdotv) * .1; - accb = zdvabs + abs(zdotv) * .2; + acca = zdvabs + fabs(zdotv) * .1; + accb = zdvabs + fabs(zdotv) * .2; if (zdvabs < acca && acca < accb) { temp = zdotv / zdota[k]; if (temp > 0. && iact[k] <= *m) { @@ -1500,7 +1499,7 @@ L130: i__1 = nact; for (k = 1; k <= i__1; ++k) { d__1 = 0., d__2 = vmultc[k] - ratio * vmultd[k]; - vmultc[k] = max(d__1,d__2); + vmultc[k] = MAX2(d__1,d__2); } if (icon < nact) { isave = iact[icon]; @@ -1681,7 +1680,7 @@ L340: ss = 0.; i__1 = *n; for (i__ = 1; i__ <= i__1; ++i__) { - if ((d__1 = dx[i__], abs(d__1)) >= *rho * 1e-6f) { + if ((d__1 = dx[i__], fabs(d__1)) >= *rho * 1e-6f) { d__2 = dx[i__]; dd -= d__2 * d__2; } @@ -1693,7 +1692,7 @@ L340: goto L490; } temp = sqrt(ss * dd); - if (abs(sd) >= temp * 1e-6f) { + if (fabs(sd) >= temp * 1e-6f) { temp = sqrt(ss * dd + sd * sd); } stpful = dd / (temp + sd); @@ -1704,7 +1703,7 @@ L340: if (step >= acca || acca >= accb) { goto L480; } - step = min(step,resmax); + step = MIN2(step,resmax); } /* SGJ, 2010: check for error here */ @@ -1730,7 +1729,7 @@ L340: for (i__ = 1; i__ <= i__2; ++i__) { temp -= a[i__ + kk * a_dim1] * dxnew[i__]; } - resmax = max(resmax,temp); + resmax = MAX2(resmax,temp); } } @@ -1747,10 +1746,10 @@ L390: for (i__ = 1; i__ <= i__1; ++i__) { temp = z__[i__ + k * z_dim1] * dxnew[i__]; zdotw += temp; - zdwabs += abs(temp); + zdwabs += fabs(temp); } - acca = zdwabs + abs(zdotw) * .1; - accb = zdwabs + abs(zdotw) * .2; + acca = zdwabs + fabs(zdotw) * .1; + accb = zdwabs + fabs(zdotw) * .2; if (zdwabs >= acca || acca >= accb) { zdotw = 0.; } @@ -1766,7 +1765,7 @@ L390: } if (mcon > *m) { d__1 = 0., d__2 = vmultd[nact]; - vmultd[nact] = max(d__1,d__2); + vmultd[nact] = MAX2(d__1,d__2); } /* Complete VMULTC by finding the new constraint residuals. */ @@ -1781,15 +1780,15 @@ L390: for (k = kl; k <= i__1; ++k) { kk = iact[k]; sum = resmax - b[kk]; - sumabs = resmax + (d__1 = b[kk], abs(d__1)); + sumabs = resmax + (d__1 = b[kk], fabs(d__1)); i__2 = *n; for (i__ = 1; i__ <= i__2; ++i__) { temp = a[i__ + kk * a_dim1] * dxnew[i__]; sum += temp; - sumabs += abs(temp); + sumabs += fabs(temp); } - acca = sumabs + abs(sum) * .1f; - accb = sumabs + abs(sum) * .2f; + acca = sumabs + fabs(sum) * .1f; + accb = sumabs + fabs(sum) * .2f; if (sumabs >= acca || acca >= accb) { sum = 0.f; } @@ -1822,7 +1821,7 @@ L390: i__1 = mcon; for (k = 1; k <= i__1; ++k) { d__1 = 0., d__2 = temp * vmultc[k] + ratio * vmultd[k]; - vmultc[k] = max(d__1,d__2); + vmultc[k] = MAX2(d__1,d__2); } if (mcon == *m) { resmax = resold + ratio * (resmax - resold); diff --git a/luksan/mssubs.c b/luksan/mssubs.c index 0d2cd14..aa464af 100644 --- a/luksan/mssubs.c +++ b/luksan/mssubs.c @@ -1,7 +1,7 @@ #include #include "luksan.h" -#define max(a,b) ((a) > (b) ? (a) : (b)) +#define MAX2(a,b) ((a) > (b) ? (a) : (b)) #define iabs(a) ((a) < 0 ? -(a) : (a)) /* subroutines extracted from mssubs.for */ @@ -34,7 +34,7 @@ double luksan_mxvmax__(int *n, double *x) for (i__ = 1; i__ <= i__1; ++i__) { /* Computing MAX */ d__2 = mxvmax, d__3 = (d__1 = x[i__], fabs(d__1)); - mxvmax = max(d__2,d__3); + mxvmax = MAX2(d__2,d__3); /* L1: */ } return mxvmax; diff --git a/luksan/plip.c b/luksan/plip.c index 09b735d..c7aef14 100644 --- a/luksan/plip.c +++ b/luksan/plip.c @@ -4,8 +4,8 @@ #include #include "luksan.h" -#define max(a,b) ((a) > (b) ? (a) : (b)) -#define min(a,b) ((a) < (b) ? (a) : (b)) +#define MAX2(a,b) ((a) > (b) ? (a) : (b)) +#define MIN2(a,b) ((a) < (b) ? (a) : (b)) /* *********************************************************************** */ /* SUBROUTINE PLIP ALL SYSTEMS 01/09/22 */ @@ -299,7 +299,7 @@ L11130: if (irest > 0) { nn = 0; par = 1.; - ld = min(ld,1); + ld = MIN2(ld,1); if (kit < stat_1->nit) { ++stat_1->nres; kit = stat_1->nit; @@ -340,14 +340,14 @@ L11130: /* TEST ON DESCENT DIRECTION */ if (snorm <= 0.) { - irest = max(irest,1); + irest = MAX2(irest,1); } else if (p + told * gnorm * snorm <= 0.) { irest = 0; } else { /* UNIFORM DESCENT CRITERION */ - irest = max(irest,1); + irest = MAX2(irest,1); } if (irest == 0) { @@ -357,7 +357,7 @@ L11130: rmin = alf1 * gnorm / snorm; /* Computing MIN */ d__1 = alf2 * gnorm / snorm, d__2 = *xmax / snorm; - rmax = min(d__1,d__2); + rmax = MIN2(d__1,d__2); } } if (*iterm != 0) { @@ -393,7 +393,7 @@ L11174: p = po; luksan_mxvcop__(nf, &xo[1], &x[1]); luksan_mxvcop__(nf, &go[1], &gf[1]); - irest = max(irest,1); + irest = MAX2(irest,1); ld = kd; goto L11130; } @@ -411,7 +411,7 @@ L11174: } L11175: if (iterh != 0) { - irest = max(irest,1); + irest = MAX2(irest,1); } if (kbf > 0) { luksan_pyadc0__(nf, &n, &x[1], &ix[1], &xl[1], &xu[1], &inew); @@ -451,13 +451,13 @@ nlopt_result luksan_plip(int n, nlopt_func f, void *f_data, and we'll assume that the main limiting factor is the memory. We'll assume that at least MEMAVAIL memory, or 4*n memory, whichever is bigger, is available. */ - mf = max(MEMAVAIL/n, 4); + mf = MAX2(MEMAVAIL/n, 4); if (stop->maxeval && stop->maxeval <= mf) - mf = max(stop->maxeval - 5, 1); /* mf > maxeval seems not good */ + mf = MAX2(stop->maxeval - 5, 1); /* mf > maxeval seems not good */ retry_alloc: - work = (double*) malloc(sizeof(double) * (n * 7 + max(n,n*mf) + - max(n,mf)*2)); + work = (double*) malloc(sizeof(double) * (n * 7 + MAX2(n,n*mf) + + MAX2(n,mf)*2)); if (!work) { if (mf > 0) { mf = 0; /* allocate minimal memory */ @@ -470,7 +470,7 @@ nlopt_result luksan_plip(int n, nlopt_func f, void *f_data, xl = work; xu = xl + n; gf = xu + n; s = gf + n; xo = s + n; go = xo + n; so = go + n; xm = so + n; - xr = xm + max(n*mf,n); gr = xr + max(n,mf); + xr = xm + MAX2(n*mf,n); gr = xr + MAX2(n,mf); for (i = 0; i < n; ++i) { int lbu = lb[i] <= -0.99 * HUGE_VAL; /* lb unbounded */ @@ -484,7 +484,7 @@ nlopt_result luksan_plip(int n, nlopt_func f, void *f_data, original Fortran code, but it is used upon input to plip if mf > 0 ... perhaps ALLOCATE initializes arrays to zero by default? */ - memset(xo, 0, sizeof(double) * max(n,n*mf)); + memset(xo, 0, sizeof(double) * MAX2(n,n*mf)); plip_(&n, &nb, x, ix, xl, xu, gf, s, xo, go, so, xm, xr, gr, diff --git a/luksan/plis.c b/luksan/plis.c index 8e4c0e6..9258953 100644 --- a/luksan/plis.c +++ b/luksan/plis.c @@ -4,8 +4,8 @@ #include #include "luksan.h" -#define max(a,b) ((a) > (b) ? (a) : (b)) -#define min(a,b) ((a) < (b) ? (a) : (b)) +#define MAX2(a,b) ((a) > (b) ? (a) : (b)) +#define MIN2(a,b) ((a) < (b) ? (a) : (b)) /* *********************************************************************** */ /* SUBROUTINE PLIS ALL SYSTEMS 01/09/22 */ @@ -287,9 +287,9 @@ L11130: } /* Computing MIN */ i__1 = stat_1->nit - kit; - k = min(i__1,*mf); + k = MIN2(i__1,*mf); if (k <= 0) { - irest = max(irest,1); + irest = MAX2(irest,1); goto L12620; } @@ -297,7 +297,7 @@ L11130: b = luksan_mxudot__(nf, &xo[1], &go[1], &ix[1], &kbf); if (b <= 0.) { - irest = max(irest,1); + irest = MAX2(irest,1); goto L12620; } uo[1] = 1. / b; @@ -314,7 +314,7 @@ L11130: snorm = sqrt(luksan_mxudot__(nf, &s[1], &s[1], &ix[1], &kbf)); /* Computing MIN */ i__1 = k + 1; - k = min(i__1,*mf); + k = MIN2(i__1,*mf); luksan_mxdrsu__(nf, &k, &xo[1], &go[1], &uo[1]); L12620: iterd = 0; @@ -347,14 +347,14 @@ L12620: /* TEST ON DESCENT DIRECTION */ if (snorm <= 0.) { - irest = max(irest,1); + irest = MAX2(irest,1); } else if (p + told * gnorm * snorm <= 0.) { irest = 0; } else { /* UNIFORM DESCENT CRITERION */ - irest = max(irest,1); + irest = MAX2(irest,1); } if (irest == 0) { @@ -364,7 +364,7 @@ L12620: rmin = alf1 * gnorm / snorm; /* Computing MIN */ d__1 = alf2 * gnorm / snorm, d__2 = *xmax / snorm; - rmax = min(d__1,d__2); + rmax = MIN2(d__1,d__2); } } if (*iterm != 0) { @@ -400,7 +400,7 @@ L11174: p = po; luksan_mxvcop__(nf, &xo[1], &x[1]); luksan_mxvcop__(nf, &go[1], &gf[1]); - irest = max(irest,1); + irest = MAX2(irest,1); ld = kd; goto L11130; } @@ -446,13 +446,13 @@ nlopt_result luksan_plis(int n, nlopt_func f, void *f_data, and we'll assume that the main limiting factor is the memory. We'll assume that at least MEMAVAIL memory, or 4*n memory, whichever is bigger, is available. */ - mf = max(MEMAVAIL/n, 4); + mf = MAX2(MEMAVAIL/n, 4); if (stop->maxeval && stop->maxeval <= mf) - mf = max(stop->maxeval - 5, 1); /* mf > maxeval seems not good */ + mf = MAX2(stop->maxeval - 5, 1); /* mf > maxeval seems not good */ retry_alloc: - work = (double*) malloc(sizeof(double) * (n * 4 + max(n,n*mf)*2 + - max(n,mf)*2)); + work = (double*) malloc(sizeof(double) * (n * 4 + MAX2(n,n*mf)*2 + + MAX2(n,mf)*2)); if (!work) { if (mf > 0) { mf = 0; /* allocate minimal memory */ @@ -463,8 +463,8 @@ nlopt_result luksan_plis(int n, nlopt_func f, void *f_data, } xl = work; xu = xl + n; gf = xu + n; s = gf + n; - xo = s + n; go = xo + max(n,n*mf); - uo = go + max(n,n*mf); vo = uo + max(n,mf); + xo = s + n; go = xo + MAX2(n,n*mf); + uo = go + MAX2(n,n*mf); vo = uo + MAX2(n,mf); for (i = 0; i < n; ++i) { int lbu = lb[i] <= -0.99 * HUGE_VAL; /* lb unbounded */ @@ -478,7 +478,7 @@ nlopt_result luksan_plis(int n, nlopt_func f, void *f_data, original Fortran code, but it is used upon input to plis if mf > 0 ... perhaps ALLOCATE initializes arrays to zero by default? */ - memset(xo, 0, sizeof(double) * max(n,n*mf)); + memset(xo, 0, sizeof(double) * MAX2(n,n*mf)); plis_(&n, &nb, x, ix, xl, xu, gf, s, xo, go, uo, vo, diff --git a/luksan/pnet.c b/luksan/pnet.c index 01e84cb..f37195c 100644 --- a/luksan/pnet.c +++ b/luksan/pnet.c @@ -4,8 +4,8 @@ #include #include "luksan.h" -#define max(a,b) ((a) > (b) ? (a) : (b)) -#define min(a,b) ((a) < (b) ? (a) : (b)) +#define MAX2(a,b) ((a) > (b) ? (a) : (b)) +#define MIN2(a,b) ((a) < (b) ? (a) : (b)) /* Table of constant values */ @@ -317,7 +317,7 @@ L11020: luksan_pyrmc0__(nf, &n, &ix[1], &gn[1], &eps8, &umax, gmax, &rmax, & iold, &irest); if (umax > eps8 * *gmax) { - irest = max(irest,1); + irest = MAX2(irest,1); } } luksan_mxvcop__(nf, &x[1], &xo[1]); @@ -348,11 +348,11 @@ L11040: gnorm = sqrt(rho1); /* Computing MIN */ d__1 = eps, d__2 = sqrt(gnorm); - par = min(d__1,d__2); + par = MIN2(d__1,d__2); if (par > .01) { /* Computing MIN */ d__1 = par, d__2 = 1. / (double) stat_1->nit; - par = min(d__1,d__2); + par = MIN2(d__1,d__2); } par *= par; @@ -480,14 +480,14 @@ L12560: /* TEST ON DESCENT DIRECTION */ if (snorm <= 0.) { - irest = max(irest,1); + irest = MAX2(irest,1); } else if (p + told * gnorm * snorm <= 0.) { irest = 0; } else { /* UNIFORM DESCENT CRITERION */ - irest = max(irest,1); + irest = MAX2(irest,1); } if (irest == 0) { @@ -497,7 +497,7 @@ L12560: rmin = alf1 * gnorm / snorm; /* Computing MIN */ d__1 = alf2 * gnorm / snorm, d__2 = *xmax / snorm; - rmax = min(d__1,d__2); + rmax = MIN2(d__1,d__2); } } ld = kd; @@ -535,7 +535,7 @@ L11064: p = po; luksan_mxvcop__(nf, &xo[1], &x[1]); luksan_mxvcop__(nf, &go[1], &gf[1]); - irest = max(irest,1); + irest = MAX2(irest,1); ld = kd; goto L11040; } @@ -545,7 +545,7 @@ L11064: if (*mos2 > 1) { /* Computing MIN */ i__1 = mx + 1; - mx = min(i__1,*mf); + mx = MIN2(i__1,*mf); luksan_mxdrsu__(nf, &mx, &xm[1], &gm[1], &u1[1]); luksan_mxvcop__(nf, &xo[1], &xm[1]); luksan_mxvcop__(nf, &go[1], &gm[1]); @@ -554,7 +554,7 @@ L11075: if (kbf > 0) { luksan_pyadc0__(nf, &n, &x[1], &ix[1], &xl[1], &xu[1], &inew); if (inew > 0) { - irest = max(irest,1); + irest = MAX2(irest,1); } } goto L11020; @@ -593,13 +593,13 @@ nlopt_result luksan_pnet(int n, nlopt_func f, void *f_data, and we'll assume that the main limiting factor is the memory. We'll assume that at least MEMAVAIL memory, or 4*n memory, whichever is bigger, is available. */ - mf = max(MEMAVAIL/n, 4); + mf = MAX2(MEMAVAIL/n, 4); if (stop->maxeval && stop->maxeval <= mf) - mf = max(stop->maxeval - 5, 1); /* mf > maxeval seems not good */ + mf = MAX2(stop->maxeval - 5, 1); /* mf > maxeval seems not good */ retry_alloc: - work = (double*) malloc(sizeof(double) * (n * 9 + max(n,n*mf)*2 + - max(n,mf)*2)); + work = (double*) malloc(sizeof(double) * (n * 9 + MAX2(n,n*mf)*2 + + MAX2(n,mf)*2)); if (!work) { if (mf > 0) { mf = 0; /* allocate minimal memory */ @@ -612,8 +612,8 @@ nlopt_result luksan_pnet(int n, nlopt_func f, void *f_data, xl = work; xu = xl + n; gf = xu + n; gn = gf + n; s = gn + n; xo = s + n; go = xo + n; xs = go + n; gs = xs + n; - xm = gs + n; gm = xm + max(n*mf,n); - u1 = gm + max(n*mf,n); u2 = u1 + max(n,mf); + xm = gs + n; gm = xm + MAX2(n*mf,n); + u1 = gm + MAX2(n*mf,n); u2 = u1 + MAX2(n,mf); for (i = 0; i < n; ++i) { int lbu = lb[i] <= -0.99 * HUGE_VAL; /* lb unbounded */ @@ -627,7 +627,7 @@ nlopt_result luksan_pnet(int n, nlopt_func f, void *f_data, original Fortran code, but it is used upon input to pnet if mf > 0 ... perhaps ALLOCATE initializes arrays to zero by default? */ - memset(xo, 0, sizeof(double) * max(n,n*mf)); + memset(xo, 0, sizeof(double) * MAX2(n,n*mf)); pnet_(&n, &nb, x, ix, xl, xu, gf, gn, s, xo, go, xs, gs, xm, gm, u1, u2, diff --git a/luksan/pssubs.c b/luksan/pssubs.c index cf7b1db..2d3f948 100644 --- a/luksan/pssubs.c +++ b/luksan/pssubs.c @@ -2,8 +2,8 @@ #include "luksan.h" #define FALSE_ 0 -#define max(a,b) ((a) > (b) ? (a) : (b)) -#define min(a,b) ((a) < (b) ? (a) : (b)) +#define MAX2(a,b) ((a) > (b) ? (a) : (b)) +#define MIN2(a,b) ((a) < (b) ? (a) : (b)) #define iabs(a) ((a) < 0 ? -(a) : (a)) /* subroutines extracted from pssubs.for */ @@ -48,13 +48,13 @@ void luksan_pcbs04__(int *nf, double *x, int *ix, /* Computing MAX */ d__2 = (d__1 = xl[i__], fabs(d__1)); if ((ixi == 1 || ixi == 3 || ixi == 4) && x[i__] <= xl[i__] + * - eps9 * max(d__2,temp)) { + eps9 * MAX2(d__2,temp)) { x[i__] = xl[i__]; } /* Computing MAX */ d__2 = (d__1 = xu[i__], fabs(d__1)); if ((ixi == 2 || ixi == 3 || ixi == 4) && x[i__] >= xu[i__] - * - eps9 * max(d__2,temp)) { + eps9 * MAX2(d__2,temp)) { x[i__] = xu[i__]; } /* L1: */ @@ -172,10 +172,10 @@ void luksan_pnint1__(double *rl, double *ru, double *fl, *r__ = *rl + (*ru - *rl) / den; /* Computing MAX */ d__1 = *r__, d__2 = *ru * 1.1; - *r__ = max(d__1,d__2); + *r__ = MAX2(d__1,d__2); /* Computing MIN */ d__1 = *r__, d__2 = *ru * 1e3; - *r__ = min(d__1,d__2); + *r__ = MIN2(d__1,d__2); return; } else if (*mode == 2 && den > 1.) { @@ -185,15 +185,15 @@ void luksan_pnint1__(double *rl, double *ru, double *fl, if (*rl == 0.) { /* Computing MAX */ d__1 = *r__, d__2 = *rl + (*ru - *rl) * .01; - *r__ = max(d__1,d__2); + *r__ = MAX2(d__1,d__2); } else { /* Computing MAX */ d__1 = *r__, d__2 = *rl + (*ru - *rl) * .1; - *r__ = max(d__1,d__2); + *r__ = MAX2(d__1,d__2); } /* Computing MIN */ d__1 = *r__, d__2 = *rl + (*ru - *rl) * .9; - *r__ = min(d__1,d__2); + *r__ = MIN2(d__1,d__2); return; } L1: @@ -316,7 +316,7 @@ void luksan_ps1l01__(double *r__, double *rp, } else { /* Computing MAX */ d__1 = *f - *fp, d__2 = *minf - *f; - rtemp = max(d__1,d__2); + rtemp = MAX2(d__1,d__2); } init1 = iabs(*inits); *rp = 0.; @@ -328,16 +328,16 @@ void luksan_ps1l01__(double *r__, double *rp, } else if (init1 == 2) { /* Computing MIN */ d__1 = 1., d__2 = rtemp * 4. / *po; - *r__ = min(d__1,d__2); + *r__ = MIN2(d__1,d__2); } else if (init1 == 3) { /* Computing MIN */ d__1 = 1., d__2 = rtemp * 2. / *po; - *r__ = min(d__1,d__2); + *r__ = MIN2(d__1,d__2); } else if (init1 == 4) { *r__ = rtemp * 2. / *po; } - *r__ = max(*r__,*rmin); - *r__ = min(*r__,*rmax); + *r__ = MAX2(*r__,*rmin); + *r__ = MIN2(*r__,*rmax); mode = 0; ru = 0.; fu = *fo; @@ -352,7 +352,7 @@ L2: goto L4; } else if (mode == 1) { --(*nred); - *r__ = min(*r__,*rmax); + *r__ = MIN2(*r__,*rmax); } else if (mode == 2) { ++(*nred); } @@ -424,7 +424,7 @@ L3: *rp = *r__; *fp = *f; *pp = *p; - mode = max(mode,1); + mode = MAX2(mode,1); mtyp = iabs(*mes); if (*f >= *maxf) { mtyp = 1; @@ -544,22 +544,22 @@ void luksan_pulsp3__(int *n, int *m, int *mf, d__1 = 0., d__2 = 1. - aa / a; /* Computing MAX */ d__3 = 0., d__4 = 1. - b * b / (den * ah); - *sig = sqrt((max(d__1,d__2))) / (sqrt((max(d__3,d__4))) + 1.) * + *sig = sqrt((MAX2(d__1,d__2))) / (sqrt((MAX2(d__3,d__4))) + 1.) * pom; } else { /* Computing MAX */ d__1 = 0., d__2 = *sig * ah / a; /* Computing MAX */ d__3 = 0., d__4 = 1. - b * b / (den * ah); - *sig = sqrt((max(d__1,d__2))) / (sqrt((max(d__3,d__4))) + 1.) * + *sig = sqrt((MAX2(d__1,d__2))) / (sqrt((MAX2(d__3,d__4))) + 1.) * pom; } /* Computing MAX */ d__1 = *sig, d__2 = pom * .2; - *sig = max(d__1,d__2); + *sig = MAX2(d__1,d__2); /* Computing MIN */ d__1 = *sig, d__2 = pom * .8; - *sig = min(d__1,d__2); + *sig = MIN2(d__1,d__2); } else { *sig = pom * .25; } @@ -687,22 +687,22 @@ void luksan_pulvp3__(int *n, int *m, double *xm, d__1 = 0., d__2 = 1. - aa / a; /* Computing MAX */ d__3 = 0., d__4 = 1. - b * b / (den * ah); - *sig = sqrt((max(d__1,d__2))) / (sqrt((max(d__3,d__4))) + 1.) * + *sig = sqrt((MAX2(d__1,d__2))) / (sqrt((MAX2(d__3,d__4))) + 1.) * pom; } else { /* Computing MAX */ d__1 = 0., d__2 = *sig * ah / a; /* Computing MAX */ d__3 = 0., d__4 = 1. - b * b / (den * ah); - *sig = sqrt((max(d__1,d__2))) / (sqrt((max(d__3,d__4))) + 1.) * + *sig = sqrt((MAX2(d__1,d__2))) / (sqrt((MAX2(d__3,d__4))) + 1.) * pom; } /* Computing MAX */ d__1 = *sig, d__2 = pom * .2; - *sig = max(d__1,d__2); + *sig = MAX2(d__1,d__2); /* Computing MIN */ d__1 = *sig, d__2 = pom * .8; - *sig = min(d__1,d__2); + *sig = MIN2(d__1,d__2); } else { *sig = pom * .25; } @@ -892,7 +892,7 @@ void luksan_pyfut1__(int *n, double *f, double *fo, double *umax, if (*nit <= 0) { /* Computing MIN */ d__1 = sqrt((fabs(*f))), d__2 = fabs(*f) / 10.; - *fo = *f + min(d__1,d__2); + *fo = *f + MIN2(d__1,d__2); } if (nlopt_stop_forced(stop)) { *iterm = -999; @@ -945,7 +945,7 @@ L1: } *iterm = 0; if (*n > 0 && *nit - *kit >= *ires1 * *n + *ires2) { - *irest = max(*irest,1); + *irest = MAX2(*irest,1); } ++(*nit); return; @@ -998,7 +998,7 @@ void luksan_pyrmc0__(int *nf, int *n, int *ix, ++(*iold); /* Computing MIN */ i__3 = (i__2 = ix[i__], iabs(i__2)); - ix[i__] = min(i__3,3); + ix[i__] = MIN2(i__3,3); if (*rmax == 0.) { goto L2; } @@ -1007,7 +1007,7 @@ void luksan_pyrmc0__(int *nf, int *n, int *ix, } L2: if (*iold > 1) { - *irest = max(*irest,1); + *irest = MAX2(*irest,1); } } } @@ -1091,8 +1091,8 @@ void luksan_pytrcd__(int *nf, double *x, int *ix, /* Computing MAX */ /* Computing MAX */ d__5 = (d__2 = x[i__], fabs(d__2)); - d__3 = *dmax__, d__4 = (d__1 = xo[i__], fabs(d__1)) / max(d__5,1.); - *dmax__ = max(d__3,d__4); + d__3 = *dmax__, d__4 = (d__1 = xo[i__], fabs(d__1)) / MAX2(d__5,1.); + *dmax__ = MAX2(d__3,d__4); L1: ; } @@ -1146,7 +1146,7 @@ void luksan_pytrcg__(int *nf, int *n, int *ix, if (ix[i__] >= 0) { /* Computing MAX */ d__1 = *gmax, d__2 = fabs(temp); - *gmax = max(d__1,d__2); + *gmax = MAX2(d__1,d__2); } else if (ix[i__] <= -5) { } else if ((ix[i__] == -1 || ix[i__] == -3) && *umax + temp >= 0.) { @@ -1236,14 +1236,14 @@ void luksan_pytrcs__(int *nf, double *x, int *ix, if (s[i__] < -1. / *eta9) { /* Computing MIN */ d__1 = *rmax, d__2 = (xl[i__] - x[i__]) / s[i__]; - *rmax = min(d__1,d__2); + *rmax = MIN2(d__1,d__2); } } if (ix[i__] == 2 || ix[i__] >= 3) { if (s[i__] > 1. / *eta9) { /* Computing MIN */ d__1 = *rmax, d__2 = (xu[i__] - x[i__]) / s[i__]; - *rmax = min(d__1,d__2); + *rmax = MIN2(d__1,d__2); } } } diff --git a/newuoa/newuoa.c b/newuoa/newuoa.c index c497917..cc35215 100644 --- a/newuoa/newuoa.c +++ b/newuoa/newuoa.c @@ -32,8 +32,8 @@ #include "newuoa.h" -#define min(a,b) ((a) <= (b) ? (a) : (b)) -#define max(a,b) ((a) >= (b) ? (a) : (b)) +#define MIN2(a,b) ((a) <= (b) ? (a) : (b)) +#define MAX2(a,b) ((a) >= (b) ? (a) : (b)) /*************************************************************************/ /* trsapp.f */ @@ -267,10 +267,10 @@ L50: if (iterc == 1) { *crvmin = temp; } - *crvmin = min(*crvmin,temp); + *crvmin = MIN2(*crvmin,temp); /* Computing MIN */ d__1 = alpha, d__2 = gg / dhd; - alpha = min(d__1,d__2); + alpha = MIN2(d__1,d__2); } qadd = alpha * (gg - half * alpha * dhd); qred += qadd; @@ -939,7 +939,7 @@ L70: goto L340; } if (iterc > 1) { - densav = max(densav,denold); + densav = MAX2(densav,denold); } if (fabs(denmax) <= fabs(densav) * 1.1) { goto L340; @@ -1851,7 +1851,7 @@ L100: } /* Computing MIN */ d__1 = delta, d__2 = sqrt(dsq); - dnorm = min(d__1,d__2); + dnorm = MIN2(d__1,d__2); if (dnorm < half * rho) { knew = -1; delta = tenth * delta; @@ -1864,8 +1864,8 @@ L100: } temp = crvmin * .125 * rho * rho; /* Computing MAX */ - d__1 = max(diffa,diffb); - if (temp <= max(d__1,diffc)) { + d__1 = MAX2(diffa,diffb); + if (temp <= MAX2(d__1,diffc)) { goto L460; } goto L490; @@ -2188,11 +2188,11 @@ L310: } else if (ratio <= .7) { /* Computing MAX */ d__1 = half * delta; - delta = max(d__1,dnorm); + delta = MAX2(d__1,dnorm); } else { /* Computing MAX */ d__1 = half * delta, d__2 = dnorm + dnorm; - delta = max(d__1,d__2); + delta = MAX2(d__1,d__2); } if (delta <= rho * 1.5) { delta = rho; @@ -2203,7 +2203,7 @@ L310: /* Computing MAX */ d__2 = tenth * delta; /* Computing 2nd power */ - d__1 = max(d__2,rho); + d__1 = MAX2(d__2,rho); rhosq = d__1 * d__1; ktemp = 0; detrat = zero; @@ -2414,15 +2414,15 @@ L460: /* Computing MAX */ /* Computing MIN */ d__2 = tenth * sqrt(distsq), d__3 = half * delta; - d__1 = min(d__2,d__3); - dstep = max(d__1,rho); + d__1 = MIN2(d__2,d__3); + dstep = MAX2(d__1,rho); dsq = dstep * dstep; goto L120; } if (ratio > zero) { goto L100; } - if (max(delta,dnorm) > rho) { + if (MAX2(delta,dnorm) > rho) { goto L100; } @@ -2440,7 +2440,7 @@ L490: } else { rho = tenth * rho; } - delta = max(delta,rho); + delta = MAX2(delta,rho); goto L90; } diff --git a/slsqp/slsqp.c b/slsqp/slsqp.c index daa472d..c9b408a 100644 --- a/slsqp/slsqp.c +++ b/slsqp/slsqp.c @@ -159,8 +159,8 @@ static const int c__0 = 0; static const int c__1 = 1; static const int c__2 = 2; -#define min(a,b) ((a) <= (b) ? (a) : (b)) -#define max(a,b) ((a) >= (b) ? (a) : (b)) +#define MIN2(a,b) ((a) <= (b) ? (a) : (b)) +#define MAX2(a,b) ((a) >= (b) ? (a) : (b)) static void h12_(const int *mode, int *lpivot, int *l1, int *m, double *u, const int *iue, double *up, @@ -225,7 +225,7 @@ static void h12_(const int *mode, int *lpivot, int *l1, for (j = *l1; j <= i__1; ++j) { sm = (d__1 = u[j * u_dim1 + 1], fabs(d__1)); /* L10: */ - cl = max(sm,cl); + cl = MAX2(sm,cl); } if (cl <= 0.0) { goto L80; @@ -456,7 +456,7 @@ L160: h12_(&c__2, &nsetp, &npp1, m, &a[j * a_dim1 + 1], &c__1, &up, &a[jj * a_dim1 + 1], &c__1, mda, &c__1); } - k = min(npp1,*mda); + k = MIN2(npp1,*mda); w[j] = 0.0; i__2 = *m - nsetp; dcopy___(&i__2, &w[j], 0, &a[k + j * a_dim1], 1); @@ -546,7 +546,7 @@ L250: goto L180; /* STEP TWELVE (SOLUTION) */ L280: - k = min(npp1,*m); + k = MIN2(npp1,*m); i__2 = *m - nsetp; *rnorm = dnrm2___(&i__2, &b[k], 1); if (npp1 > *m) { @@ -751,7 +751,7 @@ static void lsi_(double *e, double *f, double *g, for (i__ = 1; i__ <= i__1; ++i__) { /* Computing MIN */ i__2 = i__ + 1; - j = min(i__2,*n); + j = MIN2(i__2,*n); i__2 = i__ + 1; i__3 = *n - i__; h12_(&c__1, &i__, &i__2, me, &e[i__ * e_dim1 + 1], &c__1, &t, &e[j * @@ -789,7 +789,7 @@ static void lsi_(double *e, double *f, double *g, for (i__ = *n; i__ >= 1; --i__) { /* Computing MIN */ i__2 = i__ + 1; - j = min(i__2,*n); + j = MIN2(i__2,*n); /* L40: */ i__2 = *n - i__; x[i__] = (x[i__] - ddot_sl__(&i__2, &e[i__ + j * e_dim1], *le, &x[j], 1)) @@ -797,7 +797,7 @@ static void lsi_(double *e, double *f, double *g, } /* Computing MIN */ i__2 = *n + 1; - j = min(i__2,*me); + j = MIN2(i__2,*me); i__2 = *me - *n; t = dnrm2___(&i__2, &f[j], 1); *xnorm = sqrt(*xnorm * *xnorm + t * t); @@ -866,7 +866,7 @@ static void hfti_(double *a, int *mda, int *m, int * /* Function Body */ k = 0; - ldiag = min(*m,*n); + ldiag = MIN2(*m,*n); if (ldiag <= 0) { goto L270; } @@ -927,7 +927,7 @@ L50: L70: /* Computing MIN */ i__2 = j + 1; - i__ = min(i__2,*n); + i__ = MIN2(i__2,*n); i__2 = j + 1; i__3 = *n - j; h12_(&c__1, &j, &i__2, m, &a[j * a_dim1 + 1], &c__1, &h__[j], &a[i__ * @@ -988,7 +988,7 @@ L180: for (i__ = k; i__ >= 1; --i__) { /* Computing MIN */ i__1 = i__ + 1; - j = min(i__1,*n); + j = MIN2(i__1,*n); /* L210: */ i__1 = k - i__; b[i__ + jb * b_dim1] = (b[i__ + jb * b_dim1] - ddot_sl__(&i__1, & @@ -1118,7 +1118,7 @@ static void lsei_(double *c__, double *d__, double *e, for (i__ = 1; i__ <= i__1; ++i__) { /* Computing MIN */ i__2 = i__ + 1; - j = min(i__2,*lc); + j = MIN2(i__2,*lc); i__2 = i__ + 1; i__3 = *mc - i__; h12_(&c__1, &i__, &i__2, n, &c__[i__ + c_dim1], lc, &w[iw + i__], & @@ -1171,7 +1171,7 @@ static void lsei_(double *c__, double *d__, double *e, } /* SOLVE LS WITHOUT INEQUALITY CONSTRAINTS */ *mode = 7; - k = max(*le,*n); + k = MAX2(*le,*n); t = sqrt(epmach); hfti_(&w[ie], me, me, &l, &w[if__], &k, &c__1, &t, &krank, xnrm, &w[1], & w[l + 1], &jw[1]); @@ -1220,7 +1220,7 @@ L50: for (i__ = *mc; i__ >= 1; --i__) { /* Computing MIN */ i__2 = i__ + 1; - j = min(i__2,*lc); + j = MIN2(i__2,*lc); i__2 = *mc - i__; w[i__] = (d__[i__] - ddot_sl__(&i__2, &c__[j + i__ * c_dim1], 1, & w[j], 1)) / c__[i__ + i__ * c_dim1]; @@ -1413,7 +1413,7 @@ static void lsq_(int *m, int *meq, int *n, int *nl, dcopy___(n, &xu[1], 1, &w[iu], 1); d__1 = -one; dscal_sl__(n, &d__1, &w[iu], 1); */ iw = iu + *n; - i__1 = max(1,*meq); + i__1 = MAX2(1,*meq); lsei_(&w[ic], &w[id], &w[ie], &w[if__], &w[ig], &w[ih], &i__1, meq, n, n, &m1, &m1, n, &x[1], &xnorm, &w[iw], &jw[1], mode); if (*mode == 1) { @@ -1933,7 +1933,7 @@ L130: } else { /* Computing MAX */ d__1 = -c__[j]; - a[j + n1 * a_dim1] = max(d__1,0.0); + a[j + n1 * a_dim1] = MAX2(d__1,0.0); } /* L140: */ } @@ -1983,11 +1983,11 @@ L150: } /* Computing MAX */ d__1 = -c__[j]; - h2 += max(d__1,h3); + h2 += MAX2(d__1,h3); h3 = (d__1 = r__[j], fabs(d__1)); /* Computing MAX */ d__1 = h3, d__2 = (mu[j] + h3) / two; - mu[j] = max(d__1,d__2); + mu[j] = MAX2(d__1,d__2); h1 += h3 * (d__1 = c__[j], fabs(d__1)); /* L170: */ } @@ -2006,7 +2006,7 @@ L150: } /* Computing MAX */ d__1 = -c__[j]; - h1 += mu[j] * max(d__1,h3); + h1 += mu[j] * MAX2(d__1,h3); /* L180: */ } t0 = *f + h1; @@ -2048,7 +2048,7 @@ L200: } /* Computing MAX */ d__1 = h3 / (two * (h3 - h1)); - alpha = max(d__1,alfmin); + alpha = MAX2(d__1,alfmin); goto L190; /* EXACT LINESEARCH */ L210: @@ -2079,7 +2079,7 @@ L220: } /* Computing MAX */ d__1 = -c__[j]; - t += mu[j] * max(d__1,h1); + t += mu[j] * MAX2(d__1,h1); /* L230: */ } h1 = t - t0; @@ -2099,7 +2099,7 @@ L240: } /* Computing MAX */ d__1 = -c__[j]; - h3 += max(d__1,h1); + h3 += MAX2(d__1,h1); /* L250: */ } if (((d__1 = *f - f0, fabs(d__1)) < *acc || dnrm2___(n, &s[1], 1) < * @@ -2396,19 +2396,19 @@ static void slsqp(int *m, int *meq, int *la, int *n, << 1) + *n * 3 + (n1 << 2) + 1; /* Computing MAX */ i__1 = mineq, i__2 = n1 - *meq; - im = max(i__1,i__2); + im = MAX2(i__1,i__2); if (*l_w__ < il || *l_jw__ < im) { - *mode = max(10,il) * 1000; - *mode += max(10,im); + *mode = MAX2(10,il) * 1000; + *mode += MAX2(10,im); return; } /* PREPARE DATA FOR CALLING SQPBDY - INITIAL ADDRESSES IN W */ im = 1; - il = im + max(1,*m); + il = im + MAX2(1,*m); il = im + *la; ix = il + n1 * *n / 2 + 1; ir = ix + *n; - is = ir + *n + *n + max(1,*m); + is = ir + *n + *n + MAX2(1,*m); is = ir + *n + *n + *la; iu = is + n1; iv = iu + n1; @@ -2452,7 +2452,7 @@ nlopt_result nlopt_slsqp(unsigned n, nlopt_func f, void *f_data, double infeasibility = HUGE_VAL, infeasibility_cur = HUGE_VAL; unsigned max_cdim; - max_cdim = max(nlopt_max_constraint_dim(m, fc), + max_cdim = MAX2(nlopt_max_constraint_dim(m, fc), nlopt_max_constraint_dim(p, h)); length_work(&len_w, &len_jw, mpi, pi, ni); @@ -2504,7 +2504,7 @@ nlopt_result nlopt_slsqp(unsigned n, nlopt_func f, void *f_data, ret = NLOPT_FORCED_STOP; goto done; } for (k = 0; k < h[i].m; ++k, ++ii) { infeasibility_cur = - max(infeasibility_cur, fabs(c[ii])); + MAX2(infeasibility_cur, fabs(c[ii])); feasible_cur = feasible_cur && fabs(c[ii]) <= h[i].tol[k]; for (j = 0; j < n; ++ j) @@ -2518,7 +2518,7 @@ nlopt_result nlopt_slsqp(unsigned n, nlopt_func f, void *f_data, ret = NLOPT_FORCED_STOP; goto done; } for (k = 0; k < fc[i].m; ++k, ++ii) { infeasibility_cur = - max(infeasibility_cur, c[ii]); + MAX2(infeasibility_cur, c[ii]); feasible_cur = feasible_cur && c[ii] <= fc[i].tol[k]; for (j = 0; j < n; ++ j) @@ -2542,7 +2542,7 @@ nlopt_result nlopt_slsqp(unsigned n, nlopt_func f, void *f_data, ret = NLOPT_FORCED_STOP; goto done; } for (k = 0; k < h[i].m; ++k, ++ii) { infeasibility_cur = - max(infeasibility_cur, fabs(c[ii])); + MAX2(infeasibility_cur, fabs(c[ii])); feasible_cur = feasible_cur && fabs(c[ii]) <= h[i].tol[k]; } @@ -2554,7 +2554,7 @@ nlopt_result nlopt_slsqp(unsigned n, nlopt_func f, void *f_data, ret = NLOPT_FORCED_STOP; goto done; } for (k = 0; k < fc[i].m; ++k, ++ii) { infeasibility_cur = - max(infeasibility_cur, c[ii]); + MAX2(infeasibility_cur, c[ii]); feasible_cur = feasible_cur && c[ii] <= fc[i].tol[k]; c[ii] = -c[ii]; /* slsqp sign convention */ diff --git a/subplex/subplex.c b/subplex/subplex.c index 5bbe1d6..28b9a75 100644 --- a/subplex/subplex.c +++ b/subplex/subplex.c @@ -71,9 +71,8 @@ typedef int integer; typedef subplex_func D_fp; -#define max(a,b) ((a) > (b) ? (a) : (b)) -#define min(a,b) ((a) < (b) ? (a) : (b)) -#define abs(x) fabs(x) +#define MAX2(a,b) ((a) > (b) ? (a) : (b)) +#define MIN2(a,b) ((a) < (b) ? (a) : (b)) /****************************************************************************/ /****************************************************************************/ @@ -122,7 +121,7 @@ static doublereal dasum_(integer *n, doublereal *dx, integer *incx) } i__1 = *n; for (i__ = 1; i__ <= i__1; ++i__) { - dtemp += (d__1 = dx[ix], abs(d__1)); + dtemp += (d__1 = dx[ix], fabs(d__1)); ix += *incx; /* L10: */ } @@ -141,7 +140,7 @@ L20: } i__1 = m; for (i__ = 1; i__ <= i__1; ++i__) { - dtemp += (d__1 = dx[i__], abs(d__1)); + dtemp += (d__1 = dx[i__], fabs(d__1)); /* L30: */ } if (*n < 6) { @@ -151,10 +150,10 @@ L40: mp1 = m + 1; i__1 = *n; for (i__ = mp1; i__ <= i__1; i__ += 6) { - dtemp = dtemp + (d__1 = dx[i__], abs(d__1)) + (d__2 = dx[i__ + 1], - abs(d__2)) + (d__3 = dx[i__ + 2], abs(d__3)) + (d__4 = dx[i__ - + 3], abs(d__4)) + (d__5 = dx[i__ + 4], abs(d__5)) + (d__6 = - dx[i__ + 5], abs(d__6)); + dtemp = dtemp + (d__1 = dx[i__], fabs(d__1)) + (d__2 = dx[i__ + 1], + fabs(d__2)) + (d__3 = dx[i__ + 2], fabs(d__3)) + (d__4 = dx[i__ + + 3], fabs(d__4)) + (d__5 = dx[i__ + 4], fabs(d__5)) + (d__6 = + dx[i__ + 5], fabs(d__6)); /* L50: */ } L60: @@ -457,7 +456,7 @@ static doublereal dist_(integer *n, doublereal *x, doublereal *y) --x; /* Function Body */ - absxmy = (d__1 = x[1] - y[1], abs(d__1)); + absxmy = (d__1 = x[1] - y[1], fabs(d__1)); if (absxmy <= 1.) { sum = absxmy * absxmy; scale = 1.; @@ -467,7 +466,7 @@ static doublereal dist_(integer *n, doublereal *x, doublereal *y) } i__1 = *n; for (i__ = 2; i__ <= i__1; ++i__) { - absxmy = (d__1 = x[i__] - y[i__], abs(d__1)); + absxmy = (d__1 = x[i__] - y[i__], fabs(d__1)); if (absxmy <= scale) { /* Computing 2nd power */ d__1 = absxmy / scale; @@ -750,7 +749,7 @@ L20: /* L30: */ } gapmax = -1.; - i__1 = min(usubc_1.nsmax,nleft); + i__1 = MIN2(usubc_1.nsmax,nleft); for (ns1 = usubc_1.nsmin; ns1 <= i__1; ++ns1) { as1 += absdx[ip[nused + ns1]]; ns2 = nleft - ns1; @@ -1118,12 +1117,12 @@ static int fstats_(doublereal *fx, integer *ifxwt, logical *reset) usubc_1.nfxe += *ifxwt; usubc_1.fxstat[0] += *ifxwt * (*fx - usubc_1.fxstat[0]) / usubc_1.nfxe; - usubc_1.fxstat[1] = max(usubc_1.fxstat[1],*fx); - usubc_1.fxstat[2] = min(usubc_1.fxstat[2],*fx); + usubc_1.fxstat[1] = MAX2(usubc_1.fxstat[1],*fx); + usubc_1.fxstat[2] = MIN2(usubc_1.fxstat[2],*fx); /* Computing MAX */ - d__1 = abs(usubc_1.fxstat[1]), d__2 = abs(usubc_1.fxstat[2]), d__1 = - max(d__1,d__2); - fscale = max(d__1,1.); + d__1 = fabs(usubc_1.fxstat[1]), d__2 = fabs(usubc_1.fxstat[2]), d__1 = + MAX2(d__1,d__2); + fscale = MAX2(d__1,1.); /* Computing 2nd power */ d__1 = usubc_1.fxstat[3] / fscale; /* Computing 2nd power */ @@ -1463,7 +1462,7 @@ L20: stop->nevals++; /* Computing MIN */ d__1 = fr, d__2 = fs[ih]; - if (fc < min(d__1,d__2)) { + if (fc < MIN2(d__1,d__2)) { dcopy_(ns, &s[itemp * s_dim1 + 1], &c__1, &s[ih * s_dim1 + 1], & c__1); fs[ih] = fc; @@ -1602,11 +1601,11 @@ static int subopt_(integer *n) /* nsmin - subspace dimension minimum */ - usubc_1.nsmin = min(2,*n); + usubc_1.nsmin = MIN2(2,*n); /* nsmax - subspace dimension maximum */ - usubc_1.nsmax = min(5,*n); + usubc_1.nsmax = MIN2(5,*n); /* *********************************************************** */ /* subplex method special cases */ @@ -1773,8 +1772,8 @@ static int setstp_(integer *nsubs, integer *n, doublereal *deltax, /* Computing MIN */ /* Computing MAX */ d__3 = dasum_(n, &deltax[1], &c__1) / dasum_(n, &step[1], &c__1); - d__1 = max(d__3,usubc_1.omega), d__2 = 1. / usubc_1.omega; - stpfac = min(d__1,d__2); + d__1 = MAX2(d__3,usubc_1.omega), d__2 = 1. / usubc_1.omega; + stpfac = MIN2(d__1,d__2); } else { stpfac = usubc_1.psi; } @@ -1947,7 +1946,7 @@ static int subplx_(D_fp f, void *fdata, integer *n, /* L10: */ } } else { - scl = abs(scale[1]); + scl = fabs(scale[1]); i__1 = *n; for (i__ = 1; i__ <= i__1; ++i__) { xpscl = x[i__] + scl; @@ -2068,7 +2067,7 @@ static int subplx_(D_fp f, void *fdata, integer *n, L40: i__1 = *n; for (i__ = 1; i__ <= i__1; ++i__) { - work[i__] = (d__1 = work[i__], abs(d__1)); + work[i__] = (d__1 = work[i__], fabs(d__1)); /* L50: */ } sortd_(n, &work[1], &iwork[1]); @@ -2119,11 +2118,11 @@ L90: i__1 = *n; for (i__ = 1; i__ <= i__1; ++i__) { /* Computing MAX */ - d__4 = (d__2 = work[i__], abs(d__2)), d__5 = (d__1 = work[istep], abs( + d__4 = (d__2 = work[i__], fabs(d__2)), d__5 = (d__1 = work[istep], fabs( d__1)) * usubc_1.psi; /* Computing MAX */ - d__6 = (d__3 = x[i__], abs(d__3)); - if (max(d__4,d__5) / max(d__6,1.) > stop->xtol_rel) { + d__6 = (d__3 = x[i__], fabs(d__3)); + if (MAX2(d__4,d__5) / MAX2(d__6,1.) > stop->xtol_rel) { setstp_(&nsubs, n, &work[1], &work[istptr]); goto L40; } @@ -2194,8 +2193,8 @@ int nlopt_subplex(subplex_func f, double *minf, double *x, int n, void *fdata, int mode = 0, *iwork, nsmax, nsmin, errflag, nfe; double *work; - nsmax = min(5,n); - nsmin = min(2,n); + nsmax = MIN2(5,n); + nsmin = MIN2(2,n); work = (double*) malloc(sizeof(double) * (3*n + nsmax*(nsmax+4) + 1)); if (!work) return -200; -- 2.30.2