Ignore:
Timestamp:
Mar 16, 2009 6:30:25 AM (10 years ago)
Author:
forrest
Message:

chnages to try and make faster

File:
1 edited

Legend:

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

    r1131 r1132  
    790790#endif
    791791#endif
     792#ifdef CPX_KEEP_RESULTS
     793#define CBC_OTHER_SOLVER 1
     794#endif
     795#ifdef COIN_HAS_CPX
     796#include "OsiCpxSolverInterface.hpp"
     797#endif
     798#ifdef CBC_OTHER_SOLVER
     799#if CBC_OTHER_SOLVER==1
     800#include "OsiCpxSolverInterface.hpp"
     801#endif
     802#undef NEW_STYLE_SOLVER
     803#define NEW_STYLE_SOLVER 0
     804#endif
    792805//#undef COIN_HAS_ASL
    793806#ifdef COIN_HAS_ASL
     
    849862FILE * CbcOrClpReadCommand=stdin;
    850863static bool noPrinting=false;
     864#ifndef CBC_OTHER_SOLVER
    851865#if NEW_STYLE_SOLVER
    852866int * CbcSolver::analyze(OsiClpSolverInterface * solverMod, int & numberChanged, double & increment,
     
    11571171  }
    11581172}
     1173#endif
    11591174#if 1
    11601175#include "ClpSimplexOther.hpp"
     
    31013116void CbcMain0 (CbcModel  & model)
    31023117{
     3118#ifndef CBC_OTHER_SOLVER
    31033119  OsiClpSolverInterface * originalSolver = dynamic_cast<OsiClpSolverInterface *> (model.solver());
     3120#elif CBC_OTHER_SOLVER==1
     3121  OsiCpxSolverInterface * originalSolver = dynamic_cast<OsiCpxSolverInterface *> (model.solver());
     3122  // Dummy solvers
     3123  OsiClpSolverInterface dummySolver;
     3124  ClpSimplex * lpSolver = dummySolver.getModelPtr();
     3125  OsiCpxSolverInterface * clpSolver = originalSolver;
     3126#endif
    31043127  assert (originalSolver);
    31053128  CoinMessageHandler * generalMessageHandler = originalSolver->messageHandler();
    31063129  generalMessageHandler->setPrefix(true);
     3130#ifndef CBC_OTHER_SOLVER
    31073131  OsiSolverInterface * solver = model.solver();
    31083132  OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
     
    31103134  lpSolver->setPerturbation(50);
    31113135  lpSolver->messageHandler()->setPrefix(false);
     3136#endif
    31123137  establishParams(numberParameters,parameters) ;
    31133138  const char dirsep =  CoinFindDirSeparator();
     
    35563581    bool cleanModel = !model2.numberIntegers()&&!model2.numberObjects();
    35573582    model2.findIntegers(false);
    3558     int heurOptions=parameters_[whichParam(HOPTIONS,numberParameters_,parameters_)].intValue()/100;
     3583    int heurOptions=(parameters_[whichParam(HOPTIONS,numberParameters_,parameters_)].intValue()/100)%100;
    35593584    if (heurOptions==0||heurOptions==2) {
    35603585      model2.doHeuristicsAtRoot(1);
    35613586    } else if (heurOptions==1||heurOptions==3) {
    35623587      model2.setMaximumNodes(-1);
    3563       CbcStrategyDefault strategy(false,5,5);
     3588      CbcStrategyDefault strategy(0,5,5);
    35643589      strategy.setupPreProcessing(1,0);
    35653590      model2.setStrategy(strategy);
     
    37213746     It should only have one solver known to it.
    37223747  */
     3748  CoinMessageHandler * generalMessageHandler = model_.messageHandler();
     3749  generalMessageHandler->setPrefix(false);
     3750#ifndef CBC_OTHER_SOLVER
    37233751  OsiClpSolverInterface * originalSolver = dynamic_cast<OsiClpSolverInterface *> (model_.solver());
    37243752  assert (originalSolver);
    3725   CoinMessageHandler * generalMessageHandler = model_.messageHandler();
    3726   generalMessageHandler->setPrefix(false);
    37273753  // Move handler across if not default
    37283754  if (!originalSolver->defaultHandler()&&originalSolver->getModelPtr()->defaultHandler())
     
    37323758  if (originalSolver->getModelPtr()->logLevel()==0)
    37333759    noPrinting=true;
     3760#elif CBC_OTHER_SOLVER==1
     3761  OsiCpxSolverInterface * originalSolver = dynamic_cast<OsiCpxSolverInterface *> (model_.solver());
     3762  assert (originalSolver);
     3763  OsiClpSolverInterface dummySolver;
     3764  OsiCpxSolverInterface * clpSolver = originalSolver;
     3765  CoinMessages generalMessages = dummySolver.getModelPtr()->messages();
     3766  char generalPrint[10000];
     3767  noPrinting=true;
     3768#endif
    37343769#if NEW_STYLE_SOLVER==0
    37353770  bool noPrinting_=noPrinting;
     
    37713806    int complicatedInteger=0;
    37723807    OsiSolverInterface * solver = model_.solver();
     3808    if (noPrinting_)
     3809      setCbcOrClpPrinting(false);
     3810#ifndef CBC_OTHER_SOLVER
    37733811    OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
    37743812    ClpSimplex * lpSolver = clpSolver->getModelPtr();
    37753813    if (noPrinting_) {
    3776       setCbcOrClpPrinting(false);
    37773814      lpSolver->setLogLevel(0);
    37783815    }
     3816#else
     3817    ClpSimplex * lpSolver = NULL;
     3818#endif
    37793819    // For priorities etc
    37803820    int * priorities=NULL;
     
    38103850          goodModel=true;
    38113851          solver = model_.solver();
     3852#ifndef CBC_OTHER_SOLVER
    38123853          clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
    38133854          lpSolver = clpSolver->getModelPtr();
     3855#endif
    38143856        } else {
    38153857          printf("Bad input from user function %s\n",userFunction_[iUser]->name().c_str());
     
    39143956#ifdef COIN_HAS_LINK
    39153957      } else {
     3958#ifndef CBC_OTHER_SOLVER
    39163959        // save
    39173960        saveCoinModel = *coinModel;
     
    39714014          delete [] whichRow;
    39724015        }
     4016#endif
    39734017      }
    39744018#endif
     
    40364080    bool preSolveFile=false;
    40374081    bool strongChanged=false;
     4082    bool pumpChanged=false;
    40384083   
    40394084    double djFix=1.0e100;
     
    40724117    int slog = whichParam(SOLVERLOGLEVEL,numberParameters_,parameters_);
    40734118    int log = whichParam(LOGLEVEL,numberParameters_,parameters_);
     4119#ifndef CBC_OTHER_SOLVER
    40744120    double normalIncrement=model_.getCutoffIncrement();;
     4121#endif
    40754122    if (testOsiParameters>=0) {
    40764123      // trying nonlinear - switch off some stuff
     
    41084155    CglKnapsackCover knapsackGen;
    41094156    //knapsackGen.switchOnExpensive();
     4157    //knapsackGen.setMaxInKnapsack(100);
    41104158    // set default action (0=off,1=on,2=root)
    41114159    int knapsackAction=3;
     
    41814229#ifdef MORE_CUTS
    41824230      gomoryGen.setAwayAtRoot(0.005);
     4231      twomirGen.setAwayAtRoot(0.005);
     4232      twomirGen.setAway(0.01);
    41834233#else
    41844234      gomoryGen.setAwayAtRoot(0.01);
     4235      twomirGen.setAwayAtRoot(0.01);
     4236      twomirGen.setAway(0.01);
    41854237#endif
    41864238      int iParam;
     
    42984350        if (type==BAB&&goodModel) {
    42994351          // check if any integers
     4352#ifndef CBC_OTHER_SOLVER
    43004353#ifdef COIN_HAS_ASL
    43014354          if (info.numberSos&&doSOS&&statusUserFunction_[0]) {
     
    43084361              !clpSolver->numberSOS()&&!model_.numberObjects()&&!clpSolver->numberObjects())
    43094362            type=DUALSIMPLEX;
     4363#endif
    43104364        }
    43114365        if (type==GENERALQUERY) {
     
    44604514              case DJFIX:
    44614515                djFix=value;
     4516#ifndef CBC_OTHER_SOLVER
    44624517                if (goodModel&&djFix<1.0e20) {
    44634518                  // do some fixing
     
    44984553                    <<CoinMessageEol;
    44994554                }
     4555#endif
    45004556                break;
    45014557              case TIGHTENFACTOR:
     
    45624618                       parameters_[iParam].type()==NUMBERBEFORE)
    45634619                strongChanged=true;
     4620              else if (parameters_[iParam].type()==FPUMPTUNE||
     4621                       parameters_[iParam].type()==FPUMPITS)
     4622                pumpChanged=true;
    45644623              else if (parameters_[iParam].type()==EXPERIMENT) {
    45654624                if (value>=1) {
     
    45864645                  parameters_[iParam].setIntValue(30);
    45874646                  iParam = whichParam(FPUMPTUNE,numberParameters_,parameters_);
    4588                   parameters_[iParam].setIntValue(8043);
     4647                  parameters_[iParam].setIntValue(1005043);
    45894648                  iParam = whichParam(PROCESSTUNE,numberParameters_,parameters_);
    45904649                  parameters_[iParam].setIntValue(6);
     
    48874946            case LOCALTREE:
    48884947            case NAIVE:
     4948            case CPX:
    48894949              defaultSettings=false; // user knows what she is doing
    48904950              break;
     
    51935253                model_.setProblemStatus(iStatus);
    51945254                model_.setSecondaryStatus(iStatus2);
    5195                 assert (lpSolver==clpSolver->getModelPtr());
     5255                //assert (lpSolver==clpSolver->getModelPtr());
    51965256                assert (clpSolver==model_.solver());
    51975257                clpSolver->setWarmStart(NULL);
     
    55215581              int logLevel = parameters_[slog].intValue();
    55225582              // Reduce printout
    5523               if (logLevel<=1)
     5583              if (logLevel<=1) {
    55245584                model_.solver()->setHintParam(OsiDoReducePrint,true,OsiHintTry);
    5525               else
     5585              } else {
    55265586                model_.solver()->setHintParam(OsiDoReducePrint,false,OsiHintTry);
     5587              }
    55275588              {
    55285589                OsiSolverInterface * solver = model_.solver();
     5590#ifndef CBC_OTHER_SOLVER
    55295591                OsiClpSolverInterface * si =
    55305592                  dynamic_cast<OsiClpSolverInterface *>(solver) ;
    55315593                assert (si != NULL);
    55325594                si->getModelPtr()->scaling(doScaling);
    5533                 statistics_nrows=si->getNumRows();
    5534                 statistics_ncols=si->getNumCols();
    5535                 statistics_nprocessedrows=si->getNumRows();
    5536                 statistics_nprocessedcols=si->getNumCols();
    55375595                ClpSimplex * lpSolver = si->getModelPtr();
    55385596                if (doVector) {
     
    55435601                  }
    55445602                }
     5603#elif CBC_OTHER_SOLVER==1
     5604                OsiCpxSolverInterface * si =
     5605                  dynamic_cast<OsiCpxSolverInterface *>(solver) ;
     5606                assert (si != NULL);
     5607#endif
     5608                statistics_nrows=si->getNumRows();
     5609                statistics_ncols=si->getNumCols();
     5610                statistics_nprocessedrows=si->getNumRows();
     5611                statistics_nprocessedcols=si->getNumCols();
    55455612                // See if quadratic
     5613#ifndef CBC_OTHER_SOLVER
    55465614#ifdef COIN_HAS_LINK
    55475615                if (!complicatedInteger) {
     
    57505818                }
    57515819#endif
     5820#endif
    57525821                if (logLevel<=1)
    57535822                  si->setHintParam(OsiDoReducePrint,true,OsiHintTry);
     5823#ifndef CBC_OTHER_SOLVER
    57545824                si->setSpecialOptions(0x40000000);
     5825#endif
    57555826              }
    57565827              if (!miplib) {
     
    57625833                model_.initialSolve();
    57635834                OsiSolverInterface * solver = model_.solver();
     5835#ifndef CBC_OTHER_SOLVER
    57645836                OsiClpSolverInterface * si =
    57655837                  dynamic_cast<OsiClpSolverInterface *>(solver) ;
     
    58045876                }
    58055877                clpSolver->setSpecialOptions(clpSolver->specialOptions()|IN_BRANCH_AND_BOUND); // say is Cbc (and in branch and bound)
     5878#elif CBC_OTHER_SOLVER==1
     5879#endif
    58065880                if (!noPrinting_) {
    58075881                  sprintf(generalPrint,"Continuous objective value is %g - %.2f seconds",
     
    58415915                  }
    58425916                }
     5917#ifndef CBC_OTHER_SOLVER
    58435918                if (!complicatedInteger&&preProcess==0&&clpSolver->tightenPrimalBounds(0.0,0,true)!=0) {
    58445919#ifndef DISALLOW_PRINTING
     
    59276002                }
    59286003                si->resolve();  // clean up
     6004#endif
    59296005              }
    59306006              // If user made settings then use them
     
    59336009                if (!doScaling)
    59346010                  solver->setHintParam(OsiDoScale,false,OsiHintTry);
     6011#ifndef CBC_OTHER_SOLVER
    59356012                OsiClpSolverInterface * si =
    59366013                  dynamic_cast<OsiClpSolverInterface *>(solver) ;
     
    59586035                  }
    59596036                }
     6037#endif
    59606038              }
    59616039              // See if we want preprocessing
     
    59666044              delete babModel_;
    59676045              babModel_ = new CbcModel(model_);
     6046#ifndef CBC_OTHER_SOLVER
     6047              int numberChanged=0;
    59686048              OsiSolverInterface * solver3 = clpSolver->clone();
    59696049              babModel_->assignSolver(solver3);
    59706050              OsiClpSolverInterface * clpSolver2 = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    5971               int numberChanged=0;
    59726051              if (clpSolver2->messageHandler()->logLevel())
    59736052                clpSolver2->messageHandler()->setLogLevel(1);
     
    59946073                lpSolver->setFactorizationFrequency(CoinMin(maximum,frequency));
    59956074              }
     6075#elif CBC_OTHER_SOLVER==1
     6076              OsiSolverInterface * solver3 = model_.solver()->clone();
     6077              babModel_->assignSolver(solver3);
     6078#endif
    59966079              time2 = CoinCpuTime();
    59976080              totalTime += time2-time1;
     
    60136096              }
    60146097              if (preProcess&&type==BAB) {
     6098#ifndef CBC_OTHER_SOLVER
    60156099                // See if sos from mps file
    60166100                if (numberSOS==0&&clpSolver->numberSOS()&&doSOS) {
     
    60446128                  }
    60456129                }
     6130#endif
    60466131                saveSolver=babModel_->solver()->clone();
    60476132                /* Do not try and produce equality cliques and
     
    61416226                    tunePreProcess = tunePreProcess % 1000;
    61426227                  }
     6228#ifndef CBC_OTHER_SOLVER
    61436229                  if (doSprint>0) {
    61446230                    // Sprint for primal solves
     
    61616247                    osiclp->getModelPtr()->setInfeasibilityCost(1.0e11);
    61626248                  }
     6249#endif
     6250#ifndef CBC_OTHER_SOLVER
    61636251                  {
    61646252                    OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (saveSolver);
     
    61736261                    osiclp->getModelPtr()->setPerturbation(savePerturbation);
    61746262                  }
     6263#elif CBC_OTHER_SOLVER==1
     6264                  solver2 = process.preProcessNonDefault(*saveSolver,translate[preProcess],numberPasses,
     6265                                                         tunePreProcess);
     6266#endif
    61756267                  integersOK=false; // We need to redo if CbcObjects exist
    61766268                  // Tell solver we are not in Branch and Cut
     
    62656357              // now tighten bounds
    62666358              if (!miplib) {
     6359#ifndef CBC_OTHER_SOLVER
    62676360                OsiClpSolverInterface * si =
    62686361                  dynamic_cast<OsiClpSolverInterface *>(babModel_->solver()) ;
     
    62866379                }
    62876380                si->resolve();
     6381#elif CBC_OTHER_SOLVER==1
     6382#endif
    62886383              }
    62896384              if (debugValues) {
     
    63286423                                                                   saveTightenedModel);
    63296424                      if (solver) {
     6425#ifndef CBC_OTHER_SOLVER
    63306426                        clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
    63316427                        assert (clpSolver);
    63326428                        lpSolver = clpSolver->getModelPtr();
     6429#endif
    63336430                        babModel_->assignSolver(solver);
    63346431                        testOsiOptions=0;
     
    64176514              // add cut generators if wanted
    64186515              int switches[20];
     6516              int accuracyFlag[20];
    64196517              int numberGenerators=0;
    64206518              int translate[]={-100,-1,-99,-98,1,-1001,-1099,1,1,1,-1};
     
    64446542                  iAction=1;
    64456543                babModel_->addCutGenerator(&probingGen,iAction,"Probing");
     6544                accuracyFlag[numberGenerators]=5;
    64466545                switches[numberGenerators++]=0;
    64476546              }
     
    64766575                }
    64776576                babModel_->addCutGenerator(&gomoryGen,translate[gomoryAction],"Gomory");
     6577                accuracyFlag[numberGenerators]=3;
    64786578                switches[numberGenerators++]=0;
    64796579              }
     
    64866586              if (knapsackAction) {
    64876587                babModel_->addCutGenerator(&knapsackGen,translate[knapsackAction],"Knapsack");
     6588                accuracyFlag[numberGenerators]=1;
    64886589                switches[numberGenerators++]=-2;
    64896590              }
    64906591              if (redsplitAction&&!complicatedInteger) {
    64916592                babModel_->addCutGenerator(&redsplitGen,translate[redsplitAction],"Reduce-and-split");
     6593                accuracyFlag[numberGenerators]=5;
    64926594                switches[numberGenerators++]=1;
    64936595              }
    64946596              if (cliqueAction) {
    64956597                babModel_->addCutGenerator(&cliqueGen,translate[cliqueAction],"Clique");
     6598                accuracyFlag[numberGenerators]=0;
    64966599                switches[numberGenerators++]=0;
    64976600              }
    64986601              if (mixedAction) {
    64996602                babModel_->addCutGenerator(&mixedGen,translate[mixedAction],"MixedIntegerRounding2");
     6603                accuracyFlag[numberGenerators]=2;
    65006604                switches[numberGenerators++]=0;
    65016605              }
    65026606              if (flowAction) {
    65036607                babModel_->addCutGenerator(&flowGen,translate[flowAction],"FlowCover");
     6608                accuracyFlag[numberGenerators]=2;
    65046609                switches[numberGenerators++]=1;
    65056610              }
     
    65156620                }
    65166621                babModel_->addCutGenerator(&twomirGen,translate[twomirAction],"TwoMirCuts");
     6622                accuracyFlag[numberGenerators]=4;
    65176623                switches[numberGenerators++]=1;
    65186624              }
     
    65206626              if (landpAction) {
    65216627                babModel_->addCutGenerator(&landpGen,translate[landpAction],"LiftAndProject");
     6628                accuracyFlag[numberGenerators]=5;
    65226629                switches[numberGenerators++]=1;
    65236630              }
     
    65256632              if (residualCapacityAction) {
    65266633                babModel_->addCutGenerator(&residualCapacityGen,translate[residualCapacityAction],"ResidualCapacity");
     6634                accuracyFlag[numberGenerators]=5;
    65276635                switches[numberGenerators++]=1;
    65286636              }
     
    65346642                }
    65356643                babModel_->addCutGenerator(&zerohalfGen,translate[zerohalfAction],"ZeroHalf");
    6536                 switches[numberGenerators++]=0;
     6644                accuracyFlag[numberGenerators]=5;
     6645                switches[numberGenerators++]=2;
    65376646              }
    65386647#endif
     
    65496658                if (howOften==-98||howOften==-99)
    65506659                  generator->setSwitchOffIfLessThan(switches[iGenerator]);
     6660                generator->setInaccuracy(accuracyFlag[iGenerator]);
    65516661                generator->setTiming(true);
    65526662                if (cutDepth>=0)
     
    65996709              babModel_->solver()->setIntParam(OsiMaxNumIterationHotStart,
    66006710                    parameters_[whichParam(MAXHOTITS,numberParameters_,parameters_)].intValue());
     6711#ifndef CBC_OTHER_SOLVER
    66016712              OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    66026713              // go faster stripes
     
    66206731              if (!miplib&&increment==normalIncrement)
    66216732                changed=analyze( osiclp,numberChanged,increment,false,generalMessageHandler);
     6733#elif CBC_OTHER_SOLVER==1
     6734              double increment=babModel_->getCutoffIncrement();;
     6735#endif
    66226736              if (debugValues) {
    66236737                int numberColumns = babModel_->solver()->getNumCols();
     
    66756789                  <<CoinMessageEol;
    66766790              }
     6791#ifndef CBC_OTHER_SOLVER
    66776792              osiclp->setSpecialOptions(mipOptions);
     6793#elif CBC_OTHER_SOLVER==1
     6794#endif
    66786795              // probably faster to use a basis to get integer solutions
    66796796              babModel_->setSpecialOptions(babModel_->specialOptions()|2);
     
    66846801                  // try reduced model
    66856802                  babModel_->setSpecialOptions(babModel_->specialOptions()|512);
    6686                 } else if (experimentFlag==3||strategyFlag==2) {
     6803                }
     6804                if (experimentFlag==3||strategyFlag==2) {
    66876805                  // try reduced model at root
    6688                   babModel_->setSpecialOptions(babModel_->specialOptions()|2048);
     6806                  babModel_->setSpecialOptions(babModel_->specialOptions()|32768);
    66896807                }
    66906808                {
     
    67326850                    if (extra1==-7777)
    67336851                      extra1=-1;
     6852                    else if (extra1==-8888)
     6853                      extra1=1;
    67346854                    babModel_->setWhenCuts(-extra1);
    67356855                  } else if (extra1<19000) {
     
    73617481                  babModel_->setNumberBeforeTrust(0);
    73627482                if (useStrategy) {
    7363                   CbcStrategyDefault strategy(true,babModel_->numberStrong(),babModel_->numberBeforeTrust());
     7483                  CbcStrategyDefault strategy(1,babModel_->numberStrong(),babModel_->numberBeforeTrust());
    73647484                  strategy.setupPreProcessing(1);
    73657485                  babModel_->setStrategy(strategy);
     
    75907710                malloc_stats2();
    75917711#endif
     7712#ifndef CBC_OTHER_SOLVER
    75927713                if (outputFormat==5) {
    75937714                  osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
     
    75957716                  lpSolver->setPersistenceFlag(1);
    75967717                }
     7718#endif
    75977719#ifdef COIN_HAS_ASL
    75987720                // add in lotsizing
     
    77157837                  return returnCode;
    77167838                }
     7839#ifndef CBC_OTHER_SOLVER
    77177840                osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    77187841                lpSolver = osiclp->getModelPtr();
     7842#elif CBC_OTHER_SOLVER==1
     7843#endif
    77197844                if (experimentFlag>=1||strategyFlag>=2) {
    7720                   if (lpSolver->numberColumns()<200&&lpSolver->numberRows()<40)
     7845                  if (babModel_->solver()->getNumCols()<200&&
     7846                      babModel_->solver()->getNumRows()<40)
    77217847                    babModel_->setFastNodeDepth(-9);
    77227848                }
     
    77257851                  babModel_->setSpecialOptions(babModel_->specialOptions()|8192);
    77267852               
     7853#ifndef CBC_OTHER_SOLVER
    77277854#ifdef CLP_MULTIPLE_FACTORIZATIONS   
    77287855                int denseCode = parameters_[whichParam(DENSE,numberParameters_,parameters_)].intValue();
     
    77347861                    smallCode=40;
    77357862                }
    7736                 if (denseCode>0)
     7863                if (denseCode>0) {
    77377864                  lpSolver->factorization()->setGoDenseThreshold(denseCode);
     7865                  assert (osiclp==babModel_->solver());
     7866                  osiclp->setSpecialOptions(osiclp->specialOptions()|1024);
     7867                }
    77387868                if (smallCode>0&&smallCode>denseCode)
    77397869                  lpSolver->factorization()->setGoSmallThreshold(smallCode);
     
    77417871                //lpSolver->factorization()->goDense();
    77427872                //}
     7873#endif
    77437874#endif
    77447875#ifdef CLIQUE_ANALYSIS
     
    77917922                exit(1);
    77927923#endif
     7924                int hOp1 = parameters_[whichParam(HOPTIONS,numberParameters_,parameters_)].intValue()/100000;
     7925                if (hOp1%10) {
     7926                  CbcCompareDefault compare;
     7927                  compare.setBreadthDepth(hOp1%10);
     7928                  babModel_->setNodeComparison(compare);
     7929                }
     7930#if defined(CBC_OTHER_SOLVER)||defined(COIN_HAS_CPX)
     7931                if (dynamic_cast<OsiCpxSolverInterface *> (babModel_->solver()))
     7932                  babModel_->solver()->messageHandler()->setLogLevel(0);
     7933#endif
     7934                if (parameters_[whichParam(CPX,numberParameters_,parameters_)].currentOptionAsInteger()) {
     7935                  babModel_->setSpecialOptions(babModel_->specialOptions()|16384);
     7936                  //if (babModel_->fastNodeDepth()==-1)
     7937                    babModel_->setFastNodeDepth(-2); // Use Cplex at root
     7938                }
     7939                int hOp2 = parameters_[whichParam(HOPTIONS,numberParameters_,parameters_)].intValue()/10000;
     7940                if (hOp2%10) {
     7941                  babModel_->setSpecialOptions(babModel_->specialOptions()|16384);
     7942                  if (babModel_->fastNodeDepth()==-1)
     7943                    babModel_->setFastNodeDepth(-2); // Use Cplex at root
     7944                }
    77937945                babModel_->branchAndBound(statistics);
    77947946                //#define CLP_FACTORIZATION_INSTRUMENT
     
    78387990                checkSOS(babModel_, babModel_->solver());
    78397991              } else if (type==MIPLIB) {
    7840                 CbcStrategyDefault strategy(true,babModel_->numberStrong(),babModel_->numberBeforeTrust());
     7992                int typeOfCuts = babModel_->numberCutGenerators() ? 1 : -1;
     7993                CbcStrategyDefault strategy(typeOfCuts,
     7994                                            babModel_->numberStrong(),
     7995                                            babModel_->numberBeforeTrust());
    78417996                // Set up pre-processing
    78427997                int translate2[]={9999,1,1,3,2,4,5,6,6};
     
    78498004                babModel_->setThreadMode(numberThreads/100);
    78508005#endif
     8006#ifndef CBC_OTHER_SOLVER
    78518007                if (outputFormat==5) {
    78528008                  osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
     
    78548010                  lpSolver->setPersistenceFlag(1);
    78558011                }
     8012#endif
    78568013                if (testOsiOptions>=0) {
    78578014                  printf("Testing OsiObject options %d\n",testOsiOptions);
     
    78668023                }
    78678024                model_ = *babModel_;
     8025#ifndef CBC_OTHER_SOLVER
     8026                {
     8027                  osiclp = dynamic_cast< OsiClpSolverInterface*> (model_.solver());
     8028                  lpSolver = osiclp->getModelPtr();
     8029                  lpSolver->setSpecialOptions(lpSolver->specialOptions()|IN_BRANCH_AND_BOUND); // say is Cbc (and in branch and bound)
     8030                }
     8031#endif
    78688032                /* LL: this was done in CoinSolve.cpp: main(argc, argv).
    78698033                   I have moved it here so that the miplib directory location
     
    78868050                stuff[9]=doVector;
    78878051                stuff[10] = parameters_[whichParam(SMALLFACT,numberParameters_,parameters_)].intValue();
     8052                if (parameters_[whichParam(CPX,numberParameters_,parameters_)].currentOptionAsInteger()) {
     8053                  model_.setSpecialOptions(model_.specialOptions()|16384);
     8054                  //if (model_.fastNodeDepth()==-1)
     8055                    model_.setFastNodeDepth(-2); // Use Cplex at root
     8056                }
     8057                int hOp2 = parameters_[whichParam(HOPTIONS,numberParameters_,parameters_)].intValue()/10000;
     8058                if (hOp2%10) {
     8059                  model_.setSpecialOptions(model_.specialOptions()|16384);
     8060                  if (model_.fastNodeDepth()==-1)
     8061                    model_.setFastNodeDepth(-2); // Use Cplex at root
     8062                }
     8063                if (!pumpChanged) {
     8064                  // Make more lightweight
     8065                  for (int iHeur=0;iHeur<model_.numberHeuristics();iHeur++) {
     8066                    CbcHeuristic * heuristic = model_.heuristic(iHeur);
     8067                    CbcHeuristicFPump* pump =
     8068                      dynamic_cast<CbcHeuristicFPump*>(heuristic);
     8069                    if (pump) {
     8070                      CbcHeuristicFPump heuristic4(model_);
     8071                      heuristic4.setFractionSmall(0.5);
     8072                      heuristic4.setMaximumPasses(5);
     8073                      heuristic4.setFeasibilityPumpOptions(30);
     8074                      heuristic4.setWhen(13);
     8075                      heuristic4.setHeuristicName("feasibility pump");
     8076                      //CbcHeuristicFPump & pump2 = pump;
     8077                      *pump = heuristic4;
     8078                    }
     8079                  }
     8080                }
    78888081                int returnCode=CbcClpUnitTest(model_, dirMiplib, extra1==1,stuff);
    78898082                babModel_=NULL;
     
    78938086              }
    78948087              currentBranchModel = NULL;
     8088#ifndef CBC_OTHER_SOLVER
    78958089              osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    78968090              if (debugFile=="createAfterPre"&&babModel_->bestSolution()) {
     
    79018095                saveSolution(osiclp->getModelPtr(),"debug.file");
    79028096              }
     8097#endif
    79038098              statistics_cut_time=0.0;
    79048099              if (!noPrinting_) {
     
    79748169                  n = saveSolver->getNumCols();
    79758170                  bestSolution = new double [n];
     8171#ifndef CBC_OTHER_SOLVER
    79768172                  OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
     8173#else
     8174                  OsiCpxSolverInterface * clpSolver = dynamic_cast< OsiCpxSolverInterface*> (babModel_->solver());
     8175#endif
    79778176                  // Save bounds on processed model
    79788177                  const int * originalColumns = process.originalColumns();
     
    79958194                    upper2[jColumn]=columnUpper[i];
    79968195                  }
     8196#ifndef CBC_OTHER_SOLVER
    79978197                  ClpSimplex * lpSolver = clpSolver->getModelPtr();
    79988198                  lpSolver->setSpecialOptions(lpSolver->specialOptions()|IN_BRANCH_AND_BOUND); // say is Cbc (and in branch and bound)
     8199#endif
    79998200                  process.postProcess(*babModel_->solver());
    80008201                  // Solution now back in saveSolver
     
    80528253                  assert (saveSolver->isProvenOptimal());
    80538254#if NEW_STYLE_SOLVER==0
     8255#ifndef CBC_OTHER_SOLVER
    80548256                  // and original solver
    80558257                  assert (n>=originalSolver->getNumCols());
     
    80718273                  assert (originalSolver->isProvenOptimal());
    80728274#endif
     8275#endif
    80738276                  babModel_->assignSolver(saveSolver);
    80748277                  memcpy(bestSolution,babModel_->solver()->getColSolution(),n*sizeof(double));
     
    80848287                babModel_->setBestSolution(bestSolution,n,babModel_->getMinimizationObjValue());
    80858288#if NEW_STYLE_SOLVER==0
     8289#ifndef CBC_OTHER_SOLVER
    80868290                // and put back in very original solver
    80878291                {
     
    81078311                }
    81088312#endif
     8313#endif
    81098314                checkSOS(babModel_, babModel_->solver());
    81108315              } else if (model_.bestSolution()&&type==BAB&&model_.getMinimizationObjValue()<1.0e50&&preProcess) {
     
    81208325                memcpy(bestSolution,babModel_->solver()->getColSolution(),n*sizeof(double));
    81218326#if NEW_STYLE_SOLVER==0
     8327#ifndef CBC_OTHER_SOLVER
    81228328                // and put back in very original solver
    81238329                {
     
    81418347                }
    81428348#endif
     8349#endif
    81438350              }
     8351#ifndef CBC_OTHER_SOLVER
    81448352              if (type==STRENGTHEN&&strengthenedModel)
    81458353                clpSolver = dynamic_cast< OsiClpSolverInterface*> (strengthenedModel);
     
    81568364                delete [] changed;
    81578365              }
     8366#endif
    81588367              if (type==BAB) {
     8368#ifndef CBC_OTHER_SOLVER
    81598369                //move best solution (should be there -- but ..)
    81608370                int n = lpSolver->getNumCols();
     
    81718381                  saveSolution(lpSolver,"debug.file");
    81728382                }
     8383#else
     8384                if (bestSolution) {
     8385                  model_.solver()->setColSolution(bestSolution);
     8386                }
     8387#endif
    81738388                delete [] bestSolution;
    81748389                std::string statusName[]={"Finished","Stopped on ","Difficulties",
     
    82838498                    free(info.primalSolution);
    82848499                    if (!numberKnapsack) {
    8285                       info.primalSolution = (double *) malloc(n*sizeof(double));
     8500                      info.primalSolution = reinterpret_cast<double *> (malloc(n*sizeof(double)));
    82868501                      CoinCopyN(lpSolver->primalColumnSolution(),n,info.primalSolution);
    82878502                      int numberRows = lpSolver->numberRows();
    82888503                      free(info.dualSolution);
    8289                       info.dualSolution = (double *) malloc(numberRows*sizeof(double));
     8504                      info.dualSolution = reinterpret_cast<double *> (malloc(numberRows*sizeof(double)));
    82908505                      CoinCopyN(lpSolver->dualRowSolution(),numberRows,info.dualSolution);
    82918506                    } else {
     
    82938508                      info.dualSolution=NULL;
    82948509                      int numberColumns = saveCoinModel.numberColumns();
    8295                       info.primalSolution = (double *) malloc(numberColumns*sizeof(double));
     8510                      info.primalSolution = reinterpret_cast<double *> (malloc(numberColumns*sizeof(double)));
    82968511                      // Fills in original solution (coinModel length)
    82978512                      afterKnapsack(saveTightenedModel,  whichColumn,  knapsackStart,
     
    84498664              if (canOpen) {
    84508665                int status;
     8666#ifndef CBC_OTHER_SOLVER
    84518667                ClpSimplex * lpSolver = clpSolver->getModelPtr();
    84528668                if (!gmpl) {
     
    84618677                  status= lpSolver->readLp(fileName.c_str(),1.0e-12);
    84628678                }
     8679#else
     8680                status =clpSolver->readMps(fileName.c_str(),"");
     8681#endif
    84638682                if (!status||(status>0&&allowImportErrors)) {
     8683#ifndef CBC_OTHER_SOLVER
    84648684                  if (keepImportNames&&gmpl<=0) {
    84658685                    lengthName = lpSolver->lengthNames();
     
    84788698                      clpSolver->setInteger(i);
    84798699                  }
     8700#else
     8701                  lengthName=0;
     8702                  goodModel=true;
     8703#endif
    84808704                  time2 = CoinCpuTime();
    84818705                  totalTime += time2-time1;
     
    85038727            break;
    85048728          case MODELIN:
     8729#ifndef CBC_OTHER_SOLVER
    85058730#ifdef COIN_HAS_LINK
    85068731            {
     
    85868811            }
    85878812#endif
     8813#endif
    85888814            break;
    85898815          case EXPORT:
     
    86368862                  model2->setOptimizationDirection(1.0);
    86378863                }
     8864#ifndef CBC_OTHER_SOLVER
    86388865#ifdef COIN_HAS_ASL
    86398866                if (info.numberSos&&doSOS&&statusUserFunction_[0]) {
     
    86468873                  clpSolver->setSOSData(numberSOS,info.sosType,sosStart,sosIndices,sosReference);
    86478874                }
     8875#endif
    86488876#endif
    86498877                if (preSolve) {
     
    87739001              }
    87749002              if (canOpen) {
     9003#ifndef CBC_OTHER_SOLVER
    87759004                int values = lpSolver->readBasis(fileName.c_str());
    87769005                if (values==0)
     
    87809009                assert (lpSolver==clpSolver->getModelPtr());
    87819010                clpSolver->setWarmStart(NULL);
     9011#endif
    87829012              }
    87839013            } else {
     
    91359365                if (numberDebugValues<200) {
    91369366                  for (int i=0;i<numberDebugValues;i++) {
    9137                     if (lpSolver->isInteger(i)&&debugValues[i])
     9367                    if (clpSolver->isInteger(i)&&debugValues[i])
    91389368                      printf("%d %g\n",i,debugValues[i]);
    91399369                  }
     
    97539983              }
    97549984              if (fp) {
     9985#ifndef CBC_OTHER_SOLVER
    97559986                if (printMode!=5) {
    97569987                  // Write solution header (suggested by Luigi Poderico)
     
    977710008                  fprintf(fp, " - objective value %15.8g\n", objValue);
    977810009                }
     10010#endif
    977910011                // make fancy later on
    978010012                int iRow;
    9781                 int numberRows=lpSolver->numberRows();
    9782                 double * dualRowSolution = lpSolver->dualRowSolution();
    9783                 double * primalRowSolution =
    9784                   lpSolver->primalRowSolution();
    9785                 double * rowLower = lpSolver->rowLower();
    9786                 double * rowUpper = lpSolver->rowUpper();
    9787                 double primalTolerance = lpSolver->primalTolerance();
     10013                int numberRows=clpSolver->getNumRows();
     10014                const double * dualRowSolution = clpSolver->getRowPrice();
     10015                const double * primalRowSolution =
     10016                  clpSolver->getRowActivity();
     10017                const double * rowLower = clpSolver->getRowLower();
     10018                const double * rowUpper = clpSolver->getRowUpper();
     10019                double primalTolerance ;
     10020                clpSolver->getDblParam(OsiPrimalTolerance,primalTolerance);
    978810021                char format[6];
    978910022                sprintf(format,"%%-%ds",CoinMax(lengthName,8));
     
    991210145                }
    991310146                int iColumn;
    9914                 int numberColumns=lpSolver->numberColumns();
    9915                 double * dualColumnSolution =
    9916                   lpSolver->dualColumnSolution();
    9917                 double * primalColumnSolution =
    9918                   lpSolver->primalColumnSolution();
    9919                 double * columnLower = lpSolver->columnLower();
    9920                 double * columnUpper = lpSolver->columnUpper();
     10147                int numberColumns=clpSolver->getNumCols();
     10148                const double * dualColumnSolution =
     10149                  clpSolver->getReducedCost();
     10150                const double * primalColumnSolution =
     10151                  clpSolver->getColSolution();
     10152                const double * columnLower = clpSolver->getColLower();
     10153                const double * columnUpper = clpSolver->getColUpper();
    992110154                if (printMode!=2) {
    992210155                  if (printMode==5) {
     
    993910172                    }
    994010173                    // see if integer
    9941                     if ((!lpSolver->isInteger(iColumn)||fabs(primalColumnSolution[iColumn])<1.0e-8)
     10174                    if ((!clpSolver->isInteger(iColumn)||fabs(primalColumnSolution[iColumn])<1.0e-8)
    994210175                         &&printMode==1)
    994310176                      type=0;
     
    1012210355  if (babModel_) {
    1012310356    model_.moveInfo(*babModel_);
     10357#ifndef CBC_OTHER_SOLVER
    1012410358    OsiClpSolverInterface * clpSolver0 = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    1012510359    ClpSimplex * lpSolver0 = clpSolver0->getModelPtr();
     
    1012910363      lpSolver->moveInfo(*lpSolver0);
    1013010364    //babModel_->setModelOwnsSolver(false);
     10365#endif
    1013110366  }
    1013210367#ifdef CBC_SIG_TRAP
     
    1053010765    if (preProcess) {
    1053110766      strcpy(line[numberLines++],"5  // Preprocessing using CbcStrategy");
    10532       strcpy(line[numberLines++],"5  CbcStrategyDefault strategy(true,5,5);");
     10767      strcpy(line[numberLines++],"5  CbcStrategyDefault strategy(1,5,5);");
    1053310768      strcpy(line[numberLines++],"5  strategy.setupPreProcessing(1);");
    1053410769      strcpy(line[numberLines++],"5  cbcModel->setStrategy(strategy);");
Note: See TracChangeset for help on using the changeset viewer.