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/CbcModel.cpp

    r1130 r1132  
    10531053extern const double * debuggerSolution_Z;
    10541054extern int numberColumns_Z;
     1055#endif
     1056#ifdef COIN_HAS_CPX
     1057#include "OsiCpxSolverInterface.hpp"
    10551058#endif
    10561059void CbcModel::branchAndBound(int doStatistics)
     
    17151718  (problems which require further exploration).
    17161719*/
     1720  CbcCompareDefault * compareActual
     1721      = dynamic_cast<CbcCompareDefault *> (nodeCompare_);
     1722  if (compareActual) {
     1723    compareActual->setBestPossible(direction*solver_->getObjValue());
     1724    compareActual->setCutoff(getCutoff());
     1725    if (false&&!numberThreads_&&!parentModel_) {
     1726      printf("CbcTreeArray ? threads ? parentArray\n");
     1727      // Setup new style tree
     1728      delete tree_;
     1729      tree_ = new CbcTreeArray();
     1730    }
     1731  }
    17171732  tree_->setComparison(*nodeCompare_) ;
    17181733/*
     
    17741789*/
    17751790  numberIterations_ = 0 ;
     1791  numberSolves_ = 0 ;
    17761792  numberNodes_ = 0 ;
    17771793  numberNodes2_ = 0 ;
     
    18591875  if (eventHappened_)
    18601876    feasible=false;
     1877#if defined(COIN_HAS_CLP)&&defined(COIN_HAS_CPX)
     1878  if (feasible&&(specialOptions_&16384)!=0&&fastNodeDepth_==-2&&!parentModel_) {
     1879    // Use Cplex to do search!
     1880    double time1 = CoinCpuTime();
     1881    OsiClpSolverInterface * clpSolver
     1882      = dynamic_cast<OsiClpSolverInterface *> (solver_);
     1883    OsiCpxSolverInterface cpxSolver;
     1884    double direction = clpSolver->getObjSense();
     1885    cpxSolver.setObjSense(direction);
     1886    // load up cplex
     1887    const CoinPackedMatrix * matrix = continuousSolver_->getMatrixByCol();
     1888    const double * rowLower = continuousSolver_->getRowLower();
     1889    const double * rowUpper = continuousSolver_->getRowUpper();
     1890    const double * columnLower = continuousSolver_->getColLower();
     1891    const double * columnUpper = continuousSolver_->getColUpper();
     1892    const double * objective = continuousSolver_->getObjCoefficients();
     1893    cpxSolver.loadProblem(*matrix,columnLower,columnUpper,
     1894                          objective, rowLower,rowUpper);
     1895    double * setSol = new double [numberIntegers_];
     1896    int * setVar = new int [numberIntegers_];
     1897    // cplex doesn't know about objective offset
     1898    double offset = clpSolver->getModelPtr()->objectiveOffset();
     1899    for (int i=0;i<numberIntegers_;i++) {
     1900      int iColumn = integerVariable_[i];
     1901      cpxSolver.setInteger(iColumn);
     1902      if (bestSolution_) {
     1903        setSol[i]=bestSolution_[iColumn];
     1904        setVar[i]=iColumn;
     1905      }
     1906    }
     1907    CPXENVptr env = cpxSolver.getEnvironmentPtr();
     1908    CPXLPptr lpPtr = cpxSolver.getLpPtr(OsiCpxSolverInterface::KEEPCACHED_ALL);
     1909    cpxSolver.switchToMIP();
     1910    if (bestSolution_) {
     1911      CPXcopymipstart(env,lpPtr,numberIntegers_,setVar,setSol);
     1912    }
     1913    if (clpSolver->getNumRows()>continuousSolver_->getNumRows()&&false) {
     1914      // add cuts
     1915      const CoinPackedMatrix * matrix = clpSolver->getMatrixByRow();
     1916      const double * rhs = clpSolver->getRightHandSide();
     1917      const char * rowSense = clpSolver->getRowSense();
     1918      const double * elementByRow = matrix->getElements();
     1919      const int * column = matrix->getIndices();
     1920      const CoinBigIndex * rowStart = matrix->getVectorStarts();
     1921      const int * rowLength = matrix->getVectorLengths();
     1922      int nStart = continuousSolver_->getNumRows();
     1923      int nRows = clpSolver->getNumRows();
     1924      int size = rowStart[nRows-1]+rowLength[nRows-1]-
     1925        rowStart[nStart];
     1926      int nAdd=0;
     1927      double * rmatval = new double [size];
     1928      int * rmatind = new int [size];
     1929      int * rmatbeg = new int [nRows-nStart+1];
     1930      size=0;
     1931      rmatbeg[0]=0;
     1932      for (int i=nStart;i<nRows;i++) {
     1933        for (int k=rowStart[i];k<rowStart[i]+rowLength[i];k++) {
     1934          rmatind[size] = column[k];
     1935          rmatval[size++] = elementByRow[k];
     1936        }
     1937        nAdd++;
     1938        rmatbeg[nAdd]=size;
     1939      }
     1940      CPXaddlazyconstraints(env, lpPtr, nAdd, size,
     1941                            rhs, rowSense, rmatbeg,
     1942                            rmatind, rmatval, NULL);
     1943      CPXsetintparam( env, CPX_PARAM_REDUCE,
     1944                      // CPX_PREREDUCE_NOPRIMALORDUAL (0)
     1945                      CPX_PREREDUCE_PRIMALONLY);
     1946    }
     1947    if (getCutoff()<1.0e50) {
     1948      double useCutoff = getCutoff()+offset;
     1949      if (bestObjective_<1.0e50)
     1950        useCutoff = bestObjective_+offset+1.0e-7;
     1951      cpxSolver.setDblParam(OsiDualObjectiveLimit,useCutoff*
     1952                            direction);
     1953      if( direction >0.0 )
     1954        CPXsetdblparam( env, CPX_PARAM_CUTUP, useCutoff ) ; // min
     1955      else
     1956        CPXsetdblparam( env, CPX_PARAM_CUTLO, useCutoff ) ; // max
     1957    }
     1958    CPXsetdblparam(env, CPX_PARAM_EPGAP,dblParam_[CbcAllowableFractionGap]);
     1959    delete [] setSol;
     1960    delete [] setVar;
     1961    char printBuffer[200];
     1962    if (offset) {
     1963      sprintf(printBuffer,"Add %g to all Cplex messages for true objective",
     1964              -offset);
     1965      messageHandler()->message(CBC_GENERAL,messages())
     1966        << printBuffer << CoinMessageEol ;
     1967      cpxSolver.setDblParam(OsiObjOffset,offset);
     1968    }
     1969    cpxSolver.branchAndBound();
     1970    static double totalTime=0.0;
     1971    double timeTaken = CoinCpuTime()-time1;
     1972    totalTime += timeTaken;
     1973    sprintf(printBuffer,"Cplex took %g seconds - total %g",
     1974            timeTaken,totalTime);
     1975    messageHandler()->message(CBC_GENERAL,messages())
     1976      << printBuffer << CoinMessageEol ;
     1977    numberExtraNodes_ = CPXgetnodecnt(env,lpPtr);
     1978    numberExtraIterations_ = CPXgetmipitcnt(env,lpPtr);
     1979    double value = cpxSolver.getObjValue()*direction;
     1980    if (cpxSolver.isProvenOptimal()&&value<=getCutoff()) {
     1981      feasible=true;
     1982      clpSolver->setWarmStart(NULL);
     1983      // try and do solution
     1984      double * newSolution =
     1985        CoinCopyOfArray(cpxSolver.getColSolution(),
     1986                        getNumCols());
     1987      setBestSolution(CBC_STRONGSOL,value,newSolution) ;
     1988      delete [] newSolution;
     1989    }
     1990    feasible=false;
     1991  }
     1992#endif
    18611993  if(fastNodeDepth_>=0&&/*!parentModel_*/(specialOptions_&2048)==0) {
    18621994    // add in a general depth object doClp
     
    18942026 // Save copy of solver
    18952027 OsiSolverInterface * saveSolver = NULL;
    1896  if (!parentModel_&&(specialOptions_&(512+2048))!=0)
     2028 if (!parentModel_&&(specialOptions_&(512+32768))!=0)
    18972029   saveSolver = solver_->clone();
    1898  if (saveSolver&&(specialOptions_&2048)!=0) {
     2030 double checkCutoffForRestart=1.0e100;
     2031 if (saveSolver&&(specialOptions_&32768)!=0) {
    18992032   // See if worth trying reduction
    1900    bool tryNewSearch=solverCharacteristics_->reducedCostsAccurate();
     2033   checkCutoffForRestart=getCutoff();
     2034   bool tryNewSearch=solverCharacteristics_->reducedCostsAccurate()&&
     2035     (checkCutoffForRestart<1.0e20);
    19012036   int numberColumns = getNumCols();
    19022037   if (tryNewSearch) {
    1903      double cutoff = getCutoff() ;
     2038#ifdef CLP_INVESTIGATE
     2039     printf("after %d nodes, cutoff %g - looking\n",
     2040            numberNodes_,getCutoff());
     2041#endif
    19042042     saveSolver->resolve();
    19052043     double direction = saveSolver->getObjSense() ;
    1906      double gap = cutoff - saveSolver->getObjValue()*direction ;
     2044     double gap = checkCutoffForRestart - saveSolver->getObjValue()*direction ;
    19072045     double tolerance;
    19082046     saveSolver->getDblParam(OsiDualTolerance,tolerance) ;
     
    19522090   }
    19532091   if (tryNewSearch) {
    1954      // back to solver without cuts?
    1955 #if 0
     2092     // back to solver without cuts? 
     2093#if 1
    19562094     OsiSolverInterface * solver2 = continuousSolver_->clone();
    19572095#else
     
    19692107     saveSolver=solver2;
    19702108     double * newSolution = new double[numberColumns];
    1971      double objectiveValue=cutoff;
     2109     double objectiveValue=checkCutoffForRestart;
    19722110     CbcSerendipity heuristic(*this);
    19732111     if (bestSolution_)
    19742112       heuristic.setInputSolution(bestSolution_,bestObjective_);
    1975      heuristic.setFractionSmall(0.9);
     2113     heuristic.setFractionSmall(0.5);
    19762114     heuristic.setFeasibilityPumpOptions(1008013);
    19772115     // Use numberNodes to say how many are original rows
     
    19792117#ifdef COIN_DEVELOP
    19802118     if (continuousSolver_->getNumRows()<
    1981          solver_->getNumRows())
     2119         saveSolver->getNumRows())
    19822120       printf("%d rows added ZZZZZ\n",
    19832121              solver_->getNumRows()-continuousSolver_->getNumRows());
     
    19862124                                                   -1,newSolution,
    19872125                                                   objectiveValue,
    1988                                                    cutoff,"Reduce");
     2126                                                   checkCutoffForRestart,"Reduce");
    19892127     if (returnCode<0) {
    19902128#ifdef COIN_DEVELOP
     
    24002538  bool locked=false;
    24012539  int threadStats[6];
    2402   int defaultParallelIterations=500;
     2540  int defaultParallelIterations=400;
    24032541  int defaultParallelNodes=10;
    24042542  memset(threadStats,0,sizeof(threadStats));
     
    25532691        = dynamic_cast<OsiClpSolverInterface *> (solver_);
    25542692      if (clpSolver&&numberNodes_>=100&&numberNodes_<200) {
    2555         if (numberIterations_<numberNodes_*20) {
     2693        if (numberIterations_<(numberSolves_+numberNodes_)*10) {
     2694          //if (numberIterations_<numberNodes_*20) {
    25562695          ClpSimplex * simplex = clpSolver->getModelPtr();
    25572696          ClpDualRowPivot * pivotMethod=simplex->dualRowPivot();
     
    26952834#endif
    26962835    // If done 100 nodes see if worth trying reduction
    2697     if (numberNodes_==100&&saveSolver) {
    2698       bool tryNewSearch=solverCharacteristics_->reducedCostsAccurate();
     2836    if ((numberNodes_==50||numberNodes_==100)&&saveSolver) {
     2837      bool tryNewSearch=solverCharacteristics_->reducedCostsAccurate()&&
     2838        (getCutoff()<1.0e20&&getCutoff()<checkCutoffForRestart);
    26992839      int numberColumns = getNumCols();
    27002840      if (tryNewSearch) {
    2701         double cutoff = getCutoff() ;
     2841        checkCutoffForRestart = getCutoff() ;
     2842#ifdef CLP_INVESTIGATE
     2843        printf("after %d nodes, cutoff %g - looking\n",
     2844               numberNodes_,getCutoff());
     2845#endif
    27022846        saveSolver->resolve();
    27032847        double direction = saveSolver->getObjSense() ;
    2704         double gap = cutoff - saveSolver->getObjValue()*direction ;
     2848        double gap = checkCutoffForRestart - saveSolver->getObjValue()*direction ;
    27052849        double tolerance;
    27062850        saveSolver->getDblParam(OsiDualTolerance,tolerance) ;
     
    27812925        saveSolver=solver2;
    27822926        double * newSolution = new double[numberColumns];
    2783         double objectiveValue=cutoff;
     2927        double objectiveValue=checkCutoffForRestart;
    27842928        CbcSerendipity heuristic(*this);
    27852929        if (bestSolution_)
     
    27982942                                                      -1,newSolution,
    27992943                                                      objectiveValue,
    2800                                                       cutoff,"Reduce");
     2944                                                      checkCutoffForRestart,"Reduce");
    28012945        if (returnCode<0) {
    28022946#ifdef COIN_DEVELOP
     
    29073051          = dynamic_cast<OsiClpSolverInterface *> (solver_);
    29083052        if (clpSolver&&numberNodes_>=1000&&numberNodes_<2000) {
    2909           if (numberIterations_<numberNodes_*20) {
     3053          if (numberIterations_<(numberSolves_+numberNodes_)*10) {
    29103054            ClpSimplex * simplex = clpSolver->getModelPtr();
    29113055            ClpDualRowPivot * pivotMethod=simplex->dualRowPivot();
     
    34523596  if ( numberStoppedSubTrees_)
    34533597    status_=1;
     3598  numberNodes_ += numberExtraNodes_;
     3599  numberIterations_ += numberExtraIterations_;
    34543600  if (!status_) {
    34553601    // Set best possible unless stopped on gap
     
    39224068  numberNodes2_(0),
    39234069  numberIterations_(0),
     4070  numberSolves_(0),
    39244071  status_(-1),
    39254072  secondaryStatus_(-1),
     
    40864233  numberNodes2_(0),
    40874234  numberIterations_(0),
     4235  numberSolves_(0),
    40884236  status_(-1),
    40894237  secondaryStatus_(-1),
     
    43534501  numberNodes2_(rhs.numberNodes2_),
    43544502  numberIterations_(rhs.numberIterations_),
     4503  numberSolves_(rhs.numberSolves_),
    43554504  status_(rhs.status_),
    43564505  secondaryStatus_(rhs.secondaryStatus_),
     
    46814830    numberNodes2_ = rhs.numberNodes2_;
    46824831    numberIterations_ = rhs.numberIterations_;
     4832    numberSolves_ = rhs.numberSolves_;
    46834833    status_ = rhs.status_;
    46844834    secondaryStatus_ = rhs.secondaryStatus_;
     
    50595209  numberNodes2_=0;
    50605210  numberIterations_=0;
     5211  numberSolves_ = 0;
    50615212  status_=-1;
    50625213  secondaryStatus_=-1;
     
    51865337  numberNodes2_ = rhs.numberNodes2_;
    51875338  numberIterations_ = rhs.numberIterations_;
     5339  numberSolves_ = rhs.numberSolves_;
    51885340  status_ = rhs.status_;
    51895341  secondaryStatus_ = rhs.secondaryStatus_;
     
    57695921      lastws->compressRows(numberToDrop,cutsToDrop) ;
    57705922      lastws->resize(numberRowsNow,numberColumns);
     5923      assert (lastws->fullBasis());
    57715924#ifdef NODE_LAST
    57725925      bool canMissStuff=false;
     
    77177870          }
    77187871        }
     7872        // Set bit to say don't try too hard if seems reasonable
     7873        if (maximumCutPasses_<=5)
     7874          whenCuts_ += 100000;
    77197875        //// end
    77207876#ifdef CLP_INVESTIGATE
     
    83898545          //double cutoff = getCutoff();
    83908546          if (bestObjective_-getCutoffIncrement()<testValue) {
    8391 #ifdef CLP_INVESTIGATE
     8547#ifdef CLP_INVESTIGATE 
    83928548            double value ;
    83938549            solver_->getDblParam(OsiDualObjectiveLimit,value) ;
     
    96199775      CoinWarmStartBasis * basis = dynamic_cast<CoinWarmStartBasis*>(saveSolver->getWarmStart()) ;
    96209776      assert(basis != NULL);
     9777#if 0 //ndef CBC_OTHER_SOLVER
    96219778      for (i=0;i<numberObjects_;i++) {
    96229779        CbcSimpleInteger * obj =
     
    96309787        }
    96319788      }
     9789#endif
    96329790      delete basis;
    96339791    }
     
    1003610194    assert(basis != NULL);
    1003710195    objectiveValue =checkSolution(cutoff,solution,fixVariables,objectiveValue);
    10038     if (saveObjectiveValue+1.0e-5<objectiveValue) {
     10196    if (saveObjectiveValue+1.0e-3<objectiveValue) {
    1003910197#if COIN_DEVELOP>1
    1004010198      printf("First try at solution had objective %.16g, rechecked as %.16g\n",
     
    1191112069CbcModel::resolve(OsiSolverInterface * solver)
    1191212070{
     12071  numberSolves_++;
    1191312072#ifdef COIN_HAS_CLP
    1191412073  OsiClpSolverInterface * clpSolver
     
    1211412273      if (!doCutsNow(1))
    1211512274        doClp=true;
    12116       doClp = true;
    12117       int testDepth=10;
     12275      //doClp = true;
     12276      int testDepth=5;
    1211812277      // Don't do if many iterations per node
    1211912278      int totalNodes = numberNodes_+numberExtraNodes_;
    1212012279      int totalIterations = numberIterations_ + numberExtraIterations_;
    12121       if (totalNodes*40<totalIterations)
     12280      if (totalNodes*40<totalIterations||numberNodes_<1000) {
    1212212281        doClp=false;
     12282        //} else if (oldNode&&fastNodeDepth_>=0&&oldNode->depth()>=testDepth&&(specialOptions_&2048)==0) {
     12283        //printf("size %d %d - cuts %d - nodes %d its %d\n",solver_->getNumRows(),
     12284        //     solver_->getNumCols(),cuts.sizeRowCuts(),
     12285        //     totalNodes,totalIterations);
     12286      }
    1212312287      if (oldNode&&fastNodeDepth_>=0&&oldNode->depth()>=testDepth&&/*!parentModel_*/(specialOptions_&2048)==0
    1212412288          &&doClp&&!cuts.sizeRowCuts()) {
     
    1324213406      OsiClpSolverInterface * clpSolver
    1324313407        = dynamic_cast<OsiClpSolverInterface *> (solver_);
    13244       if (clpSolver&&fastNodeDepth_<-1) {
    13245 #define FATHOM_BIAS 1
     13408      if ((clpSolver||(specialOptions_&16384)!=0)&&fastNodeDepth_<-1
     13409          &&!parentModel_) {
     13410#define FATHOM_BIAS -2
    1324613411        //#ifdef COIN_DEVELOP
    1324713412        if (numberNodes_==1) {
     
    1327613441        }
    1327713442        int go_fathom = FATHOM_BIAS+fastNodeDepth1;
     13443        if((specialOptions_&16384)!=0)
     13444          numberNodesBeforeFathom = 0;
    1327813445        if (node->depth()>=go_fathom &&!parentModel_
    1327913446            //if (node->depth()>=FATHOM_BIAS-fastNodeDepth_&&!parentModel_
    13280             &&numberNodes_>numberNodesBeforeFathom) {
    13281           info->integerTolerance_=getIntegerTolerance();
    13282           info->integerIncrement_=getCutoffIncrement();
    13283           double * down = new double[numberIntegers_];
    13284           double * up = new double[numberIntegers_];
    13285           int * numberDown = new int[numberIntegers_];
    13286           int * numberUp = new int[numberIntegers_];
    13287           int * numberDownInfeasible = new int[numberIntegers_];
    13288           int * numberUpInfeasible = new int[numberIntegers_];
    13289           fillPseudoCosts(down,up,numberDown,numberUp,
    13290                           numberDownInfeasible,numberUpInfeasible);
    13291           info->fillPseudoCosts(down,up,numberDown,numberUp,
    13292                                 numberDownInfeasible,
    13293                                 numberUpInfeasible,numberIntegers_);
    13294           info->presolveType_=1;
    13295           // for reduced costs and duals
    13296           info->solverOptions_ |= 7;
    13297           delete [] down;
    13298           delete [] up;
    13299           delete [] numberDown;
    13300           delete [] numberUp;
    13301           delete [] numberDownInfeasible;
    13302           delete [] numberUpInfeasible;
    13303           bool takeHint;
    13304           OsiHintStrength strength;
    13305           solver_->getHintParam(OsiDoReducePrint,takeHint,strength);
    13306           ClpSimplex * simplex = clpSolver->getModelPtr();
    13307           int saveLevel = simplex->logLevel();
    13308           if (strength!=OsiHintIgnore&&takeHint&&saveLevel==1)
    13309             simplex->setLogLevel(0);
    13310           clpSolver->setBasis();
    13311           feasible = simplex->fathom(info)!=0;
    13312           numberExtraNodes_ += info->numberNodesExplored_;
    13313           numberExtraIterations_ += info->numberIterations_;
    13314           if (info->nNodes_<0) {
    13315             // we gave up
    13316             //abort();
    13317             fastNodeDepth_ -= 2;
     13447            &&numberNodes_>=numberNodesBeforeFathom) {
     13448#ifndef COIN_HAS_CPX
     13449          specialOptions_ &= ~16384;
     13450#endif
     13451          if ((specialOptions_&16384)==0) {
     13452            info->integerTolerance_=getIntegerTolerance();
     13453            info->integerIncrement_=getCutoffIncrement();
     13454            double * down = new double[numberIntegers_];
     13455            double * up = new double[numberIntegers_];
     13456            int * numberDown = new int[numberIntegers_];
     13457            int * numberUp = new int[numberIntegers_];
     13458            int * numberDownInfeasible = new int[numberIntegers_];
     13459            int * numberUpInfeasible = new int[numberIntegers_];
     13460            fillPseudoCosts(down,up,numberDown,numberUp,
     13461                            numberDownInfeasible,numberUpInfeasible);
     13462            info->fillPseudoCosts(down,up,numberDown,numberUp,
     13463                                  numberDownInfeasible,
     13464                                  numberUpInfeasible,numberIntegers_);
     13465            info->presolveType_=1;
     13466            // for reduced costs and duals
     13467            info->solverOptions_ |= 7;
     13468            delete [] down;
     13469            delete [] up;
     13470            delete [] numberDown;
     13471            delete [] numberUp;
     13472            delete [] numberDownInfeasible;
     13473            delete [] numberUpInfeasible;
     13474            bool takeHint;
     13475            OsiHintStrength strength;
     13476            solver_->getHintParam(OsiDoReducePrint,takeHint,strength);
     13477            ClpSimplex * simplex = clpSolver->getModelPtr();
     13478            int saveLevel = simplex->logLevel();
     13479            if (strength!=OsiHintIgnore&&takeHint&&saveLevel==1)
     13480              simplex->setLogLevel(0);
     13481            clpSolver->setBasis();
     13482            feasible = simplex->fathom(info)!=0;
     13483            numberExtraNodes_ += info->numberNodesExplored_;
     13484            numberExtraIterations_ += info->numberIterations_;
     13485            if (info->nNodes_<0) {
     13486              // we gave up
     13487              //abort();
     13488              fastNodeDepth_ -= 2;
    1331813489#ifdef COIN_DEVELOP
    13319             printf("fastNodeDepth now %d - so at depth >= %d\n",
    13320                    fastNodeDepth_,FATHOM_BIAS-fastNodeDepth_);
    13321 #endif
    13322             if (feasible) {
     13490              printf("fastNodeDepth now %d - so at depth >= %d\n",
     13491                     fastNodeDepth_,FATHOM_BIAS-fastNodeDepth_);
     13492#endif
     13493              if (feasible) {
     13494                // Save bounds round bestSolution
     13495                //double * saveLower = CoinCopyOfArray(solver_->getColLower(),
     13496                //                           numberColumns);
     13497                //double * saveUpper = CoinCopyOfArray(solver_->getColUpper(),
     13498                //                           numberColumns);
     13499                clpSolver->setWarmStart(NULL);
     13500                // try and do solution
     13501                double value = simplex->objectiveValue()*
     13502                  simplex->optimizationDirection();
     13503                double * newSolution =
     13504                  CoinCopyOfArray(simplex->primalColumnSolution(),
     13505                                  numberColumns);
     13506                setBestSolution(CBC_STRONGSOL,value,newSolution) ;
     13507                delete [] newSolution;
     13508                //solver_->setColLower(saveLower);
     13509                //solver_->setColUpper(saveUpper);
     13510                //delete [] saveLower;
     13511                //delete [] saveUpper;
     13512              }
     13513              // say feasible so will redo node
     13514              feasible=true;
     13515            } else {
     13516              if (feasible) {
     13517                clpSolver->setWarmStart(NULL);
     13518                // try and do solution
     13519                double value = simplex->objectiveValue()*
     13520                  simplex->optimizationDirection();
     13521                double * newSolution =
     13522                  CoinCopyOfArray(simplex->primalColumnSolution(),
     13523                                  numberColumns);
     13524                setBestSolution(CBC_STRONGSOL,value,newSolution) ;
     13525                delete [] newSolution;
     13526              }
     13527              // update pseudo costs
     13528              double smallest=1.0e50;
     13529              double largest=-1.0;
     13530              for (int i=0;i<numberIntegers_;i++) {
     13531#ifndef NDEBUG
     13532                CbcSimpleIntegerDynamicPseudoCost * obj =
     13533                  dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object_[i]) ;
     13534                assert (obj&&obj->columnNumber()==integerVariable_[i]);
     13535#else
     13536                CbcSimpleIntegerDynamicPseudoCost * obj =
     13537                  static_cast <CbcSimpleIntegerDynamicPseudoCost *>(object_[i]) ;
     13538#endif
     13539                if (info->numberUp_[i]>0) {
     13540                  if (info->downPseudo_[i]>largest)
     13541                    largest=info->downPseudo_[i];
     13542                  if (info->downPseudo_[i]<smallest)
     13543                    smallest=info->downPseudo_[i];
     13544                  if (info->upPseudo_[i]>largest)
     13545                    largest=info->upPseudo_[i];
     13546                  if (info->upPseudo_[i]<smallest)
     13547                    smallest=info->upPseudo_[i];
     13548                  obj->updateAfterMini(info->numberDown_[i],
     13549                                       info->numberDownInfeasible_[i],
     13550                                       info->downPseudo_[i],
     13551                                       info->numberUp_[i],
     13552                                       info->numberUpInfeasible_[i],
     13553                                       info->upPseudo_[i]);
     13554                }
     13555              }
     13556              //printf("range of costs %g to %g\n",smallest,largest);
     13557              // If value of objective borderline then may not be feasible
     13558              double value = simplex->objectiveValue()*simplex->optimizationDirection();
     13559              if (value-getCutoff()<-1.0e-1)
     13560                fathomDone=true;
     13561            }
     13562            simplex->setLogLevel(saveLevel);
     13563#ifdef COIN_HAS_CPX
     13564          } else {
     13565            // try cplex
     13566            OsiCpxSolverInterface cpxSolver;
     13567            double direction = clpSolver->getObjSense();
     13568            cpxSolver.setObjSense(direction);
     13569            // load up cplex
     13570            const CoinPackedMatrix * matrix = clpSolver->getMatrixByCol();
     13571            const double * rowLower = clpSolver->getRowLower();
     13572            const double * rowUpper = clpSolver->getRowUpper();
     13573            const double * columnLower = clpSolver->getColLower();
     13574            const double * columnUpper = clpSolver->getColUpper();
     13575            const double * objective = clpSolver->getObjCoefficients();
     13576            cpxSolver.loadProblem(*matrix,columnLower,columnUpper,
     13577                                  objective, rowLower,rowUpper);
     13578            double * setSol = new double [numberIntegers_];
     13579            int * setVar = new int [numberIntegers_];
     13580            // cplex doesn't know about objective offset
     13581            double offset = clpSolver->getModelPtr()->objectiveOffset();
     13582            for (int i=0;i<numberIntegers_;i++) {
     13583              int iColumn = integerVariable_[i];
     13584              cpxSolver.setInteger(iColumn);
     13585              if (bestSolution_) {
     13586                setSol[i]=bestSolution_[iColumn];
     13587                setVar[i]=iColumn;
     13588              }
     13589            }
     13590            CPXENVptr env = cpxSolver.getEnvironmentPtr();
     13591            CPXLPptr lpPtr = cpxSolver.getLpPtr(OsiCpxSolverInterface::KEEPCACHED_ALL);
     13592            cpxSolver.switchToMIP();
     13593            if (bestSolution_) {
     13594              CPXcopymipstart(env,lpPtr,numberIntegers_,setVar,setSol);
     13595            }
     13596            if (getCutoff()<1.0e50) {
     13597              double useCutoff = getCutoff()+offset;
     13598              if (bestObjective_<1.0e50)
     13599                useCutoff = bestObjective_+offset+1.0e-7;
     13600              cpxSolver.setDblParam(OsiDualObjectiveLimit,useCutoff*
     13601                                    direction);
     13602              if( direction >0.0 )
     13603                CPXsetdblparam( env, CPX_PARAM_CUTUP, useCutoff ) ; // min
     13604              else
     13605                CPXsetdblparam( env, CPX_PARAM_CUTLO, useCutoff ) ; // max
     13606            }
     13607            CPXsetdblparam(env, CPX_PARAM_EPGAP,dblParam_[CbcAllowableFractionGap]);
     13608            delete [] setSol;
     13609            delete [] setVar;
     13610            if (offset) {
     13611              char printBuffer[200];
     13612              sprintf(printBuffer,"Add %g to all Cplex messages for true objective",
     13613                      -offset);
     13614              messageHandler()->message(CBC_GENERAL,messages())
     13615                << printBuffer << CoinMessageEol ;
     13616              cpxSolver.setDblParam(OsiObjOffset,offset);
     13617            }
     13618            cpxSolver.branchAndBound();
     13619            numberExtraNodes_ += CPXgetnodecnt(env,lpPtr);
     13620            numberExtraIterations_ += CPXgetmipitcnt(env,lpPtr);
     13621            double value = cpxSolver.getObjValue()*direction;
     13622            if (cpxSolver.isProvenOptimal()&&value<=getCutoff()) {
     13623              feasible=true;
    1332313624              clpSolver->setWarmStart(NULL);
    1332413625              // try and do solution
    13325               double value = simplex->objectiveValue()*
    13326                 simplex->optimizationDirection();
    1332713626              double * newSolution =
    13328                 CoinCopyOfArray(simplex->primalColumnSolution(),
    13329                                 numberColumns);
     13627                CoinCopyOfArray(cpxSolver.getColSolution(),
     13628                                getNumCols());
    1333013629              setBestSolution(CBC_STRONGSOL,value,newSolution) ;
    1333113630              delete [] newSolution;
     13631              fathomDone=true;
     13632            } else {
     13633              feasible=false;
    1333213634            }
    13333             // say feasible so will redo node
    13334             feasible=true;
    13335           } else {
    13336             if (feasible) {
    13337               clpSolver->setWarmStart(NULL);
    13338               // try and do solution
    13339               double value = simplex->objectiveValue()*
    13340                 simplex->optimizationDirection();
    13341               double * newSolution =
    13342                 CoinCopyOfArray(simplex->primalColumnSolution(),
    13343                                 numberColumns);
    13344               setBestSolution(CBC_STRONGSOL,value,newSolution) ;
    13345               delete [] newSolution;
    13346             }
    13347             // update pseudo costs
    13348             double smallest=1.0e50;
    13349             double largest=-1.0;
    13350             for (int i=0;i<numberIntegers_;i++) {
    13351 #ifndef NDEBUG
    13352               CbcSimpleIntegerDynamicPseudoCost * obj =
    13353                 dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object_[i]) ;
    13354               assert (obj&&obj->columnNumber()==integerVariable_[i]);
    13355 #else
    13356               CbcSimpleIntegerDynamicPseudoCost * obj =
    13357                 static_cast <CbcSimpleIntegerDynamicPseudoCost *>(object_[i]) ;
    13358 #endif
    13359               if (info->numberUp_[i]>0) {
    13360                 if (info->downPseudo_[i]>largest)
    13361                   largest=info->downPseudo_[i];
    13362                 if (info->downPseudo_[i]<smallest)
    13363                   smallest=info->downPseudo_[i];
    13364                 if (info->upPseudo_[i]>largest)
    13365                   largest=info->upPseudo_[i];
    13366                 if (info->upPseudo_[i]<smallest)
    13367                   smallest=info->upPseudo_[i];
    13368                 obj->updateAfterMini(info->numberDown_[i],
    13369                                      info->numberDownInfeasible_[i],
    13370                                      info->downPseudo_[i],
    13371                                      info->numberUp_[i],
    13372                                      info->numberUpInfeasible_[i],
    13373                                      info->upPseudo_[i]);
    13374               }
    13375             }
    13376             //printf("range of costs %g to %g\n",smallest,largest);
    13377             // If value of objective borderline then may not be feasible
    13378             double value = simplex->objectiveValue()*simplex->optimizationDirection();
    13379             if (value-getCutoff()<-1.0e-1)
    13380               fathomDone=true;
     13635#endif
    1338113636          }
    13382           simplex->setLogLevel(saveLevel);
    1338313637        }
    1338413638      }
    1338513639      if (feasible) {
    13386         feasible = solveWithCuts(cuts,maximumCutPasses_,node);
     13640        //int numberPasses = doCutsNow(1) ? maximumCutPasses_ : 0;
     13641        int numberPasses = /*doCutsNow(1) ?*/ maximumCutPasses_ /*: 0*/;
     13642        feasible = solveWithCuts(cuts,numberPasses,node);
    1338713643        if (fathomDone)
    1338813644          assert (feasible);
     
    1396414220  */
    1396514221#if 1
    13966   int numberToDelete = getNumRows()-numberRowsAtContinuous_ ;
    13967   if (numberToDelete) {
    13968     int * delRows = new int[numberToDelete] ;
    13969     int i ;
    13970     for (i = 0 ; i < numberToDelete ; i++)
    13971       delRows[i] = i+numberRowsAtContinuous_ ;
    13972     solver_->deleteRows(numberToDelete,delRows) ;
    13973     delete [] delRows ;
     14222  //if (numberThreads_)
     14223  {
     14224    int numberToDelete = getNumRows()-numberRowsAtContinuous_ ;
     14225    if (numberToDelete) {
     14226      int * delRows = new int[numberToDelete] ;
     14227      int i ;
     14228      for (i = 0 ; i < numberToDelete ; i++)
     14229        delRows[i] = i+numberRowsAtContinuous_ ;
     14230      solver_->deleteRows(numberToDelete,delRows) ;
     14231      delete [] delRows ;
     14232    }
    1397414233  }
    1397514234#endif
     
    1416414423    numberIterations_ = baseModel->numberIterations_;
    1416514424    numberFixedAtRoot_ = numberIterations_; // for statistics
     14425    numberSolves_=0;
    1416614426    phase_ = baseModel->phase_;
    1416714427    assert (!nextRowCut_);
     
    1423214492    baseModel->numberIterations_ +=
    1423314493      numberIterations_ - numberFixedAtRoot_;
     14494    baseModel->numberSolves_ += numberSolves_;
    1423414495#ifdef PUSH_LATER
    1423514496    if (stuff->node)
     
    1449114752        int nodesThisTime=thisModel->getNodeCount();
    1449214753        int iterationsThisTime=thisModel->getIterationCount();
     14754        int strongThisTime=thisModel->numberStrongIterations();
    1449314755        thisModel->setStopNumberIterations(thisModel->getIterationCount()+numberIterations);
    1449414756        int numberColumns = thisModel->getNumCols();
     
    1449814760          if (thisModel->tree()->empty()) {
    1449914761            returnCode=1+1;
     14762#ifdef CLP_INVESTIGATE
     14763            printf("%x tree empty - time %18.6f\n",thisModel,CoinGetTimeOfDay()-1.2348e9);
     14764#endif
    1450014765            break;
    1450114766          }
    14502           if (thisModel->getIterationCount()>thisModel->getStopNumberIterations()) {
     14767#define NODE_ITERATIONS 2
     14768          int nodesNow = thisModel->getNodeCount();
     14769          int iterationsNow = thisModel->getIterationCount();
     14770          int strongNow=thisModel->numberStrongIterations();
     14771          bool exit1 = (NODE_ITERATIONS*((nodesNow-nodesThisTime)+
     14772                                         ((strongNow-strongThisTime)>>1))+
     14773                        (iterationsNow-iterationsThisTime)>numberIterations);
     14774          //bool exit2 =(thisModel->getIterationCount()>thisModel->getStopNumberIterations()) ;
     14775          //assert (exit1==exit2);
     14776          if (exit1&&nodesNow-nodesThisTime>=10) {
    1450314777            // out of loop
    1450414778            //printf("out of loop\n");
     14779#ifdef CLP_INVESTIGATE
     14780            printf("%x tree %d nodes left, done %d and %d its - time %18.6f\n",thisModel,
     14781                   thisModel->tree()->size(),nodesNow-nodesThisTime,
     14782                   iterationsNow-iterationsThisTime,CoinGetTimeOfDay()-1.2348e9);
     14783#endif
    1450514784            break;
    1450614785          }
     
    1496515244CbcModel::doCutsNow(int allowForTopOfTree) const
    1496615245{
     15246  int whenCutsUse = whenCuts_;
     15247  int alwaysReturnAt10 = whenCutsUse%100000;
     15248  if (whenCutsUse>0&&alwaysReturnAt10) {
     15249    whenCutsUse -= alwaysReturnAt10;
     15250    if (currentDepth_>10)
     15251    return false;
     15252  }
     15253  //if (currentDepth_>10)
     15254  //return false;
     15255#define TRY_IDEA1 2
    1496715256  int size = continuousSolver_->getNumRows()+continuousSolver_->getNumCols();
    1496815257
    14969   if (whenCuts_<0||(size<=500&&allowForTopOfTree!=3)) {
     15258  if (true&&(whenCutsUse<0||(size<=500-500*TRY_IDEA1&&allowForTopOfTree!=3))) {
    1497015259    int whenCuts = (size<=500) ? -1 :1;
     15260    //whenCuts = (size<=500) ? 1 :1;
    1497115261    if (parentModel_)
    1497215262      whenCuts=1;
    1497315263    //int nodeDepth = currentDepth_-1;
    1497415264    bool doCuts2 =  !(currentDepth_>11&&(currentDepth_&1)==whenCuts);
    14975     //printf("when %d node %d depth %d size %d doing cuts %s\n",whenCuts_,
     15265    if (fastNodeDepth_>0&&currentDepth_>10)
     15266      doCuts2=false;
     15267    //printf("when %d node %d depth %d size %d doing cuts %s\n",whenCutsUse,
    1497615268    //   numberNodes_,currentDepth_,size,doCuts2 ? "yes" : "no");
    1497715269    return doCuts2;
     
    1497915271  //if (!parentModel_&&currentDepth_==7)
    1498015272  //printf("q\n");
    14981   int top=whenCuts_/1000000;
     15273  int top=whenCutsUse/1000000;
    1498215274  int shallow = top ? (top-1) : 9;
    14983   int when = whenCuts_ -1000000*top;
     15275  int when = whenCutsUse -1000000*top;
     15276#if TRY_IDEA1
     15277  if (when<15&&when>1&&size<=500)
     15278    when /= 2;
     15279#endif
    1498415280  if ((when>15||(top&&top<5))&&currentDepth_>when)
    1498515281    when=100000; // off
     
    1498915285  } else if (allowForTopOfTree==2&&shallow>=1) {
    1499015286    doCuts=true;
     15287#if TRY_IDEA1<2
    1499115288  } else if (allowForTopOfTree==3&&doCuts) {
    1499215289    // only if first
    1499315290    if(currentDepth_<=shallow||currentDepth_-when>shallow)
    1499415291      doCuts=false;
     15292#else
     15293  } else if (allowForTopOfTree==3) {
     15294    // only exactly at 10
     15295    doCuts = (currentDepth_==10);
     15296#endif
    1499515297  }
    1499615298  //if (!doCuts&&currentDepth_&&!parentModel_)
Note: See TracChangeset for help on using the changeset viewer.