Ignore:
Timestamp:
Jun 26, 2007 5:59:58 AM (12 years ago)
Author:
forrest
Message:

update branches/devel for threads

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/devel/Cbc/src/CbcCutGenerator.cpp

    r529 r642  
    8383  model_ = rhs.model_;
    8484  generator_=rhs.generator_->clone();
    85   generator_->refreshSolver(model_->solver());
     85  //generator_->refreshSolver(model_->solver());
    8686  whenCutGenerator_=rhs.whenCutGenerator_;
    8787  whenCutGeneratorInSub_ = rhs.whenCutGeneratorInSub_;
     
    160160*/
    161161bool
    162 CbcCutGenerator::generateCuts( OsiCuts & cs , bool fullScan, CbcNode * node)
     162CbcCutGenerator::generateCuts( OsiCuts & cs , bool fullScan, OsiSolverInterface * solver, CbcNode * node)
    163163{
    164164  int howOften = whenCutGenerator_;
     
    172172    howOften=1;
    173173  bool returnCode=false;
    174   OsiSolverInterface * solver = model_->solver();
     174  //OsiSolverInterface * solver = model_->solver();
    175175  int depth;
    176176  if (node)
     
    210210    if (!generator) {
    211211      // Pass across model information in case it could be useful
    212       //OsiSolverInterface * solver = model_->solver();
    213212      //void * saveData = solver->getApplicationData();
    214213      //solver->setApplicationData(model_);
     
    235234      int numberColumns = solver->getNumCols();
    236235      double primalTolerance = 1.0e-8;
    237 #if 0
    238       int numberChanged=0,ifCut=0;
    239       CoinPackedVector lbs;
    240       CoinPackedVector ubs;
    241       for (j=0;j<numberColumns;j++) {
    242         if (solver->isInteger(j)) {
    243           if (tightUpper[j]<upper[j]) {
    244             numberChanged++;
    245             assert (tightUpper[j]==floor(tightUpper[j]+0.5));
    246             ubs.insert(j,tightUpper[j]);
    247             if (tightUpper[j]<solution[j]-primalTolerance)
    248               ifCut=1;
    249           }
    250           if (tightLower[j]>lower[j]) {
    251             numberChanged++;
    252             assert (tightLower[j]==floor(tightLower[j]+0.5));
    253             lbs.insert(j,tightLower[j]);
    254             if (tightLower[j]>solution[j]+primalTolerance)
    255               ifCut=1;
    256           }
    257         } else {
    258           if (tightUpper[j]==tightLower[j]&&
    259               upper[j]>lower[j]) {
    260             // fix
    261             //solver->setColLower(j,tightLower[j]);
    262             //solver->setColUpper(j,tightUpper[j]);
    263             double value = tightUpper[j];
    264             numberChanged++;
    265             if (value<upper[j])
    266               ubs.insert(j,value);
    267             if (value>lower[j])
    268               lbs.insert(j,value);
    269           }
    270         }
    271       }
    272       if (numberChanged) {
    273         OsiColCut cc;
    274         cc.setUbs(ubs);
    275         cc.setLbs(lbs);
    276         if (ifCut) {
    277           cc.setEffectiveness(100.0);
    278         } else {
    279           cc.setEffectiveness(1.0e-5);
    280         }
    281         cs.insert(cc);
    282       }
    283       // need to resolve if some bounds changed
    284       returnCode = !solver->basisIsAvailable();
    285       assert (!returnCode);
    286 #else
    287236      const char * tightenBounds = generator->tightenBounds();
    288       for (j=0;j<numberColumns;j++) {
    289         if (solver->isInteger(j)) {
    290           if (tightUpper[j]<upper[j]) {
    291             double nearest = floor(tightUpper[j]+0.5);
    292             //assert (fabs(tightUpper[j]-nearest)<1.0e-5); may be infeasible
    293             solver->setColUpper(j,nearest);
    294             if (nearest<solution[j]-primalTolerance)
    295               returnCode=true;
    296           }
    297           if (tightLower[j]>lower[j]) {
    298             double nearest = floor(tightLower[j]+0.5);
    299             //assert (fabs(tightLower[j]-nearest)<1.0e-5); may be infeasible
    300             solver->setColLower(j,nearest);
    301             if (nearest>solution[j]+primalTolerance)
    302               returnCode=true;
    303           }
    304         } else {
    305           if (upper[j]>lower[j]) {
    306             if (tightUpper[j]==tightLower[j]) {
    307               // fix
    308               solver->setColLower(j,tightLower[j]);
    309               solver->setColUpper(j,tightUpper[j]);
    310               if (tightLower[j]>solution[j]+primalTolerance||
    311                   tightUpper[j]<solution[j]-primalTolerance)
    312                 returnCode=true;
    313             } else if (tightenBounds&&tightenBounds[j]) {
    314               solver->setColLower(j,CoinMax(tightLower[j],lower[j]));
    315               solver->setColUpper(j,CoinMin(tightUpper[j],upper[j]));
    316               if (tightLower[j]>solution[j]+primalTolerance||
    317                   tightUpper[j]<solution[j]-primalTolerance)
     237      if ((model_->getThreadMode()&2)==0) {
     238        for (j=0;j<numberColumns;j++) {
     239          if (solver->isInteger(j)) {
     240            if (tightUpper[j]<upper[j]) {
     241              double nearest = floor(tightUpper[j]+0.5);
     242              //assert (fabs(tightUpper[j]-nearest)<1.0e-5); may be infeasible
     243              solver->setColUpper(j,nearest);
     244              if (nearest<solution[j]-primalTolerance)
    318245                returnCode=true;
    319246            }
     247            if (tightLower[j]>lower[j]) {
     248              double nearest = floor(tightLower[j]+0.5);
     249              //assert (fabs(tightLower[j]-nearest)<1.0e-5); may be infeasible
     250              solver->setColLower(j,nearest);
     251              if (nearest>solution[j]+primalTolerance)
     252                returnCode=true;
     253            }
     254          } else {
     255            if (upper[j]>lower[j]) {
     256              if (tightUpper[j]==tightLower[j]) {
     257                // fix
     258                solver->setColLower(j,tightLower[j]);
     259                solver->setColUpper(j,tightUpper[j]);
     260                if (tightLower[j]>solution[j]+primalTolerance||
     261                    tightUpper[j]<solution[j]-primalTolerance)
     262                  returnCode=true;
     263              } else if (tightenBounds&&tightenBounds[j]) {
     264                solver->setColLower(j,CoinMax(tightLower[j],lower[j]));
     265                solver->setColUpper(j,CoinMin(tightUpper[j],upper[j]));
     266                if (tightLower[j]>solution[j]+primalTolerance||
     267                    tightUpper[j]<solution[j]-primalTolerance)
     268                  returnCode=true;
     269              }
     270            }
    320271          }
    321         }
     272        }
     273      } else {
     274        CoinPackedVector lbs;
     275        CoinPackedVector ubs;
     276        int numberChanged=0;
     277        bool ifCut=false;
     278        for (j=0;j<numberColumns;j++) {
     279          if (solver->isInteger(j)) {
     280            if (tightUpper[j]<upper[j]) {
     281              double nearest = floor(tightUpper[j]+0.5);
     282              //assert (fabs(tightUpper[j]-nearest)<1.0e-5); may be infeasible
     283              ubs.insert(j,nearest);
     284              numberChanged++;
     285              if (nearest<solution[j]-primalTolerance)
     286                ifCut=true;
     287            }
     288            if (tightLower[j]>lower[j]) {
     289              double nearest = floor(tightLower[j]+0.5);
     290              //assert (fabs(tightLower[j]-nearest)<1.0e-5); may be infeasible
     291              lbs.insert(j,nearest);
     292              numberChanged++;
     293              if (nearest>solution[j]+primalTolerance)
     294                ifCut=true;
     295            }
     296          } else {
     297            if (upper[j]>lower[j]) {
     298              if (tightUpper[j]==tightLower[j]) {
     299                // fix
     300                lbs.insert(j,tightLower[j]);
     301                ubs.insert(j,tightUpper[j]);
     302                if (tightLower[j]>solution[j]+primalTolerance||
     303                    tightUpper[j]<solution[j]-primalTolerance)
     304                  ifCut=true;
     305              } else if (tightenBounds&&tightenBounds[j]) {
     306                lbs.insert(j,CoinMax(tightLower[j],lower[j]));
     307                ubs.insert(j,CoinMin(tightUpper[j],upper[j]));
     308                if (tightLower[j]>solution[j]+primalTolerance||
     309                    tightUpper[j]<solution[j]-primalTolerance)
     310                  ifCut=true;
     311              }
     312            }
     313          }
     314        }
     315        if (numberChanged) {
     316          OsiColCut cc;
     317          cc.setUbs(ubs);
     318          cc.setLbs(lbs);
     319          if (ifCut) {
     320            cc.setEffectiveness(100.0);
     321          } else {
     322            cc.setEffectiveness(1.0e-5);
     323          }
     324          cs.insert(cc);
     325        }
    322326      }
    323327      //if (!solver->basisIsAvailable())
    324328      //returnCode=true;
    325 #endif
    326329#if 0
    327330      // Pass across info to pseudocosts
     
    352355      int k ;
    353356      int nOdd=0;
    354       const OsiSolverInterface * solver = model_->solver();
     357      //const OsiSolverInterface * solver = model_->solver();
    355358      for (k = numberRowCutsAfter-1;k>=numberRowCutsBefore;k--) {
    356359        OsiRowCut & thisCut = cs.rowCut(k) ;
Note: See TracChangeset for help on using the changeset viewer.