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,
/* 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;
}
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: */
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];
/* 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;
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];
}
}
/* 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__];
}
/* 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];
}
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. */
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) {
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__;
}
}
/* 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];
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 */
/* 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) {
/* 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;
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, */
++iterc;
temp = shs / stepsq;
if (iact == 0 && temp > zero) {
- *crvmin = min(*crvmin,temp);
+ *crvmin = MIN2(*crvmin,temp);
if (*crvmin == onemin) {
*crvmin = temp;
}
}
/* Computing MAX */
d__1 = stplen * (ggsav - half * stplen * shs);
- sdec = max(d__1,zero);
+ sdec = MAX2(d__1,zero);
qred += sdec;
}
/* 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__];
}
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;
}
/* 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];
}
&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 */
/* 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;
/* 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;
/* 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:
;
}
/* 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__];
}
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;
/* 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;
/* 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;
/* 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 */
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__];
/* 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;
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;
}
/* 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;
}
if (ratio > zero) {
goto L60;
}
- if (max(delta,dnorm) > rho) {
+ if (MAX2(delta,dnorm) > rho) {
goto L60;
}
} else {
rho = tenth * rho;
}
- delta = max(delta,rho);
+ delta = MAX2(delta,rho);
ntrits = 0;
nfsav = stop->nevals;
goto L60;
/* 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__];
}
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) {
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;
}
}
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))
--lb; --ub;
/* Function Body */
- iptem = min(*n,4);
+ iptem = MIN2(*n,4);
iptemp = iptem + 1;
np = *n + 1;
mp = *m + 1;
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 */
}
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) {
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.;
sum -= a[i__ + k * a_dim1] * dx[i__];
}
if (k < mp) {
- resnew = max(resnew,sum);
+ resnew = MAX2(resnew,sum);
}
}
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;
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);
}
}
}
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.;
}
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) {
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];
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;
}
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);
if (step >= acca || acca >= accb) {
goto L480;
}
- step = min(step,resmax);
+ step = MIN2(step,resmax);
}
/* SGJ, 2010: check for error here */
for (i__ = 1; i__ <= i__2; ++i__) {
temp -= a[i__ + kk * a_dim1] * dxnew[i__];
}
- resmax = max(resmax,temp);
+ resmax = MAX2(resmax,temp);
}
}
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.;
}
}
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. */
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;
}
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);
#include <math.h>
#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 */
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;
#include <string.h>
#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 */
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;
/* 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) {
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) {
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;
}
}
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);
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 */
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 */
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,
#include <string.h>
#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 */
}
/* 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;
}
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;
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;
/* 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) {
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) {
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;
}
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 */
}
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 */
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,
#include <string.h>
#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 */
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]);
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;
/* 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) {
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;
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;
}
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]);
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;
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 */
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 */
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,
#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 */
/* 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: */
*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.) {
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:
} 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.;
} 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;
goto L4;
} else if (mode == 1) {
--(*nred);
- *r__ = min(*r__,*rmax);
+ *r__ = MIN2(*r__,*rmax);
} else if (mode == 2) {
++(*nred);
}
*rp = *r__;
*fp = *f;
*pp = *p;
- mode = max(mode,1);
+ mode = MAX2(mode,1);
mtyp = iabs(*mes);
if (*f >= *maxf) {
mtyp = 1;
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;
}
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;
}
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;
}
*iterm = 0;
if (*n > 0 && *nit - *kit >= *ires1 * *n + *ires2) {
- *irest = max(*irest,1);
+ *irest = MAX2(*irest,1);
}
++(*nit);
return;
++(*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;
}
}
L2:
if (*iold > 1) {
- *irest = max(*irest,1);
+ *irest = MAX2(*irest,1);
}
}
}
/* 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:
;
}
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.)
{
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);
}
}
}
#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 */
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;
goto L340;
}
if (iterc > 1) {
- densav = max(densav,denold);
+ densav = MAX2(densav,denold);
}
if (fabs(denmax) <= fabs(densav) * 1.1) {
goto L340;
}
/* 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;
}
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;
} 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;
/* 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;
/* 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;
}
} else {
rho = tenth * rho;
}
- delta = max(delta,rho);
+ delta = MAX2(delta,rho);
goto L90;
}
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,
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;
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);
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) {
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 *
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))
}
/* 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);
/* Function Body */
k = 0;
- ldiag = min(*m,*n);
+ ldiag = MIN2(*m,*n);
if (ldiag <= 0) {
goto L270;
}
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__ *
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, &
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__], &
}
/* 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]);
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];
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) {
} 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: */
}
}
/* 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: */
}
}
/* Computing MAX */
d__1 = -c__[j];
- h1 += mu[j] * max(d__1,h3);
+ h1 += mu[j] * MAX2(d__1,h3);
/* L180: */
}
t0 = *f + h1;
}
/* Computing MAX */
d__1 = h3 / (two * (h3 - h1));
- alpha = max(d__1,alfmin);
+ alpha = MAX2(d__1,alfmin);
goto L190;
/* EXACT LINESEARCH */
L210:
}
/* Computing MAX */
d__1 = -c__[j];
- t += mu[j] * max(d__1,h1);
+ t += mu[j] * MAX2(d__1,h1);
/* L230: */
}
h1 = t - t0;
}
/* 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) < *
<< 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;
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);
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)
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)
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];
}
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 */
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))
/****************************************************************************/
/****************************************************************************/
}
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: */
}
}
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) {
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:
--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.;
}
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;
/* 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;
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 */
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;
/* 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 */
/* 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;
}
/* L10: */
}
} else {
- scl = abs(scale[1]);
+ scl = fabs(scale[1]);
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
xpscl = x[i__] + scl;
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]);
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;
}
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;
~ianmdlvl / nlopt.git / commitdiff