Ignore:
Timestamp:
Sep 16, 2008 5:31:36 PM (12 years ago)
Author:
ladanyi
Message:

changed max/min to CoinMax/CoinMin?

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/src/ClpPdco.cpp

    r1197 r1276  
    253253  int  LSproblem = options.LSproblem;  // See below
    254254  int  LSmethod  = options.LSmethod;   // 1=Cholesky    2=QR    3=LSQR
    255   int  itnlim    = options.LSQRMaxIter * min(m,n);
     255  int  itnlim    = options.LSQRMaxIter * CoinMin(m,n);
    256256  double atol1     = options.LSQRatol1;  // Initial  atol
    257257  double atol2     = options.LSQRatol2;  // Smallest atol,unless atol1 is smaller
     
    431431
    432432  for (int k=0; k<nlow; k++){
    433     x_elts[low[k]]  = max( x_elts[low[k]], bl[low[k]]);
    434     x1_elts[low[k]] = max( x_elts[low[k]] - bl[low[k]], x0min  );
    435     z1_elts[low[k]] = max( z_elts[low[k]], z0min  );
     433    x_elts[low[k]]  = CoinMax( x_elts[low[k]], bl[low[k]]);
     434    x1_elts[low[k]] = CoinMax( x_elts[low[k]] - bl[low[k]], x0min  );
     435    z1_elts[low[k]] = CoinMax( z_elts[low[k]], z0min  );
    436436  }
    437437  for (int k=0; k<nupp; k++){
    438     x_elts[upp[k]]  = min( x_elts[upp[k]], bu[upp[k]]);
    439     x2_elts[upp[k]] = max(bu[upp[k]] -  x_elts[upp[k]], x0min  );
    440     z2_elts[upp[k]] = max(-z_elts[upp[k]], z0min  );
     438    x_elts[upp[k]]  = CoinMin( x_elts[upp[k]], bu[upp[k]]);
     439    x2_elts[upp[k]] = CoinMax(bu[upp[k]] -  x_elts[upp[k]], x0min  );
     440    z2_elts[upp[k]] = CoinMax(-z_elts[upp[k]], z0min  );
    441441  }
    442442  //////////////////// Assume hessian is diagonal. //////////////////////
     
    488488  double mufirst = mu0;   // revert to absolute value
    489489  double mulast  = 0.1 * opttol;
    490   mulast  = min( mulast, mufirst );
     490  mulast  = CoinMin( mulast, mufirst );
    491491  double mu      = mufirst;
    492492  double center,  fmerit;
     
    501501  bool converged = false;
    502502  double atol      = atol1;
    503   atol2     = max( atol2, atolmin );
     503  atol2     = CoinMax( atol2, atolmin );
    504504  atolmin   = atol2;
    505505  //  pdDDD2    = d2;    // Global vector for diagonal matrix D2
     
    552552    //              Now that starting conditions are better, go back to 0.1.
    553553
    554     double r3norm = max(Pinf,   max(Dinf,  Cinf));
    555     atol   = min(atol,  r3norm*0.1);
    556     atol   = max(atol,  atolmin   );
     554    double r3norm = CoinMax(Pinf,   CoinMax(Dinf,  Cinf));
     555    atol   = CoinMin(atol,  r3norm*0.1);
     556    atol   = CoinMax(atol,  atolmin   );
    557557    info.r3norm = r3norm;
    558558
     
    682682    if (nupp > 0)
    683683      stepz2 = pdxxxstep( z2     , dz2      );
    684     double stepx  = min( stepx1, stepx2 );
    685     double stepz  = min( stepz1, stepz2 );
    686     stepx  = min( steptol*stepx, 1.0 );
    687     stepz  = min( steptol*stepz, 1.0 );
     684    double stepx  = CoinMin( stepx1, stepx2 );
     685    double stepz  = CoinMin( stepz1, stepz2 );
     686    stepx  = CoinMin( steptol*stepx, 1.0 );
     687    stepz  = CoinMin( steptol*stepz, 1.0 );
    688688    if (stepSame){                   // For NLPs, force same step
    689       stepx = min( stepx, stepz );   // (true Newton method)
     689      stepx = CoinMin( stepx, stepz );   // (true Newton method)
    690690      stepz = stepx;
    691691    }
     
    729729                               &center, &Cinf, &Cinf0);
    730730      double fmeritnew = pdxxxmerit(nlow, nupp, low,upp,r1,r2,rL,rU,cL,cU );
    731       double step      = min( stepx, stepz );
     731      double step      = CoinMin( stepx, stepz );
    732732
    733733      if (fmeritnew <= (1 - eta*step)*fmerit){
     
    829829      // Reduce mu, and reset certain residuals.
    830830
    831       double stepmu  = min( stepx , stepz   );
    832       stepmu  = min( stepmu, steptol );
     831      double stepmu  = CoinMin( stepx , stepz   );
     832      stepmu  = CoinMin( stepmu, steptol );
    833833      double muold   = mu;
    834834      mu      = mu   -  stepmu * mu;
     
    837837
    838838      // mutrad = mu0*(sum(Xz)/n); // 24 May 1998: Traditional value, but
    839       // mu     = min(mu,mutrad ); // it seemed to decrease mu too much.
    840 
    841       mu      = max(mu,mulast);  // 13 Jun 1998: No need for smaller mu.
     839      // mu     = CoinMin(mu,mutrad ); // it seemed to decrease mu too much.
     840
     841      mu      = CoinMax(mu,mulast);  // 13 Jun 1998: No need for smaller mu.
    842842      //      [cL,cU,center,Cinf,Cinf0] = ...
    843843      pdxxxresid2( mu, nlow, nupp, low, upp, cL, cU, x1, x2, z1, z2,
     
    851851      // if atol > atol2
    852852      //   atolfac = (mu/mufirst)^0.25;
    853       //   atol    = max( atol*atolfac, atol2 );
     853      //   atol    = CoinMax( atol*atolfac, atol2 );
    854854      // end
    855855
    856       // atol = min( atol, mu );     // 22 Jan 2001: a la Inexact Newton.
    857       // atol = min( atol, 0.5*mu ); // 30 Jan 2001: A bit tighter
     856      // atol = CoinMin( atol, mu );     // 22 Jan 2001: a la Inexact Newton.
     857      // atol = CoinMin( atol, 0.5*mu ); // 30 Jan 2001: A bit tighter
    858858
    859859      // If the linesearch took more than one function (nf > 1),
     
    865865      // 06 Feb 2001: Not necessarily.  Reinstated tests in next line.
    866866
    867       if (nf > 2  ||  min( stepx, stepz ) <= 0.01)
     867      if (nf > 2  ||  CoinMin( stepx, stepz ) <= 0.01)
    868868        atol = atolold*0.1;
    869869    }
Note: See TracChangeset for help on using the changeset viewer.