Changeset 574


Ignore:
Timestamp:
May 10, 2011 6:00:24 AM (9 years ago)
Author:
fmargot
Message:

Fix bugs related to CouenneRecordBestSol?, add flags FM_UP_BND and FM_PRINT_INFO

Location:
trunk/Couenne/src
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/Couenne/src/branch/CouenneChooseVariable.cpp

    r533 r574  
    138138
    139139  double obj = solution [problem_ -> Obj (0) -> Body () -> Index ()];
    140   return problem_ -> checkNLP (solution, obj);
     140
     141#ifdef FM_CHECKNLP2
     142  bool isFeas = problem_->checkNLP2(solution,
     143                                    0, false, // do not care about obj
     144                                    true, // stopAtFirstViol
     145                                    true, // checkAll
     146                                    problem_->getFeasTol());
     147 
     148  return isFeas;
     149#else
     150  return problem_ -> checkNLP(solution, obj);
     151#endif
    141152}
    142153
  • trunk/Couenne/src/convex/CouenneCutGenerator.cpp

    r490 r574  
    1616#include "CouenneChooseStrong.hpp"
    1717#include "CouenneChooseVariable.hpp"
     18
     19#include "BonCbc.hpp"
     20#include "CouenneRecordBestSol.hpp"
    1821
    1922using namespace Couenne;
     
    196199    );
    197200}
     201
     202/*********************************************************************/
     203void CouenneCutGenerator::printLineInfo() const {
     204
     205  double cbcLb = BabPtr_->model().getBestPossibleObjValue();
     206  double lpVal = BabPtr_->model().solver()->getObjValue();
     207  int nbNodes = BabPtr_->model().getNodeCount();
     208  int depth = BabPtr_->model().currentDepth();
     209  CouenneRecordBestSol *rs = problem_->getRecordBestSol();
     210
     211  if(rs->getHasSol()) {
     212    double bestSolVal = rs->getVal();
     213    printf("%10d  %10d  %10.6f  %10.6f  %10.6f\n",
     214           nbNodes, depth, cbcLb, lpVal, bestSolVal);
     215  }
     216  else {
     217    printf("%10d  %10d  %10.6f  %10.6f   ----------\n",
     218           nbNodes, depth, cbcLb, lpVal);
     219  }
     220} /* printLineInfo */
  • trunk/Couenne/src/convex/CouenneCutGenerator.hpp

    r490 r574  
    122122  /// to have caused some problems some time ago
    123123  bool enable_lp_implied_bounds_;
     124
     125  /// Running count of printed info lines
     126  mutable int lastPrintLine;
    124127
    125128 public:
     
    251254  static void registerOptions (Ipopt::SmartPtr <Bonmin::RegisteredOptions> roptions);
    252255
     256  /// print node, depth, LB/UB/LP info
     257  void printLineInfo() const;
     258
    253259  /// Provide Journalist
    254260  inline ConstJnlstPtr Jnlst() const
  • trunk/Couenne/src/convex/generateCuts.cpp

    r573 r574  
    99 */
    1010
     11#include "BonCbc.hpp"
    1112#include "BonBabInfos.hpp"
    1213#include "CglCutGenerator.hpp"
     
    112113#endif
    113114
     115#ifdef FM_PRINT_INFO
     116  if((BabPtr_ != NULL) && (info.level >= 0) && (info.pass == 0) &&
     117     (BabPtr_->model().getNodeCount() > lastPrintLine)) {
     118    printLineInfo();
     119    lastPrintLine += 1;
     120  }
     121#endif
    114122
    115123  const int infeasible = 1;
  • trunk/Couenne/src/heuristics/CouenneFeasPump.cpp

    r490 r574  
    2020#include "CouenneTNLP.hpp"
    2121
     22#include "CouenneRecordBestSol.hpp"
     23
    2224using namespace Couenne;
    2325
     
    9092    double z = solveMILP (nSol, iSol);
    9193
    92     if (problem_ -> checkNLP (iSol, z)) {
     94    bool isChecked = false;
     95#ifdef FM_CHECKNLP2
     96    isChecked = problem_->checkNLP2(iSol, 0, false, // do not care about obj
     97                                    true, // stopAtFirstViol
     98                                    true, // checkALL
     99                                    problem_->getFeasTol());
     100    if(isChecked) {
     101      z = problem_->getRecordBestSol()->getModSolVal();
     102    }
     103#else /* not FM_CHECKNLP2 */
     104    isChecked = problem_ -> checkNLP (iSol, z, true);
     105#endif  /* not FM_CHECKNLP2 */
     106
     107    if (isChecked) {
    93108
    94109      // solution is MINLP feasible!
     
    99114        retval = 1;
    100115        objVal = z;
     116
     117#ifdef FM_CHECKNLP2
     118#ifdef FM_TRACE_OPTSOL
     119        problem_->getRecordBestSol()->update();
     120        best = problem_->getRecordBestSol()->getSol();
     121        objVal = problem_->getRecordBestSol()->getVal();
     122#else /* not FM_TRACE_OPTSOL */
     123        best = problem_->getRecordBestSol()->getModSol();
     124        objVal = z;
     125#endif /* not FM_TRACE_OPTSOL */
     126#else /* not FM_CHECKNLP2 */
     127#ifdef FM_TRACE_OPTSOL
     128        problem_->getRecordBestSol()->update(iSol, problem_->nVars(),
     129                                             z, problem_->getFeasTol());
     130        best = problem_->getRecordBestSol()->getSol();
     131        objVal = problem_->getRecordBestSol()->getVal();
     132#else /* not FM_TRACE_OPTSOL */
    101133        best   = iSol;
    102         problem_ -> setCutOff (z);
     134        objVal = z;
     135#endif /* not FM_TRACE_OPTSOL */
     136#endif /* not FM_CHECKNLP2 */
     137
     138        problem_ -> setCutOff (objVal);
    103139
    104140        // if bound tightening clears the whole feasible set, stop
     
    132168
    133169    // check if newly found NLP solution is also integer
    134     if (problem_ -> checkNLP (nSol, z) &&
     170
     171    isChecked = false;
     172#ifdef FM_CHECKNLP2
     173    isChecked = problem_->checkNLP2(nSol, 0, false, // do not care about obj
     174                                    true, // stopAtFirstViol
     175                                    true, // checkALL
     176                                    problem_->getFeasTol());
     177    if(isChecked) {
     178      z = problem_->getRecordBestSol()->getModSolVal();
     179    }
     180#else /* not FM_CHECKNLP2 */
     181    isChecked = problem_ -> checkNLP (nSol, z, true);
     182#endif  /* not FM_CHECKNLP2 */
     183
     184     if (isChecked &&
    135185        (z < problem_ -> getCutOff ())) {
    136186
    137187      retval = 1;
     188
     189#ifdef FM_CHECKNLP2
     190#ifdef FM_TRACE_OPTSOL
     191      problem_->getRecordBestSol()->update();
     192      best = problem_->getRecordBestSol()->getSol();
     193      objVal = problem_->getRecordBestSol()->getVal();
     194#else /* not FM_TRACE_OPTSOL */
     195      best = problem_->getRecordBestSol()->getModSol();
    138196      objVal = z;
     197#endif /* not FM_TRACE_OPTSOL */
     198#else /* not FM_CHECKNLP2 */
     199#ifdef FM_TRACE_OPTSOL
     200      problem_->getRecordBestSol()->update(nSol, problem_->nVars(),
     201                                           z, problem_->getFeasTol());
     202      best = problem_->getRecordBestSol()->getSol();
     203      objVal = problem_->getRecordBestSol()->getVal();
     204#else /* not FM_TRACE_OPTSOL */
    139205      best   = nSol;
    140       problem_ -> setCutOff (z);
    141 
     206      objVal = z;
     207#endif /* not FM_TRACE_OPTSOL */
     208#endif /* not FM_CHECKNLP2 */
     209     
     210      problem_ -> setCutOff (objVal);
     211     
    142212      // if bound tightening clears the whole feasible set, stop
    143213      if (!(problem_ -> btCore (NULL)))
    144214        break;
    145     }   
     215     
    146216
    147217  } while ((niter++ < maxIter_) &&
     
    187257
    188258    // check if newly found NLP solution is also integer (unlikely...)
    189     if (problem_ -> checkNLP (nSol, z) &&
     259    bool isChecked = false;
     260#ifdef FM_CHECKNLP2
     261    isChecked = problem_->checkNLP2(nSol, 0, false, // do not care about obj
     262                                    true, // stopAtFirstViol
     263                                    true, // checkALL
     264                                    problem_->getFeasTol());
     265    if(isChecked) {
     266      z = problem_->getRecordBestSol()->getModSolVal();
     267    }
     268#else /* not FM_CHECKNLP2 */
     269    isChecked = problem_ -> checkNLP (nSol, z, true);
     270#endif  /* not FM_CHECKNLP2 */
     271
     272    if (isChecked &&
    190273        (z < problem_ -> getCutOff ())) {
    191274
    192       problem_ -> setCutOff (z);
     275#ifdef FM_CHECKNLP2
     276#ifdef FM_TRACE_OPTSOL
     277      problem_->getRecordBestSol()->update();
     278      best = problem_->getRecordBestSol()->getSol();
     279      objVal = problem_->getRecordBestSol()->getVal();
     280#else /* not FM_TRACE_OPTSOL */
     281      best = problem_->getRecordBestSol()->getModSol();
    193282      objVal = z;
     283#endif /* not FM_TRACE_OPTSOL */
     284#else /* not FM_CHECKNLP2 */
     285#ifdef FM_TRACE_OPTSOL
     286      problem_->getRecordBestSol()->update(nSol, problem_->nVars(),
     287                                           z, problem_->getFeasTol());
     288      best = problem_->getRecordBestSol()->getSol();
     289      objVal = problem_->getRecordBestSol()->getVal();
     290#else /* not FM_TRACE_OPTSOL */
    194291      best   = nSol;
     292      objVal = z;
     293#endif /* not FM_TRACE_OPTSOL */
     294#endif /* not FM_CHECKNLP2 */
     295
     296      problem_ -> setCutOff (objVal);
    195297    }   
    196298  }
  • trunk/Couenne/src/heuristics/CouenneIterativeRounding.cpp

    r553 r574  
    1616#include "cplex.h"
    1717#endif
     18
     19#include "CouenneRecordBestSol.hpp"
    1820
    1921#define MILPTIME 5
     
    551553        // check solution of the NLP;
    552554        // if we have a new incumbent we are done, otherwise we iterate
     555
     556        bool isChecked = false;
     557#ifdef FM_CHECKNLP2
     558        isChecked = couenne_->checkNLP2(tmpSolution, 0, false, // do not care about obj
     559                                        true, // stopAtFirstViol
     560                                        false, // checkALL
     561                                        couenne_->getFeasTol());
     562        if(isChecked) {
     563          obj = couenne_->getRecordBestSol()->getModSolVal();
     564        }
     565#else /* not FM_CHECKNLP2 */
     566        isChecked = couenne_->checkNLP(tmpSolution, obj, true);
     567#endif  /* not FM_CHECKNLP2 */
     568       
    553569        if (cinlp_->isProvenOptimal () &&
    554             couenne_->checkNLP (tmpSolution, obj, true) &&
     570            isChecked &&
    555571            (obj < couenne_->getCutOff())) {
     572         
     573#ifdef FM_CHECKNLP2
     574#ifdef FM_TRACE_OPTSOL
     575          couenne_->getRecordBestSol()->update();
     576          CoinCopyN (couenne_->getRecordBestSol()->getSol(), n, tmpSolution);
     577          obj = couenne_->getRecordBestSol()->getVal();
     578#else /* not FM_TRACE_OPTSOL */
     579          CoinCopyN (couenne_->getRecordBestSol()->getModSol(), n, tmpSolution);
     580#endif /* not FM_TRACE_OPTSOL */
     581#else /* not FM_CHECKNLP2 */
     582         
    556583          //Get correct values for all auxiliary variables
    557584          couenne_ -> getAuxs (tmpSolution);
     585         
     586#ifdef FM_TRACE_OPTSOL
     587          couenne_->getRecordBestSol()->update(tmpSolution, n,
     588                                               obj, couenne_->getFeasTol());
     589          CoinCopyN (couenne_->getRecordBestSol()->getSol(), n, tmpSolution);
     590          obj = couenne_->getRecordBestSol()->getVal();
     591#endif /* FM_TRACE_OPTSOL */
     592#endif /* not FM_CHECKNLP2 */
     593         
    558594          if (babInfo){
    559595            babInfo->setNlpSolution (tmpSolution, n, obj);
    560596            babInfo->setHasNlpSolution (true);
    561597          }
    562 
     598         
    563599          std::cout << "Final Nlp solution with objective " << obj << " :" << std::endl;
    564 
     600         
    565601          if (obj < objectiveValue - COUENNE_EPS) { // found better solution?
    566602            std::cout << "New incumbent found" << std::endl;
     
    568604              *lb = solver -> getColLower (),
    569605              *ub = solver -> getColUpper ();
    570 
     606           
    571607            // check bounds once more after getAux. This avoids false
    572608            // asserts in CbcModel.cpp:8305 on integerTolerance violated
     
    853889      // check solution of the NLP;
    854890      // if we have a new incumbent we are done, otherwise we iterate
     891
     892      bool isChecked = false;
     893#ifdef FM_CHECKNLP2
     894      isChecked = couenne_->checkNLP2(tmpSolution, 0, false, // do not care about obj
     895                                      true, // stopAtFirstViol
     896                                      false, // checkALL
     897                                      couenne_->getFeasTol());
     898      if(isChecked) {
     899        obj = couenne_->getRecordBestSol()->getModSolVal();
     900      }
     901#else /* not FM_CHECKNLP2 */
     902      isChecked = couenne_->checkNLP(tmpSolution, obj, true);
     903#endif  /* not FM_CHECKNLP2 */
     904     
    855905      if (cinlp_->isProvenOptimal () &&
    856           couenne_->checkNLP (tmpSolution, obj, true) &&
     906          isChecked &&
    857907          (obj < couenne_->getCutOff())) {
     908       
     909#ifdef FM_CHECKNLP2
     910#ifdef FM_TRACE_OPTSOL
     911        couenne_->getRecordBestSol()->update();
     912        CoinCopyN (couenne_->getRecordBestSol()->getSol(), n, tmpSolution);
     913        obj = couenne_->getRecordBestSol()->getVal();
     914#else /* not FM_TRACE_OPTSOL */
     915        CoinCopyN (couenne_->getRecordBestSol()->getModSol(), n, tmpSolution);
     916#endif /* not FM_TRACE_OPTSOL */
     917#else /* not FM_CHECKNLP2 */
     918       
    858919        //Get correct values for all auxiliary variables
    859920        couenne_ -> getAuxs (tmpSolution);
     921       
     922#ifdef FM_TRACE_OPTSOL
     923        couenne_->getRecordBestSol()->update(tmpSolution, n,
     924                                             obj, couenne_->getFeasTol());
     925        CoinCopyN (couenne_->getRecordBestSol()->getSol(), n, tmpSolution);
     926        obj = couenne_->getRecordBestSol()->getVal();
     927#endif /* FM_TRACE_OPTSOL */
     928#endif /* not FM_CHECKNLP2 */
     929       
    860930        if (babInfo){
    861931          babInfo->setNlpSolution (tmpSolution, n, obj);
  • trunk/Couenne/src/interfaces/BonCouenneInterface.cpp

    r573 r574  
    261261
    262262#ifdef FM_CHECKNLP2
    263           (p->checkNLP2(solution, 0, false, true, true, p->getFeasTol())) &&
     263          (p->checkNLP2(solution, 0, false, true, false, p->getFeasTol())) &&
    264264          (p->getRecordBestSol()->getModSolVal() < p->getCutOff())
    265265#else
  • trunk/Couenne/src/main/BonCouenne.cpp

    r573 r574  
    115115    if (!couenne.InitializeCouenne (argv, p, NULL, ci, &bb))
    116116      throw infeasible;
     117
     118#ifdef FM_PRINT_INFO
     119    // This assumes that first cut generator is CouenneCutGenerator
     120    CouenneCutGenerator *ccg = dynamic_cast<CouenneCutGenerator *>
     121      (couenne.cutGenerators().begin()->cgl);
     122    if(ccg) {
     123      ccg->setBabPtr(&bb);
     124    }
     125    else {
     126      printf("main(): ### ERROR: Can not get CouenneCutGenerator\n");
     127      exit(1);
     128    }
     129#endif
    117130
    118131    // initial printout
  • trunk/Couenne/src/main/BonCouenneSetup.cpp

    r556 r574  
    879879    }
    880880  }
     881
     882#ifdef FM_UP_BND
     883  double givenAllowFGap2 = 0.0;
     884  options_->GetNumericValue(std::string("allowable_fraction_gap"),
     885                            givenAllowFGap2, "bonmin.");
     886  double upval = 1e50;
     887  printf("CutOff value:\n");
     888  scanf("%lf", &upval);
     889  couenneProb_->setCutOff((1-givenAllowFGap2) * upval);
     890  printf("CutOff set to %f\n", (1-givenAllowFGap2) * upval);
     891#endif
     892
    881893}
  • trunk/Couenne/src/problem/CouenneSolverInterface.cpp

    r573 r574  
    147147
    148148  // check if resolve found new integer solution
    149   bool isChecked = false;                                                       
    150 #ifdef FM_CHECKNLP2                                                             
    151   double curBestVal = 1e50;                                                     
    152   if(cutgen_->Problem()->getRecordBestSol()->getHasSol()) {                     
    153     curBestVal =  cutgen_->Problem()->getRecordBestSol()->getVal();             
    154   }                                                                             
    155   curBestVal = (curBestVal < curCutoff ? curBestVal : curCutoff);               
    156   if(isProvenOptimal()) {                                                       
    157     isChecked = cutgen_->Problem()->checkNLP2(T::getColSolution(),             
    158                                               curBestVal, false,               
    159                                               true, // stopAtFirstViol         
    160                                               true, // checkALL                 
    161                                               cutgen_->Problem()->getFeasTol());         
    162     if(isChecked) {                                                             
    163       objvalGlob = cutgen_->Problem()->getRecordBestSol()->getModSolVal();     
    164                                                                                
    165       if(!(objvalGlob < curBestVal - COUENNE_EPS)) {                           
    166         isChecked = false;                                                     
    167       }                                                                         
    168     }                                                                           
    169   }                                                                             
    170 #else                                                                           
    171   if(isProvenOptimal () &&                                                     
    172      (objvalGlob < curCutoff - COUENNE_EPS)) {                                 
    173     isChecked = cutgen_->Problem()->checkNLP(T::getColSolution (),             
    174                                              objvalGlob, true);                 
    175   }                                                                             
    176                                                                                
    177 #endif
    178 
    179 
    180 
    181   if (//doingResolve () &&                 // this is not called from strong branching
    182       isProvenOptimal () &&
    183       (objvalGlob < curCutoff - COUENNE_EPS) &&
    184       (cutgen_ -> Problem () -> checkNLP (T::getColSolution (), objvalGlob, true)) &&
    185       //      (objvalGlo < curCutoff - COUENNE_EPS) && // check again as it may have changed
     149  bool isChecked = false; 
     150#ifdef FM_CHECKNLP2
     151  double curBestVal = 1e50;                                                   
     152  if(cutgen_->Problem()->getRecordBestSol()->getHasSol()) {
     153    curBestVal =  cutgen_->Problem()->getRecordBestSol()->getVal();
     154  }
     155  curBestVal = (curBestVal < curCutoff ? curBestVal : curCutoff);
     156  if(isProvenOptimal()) {
     157    isChecked = cutgen_->Problem()->checkNLP2(T::getColSolution(),
     158                                              curBestVal, false,
     159                                              true, // stopAtFirstViol
     160                                              true, // checkALL
     161                                              cutgen_->Problem()->getFeasTol());
     162    if(isChecked) {
     163      objvalGlob = cutgen_->Problem()->getRecordBestSol()->getModSolVal();
     164      if(!(objvalGlob < curBestVal - COUENNE_EPS)) {
     165        isChecked = false;
     166      }
     167    }
     168  }
     169#else /* not FM_CHECKNLP2 */
     170  if(isProvenOptimal () &&
     171     (objvalGlob < curCutoff - COUENNE_EPS)) {
     172    isChecked = cutgen_->Problem()->checkNLP(T::getColSolution (),
     173                                             objvalGlob, true);
     174  }
     175#endif /* not FM_CHECKNLP2 */
     176
     177  if (//doingResolve () &&    // this is not called from strong branching
     178      isChecked &&
    186179      (objvalGlob > -COUENNE_INFINITY/2)) {    // check if it makes sense
    187180
     
    189182
    190183    //printf ("new cutoff from CSI: %g\n", objval);
    191     cutgen_ -> Problem () -> setCutOff (objvalGlob, T::getColSolution ());
    192   }
     184    cutgen_ -> Problem () -> setCutOff (objvalGlob);
     185
     186#ifdef FM_TRACE_OPTSOL
     187#ifdef FM_CHECKNLP2
     188    cutgen_->Problem()->getRecordBestSol()->update();
     189#else /* not FM_CHECKNLP2 */
    193190
    194191  // some originals may be unused due to their zero multiplicity (that
     
    202199  }
    203200
     201  cutgen_->Problem()->getRecordBestSol()->update(T::getColSolution(),
     202                                                 cutgen_->Problem()->nVars(),
     203                                                 objvalGlob,
     204                                                 cutgen_->Problem()->getFeasTol());
     205#endif  /* not FM_CHECKNLP2 */
     206#endif /* FM_TRACE_OPTSOL */
     207
     208  }
     209
    204210  // check LP independently
    205211  if (cutgen_ && (cutgen_ -> check_lp ())) {
  • trunk/Couenne/src/problem/reformulate.cpp

    r573 r574  
    111111  CouNumber cutoff;
    112112  // check for initial solution given to Couenne. If feasible, set cutoff
     113
     114#ifdef FM_CHECKNLP2
     115  cutoff = X (objectives_ [0] -> Body () -> Index ());
     116  if(checkNLP2(X(), cutoff, false, // do not care about obj value
     117               true, // stop at first viol
     118               false, // checkAll
     119               getFeasTol())) {
     120   
     121    jnlst_ -> Printf (Ipopt::J_ERROR, J_PROBLEM,
     122                      "Couenne: initial solution (value %g) is MINLP feasible\n",
     123                      cutoff);
     124
     125#ifdef FM_TRACE_OPTSOL
     126    getRecordBestSol()->update();
     127#endif
     128
     129    setCutOff(getRecordBestSol()->getVal(), getRecordBestSol()->getSol());   
     130  }
     131#else /* not FM_CHECKNLP2 */
    113132  if (checkNLP (X (), cutoff = X (objectives_ [0] -> Body () -> Index ()), true)) {
    114133    jnlst_ -> Printf (Ipopt::J_ERROR, J_PROBLEM,
     
    116135                      cutoff);
    117136    setCutOff (cutoff, X ());   
    118   }
    119 
     137
     138#ifdef FM_TRACE_OPTSOL
     139    getRecordBestSol()->update(X(), nVars(), cutoff, getFeasTol());
     140#endif
     141  }
     142#endif /* not FM_CHECKNLP2 */
     143 
    120144  // fill dependence_ structure
    121145  fillDependence (bonBase_, cg);
Note: See TracChangeset for help on using the changeset viewer.