Changeset 1016


Ignore:
Timestamp:
Jul 20, 2008 7:15:03 PM (11 years ago)
Author:
forrest
Message:

changes which should not change anything???

Location:
trunk/Cbc/src
Files:
2 edited

Legend:

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

    r1015 r1016  
    212212    doThis=false;
    213213  // Switch off if special setting
    214   if (whenCutGeneratorInSub_==-200) {
     214  if (whenCutGeneratorInSub_==-200&&model_->parentModel()) {
    215215    fullScan=0;
    216216    doThis=false;
  • trunk/Cbc/src/CbcModel.cpp

    r1015 r1016  
    55#  pragma warning(disable:4786)
    66#endif
    7 //#define COIN_DEVELOP
     7#define MODEL1 0
     8#define MODEL2 0
     9#define MODEL3 1
     10#define MODEL4 0
     11#define MODEL5 1
     12#define MODEL6 0
     13#define MODEL7 0
     14#define MODEL8 0
     15#define MODEL10 1
     16#define MODEL11 0
     17#define MODEL12 1
    818
    919#include "CbcConfig.h"
     
    898908  strongInfo_[1]=0;
    899909  strongInfo_[2]=0;
     910  strongInfo_[3]=0;
     911  strongInfo_[4]=0;
     912  strongInfo_[5]=0;
     913  strongInfo_[6]=0;
    900914  numberStrongIterations_ = 0;
     915  currentNode_ = NULL;
    901916  CoinThreadRandom randomGenerator(1234567);
    902917#ifdef COIN_HAS_CLP
     
    907922     // Initialise solvers seed
    908923     clpSolver->getModelPtr()->setRandomSeed(1234567);
     924#if MODEL1
     925     // reduce factorization frequency
     926     int frequency = clpSolver->getModelPtr()->factorizationFrequency();
     927     clpSolver->getModelPtr()->setFactorizationFrequency(CoinMin(frequency,120));
     928#endif
    909929   }
    910930 }
     
    11041124  if (eventHandler)
    11051125    eventHandler->setModel(this);
     1126#if MODEL12
     1127#define CLIQUE_ANALYSIS
     1128#endif
    11061129#ifdef CLIQUE_ANALYSIS
    11071130  // set up for probing
    1108   probingInfo_ = new CglTreeProbingInfo(solver_);
     1131  if (!parentModel_)
     1132    probingInfo_ = new CglTreeProbingInfo(solver_);
     1133  else
     1134    probingInfo_=NULL;
    11091135#else
    11101136  probingInfo_=NULL;
     
    15891615  statistics_ = NULL;
    15901616  // Do on switch
    1591   if (doStatistics>0&&doStatistics<100) {
     1617  if (doStatistics>0&&doStatistics<=100) {
    15921618    maximumStatistics_=10000;
    15931619    statistics_ = new CbcStatistics * [maximumStatistics_];
     
    16811707 if (!parentModel_&&(specialOptions_&(512+2048))!=0)
    16821708   saveSolver = solver_->clone();
    1683  if (!parentModel_&&(specialOptions_&2048)!=0) {
     1709 if (saveSolver&&(specialOptions_&2048)!=0) {
    16841710   // See if worth trying reduction
    16851711   bool tryNewSearch=solverCharacteristics_->reducedCostsAccurate();
     
    18131839  //solverCharacteristics_->setSolver(solver_);
    18141840  if (feasible) {
     1841    //#define HOTSTART 1
     1842#if HOTSTART
     1843    if (hotstartSolution_&&!hotstartPriorities_) {
     1844      // Set up hot start
     1845      OsiSolverInterface * solver = solver_->clone();
     1846      double direction = solver_->getObjSense() ;
     1847      int numberColumns = solver->getNumCols();
     1848      double * saveLower = CoinCopyOfArray(solver->getColLower(),numberColumns);
     1849      double * saveUpper = CoinCopyOfArray(solver->getColUpper(),numberColumns);
     1850      // move solution
     1851      solver->setColSolution(hotstartSolution_);
     1852      // point to useful information
     1853      const double * saveSolution = testSolution_;
     1854      testSolution_ = solver->getColSolution();
     1855      OsiBranchingInformation usefulInfo=usefulInformation();
     1856      testSolution_ = saveSolution;
     1857      /*
     1858        Run through the objects and use feasibleRegion() to set variable bounds
     1859        so as to fix the variables specified in the objects at their value in this
     1860        solution. Since the object list contains (at least) one object for every
     1861        integer variable, this has the effect of fixing all integer variables.
     1862      */
     1863      for (int i=0;i<numberObjects_;i++)
     1864        object_[i]->feasibleRegion(solver,&usefulInfo);
     1865      solver->resolve();
     1866      assert (solver->isProvenOptimal());
     1867      double gap = CoinMax((solver->getObjValue()-solver_->getObjValue())*direction,0.0) ;
     1868      const double * dj = solver->getReducedCost();
     1869      const double * colLower = solver->getColLower();
     1870      const double * colUpper = solver->getColUpper();
     1871      const double * solution = solver->getColSolution();
     1872      int nAtLbNatural=0;
     1873      int nAtUbNatural=0;
     1874      int nAtLbNaturalZero=0;
     1875      int nAtUbNaturalZero=0;
     1876      int nAtLbFixed=0;
     1877      int nAtUbFixed=0;
     1878      int nAtOther=0;
     1879      int nAtOtherNatural=0;
     1880      int nNotNeeded=0;
     1881      delete [] hotstartSolution_;
     1882      hotstartSolution_ = new double [numberColumns];
     1883      delete [] hotstartPriorities_;
     1884      hotstartPriorities_ = new int [numberColumns];
     1885      int * order = (int *) saveUpper;
     1886      int nFix=0;
     1887      double bestRatio=COIN_DBL_MAX;
     1888      for (int iColumn = 0 ; iColumn < numberColumns ; iColumn++) {
     1889        double value = solution[iColumn] ;
     1890        value = CoinMax(value, saveLower[iColumn]) ;
     1891        value = CoinMin(value, saveUpper[iColumn]) ;
     1892        double sortValue=COIN_DBL_MAX;
     1893        if (solver->isInteger(iColumn)) {
     1894          assert(fabs(value-solution[iColumn]) <= 1.0e-5) ;
     1895          double value2 = floor(value+0.5);
     1896          if (dj[iColumn]<-1.0e-6) {
     1897            // negative dj
     1898            //assert (value2==colUpper[iColumn]);
     1899            if (saveUpper[iColumn]==colUpper[iColumn]) {
     1900              nAtUbNatural++;
     1901              sortValue = 0.0;
     1902              double value=-dj[iColumn];
     1903              if (value>gap)
     1904                nFix++;
     1905              else if (gap<value*bestRatio)
     1906                bestRatio=gap/value;
     1907              if (saveLower[iColumn]!=colLower[iColumn]) {
     1908                nNotNeeded++;
     1909                sortValue = 1.0e20;
     1910              }
     1911            } else if (saveLower[iColumn]==colUpper[iColumn]) {
     1912              nAtLbFixed++;
     1913              sortValue = dj[iColumn];
     1914            } else {
     1915              nAtOther++;
     1916              sortValue = 0.0;
     1917              if (saveLower[iColumn]!=colLower[iColumn]&&
     1918                  saveUpper[iColumn]!=colUpper[iColumn]) {
     1919                nNotNeeded++;
     1920                sortValue = 1.0e20;
     1921              }
     1922            }
     1923          } else if (dj[iColumn]>1.0e-6) {
     1924            // positive dj
     1925            //assert (value2==colLower[iColumn]);
     1926            if (saveLower[iColumn]==colLower[iColumn]) {
     1927              nAtLbNatural++;
     1928              sortValue = 0.0;
     1929              double value=dj[iColumn];
     1930              if (value>gap)
     1931                nFix++;
     1932              else if (gap<value*bestRatio)
     1933                bestRatio=gap/value;
     1934              if (saveUpper[iColumn]!=colUpper[iColumn]) {
     1935                nNotNeeded++;
     1936                sortValue = 1.0e20;
     1937              }
     1938            } else if (saveUpper[iColumn]==colLower[iColumn]) {
     1939              nAtUbFixed++;
     1940              sortValue = -dj[iColumn];
     1941            } else {
     1942              nAtOther++;
     1943              sortValue = 0.0;
     1944              if (saveLower[iColumn]!=colLower[iColumn]&&
     1945                  saveUpper[iColumn]!=colUpper[iColumn]) {
     1946                nNotNeeded++;
     1947                sortValue = 1.0e20;
     1948              }
     1949            }
     1950          } else {
     1951            // zero dj
     1952            if (value2==saveUpper[iColumn]) {
     1953              nAtUbNaturalZero++;
     1954              sortValue = 0.0;
     1955              if (saveLower[iColumn]!=colLower[iColumn]) {
     1956                nNotNeeded++;
     1957                sortValue = 1.0e20;
     1958              }
     1959            } else if (value2==saveLower[iColumn]) {
     1960              nAtLbNaturalZero++;
     1961              sortValue = 0.0;
     1962            } else {
     1963              nAtOtherNatural++;
     1964              sortValue = 0.0;
     1965              if (saveLower[iColumn]!=colLower[iColumn]&&
     1966                  saveUpper[iColumn]!=colUpper[iColumn]) {
     1967                nNotNeeded++;
     1968                sortValue = 1.0e20;
     1969              }
     1970            }
     1971          }
     1972#if HOTSTART==3
     1973          sortValue=-fabs(dj[iColumn]);
     1974#endif
     1975        }
     1976        hotstartSolution_[iColumn] = value ;
     1977        saveLower[iColumn]=sortValue;
     1978        order[iColumn]=iColumn;
     1979      }
     1980      printf("** can fix %d columns - best ratio for others is %g on gap of %g\n",
     1981             nFix,bestRatio,gap);
     1982      int nNeg=0;
     1983      CoinSort_2(saveLower,saveLower+numberColumns,order);
     1984      for (int i=0;i<numberColumns;i++) {
     1985        if (saveLower[i]<0.0) {
     1986          nNeg++;
     1987#if HOTSTART==2||HOTSTART==3
     1988          // swap sign ?
     1989          saveLower[i]=-saveLower[i];
     1990#endif
     1991        }
     1992      }
     1993      CoinSort_2(saveLower,saveLower+nNeg,order);
     1994      for (int i=0;i<numberColumns;i++) {
     1995#if HOTSTART==1
     1996        hotstartPriorities_[order[i]]=100;
     1997#else
     1998        hotstartPriorities_[order[i]]=-(i+1);
     1999#endif
     2000      }
     2001      printf("nAtLbNat %d,nAtUbNat %d,nAtLbNatZero %d,nAtUbNatZero %d,nAtLbFixed %d,nAtUbFixed %d,nAtOther %d,nAtOtherNat %d, useless %d %d\n",
     2002             nAtLbNatural,
     2003             nAtUbNatural,
     2004             nAtLbNaturalZero,
     2005             nAtUbNaturalZero,
     2006             nAtLbFixed,
     2007             nAtUbFixed,
     2008             nAtOther,
     2009             nAtOtherNatural,nNotNeeded,nNeg);
     2010      delete [] saveLower;
     2011      delete [] saveUpper;
     2012      if (!saveCompare) {
     2013        // create depth first comparison
     2014        saveCompare = nodeCompare_;
     2015        // depth first
     2016        nodeCompare_ = new CbcCompareDepth();
     2017        tree_->setComparison(*nodeCompare_) ;
     2018      }
     2019    }
     2020#endif
    18152021    if (probingInfo_) {
    18162022      int number01 = probingInfo_->numberIntegers();
     
    18202026      //const int * integerVariable = probingInfo_->integerVariable();
    18212027      if (toZero[number01]) {
    1822         for (int i = 0;i<numberCutGenerators_;i++) {
    1823           CglFakeClique * clique = dynamic_cast<CglFakeClique*>(generator_[i]->generator());
    1824           if (clique) {
    1825             OsiSolverInterface * fakeSolver = probingInfo_->analyze(*solver_,1);
    1826             if (fakeSolver) {
    1827               printf("Probing fake solver has %d rows\n",fakeSolver->getNumRows());
    1828               //if (fakeSolver)
    1829               //fakeSolver->writeMps("bad");
    1830               if (generator_[i]->numberCutsInTotal())
    1831                 generator_[i]->setHowOften(1);
    1832             }
    1833             clique->assignSolver(fakeSolver);
    1834             //stored->setProbingInfo(probingInfo_);
    1835             break;
    1836           }
    1837         }
    1838       }
    1839       delete probingInfo_;
    1840       probingInfo_=NULL;
     2028        if (probingInfo_->packDown()) {
     2029#if 1 //def CLP_INVESTIGATE
     2030          printf("%d implications on %d 0-1\n",toZero[number01],number01);
     2031#endif
     2032          CglImplication implication(probingInfo_);
     2033          addCutGenerator(&implication,1,"implication",true,false,false,-200);
     2034        } else {
     2035          delete probingInfo_;
     2036          probingInfo_=NULL;
     2037        }
     2038      } else {
     2039        delete probingInfo_;
     2040
     2041        probingInfo_=NULL;
     2042      }
    18412043    }
    18422044    newNode = new CbcNode ;
     
    25492751      if (redoTree)
    25502752        tree_->setComparison(*nodeCompare_) ;
     2753#if MODEL2
     2754      if (searchStrategy_==2) {
     2755        // may be time to tweak numberBeforeTrust
     2756        if (numberStrongIterations_*5<numberIterations_&&numberNodes_<-10000) {
     2757          int numberDone = strongInfo_[0]-strongInfo_[3];
     2758          int numberFixed = strongInfo_[1]-strongInfo_[4];
     2759          int numberInfeasible = strongInfo_[2]-strongInfo_[5];
     2760          int numberNodes=numberNodes_-strongInfo_[6];
     2761          for (int i=0;i<7;i++)
     2762            printf("%d ",strongInfo_[i]);
     2763          printf("its %d strong %d\n",
     2764                 numberIterations_,numberStrongIterations_);
     2765          printf("done %d fixed %d inf %d in %d nodes\n",
     2766                 numberDone,numberFixed,numberInfeasible,numberNodes);
     2767          if (numberInfeasible*500+numberFixed*10>numberDone) {
     2768            synchronizeNumberBeforeTrust(1);
     2769            strongInfo_[3]=strongInfo_[0];
     2770            strongInfo_[4]=strongInfo_[1];
     2771            strongInfo_[5]=strongInfo_[2];
     2772            strongInfo_[6]=numberNodes_;
     2773          }
     2774        }
     2775      }
     2776#endif
    25512777#ifndef CBC_DETERMINISTIC_THREAD
    25522778      unlockThread();
     
    29653191            int iHeur ;
    29663192            for (iHeur = 0 ; iHeur < numberHeuristics_ ; iHeur++) {
     3193#if MODEL3
     3194              // skip if can't run here
     3195              if (!heuristic_[iHeur]->shouldHeurRun())
     3196                continue;
     3197#endif
    29673198              double saveValue = heurValue ;
    29683199              int ifSol = heuristic_[iHeur]->solution(heurValue,newSolution) ;
     
    35493780      lookup=NULL;
    35503781    }
    3551     if (doStatistics==3) {
     3782    if (doStatistics>=3) {
    35523783      printf("  node parent depth column   value                    obj      inf\n");
    35533784      for ( i=0;i<numberNodes2_;i++) {
     
    40644295  strongInfo_[1]=0;
    40654296  strongInfo_[2]=0;
     4297  strongInfo_[3]=0;
     4298  strongInfo_[4]=0;
     4299  strongInfo_[5]=0;
     4300  strongInfo_[6]=0;
    40664301  solverCharacteristics_ = NULL;
    40674302  nodeCompare_=new CbcCompareDefault();;
     
    42204455  strongInfo_[1]=0;
    42214456  strongInfo_[2]=0;
     4457  strongInfo_[3]=0;
     4458  strongInfo_[4]=0;
     4459  strongInfo_[5]=0;
     4460  strongInfo_[6]=0;
    42224461  solverCharacteristics_ = NULL;
    42234462
     
    44404679  strongInfo_[1]=rhs.strongInfo_[1];
    44414680  strongInfo_[2]=rhs.strongInfo_[2];
     4681  strongInfo_[3]=rhs.strongInfo_[3];
     4682  strongInfo_[4]=rhs.strongInfo_[4];
     4683  strongInfo_[5]=rhs.strongInfo_[5];
     4684  strongInfo_[6]=rhs.strongInfo_[6];
    44424685  solverCharacteristics_ = NULL;
    44434686  if (rhs.emptyWarmStart_) emptyWarmStart_ = rhs.emptyWarmStart_->clone() ;
     
    47845027    strongInfo_[1]=rhs.strongInfo_[1];
    47855028    strongInfo_[2]=rhs.strongInfo_[2];
     5029    strongInfo_[3]=rhs.strongInfo_[3];
     5030    strongInfo_[4]=rhs.strongInfo_[4];
     5031    strongInfo_[5]=rhs.strongInfo_[5];
     5032    strongInfo_[6]=rhs.strongInfo_[6];
    47865033    solverCharacteristics_ = NULL;
    47875034    lastHeuristic_ = NULL;
     
    52165463  strongInfo_[1]=rhs.strongInfo_[1];
    52175464  strongInfo_[2]=rhs.strongInfo_[2];
     5465  strongInfo_[3]=rhs.strongInfo_[3];
     5466  strongInfo_[4]=rhs.strongInfo_[4];
     5467  strongInfo_[5]=rhs.strongInfo_[5];
     5468  strongInfo_[6]=rhs.strongInfo_[6];
    52185469  numberRowsAtContinuous_ = rhs.numberRowsAtContinuous_;
    52195470  maximumDepth_= rhs.maximumDepth_;
     
    54305681bool CbcModel::addCuts1 (CbcNode * node, CoinWarmStartBasis *&lastws)
    54315682{
    5432 #if 0
    54335683  int nNode=0;
    54345684  int numberColumns = getNumCols();
     
    56435893  }
    56445894  return sameProblem;
    5645 #else
    5646   int i;
    5647   int nNode=0;
    5648   int numberColumns = getNumCols();
    5649   CbcNodeInfo * nodeInfo = node->nodeInfo();
    5650 
    5651 /*
    5652   Accumulate the path from node to the root in walkback_, and accumulate a
    5653   cut count in currentNumberCuts.
    5654 
    5655   original comment: when working then just unwind until where new node joins
    5656   old node (for cuts?)
    5657 */
    5658   int currentNumberCuts = 0;
    5659   while (nodeInfo) {
    5660     //printf("nNode = %d, nodeInfo = %x\n",nNode,nodeInfo);
    5661     walkback_[nNode++]=nodeInfo;
    5662     currentNumberCuts += nodeInfo->numberCuts() ;
    5663     nodeInfo = nodeInfo->parent() ;
    5664     if (nNode==maximumDepth_) {
    5665       maximumDepth_ *= 2;
    5666       CbcNodeInfo ** temp = new CbcNodeInfo * [maximumDepth_];
    5667       for (i=0;i<nNode;i++)
    5668         temp[i] = walkback_[i];
    5669       delete [] walkback_;
    5670       walkback_ = temp;
    5671     }
    5672   }
    5673 /*
    5674   Create an empty basis with sufficient capacity for the constraint system
    5675   we'll construct: original system plus cuts. Make sure we have capacity to
    5676   record those cuts in addedCuts_.
    5677 
    5678   The method of adjusting the basis at a FullNodeInfo object (the root, for
    5679   example) is to use a copy constructor to duplicate the basis held in the
    5680   nodeInfo, then resize it and return the new basis object. Guaranteed,
    5681   lastws will point to a different basis when it returns. We pass in a basis
    5682   because we need the parameter to return the allocated basis, and it's an
    5683   easy way to pass in the size. But we take a hit for memory allocation.
    5684 */
    5685   currentNumberCuts_=currentNumberCuts;
    5686   if (currentNumberCuts > maximumNumberCuts_) {
    5687     maximumNumberCuts_ = currentNumberCuts;
    5688     delete [] addedCuts_;
    5689     addedCuts_ = new CbcCountRowCut * [maximumNumberCuts_];
    5690   }
    5691   lastws->setSize(numberColumns,numberRowsAtContinuous_+currentNumberCuts);
    5692 /*
    5693   This last bit of code traverses the path collected in walkback_ from the
    5694   root back to node. At the end of the loop,
    5695    * lastws will be an appropriate basis for node;
    5696    * variable bounds in the constraint system will be set to be correct for
    5697      node; and
    5698    * addedCuts_ will be set to a list of cuts that need to be added to the
    5699      constraint system at node.
    5700   applyToModel does all the heavy lifting.
    5701 */
    5702   currentNumberCuts=0;
    5703   //#define CBC_PRINT2
    5704 #ifdef CBC_PRINT2
    5705   printf("Starting bounds at node %d\n",numberNodes_);
    5706 #endif
    5707   currentDepth_=nNode;
    5708   while (nNode) {
    5709     --nNode;
    5710     walkback_[nNode]->applyToModel(this,lastws,addedCuts_,currentNumberCuts);
    5711   }
    5712   if (!lastws->fullBasis()) {
    5713 #ifdef COIN_DEVELOP
    5714     printf("******* bad basis\n");
    5715 #endif
    5716     int numberRows = lastws->getNumArtificial();
    5717     int i;
    5718     for (i=0;i<numberRows;i++)
    5719       lastws->setArtifStatus(i,CoinWarmStartBasis::basic);
    5720     int numberColumns = lastws->getNumStructural();
    5721     for (i=0;i<numberColumns;i++) {
    5722       if (lastws->getStructStatus(i)==CoinWarmStartBasis::basic)
    5723         lastws->setStructStatus(i,CoinWarmStartBasis::atLowerBound);
    5724     }
    5725 #if 0
    5726   } else {
    5727     // OPTION - take off slack cuts
    5728     // First see if any cuts are slack
    5729     int numberAdded = currentNumberCuts;
    5730     if (saveNode<2&&false) {
    5731       printf("nNode %d cuts %d\n",saveNode,currentNumberCuts);
    5732       for (int i=0;i<currentNumberCuts;i++)
    5733         addedCuts_[i]->print();
    5734     }
    5735     if (numberAdded&&saveNode<5&&!parentModel_) {
    5736 #if 0
    5737       currentNumberCuts=0;
    5738       for (int j=numberRowsAtContinuous_;
    5739            j<numberAdded+numberRowsAtContinuous_;j++) {
    5740         CoinWarmStartBasis::Status status = lastws->getArtifStatus(j);
    5741         if (status!=CoinWarmStartBasis::basic) {
    5742           lastws->setArtifStatus(currentNumberCuts+numberRowsAtContinuous_,
    5743                                  status);
    5744           addedCuts_[currentNumberCuts++]=addedCuts_[j-numberRowsAtContinuous_];
    5745         }
    5746       }
    5747       if (currentNumberCuts<numberAdded) {
    5748         printf("deleting %d rows\n",numberAdded-currentNumberCuts);
    5749         lastws->resize(currentNumberCuts+numberRowsAtContinuous_,
    5750                        lastws->getNumStructural());
    5751         currentNumberCuts_=currentNumberCuts;
    5752       }
    5753 #else
    5754       int nDelete=0;
    5755       for (int j=numberRowsAtContinuous_;
    5756            j<numberAdded+numberRowsAtContinuous_;j++) {
    5757         CoinWarmStartBasis::Status status = lastws->getArtifStatus(j);
    5758         if (status==CoinWarmStartBasis::basic)
    5759           nDelete++;
    5760       }
    5761       if (nDelete)
    5762         printf("depth %d can delete %d\n",saveNode-1,nDelete);
    5763 #endif
    5764     }
    5765 #endif
    5766   }
    5767   if (0) {
    5768     int numberDebugValues=18;
    5769     double * debugValues = new double[numberDebugValues];
    5770     CoinZeroN(debugValues,numberDebugValues);
    5771     debugValues[1]=6.0;
    5772     debugValues[3]=60.0;
    5773     debugValues[4]=6.0;
    5774     debugValues[6]=60.0;
    5775     debugValues[7]=16.0;
    5776     debugValues[9]=70.0;
    5777     debugValues[10]=7.0;
    5778     debugValues[12]=70.0;
    5779     debugValues[13]=12.0;
    5780     debugValues[15]=75.0;
    5781     int nBad=0;
    5782     for (int j=0;j<numberColumns;j++) {
    5783       if (integerInfo_[j]) {
    5784         if(solver_->getColLower()[j]>debugValues[j]||
    5785            solver_->getColUpper()[j]<debugValues[j]) {
    5786           printf("** (%g) ** ",debugValues[j]);
    5787           nBad++;
    5788         }
    5789         printf("%d bounds %g %g\n",j,solver_->getColLower()[j],solver_->getColUpper()[j]);
    5790       }
    5791     }
    5792     if (nBad)
    5793       printf("%d BAD\n",nBad);
    5794     else
    5795       printf("OKAY\n");
    5796     delete [] debugValues;
    5797   }
    5798   return false;
    5799 #endif
    58005895}
    58015896
     
    63306425
    63316426{
     6427#if MODEL4
     6428  if (node&&numberTries>1) {
     6429    if (currentDepth_<5)
     6430      numberTries *= 4; // boost
     6431    else if (currentDepth_<10)
     6432      numberTries *= 2; // boost
     6433  }
     6434#endif
    63326435# ifdef COIN_HAS_CLP
    63336436  OsiClpSolverInterface * clpSolver
     
    67616864          generate=false;
    67626865        if (generator_[i]->switchedOff())
    6763           generate=false;;
     6866          generate=false;
     6867#if MODEL5
     6868        if (generator_[i]->howOften()==1000000||
     6869            generator_[i]->howOften()==-100||
     6870            generator_[i]->howOften()==0)
     6871          generate=false;
     6872#endif
    67646873        if (!doCutsNow(1)&&!fullScan) {
    67656874          //if (node)
     
    67676876          //if (node&&node->depth()>10&&(node->depth()&1)==whenCuts&&!fullScan) {
    67686877          // switch off if default
     6878#if MODEL6
     6879          if (generator_[i]->whatDepth()<0)
     6880            generate=false;
     6881#else
    67696882          if (generator_[i]->howOften()==1&&generator_[i]->whatDepth()<0)
    67706883            generate=false;
     6884#endif
    67716885        }
    67726886        if (generate) {
     
    71937307      int found = -1; // no solution found
    71947308      for (i = 0;i<numberHeuristics_;i++) {
     7309#if MODEL3
     7310        // skip if can't run here
     7311        if (!heuristic_[i]->shouldHeurRun())
     7312          continue;
     7313#endif
    71957314        // see if heuristic will do anything
    71967315        double saveValue = heuristicValue ;
     
    76107729    int found = -1; // no solution found
    76117730    for (int i = 0;i<numberHeuristics_;i++) {
     7731#if MODEL3
     7732      // skip if can't run here
     7733      if (!heuristic_[i]->shouldHeurRun())
     7734        continue;
     7735#endif
    76127736      // see if heuristic will do anything
    76137737      double saveValue = heuristicValue ;
     
    78297953        numberActiveGenerators++;
    78307954#ifdef JUST_ACTIVE
    7831       totalCuts += count[i] + 5.0*generator_[i]->numberColumnCuts() ;
     7955      double value = count[i] + 5.0*generator_[i]->numberColumnCuts() ;
    78327956#else
    7833       totalCuts += generator_[i]->numberCutsInTotal() + 5.0*generator_[i]->numberColumnCuts() ;
     7957      double value = generator_[i]->numberCutsInTotal() + 5.0*generator_[i]->numberColumnCuts() ;
     7958#endif
     7959#if MODEL7
     7960      // But cap
     7961      totalCuts += CoinMin(value,2.0*currentPassNumber_+10);
     7962#else
     7963      totalCuts += value;
    78347964#endif
    78357965    }
     
    78778007          }
    78788008          if (!thisCuts||howOften == -99) {
     8009#if MODEL8
     8010            howOften = -100 ;
     8011#else
    78798012            if (howOften == -99||howOften == -98)
    78808013              howOften = -100 ;
    78818014            else
    78828015              howOften = 1000000+SCANCUTS; // wait until next time
     8016#endif
    78838017          } else if (thisCuts<small) {
    78848018            if (howOften!=1&&!probingWasOnBut) {
     
    81028236    // delete models and solvers
    81038237    for (i=0;i<numberThreads_;i++) {
     8238      // make sure message handler will be deleted
     8239      threadModel[i]->defaultHandler_=true;
    81048240      delete threadModel[i];
    81058241    }
     
    1103111167        double heuristicValue=getCutoff();
    1103211168        for (iHeuristic=0;iHeuristic<numberHeuristics_;iHeuristic++) {
     11169#if MODEL3
     11170          // skip if can't run here
     11171          if (!heuristic_[iHeuristic]->shouldHeurRun())
     11172            continue;
     11173#endif
    1103311174          double saveValue=heuristicValue;
    1103411175          int ifSol = heuristic_[iHeuristic]->solution(heuristicValue,
     
    1190312044CbcModel::resolve(OsiSolverInterface * solver)
    1190412045{
     12046#ifdef CLIQUE_ANALYSIS
     12047  if (probingInfo_&&currentDepth_>0) {
     12048    int nFix=probingInfo_->fixColumns(*solver);
     12049    if (nFix<0)
     12050      return 0;
     12051  }
     12052#endif
    1190512053#ifdef COIN_HAS_CLP
    1190612054  OsiClpSolverInterface * clpSolver
     
    1191812066    ClpSimplex * clpSimplex = clpSolver->getModelPtr();
    1191912067    int save = clpSimplex->specialOptions();
    11920     clpSimplex->setSpecialOptions(save|0x01000000); // say is Cbc (and in branch and bound)
     12068    clpSimplex->setSpecialOptions(save|0x11000000); // say is Cbc (and in branch and bound)
    1192112069    clpSolver->resolve();
    1192212070    clpSimplex->setSpecialOptions(save);
     
    1210812256      //branchingState=0;
    1210912257    }
     12258#if MODEL10
     12259#if NEW_UPDATE_OBJECT>1
     12260    if (!oldNode) {
     12261      if (numberUpdateItems_) {
     12262        for (int i=0;i<numberUpdateItems_;i++) {
     12263          CbcObjectUpdateData * update = updateItems_+i;
     12264          CbcObject * object = dynamic_cast<CbcObject *> (update->object_);
     12265#ifndef NDEBUG
     12266          bool found=false;
     12267          for (int j=0;j<numberObjects_;j++) {
     12268            if (update->object_== object_[j]) {
     12269              found=true;
     12270              break;
     12271            }
     12272          }
     12273          assert (found);
     12274#endif
     12275          //if (object)
     12276          //assert (object==object_[update->objectNumber_]);
     12277          if (object)
     12278            object->updateInformation(*update);
     12279        }
     12280        numberUpdateItems_=0;
     12281      }
     12282    }
     12283#endif
     12284#endif
    1211012285    if (solverCharacteristics_ &&
    1211112286        solverCharacteristics_->solutionAddsCuts() && // we are in some OA based bab
     
    1260712782    currentPassNumber_ = 1; // so root heuristics will run
    1260812783    for (i = 0;i<numberHeuristics_;i++) {
     12784#if MODEL3
     12785      // skip if can't run here
     12786      if (!heuristic_[i]->shouldHeurRun())
     12787        continue;
     12788#endif
    1260912789      // see if heuristic will do anything
    1261012790      double saveValue = heuristicValue ;
     
    1312213302        //double * lowerBefore = NULL;
    1312313303        //double * upperBefore = NULL;
    13124         int fastNodeDepth1 = -fastNodeDepth_ % 1000000;
     13304        int fastNodeDepth1 = -fastNodeDepth_ % 1000000;
     13305#if MODEL11
     13306        int numberNodesBeforeFathom = 1000;
     13307#else
    1312513308        int numberNodesBeforeFathom = 500;
     13309#endif
    1312613310        if (fastNodeDepth_<-1000001) {
    1312713311          numberNodesBeforeFathom = (-fastNodeDepth_)/1000000;
     
    1365013834          int iHeur ;
    1365113835          for (iHeur = 0 ; iHeur < numberHeuristics_ ; iHeur++) {
     13836#if MODEL3
     13837            // skip if can't run here
     13838            if (!heuristic_[iHeur]->shouldHeurRun())
     13839              continue;
     13840#endif
    1365213841            double saveValue = heurValue ;
    1365313842            int ifSol = heuristic_[iHeur]->solution(heurValue,newSolution) ;
Note: See TracChangeset for help on using the changeset viewer.