Changeset 2013 for trunk


Ignore:
Timestamp:
Mar 7, 2014 12:00:35 PM (5 years ago)
Author:
forrest
Message:

mods for mipstart

Location:
trunk/Cbc/src
Files:
3 edited

Legend:

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

    r1957 r2013  
    8282      model->messageHandler()->message(CBC_GENERAL, model->messages())
    8383        << printLine << CoinMessageEol;
     84      if (colValues.size()<model->getNumCols()) {
     85        int numberColumns = model->getNumCols();
     86        OsiSolverInterface * solver = model->solver();
     87        vector< pair< string, double > > fullValues;
     88        /* for fast search of column names */
     89        map< string, int > colIdx;
     90        for (int i=0;i<numberColumns;i++) {
     91          fullValues.push_back( pair<string, double>(solver->getColName(i),0.0) );
     92          colIdx[solver->getColName(i)] = i;
     93        }
     94        for ( int i=0 ; (i<(int)colValues.size()) ; ++i )
     95          {
     96            map< string, int >::const_iterator mIt = colIdx.find( colValues[i].first );
     97            if ( mIt != colIdx.end() ) {
     98              const int idx = mIt->second;
     99              double v = colValues[i].second;
     100              fullValues[idx].second=v;
     101            }
     102          }
     103        colValues=fullValues;
     104      }
    84105   } else
    85106   {
     
    105126   map< string, int > colIdx;
    106127   assert( ((int)colNames.size()) == lp->getNumCols() );
    107 
    108128   /* for fast search of column names */
    109129   for ( int i=0 ; (i<(int)colNames.size()) ; ++i )
     
    170190   lp->setHintParam(OsiDoPresolveInInitial, true, OsiHintDo) ;
    171191#endif
     192   lp->setDblParam(OsiDualObjectiveLimit,COIN_DBL_MAX);
    172193   lp->initialSolve();
    173194   //lp->writeMps("fixed","mps");
  • trunk/Cbc/src/CbcModel.cpp

    r2003 r2013  
    7171#include "CglStored.hpp"
    7272#include "CglClique.hpp"
     73#include "CglKnapsackCover.hpp"
    7374
    7475#include "CoinTime.hpp"
     
    38433844        if (toZero[number01]) {
    38443845            CglTreeProbingInfo info(*probingInfo_);
    3845 #ifdef JJF_ZERO
    3846             /*
    3847               Marginal idea. Further exploration probably good. Build some extra
    3848               cliques from probing info. Not quite worth the effort?
    3849             */
    3850             OsiSolverInterface * fake = info.analyze(*solver_, 1);
    3851             if (fake) {
    3852                 fake->writeMps("fake");
     3846            if ((moreSpecialOptions_&1048576)!=0&&!parentModel_) {
     3847              /*
     3848                Marginal idea. Further exploration probably good. Build some extra
     3849                cliques from probing info. Not quite worth the effort?
     3850              */
     3851              CglProbing generator1;
     3852              generator1.setUsingObjective(false);
     3853              generator1.setMaxPass(1);
     3854              generator1.setMaxPassRoot(1);
     3855              generator1.setMaxLook(100);
     3856              generator1.setRowCuts(3);
     3857              generator1.setMaxElements(300);
     3858              generator1.setMaxProbeRoot(solver_->getNumCols());
     3859              CoinThreadRandom randomGenerator;
     3860              //CglTreeProbingInfo info(solver_);
     3861              info.level = 0;
     3862              info.formulation_rows = solver_->getNumRows();
     3863              info.inTree = false;
     3864              info.randomNumberGenerator=&randomGenerator;
     3865              info.pass=4;
     3866              generator1.setMode(8);
     3867              OsiCuts cs;
     3868              generator1.generateCutsAndModify(*solver_,cs,&info);
     3869              // very clunky
     3870              OsiSolverInterface * temp = generator1.cliqueModel(solver_,2);
     3871              CglPreProcess dummy;
     3872              OsiSolverInterface * newSolver=dummy.cliqueIt(*temp,0.0001);
     3873              delete temp;
     3874              OsiSolverInterface * fake = NULL;
     3875              if (newSolver) {
     3876#if 0
     3877                int numberCliques = generator1.numberCliques();
     3878                cliqueEntry * entry = generator1.cliqueEntry();
     3879                cliqueType * type = new cliqueType [numberCliques];
     3880                int * start = new int [numberCliques+1];
     3881                start[numberCliques]=2*numberCliques;
     3882                int n=0;
     3883                for (int i=0;i<numberCliques;i++) {
     3884                  start[i]=2*i;
     3885                  setOneFixesInCliqueEntry(entry[2*i],true);
     3886                  setOneFixesInCliqueEntry(entry[2*i+1],true);
     3887                  type[i]=0;
     3888                }
     3889                fake = info.analyze(*solver_, 1,numberCliques,start,
     3890                                    entry,type);
     3891                delete [] type;
     3892                delete [] entry;
     3893#else
     3894                fake = info.analyze(*newSolver, 1,-1);
     3895#endif
     3896                delete newSolver;
     3897              } else {
     3898                fake = info.analyze(*solver_, 1);
     3899              }
     3900              if (fake) {
     3901                //fake->writeMps("fake");
    38533902                CglFakeClique cliqueGen(fake);
    38543903                cliqueGen.setStarCliqueReport(false);
     
    38573906                addCutGenerator(&cliqueGen, 1, "Fake cliques", true, false, false, -200);
    38583907                generator_[numberCutGenerators_-1]->setTiming(true);
    3859             }
    3860 #endif
     3908                for (int i = 0; i < numberCutGenerators_; i++) {
     3909                  CglKnapsackCover * cutGen =
     3910                  dynamic_cast<CglKnapsackCover *>(generator_[i]->generator());
     3911                  if (cutGen) {
     3912                    cutGen->createCliques(*fake,2,200,false);
     3913                  }
     3914                }
     3915              }
     3916            }
    38613917            if (probingInfo_->packDown()) {
    38623918#ifdef CLP_INVESTIGATE
     
    50625118    originalContinuousObjective_ = solver_->getObjValue() * solver_->getObjSense();
    50635119    bestPossibleObjective_ = originalContinuousObjective_;
     5120    if (solver_->isProvenDualInfeasible())
     5121      originalContinuousObjective_ = -COIN_DBL_MAX;
    50645122    delete [] continuousSolution_;
    50655123    continuousSolution_ = CoinCopyOfArray(solver_->getColSolution(),
     
    66096667CbcModel::isProvenInfeasible() const
    66106668{
    6611     if (!status_ && bestObjective_ >= 1.0e30)
     6669    if (!status_ && (bestObjective_ >= 1.0e30  && !secondaryStatus_))
    66126670        return true;
    66136671    else
     
    79047962#define CHECK_DEBUGGER
    79057963#ifdef CHECK_DEBUGGER
    7906                 if ((specialOptions_&1) != 0 ) {
     7964                if ((specialOptions_&1) != 0 && ! parentModel_) {
    79077965                  CoinAssert (!solver_->getRowCutDebuggerAlways()->invalidCut(*thisCut));
    79087966                }
     
    1368713745{
    1368813746    if (status_ != -1) {
    13689         return originalContinuousObjective_ < 1.0e50;
     13747        return fabs(originalContinuousObjective_) < 1.0e50;
    1369013748    } else {
    1369113749        return solver_->isProvenOptimal();
     
    1749217550    bool hitMaxTime = (totalTime >= maxSeconds);
    1749317551    if (parentModel_ && !hitMaxTime) {
    17494         // In a sub tree so need to add both times
    17495         totalTime += parentModel_->getCurrentSeconds();
     17552        // In a sub tree
     17553        assert (parentModel_);
    1749617554        maxSeconds = parentModel_->getMaximumSeconds();
    1749717555        hitMaxTime = (totalTime >= maxSeconds);
  • trunk/Cbc/src/CbcSolver.cpp

    r1998 r2013  
    976976extern int CbcOrClpEnvironmentIndex;
    977977
     978int callCbc1(const char * input2, CbcModel & model,
     979             int callBack(CbcModel * currentSolver, int whereFrom),
     980             CbcSolverUsefulData & parameterData);
     981
    978982/*
    979983  Wrappers for CbcMain0, CbcMain1. The various forms of callCbc will eventually
     
    10271031int callCbc(const char * input2, CbcModel & babSolver)
    10281032{
    1029     CbcMain0(babSolver);
    1030     return callCbc1(input2, babSolver);
     1033  CbcSolverUsefulData data;
     1034#ifndef CBC_NO_INTERRUPT
     1035    data.useSignalHandler_=true;
     1036#endif
     1037#ifndef CBC_NO_PRINTING
     1038    data.noPrinting_ = false;
     1039#endif
     1040  CbcMain0(babSolver, data);
     1041  return callCbc1(input2, babSolver, dummyCallBack, data);
    10311042}
    10321043
     
    10711082    return returnCode;
    10721083}
    1073 
    1074 static CbcSolverUsefulData staticParameterData;
    10751084int callCbc1(const char * input2, CbcModel & model,
    1076              int callBack(CbcModel * currentSolver, int whereFrom))
     1085             int callBack(CbcModel * currentSolver, int whereFrom),
     1086             CbcSolverUsefulData & parameterData)
    10771087{
    10781088    char * input = CoinStrdup(input2);
     
    11201130    argv[n+1] = CoinStrdup("-quit");
    11211131    free(input);
    1122     // allow interrupts and printing
    1123     staticParameterData.noPrinting_ = false;
    1124     staticParameterData.useSignalHandler_=true;
    11251132    currentBranchModel = NULL;
    11261133    CbcOrClpRead_mode = 1;
    11271134    CbcOrClpReadCommand = stdin;
    11281135    int returnCode = CbcMain1(n + 2, const_cast<const char **>(argv),
    1129                               model, callBack,staticParameterData);
     1136                              model, callBack,parameterData);
    11301137    for (int k = 0; k < n + 2; k++)
    11311138        free(argv[k]);
    11321139    delete [] argv;
    11331140    return returnCode;
     1141}
     1142static CbcSolverUsefulData staticParameterData;
     1143int callCbc1(const char * input2, CbcModel & model,
     1144             int callBack(CbcModel * currentSolver, int whereFrom))
     1145{
     1146  // allow interrupts and printing
     1147#ifndef CBC_NO_INTERRUPT
     1148  staticParameterData.useSignalHandler_=true;
     1149#endif
     1150#ifndef CBC_NO_PRINTING
     1151  staticParameterData.noPrinting_ = false;
     1152#endif
     1153  return callCbc1(input2,model,callBack,staticParameterData);
    11341154}
    11351155
     
    38283848                              {
    38293849                                CbcModel tempModel=*babModel_;
     3850                                assert (babModel_->getNumCols()==model_.getNumCols());
    38303851                                std::vector< std::string > colNames;
    3831                                 for ( int i=0 ; (i<babModel_->solver()->getNumCols()) ; ++i )
     3852                                for ( int i=0 ; (i<model_.solver()->getNumCols()) ; ++i )
    38323853                                  colNames.push_back( model_.solver()->getColName(i) );
    3833                                 std::vector< double > x( babModel_->getNumCols(), 0.0 );
     3854                                std::vector< double > x( model_.getNumCols(), 0.0 );
    38343855                                double obj;
    38353856                                int status = computeCompleteSolution( &tempModel, colNames, mipStartBefore, &x[0], obj );
    38363857                                // set cutoff
    3837                                 if (!status)
     3858                                if (!status) {
    38383859                                  babModel_->setCutoff(CoinMin(babModel_->getCutoff(),obj+1.0e-4));
     3860                                  babModel_->setBestSolution( &x[0], static_cast<int>(x.size()), obj, false );
     3861                                  babModel_->setSolutionCount(1);
     3862                                  model_.setCutoff(CoinMin(model_.getCutoff(),obj+1.0e-4));
     3863                                  model_.setBestSolution( &x[0], static_cast<int>(x.size()), obj, false );
     3864                                  model_.setSolutionCount(1);
     3865                                }
    38393866                              }
    38403867                            if (preProcess && type == CBC_PARAM_ACTION_BAB) {
     
    39904017                                        numberPasses = (tunePreProcess / 1000000) - 1;
    39914018                                        tunePreProcess = tunePreProcess % 1000000;
    3992                                     } else if (tunePreProcess >= 1000) {
    3993                                         numberPasses = (tunePreProcess / 1000) - 1;
    3994                                         tunePreProcess = tunePreProcess % 1000;
     4019                                    } else if (tunePreProcess >= 10000) {
     4020                                        numberPasses = (tunePreProcess / 10000) - 1;
     4021                                        tunePreProcess = tunePreProcess % 10000;
    39954022                                    }
    39964023#ifndef CBC_OTHER_SOLVER
     
    50855112#endif
    50865113                                const int * originalColumns = preProcess ? process.originalColumns() : NULL;
    5087                                 if (model.getMIPStart().size())
    5088                                   mipStart = model.getMIPStart();
    5089                                  if (mipStart.size())
     5114                                //if (model.getMIPStart().size())
     5115                                // mipStart = model.getMIPStart();
     5116                                if (mipStart.size() && !mipStartBefore.size())
    50905117                                {
    50915118                                   std::vector< std::string > colNames;
    50925119                                   if (preProcess)
    50935120                                   {
     5121                                     std::vector< std::pair< std::string, double > > mipStart2;
    50945122                                     for ( int i=0 ; (i<babModel_->solver()->getNumCols()) ; ++i ) {
    50955123                                       int iColumn = babModel_->originalColumns()[i];
    50965124                                       if (iColumn>=0) {
    50975125                                         colNames.push_back( model_.solver()->getColName( iColumn ) );
     5126                                         babModel_->solver()->setColName(i,model_.solver()->getColName(iColumn));
     5127                                         mipStart2.push_back(mipStart[iColumn]);
    50985128                                       } else {
    50995129                                         // created variable
     
    51035133                                       }
    51045134                                     }
     5135                                     mipStart = mipStart2;
    51055136                                   } else {
    51065137                                      for ( int i=0 ; (i<babModel_->solver()->getNumCols()) ; ++i )
Note: See TracChangeset for help on using the changeset viewer.