Changeset 307


Ignore:
Timestamp:
Apr 19, 2006 1:07:33 PM (13 years ago)
Author:
forrest
Message:

for bonmin

Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/CbcBranchActual.cpp

    r295 r307  
    758758    solution[columnNumber_],upper[columnNumber_]);*/
    759759  double nearest = floor(value+(1.0-breakEven_));
     760  assert (breakEven_>0.0&&breakEven_<1.0);
    760761  double integerTolerance =
    761762    model_->getDblParam(CbcModel::CbcIntegerTolerance);
  • trunk/CbcBranchDynamic.cpp

    r293 r307  
    311311    return 0.0;
    312312  }
     313  assert (breakEven_>0.0&&breakEven_<1.0);
    313314  double value = solution[columnNumber_];
    314315  value = CoinMax(value, lower[columnNumber_]);
  • trunk/CbcModel.cpp

    r299 r307  
    10411041*/
    10421042  while (!tree_->empty()) {
     1043#ifdef BONMIN
     1044    assert(!solverCharacteristics_->solutionAddsCuts() || solverCharacteristics_->mipFeasible());
     1045#endif
    10431046    if (cutoff > getCutoff()) {
    10441047      double newCutoff = getCutoff();
     
    13641367                anyAction = newNode->chooseBranch(this,node,numberPassesLeft) ; // dynamic did nothing
    13651368            }
     1369            if (solverCharacteristics_ &&
     1370                solverCharacteristics_->solutionAddsCuts() && // we are in some OA based bab
     1371                feasible && (newNode->numberUnsatisfied()==0) //solution has become integer feasible during strong branching
     1372                )
     1373              {
     1374                //in the present case we need to check here integer infeasibility if the node is not fathomed we will have to do the loop
     1375                // again
     1376                std::cout<<solver_<<std::endl;
     1377                solver_->resolve();
     1378                double objval = solver_->getObjValue();
     1379                setBestSolution(CBC_SOLUTION, objval,
     1380                                solver_->getColSolution()) ;
     1381                lastHeuristic_ = NULL;
     1382                int easy=2;
     1383                if (!solverCharacteristics_->mipFeasible())//did we prove that the node could be pruned?
     1384                  feasible = false;
     1385                // Reset the bound now
     1386                solverCharacteristics_->setMipBound(-COIN_DBL_MAX);
     1387               
     1388               
     1389                //numberPassesLeft++;
     1390                solver_->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,&easy) ;
     1391                feasible &= resolve(node ? node->nodeInfo() : NULL,11) != 0 ;
     1392                solver_->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,NULL) ;
     1393                resolved = true ;
     1394                if (problemFeasibility_->feasible(this,0)<0) {
     1395                  feasible=false; // pretend infeasible
     1396                }
     1397                if(feasible)
     1398                  anyAction = -1;
     1399                else
     1400                  anyAction = -2;
     1401              }
    13661402/*
    13671403  Yep, false positives for sure. And no easy way to distinguish honest
     
    14211457              newNode->nodeInfo()->addCuts(cuts,newNode->numberBranches(),
    14221458                                           whichGenerator_) ; } } }
    1423         else
    1424         { anyAction = -2 ; }
     1459        else {
     1460          anyAction = -2 ;
     1461          // Reset bound anyway (no harm if not odd)
     1462          solverCharacteristics_->setMipBound(-COIN_DBL_MAX);
     1463        }
    14251464        // May have slipped through i.e. anyAction == 0 and objective above cutoff
    14261465        // I think this will screw up cut reference counts if executed.
     
    15411580          }
    15421581          else
    1543           { for (i = 0 ; i < currentNumberCuts_ ; i++)
     1582          {
     1583            if(solverCharacteristics_ && //we may be in a non standard bab
     1584               solverCharacteristics_->solutionAddsCuts()// we are in some kind of OA based bab.
     1585               )
     1586              {
     1587                std::cerr<<"You should never get here"<<std::endl;
     1588                throw CoinError("Nodes should not be fathomed on integer infeasibility in this setting",
     1589                                "branchAndBound","CbcModel") ;
     1590              }
     1591            for (i = 0 ; i < currentNumberCuts_ ; i++)
    15441592            { if (addedCuts_[i])
    15451593              { if (!addedCuts_[i]->decrement(1))
     
    57585806        delete [] saveUpper;
    57595807      }
     5808    //If the variables were fixed the cutting plane procedure may have believed that the node could be fathomed
     5809    //re-establish truth.- should do no harm for non nlp
     5810    if(!solutionComesFromNlp && fixVariables)
     5811      solverCharacteristics_->setMipBound(-COIN_DBL_MAX);
    57605812    return objectiveValue;
    57615813  }
  • trunk/CbcNode.cpp

    r300 r307  
    985985        choice[i].possibleBranch = NULL ;
    986986      numberStrong=0;
     987      bool canDoOneHot=false;
    987988      for (i=0;i<numberObjects;i++) {
    988989        CbcObject * object = model->modifiableObject(i);
     
    995996          if (thisOne) {
    996997            int iColumn = thisOne->modelSequence();
     998            bool canDoThisHot=true;
    997999            double targetValue = hotstartSolution[iColumn];
    9981000            if (saveUpper[iColumn]>saveLower[iColumn]) {
     
    10301032                    // can't
    10311033                    priorityLevel += 10000000;
     1034                    canDoThisHot=false;
    10321035                  }
    10331036                } else {
    10341037                  priorityLevel += 10000000;
     1038                  canDoThisHot=false;
    10351039                }
    10361040              } else {
    10371041                // switch off if not possible
    1038                 hotstartSolution=NULL;
    1039                 model->setHotstartSolution(NULL,NULL);
     1042                canDoThisHot=false;
    10401043              }
     1044              if (canDoThisHot)
     1045                canDoOneHot=true;
    10411046            } else if (targetValue<saveLower[iColumn]||targetValue>saveUpper[iColumn]) {
    1042               // switch off as not possible
    1043               hotstartSolution=NULL;
    1044               model->setHotstartSolution(NULL,NULL);
    10451047            }
    10461048          } else {
     
    10871089          }
    10881090        }
     1091      }
     1092      if (!canDoOneHot&&hotstartSolution) {
     1093        // switch off as not possible
     1094        hotstartSolution=NULL;
     1095        model->setHotstartSolution(NULL,NULL);
    10891096      }
    10901097      if (numberUnsatisfied_) {
     
    27282735                                        numberIntegerInfeasibilities,
    27292736                                        numberObjectInfeasibilities)) {
     2737#ifdef BONMIN
     2738              //In this case node has become integer feasible, let us exit the loop
     2739              std::cout<<"Node has become integer feasible"<<std::endl;
     2740              numberUnsatisfied_ = 0;
     2741              break;
     2742#endif
    27302743              double objValue = solver->getObjValue();
    27312744              model->setBestSolution(CBC_STRONGSOL,
     
    27772790                                          choice.numObjInfeasUp)
    27782791                  &&model->problemFeasibility()->feasible(model,-1)>=0) {
     2792#ifdef BONMIN
     2793                std::cout<<"Node has become integer feasible"<<std::endl;
     2794                numberUnsatisfied_ = 0;
     2795                break;
     2796#endif
    27792797                if (auxiliaryInfo->solutionAddsCuts()) {
    27802798                  needHotStartUpdate=true;
Note: See TracChangeset for help on using the changeset viewer.