Changeset 2382 for trunk


Ignore:
Timestamp:
Sep 3, 2018 9:09:44 AM (11 months ago)
Author:
forrest
Message:

coding for getting postprocessed model

Location:
trunk/Cbc/src
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src/CbcHeuristic.cpp

    r2354 r2382  
    11111111                    model.setMaximumNodes(numberNodes);
    11121112                    model.solver()->setHintParam(OsiDoReducePrint, true, OsiHintTry);
    1113                     if ((saveModelOptions&2048) == 0)
     1113                    if ((saveModelOptions&2048) == 0) 
    11141114                      model.setMoreSpecialOptions(model_->moreSpecialOptions());
    1115                       model.setMoreSpecialOptions2(model_->moreSpecialOptions2());
     1115                    model.setMoreSpecialOptions2(model_->moreSpecialOptions2());
    11161116                    // off conflict analysis
    11171117                    model.setMoreSpecialOptions(model.moreSpecialOptions()&~4194304);
     
    11411141                    }
    11421142                } else {
     1143                    // modify for event handler
    11431144                    model.setSpecialOptions(saveModelOptions);
    11441145                    model_->messageHandler()->message(CBC_RESTART, model_->messages())
     
    14571458                    }
    14581459#endif
     1460                    model.setPreProcess(&process);
    14591461                    model.branchAndBound();
    14601462                    model_->setHeuristicModel(NULL);
  • trunk/Cbc/src/CbcHeuristicDive.cpp

    r2344 r2382  
    11691169    memcpy(betterSolution, newSolution, numberColumns*sizeof(double));
    11701170
    1171     delete [] newSolution;
    1172     return returnCode;
     1171  delete [] newSolution;
     1172  return returnCode;
    11731173}
    11741174/* returns 0 if no solution, 1 if valid solution
  • trunk/Cbc/src/CbcHeuristicFPump.cpp

    r2344 r2382  
    10561056                                    model_->setBestSolution(saveOldSolution, numberColumns, saveObjectiveValue);
    10571057                                delete [] saveOldSolution;
    1058                                 realCutoff = model_->getMinimizationObjValue();
     1058                                realCutoff = model_->getMinimizationObjValue()-model_->getCutoffIncrement();
    10591059                            }
    10601060                            if (action == 0 || model_->maximumSecondsReached()) {
     
    19331933            solutionValue = roundingObjective;
    19341934            newSolutionValue = solutionValue;
    1935             realCutoff=solutionValue-1.0e-5;
     1935            realCutoff=solutionValue-model_->getCutoffIncrement();
    19361936            memcpy(betterSolution, roundingSolution, numberColumns*sizeof(double));
    19371937            solutionFound = true;
     
    20562056                    double cutoff2 = newSolutionValue +
    20572057                                     CoinMax(model_->getCutoffIncrement(), 1.0e-3);
     2058                    cutoff2 = CoinMin(cutoff2,realCutoff);
    20582059#if 0
    20592060                      {
  • trunk/Cbc/src/CbcHeuristicGreedy.cpp

    r2280 r2382  
    18581858          if (!columnLength[iColumn])
    18591859            continue;
    1860             if (columnLower[iColumn] < 0.0 || columnUpper[iColumn] > 1.0)
    1861                 good = false;
    1862             CoinBigIndex j;
    1863             int nSOS=0;
    1864             if (!isHeuristicInteger(solver,iColumn))
     1860          if (columnLower[iColumn] < 0.0 || columnUpper[iColumn] > 1.0)
     1861            good = false;
     1862          CoinBigIndex j;
     1863          int nSOS=0;
     1864          if (!isHeuristicInteger(solver,iColumn))
     1865            good = false;
     1866          for (j = columnStart[iColumn];
     1867               j < columnStart[iColumn] + columnLength[iColumn]; j++) {
     1868            if (element[j] < 0.0)
    18651869              good = false;
    1866             for (j = columnStart[iColumn];
    1867                     j < columnStart[iColumn] + columnLength[iColumn]; j++) {
    1868                 if (element[j] < 0.0)
    1869                     good = false;
    1870                 int iRow = row[j];
    1871                 if (originalRhs_[iRow]==-1.0) {
    1872                   if (element[j] != 1.0)
    1873                     good = false;
    1874                   nSOS++;
    1875                 }
    1876             }
    1877             if (nSOS > 1)
    1878               good = false;
     1870            int iRow = row[j];
     1871            if (originalRhs_[iRow]==-1.0) {
     1872              if (element[j] != 1.0)
     1873                good = false;
     1874              nSOS++;
     1875            }
     1876          }
     1877          if (nSOS > 1)
     1878            good = false;
    18791879        }
    18801880        if (!good)
  • trunk/Cbc/src/CbcHeuristicRINS.cpp

    r2280 r2382  
    254254                  break;
    255255                case 1:
    256                 if (nearest==originalLower)
    257                   fix = true;
     256                  if (nearest==originalLower)
     257                    fix = true;
    258258                  break;
    259259                case 2:
    260                 if (nearest!=originalLower)
    261                   fix = true;
     260                  if (nearest!=originalLower)
     261                    fix = true;
    262262                  break;
    263263                case 3:
    264                 if (nearest==originalLower && !used[iColumn])
    265                   fix = true;
     264                  if (nearest==originalLower && !used[iColumn])
     265                    fix = true;
    266266                  break;
    267267                }
  • trunk/Cbc/src/CbcModel.cpp

    r2380 r2382  
    56105610        testSolution_(NULL),
    56115611        globalConflictCuts_(NULL),
    5612         minimumDrop_(1.0e-4),
     5612        minimumDrop_(1.0e-7),
    56135613        numberSolutions_(0),
    56145614        numberSavedSolutions_(0),
     
    56335633        maximumDepth_(0),
    56345634        walkback_(NULL),
     5635        preProcess_(NULL),
    56355636        lastNodeInfo_(NULL),
    56365637        lastCut_(NULL),
     
    57845785        sumChangeObjective2_(0.0),
    57855786        globalConflictCuts_(NULL),
    5786         minimumDrop_(1.0e-4),
     5787        minimumDrop_(1.0e-7),
    57875788        numberSolutions_(0),
    57885789        numberSavedSolutions_(0),
     
    58065807        maximumDepth_(0),
    58075808        walkback_(NULL),
     5809        preProcess_(NULL),
    58085810        lastNodeInfo_(NULL),
    58095811        lastCut_(NULL),
     
    61176119        status_(rhs.status_),
    61186120        secondaryStatus_(rhs.secondaryStatus_),
     6121        preProcess_(rhs.preProcess_),
    61196122        specialOptions_(rhs.specialOptions_),
    61206123        moreSpecialOptions_(rhs.moreSpecialOptions_),
     
    65176520        numberExtraIterations_ = rhs.numberExtraIterations_;
    65186521        numberExtraNodes_ = rhs.numberExtraNodes_;
     6522        preProcess_ = rhs.preProcess_;
    65196523        numberFathoms_ = rhs.numberFathoms_;
    65206524        continuousObjective_ = rhs.continuousObjective_;
     
    1879618800    solver_ = process->originalModel();
    1879718801}
     18802
    1879818803/* Process root node and return a strengthened model
    1879918804
     
    1980619811  return cleanVariables;
    1980719812}
    19808 
    19809 
     19813/* Returns postProcessed solution in solver(called from event handler)
     19814   Normally used for integer solution (not really tested otherwise)
     19815   solutionType 1 is best integer so far, 0 is current solution
     19816   (may not be integer) */
     19817const OsiSolverInterface *
     19818CbcModel::postProcessedSolver(int solutionType)
     19819{
     19820  CbcModel * model = this;
     19821  CglPreProcess * processPointer = model->preProcess();
     19822  OsiSolverInterface * originalModel = NULL;
     19823  const double * solution = bestSolution();
     19824  while (processPointer) {
     19825    int numberSolvers = processPointer->numberSolvers();
     19826    OsiSolverInterface * solver =
     19827      processPointer->presolve(numberSolvers-1)->presolvedModel();
     19828    if (solutionType) {
     19829      // massage solution
     19830      int numberColumns = solver->getNumCols();
     19831      double * saveLower = CoinCopyOfArray(model->solver()->getColLower(),numberColumns);
     19832      double * saveUpper = CoinCopyOfArray(model->solver()->getColUpper(),numberColumns);
     19833      const double * saveSolution = testSolution_;
     19834      setTestSolution(solution);
     19835      model->solver()->setColLower(solution);
     19836      model->solver()->setColUpper(solution);
     19837      OsiBranchingInformation usefulInfo = model->usefulInformation();
     19838      /*
     19839        Run through the objects and use feasibleRegion() to set variable bounds
     19840        so as to fix the variables specified in the objects at their value in this
     19841        solution. Since the object list contains (at least) one object for every
     19842        integer variable, this has the effect of fixing all integer variables.
     19843      */
     19844      for (int i = 0; i < model->numberObjects(); i++)
     19845        model->object(i)->feasibleRegion(solver, &usefulInfo);
     19846      setTestSolution(saveSolution);
     19847      model->solver()->setColLower(saveLower);
     19848      model->solver()->setColUpper(saveUpper);
     19849      delete [] saveLower;
     19850      delete [] saveUpper;
     19851    }
     19852    solver->resolve();
     19853    processPointer->postProcess(*solver,false);
     19854    originalModel = processPointer->originalModel();
     19855    solution = originalModel->getColSolution();
     19856    processPointer=NULL;
     19857    model = model->parentModel();
     19858    processPointer = model ? model->preProcess() : NULL;
     19859  }
     19860  return originalModel;
     19861}
  • trunk/Cbc/src/CbcModel.hpp

    r2373 r2382  
    320320    void postProcess(CglPreProcess * process);
    321321#endif
     322    /// Returns CglPreProcess used before branch and bound
     323    inline CglPreProcess * preProcess( ) const
     324    { return preProcess_;}
     325    /// Set CglPreProcess used before branch and bound
     326    inline void setPreProcess(CglPreProcess * preProcess)
     327    { preProcess_ = preProcess;}
    322328    /// Adds an update information object
    323329    void addUpdateInformation(const CbcObjectUpdateData & data);
     
    438444    */
    439445    void analyzeObjective();
     446    /** Returns postProcessed solution in solver(called from event handler)
     447     Normally used for integer solution (not really tested otherwise)
     448    solutionType 1 is best integer so far, 0 is current solution
     449    (may not be integer) */
     450    const OsiSolverInterface * postProcessedSolver(int solutionType=1);
    440451
    441452    /**
     
    26032614    */
    26042615    CbcNodeInfo ** walkback_;
     2616    /// preProcess used before branch and bound (optional)
     2617    CglPreProcess * preProcess_;
    26052618    CbcNodeInfo ** lastNodeInfo_;
    26062619    const OsiRowCut ** lastCut_;
  • trunk/Cbc/src/CbcSolver.cpp

    r2381 r2382  
    13211321    bool useSignalHandler = parameterData.useSignalHandler_;
    13221322    CbcModel & model_ = model;
     1323    CglPreProcess * preProcessPointer=NULL;
    13231324#ifdef CBC_THREAD_SAFE
    13241325    // Initialize argument
     
    43584359                                          process.setOptions(2+4+8); // no cuts
    43594360                                        cbcPreProcessPointer = & process;
     4361                                        preProcessPointer = & process; // threadsafe
    43604362                                        int saveOptions = osiclp->getModelPtr()->moreSpecialOptions();
    43614363                                        if ((model_.specialOptions()&16777216)!=0&&
     
    43814383#elif CBC_OTHER_SOLVER==1
    43824384                                    cbcPreProcessPointer = & process;
     4385                                    preProcessPointer = & process; // threadsafe
    43834386                                    redoSOS=true;
    43844387                                    solver2 = process.preProcessNonDefault(*saveSolver, translate[preProcess], numberPasses,
     
    54725475                                        babModel_->setMaximumCutPassesAtRoot(100); // use minimum drop
    54735476                                    else
    5474                                         babModel_->setMaximumCutPassesAtRoot(20);
     5477                                        babModel_->setMaximumCutPassesAtRoot(50);
    54755478                                } else {
    54765479                                    babModel_->setMaximumCutPassesAtRoot(cutPass);
     
    72167219                                  else
    72177220                                    sprintf(generalPrint,"Ending major passes - no solution found");
    7218                                     generalMessageHandler->message(CLP_GENERAL, generalMessages)
     7221                                  generalMessageHandler->message(CLP_GENERAL, generalMessages)
    72197222                                      << generalPrint
    72207223                                      << CoinMessageEol;
     
    72367239                                }
    72377240#endif
     7241                                // Set up pointer to preProcess
     7242                                if (preProcessPointer) {
     7243                                  babModel_->setPreProcess(preProcessPointer);
     7244                                }
    72387245                                babModel_->branchAndBound(statistics);
    72397246                                if (truncateColumns<babModel_->solver()->getNumCols()) {
Note: See TracChangeset for help on using the changeset viewer.