Changeset 1211


Ignore:
Timestamp:
Aug 8, 2009 11:59:19 AM (10 years ago)
Author:
forrest
Message:

changes for heuristic clone

Location:
trunk/Cbc/src
Files:
13 edited

Legend:

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

    r1205 r1211  
    45294529      double * down = new double[numberIntegers];
    45304530      double * up = new double[numberIntegers];
     4531      int * priority = new int[numberIntegers];
    45314532      int * numberDown = new int[numberIntegers];
    45324533      int * numberUp = new int[numberIntegers];
    45334534      int * numberDownInfeasible = new int[numberIntegers];
    45344535      int * numberUpInfeasible = new int[numberIntegers];
    4535       model_->fillPseudoCosts(down,up,numberDown,numberUp,
     4536      model_->fillPseudoCosts(down,up,priority,numberDown,numberUp,
    45364537                      numberDownInfeasible,numberUpInfeasible);
    4537       info->fillPseudoCosts(down,up,numberDown,numberUp,
     4538      info->fillPseudoCosts(down,up,priority,numberDown,numberUp,
    45384539                            numberDownInfeasible,
    45394540                            numberUpInfeasible,numberIntegers);
  • trunk/Cbc/src/CbcCutGenerator.cpp

    r1205 r1211  
    236236    info.randomNumberGenerator=randomNumberGenerator;
    237237    info.options=(globalCutsAtRoot()) ? 8 : 0;
     238    if (ineffectualCuts())
     239      info.options |= 32;
    238240    if (globalCuts())
    239241      info.options |=16;
     
    816818          const OsiRowCut * thisCut = cs.rowCutPtr(iCut) ;
    817819          int n=thisCut->row().getNumElements();
    818           if (n&&sort[k]) {
     820          // may be best, just to save if short
     821          if (false&&n&&sort[k]) {
    819822            // add to saved cuts
    820823            savedCuts_.insert(*thisCut);
  • trunk/Cbc/src/CbcCutGenerator.hpp

    r1205 r1211  
    240240  inline void setSwitchedOff(bool yesNo)
    241241  { switches_&=~16;switches_ |= yesNo ? 16 : 0;}
     242  /// Whether last round of cuts did little
     243  inline bool ineffectualCuts() const
     244  { return (switches_&512)!=0;}
     245  /// Set whether last round of cuts did little
     246  inline void setIneffectualCuts(bool yesNo)
     247  { switches_&=~512;switches_ |= yesNo ? 512 : 0;}
    242248  /// Number of cuts generated at root
    243249  inline int numberCutsAtRoot() const
  • trunk/Cbc/src/CbcHeuristic.cpp

    r1205 r1211  
    479479{
    480480  model_ = model;
     481}
     482/* Clone but ..
     483   type 0 clone solver, 1 clone continuous solver
     484   Add 2 to say without integer variables which are at low priority
     485   Add 4 to say quite likely infeasible so give up easily.*/
     486OsiSolverInterface *
     487CbcHeuristic::cloneBut(int type)
     488{
     489  OsiSolverInterface * solver;
     490  if ((type&1)==0||!model_->continuousSolver())
     491    solver = model_->solver()->clone();
     492  else
     493    solver = model_->continuousSolver()->clone();
     494#ifdef COIN_HAS_CLP
     495  OsiClpSolverInterface * clpSolver
     496    = dynamic_cast<OsiClpSolverInterface *> (solver);
     497#endif
     498  if ((type&2)!=0) {
     499    int n=model_->numberObjects();
     500    int priority = model_->continuousPriority();
     501    if (priority<COIN_INT_MAX) {
     502      for (int i=0;i<n;i++) {
     503        const OsiObject * obj = model_->object(i);
     504        const CbcSimpleInteger * thisOne =
     505          dynamic_cast <const CbcSimpleInteger *> (obj);
     506        if (thisOne) {
     507          int iColumn=thisOne->columnNumber();
     508          if (thisOne->priority()>=priority)
     509            solver->setContinuous(iColumn);
     510        }
     511      }
     512    }
     513#ifdef COIN_HAS_CLP
     514    if (clpSolver) {
     515      for (int i=0;i<n;i++) {
     516        const OsiObject * obj = model_->object(i);
     517        const CbcSimpleInteger * thisOne =
     518          dynamic_cast <const CbcSimpleInteger *> (obj);
     519        if (thisOne) {
     520          int iColumn=thisOne->columnNumber();
     521          if (clpSolver->isOptionalInteger(iColumn))
     522            clpSolver->setContinuous(iColumn);
     523        }
     524      }
     525    }
     526#endif
     527  }
     528#ifdef COIN_HAS_CLP
     529  if ((type&4)!=0&&clpSolver) {
     530    int options = clpSolver->getModelPtr()->moreSpecialOptions();
     531    clpSolver->getModelPtr()->setMoreSpecialOptions(options|64);
     532  }
     533#endif
     534  return solver;
    481535}
    482536// Whether to exit at once on gap
  • trunk/Cbc/src/CbcHeuristic.hpp

    r1205 r1211  
    233233  inline int numCouldRun() const
    234234  { return numCouldRun_;}
     235  /** Clone but ..
     236      type 0 clone solver, 1 clone continuous solver
     237      Add 2 to say without integer variables which are at low priority
     238      Add 4 to say quite likely infeasible so give up easily.*/
     239  OsiSolverInterface * cloneBut(int type);
    235240
    236241protected:
  • trunk/Cbc/src/CbcHeuristicDive.cpp

    r1205 r1211  
    217217    : maxSimplexIterationsAtRoot_;
    218218
    219   OsiSolverInterface * solver = model_->solver()->clone();
     219  OsiSolverInterface * solver = cloneBut(6); // was model_->solver()->clone();
    220220  const double * lower = solver->getColLower();
    221221  const double * upper = solver->getColUpper();
  • trunk/Cbc/src/CbcHeuristicFPump.cpp

    r1200 r1211  
    360360  int dualPass = 0;
    361361  int secondPassOpt=0;
    362   if (feasibilityPumpOptions_>0) {
     362#define RAND_RAND
     363#ifdef RAND_RAND
     364  int offRandom=0;
     365#endif
     366  int maximumAllowed=-1;
     367  bool moreIterations=false;
     368  if (feasibilityPumpOptions_>0) {
     369    if (feasibilityPumpOptions_>=1000)
     370      maximumAllowed = feasibilityPumpOptions_/1000;
     371    int options2 = (feasibilityPumpOptions_%1000)/100;
     372#ifdef RAND_RAND
     373    offRandom=options2&1;
     374#endif
     375    moreIterations = (options2&2)!=0;
    363376    secondPassOpt = (feasibilityPumpOptions_/10)%10;
    364377    /* 1 to 7 - re-use solution
     
    385398  }
    386399#endif
    387 #define RAND_RAND
    388400#ifdef RAND_RAND
    389401  double * randomFactor = new double [numberColumns];
     
    407419  //printf("exact multiple %g\n",exactMultiple);
    408420  // Clone solver for rounding
    409   OsiSolverInterface * clonedSolver = model_->solver()->clone();
     421  OsiSolverInterface * clonedSolver = cloneBut(2); // wasmodel_->solver()->clone();
    410422  while (!exitAll) {
    411423    // Cutoff rhs
     
    418430    numberTries++;
    419431    // Clone solver - otherwise annoys root node computations
    420     solver = model_->solver()->clone();
     432    solver = cloneBut(2); // was model_->solver()->clone();
    421433#ifdef COIN_HAS_CLP
    422434    {
     
    559571    if (scaleFactor)
    560572      scaleFactor = (initialWeight_*sqrt(static_cast<double> (numberIntegers)))/sqrt(scaleFactor);
     573#ifdef CLP_INVESTIGATE
    561574#ifdef COIN_DEVELOP
     575    if (scaleFactor||nArtificial)
     576      printf("Using %g fraction of original objective (decay %g) - largest %g - %d artificials\n",scaleFactor,weightFactor_,
     577             largestCost,nArtificial);
     578#else
    562579    if (scaleFactor)
    563       printf("Using %g fraction of original objective - largest %g - %d artificials\n",scaleFactor,
    564              largestCost,nArtificial);
     580      printf("Using %g fraction of original objective (decay %g)\n",
     581             scaleFactor,weightFactor_);
     582#endif
    565583#endif
    566584    // This is an array of sums of infeasibilities so can see if "bobbling"
     
    591609      if (numberIterationsPass1>=0) {
    592610        int n = totalNumberIterations - numberIterationsLastPass;
     611        double perPass = totalNumberIterations/(totalNumberPasses+numberPasses);
     612        perPass /= (solver->getNumRows()+numberColumns);
     613        double test = moreIterations ? 0.3 : 0.0;
    593614        if (n>CoinMax(20000,3*numberIterationsPass1)
    594             &&(switches_&2)==0&&maximumPasses<200) {
     615            &&(switches_&2)==0&&maximumPasses<200&&perPass>test) {
    595616          exitAll=true;
    596617        }
     
    881902          }
    882903#ifdef RAND_RAND
    883           newValue *= randomFactor[iColumn];
     904          if (!offRandom)
     905            newValue *= randomFactor[iColumn];
    884906#endif
    885907          if (newValue!=oldObjective[iColumn]) {
     
    15031525    // see if rounding worked!
    15041526    if (roundingObjective<solutionValue) {
    1505       sprintf(pumpPrint,"Rounding solution of %g is better than previous of %g !\n",
    1506               roundingObjective,solutionValue);
    1507       model_->messageHandler()->message(CBC_FPUMP1,model_->messages())
    1508         << pumpPrint
    1509         <<CoinMessageEol;
     1527      if (roundingObjective<solutionValue-1.0e-6*fabs(roundingObjective)) {
     1528        sprintf(pumpPrint,"Rounding solution of %g is better than previous of %g\n",
     1529                roundingObjective,solutionValue);
     1530        model_->messageHandler()->message(CBC_FPUMP1,model_->messages())
     1531          << pumpPrint
     1532          <<CoinMessageEol;
     1533      }
    15101534      solutionValue=roundingObjective;
    15111535      newSolutionValue = solutionValue;
     
    15291553    delete [] saveObjective;
    15301554    if (usedColumn&&!exitAll) {
    1531       OsiSolverInterface * newSolver = model_->continuousSolver()->clone();
     1555      OsiSolverInterface * newSolver = cloneBut(3); // was model_->continuousSolver()->clone();
    15321556      const double * colLower = newSolver->getColLower();
    15331557      const double * colUpper = newSolver->getColUpper();
    15341558      bool stopBAB=false;
    15351559      int allowedPass=-1;
     1560      if (maximumAllowed>0)
     1561        allowedPass=CoinMax(numberPasses-maximumAllowed,-1);
    15361562      while (!stopBAB) {
    15371563        stopBAB=true;
     
    16541680        if (returnCode&&true) {
    16551681          delete newSolver;
    1656           newSolver = model_->continuousSolver()->clone();
     1682          newSolver = cloneBut(3); // was model_->continuousSolver()->clone();
    16571683          newSolutionValue = -saveOffset;
    16581684          double newSumInfeas=0.0;
     
    18411867  if (!finalReturnCode&&closestSolution&&closestObjectiveValue <= 10.0&&usedColumn) {
    18421868    // try a bit of branch and bound
    1843     OsiSolverInterface * newSolver = model_->continuousSolver()->clone();
     1869    OsiSolverInterface * newSolver = cloneBut(1); // was model_->continuousSolver()->clone();
    18441870    const double * colLower = newSolver->getColLower();
    18451871    const double * colUpper = newSolver->getColUpper();
  • trunk/Cbc/src/CbcHeuristicLocal.cpp

    r1200 r1211  
    711711  }
    712712  // First just fix all integers as close to zero as possible
    713   OsiSolverInterface * newSolver = solver->clone();
     713  OsiSolverInterface * newSolver = cloneBut(7); // wassolver->clone();
    714714  for (i=0;i<numberIntegers;i++) {
    715715    int iColumn=integerVariable[i];
  • trunk/Cbc/src/CbcHeuristicRINS.cpp

    r1205 r1211  
    194194 
    195195    const double * currentSolution = solver->getColSolution();
    196     OsiSolverInterface * newSolver = model_->continuousSolver()->clone();
     196    OsiSolverInterface * newSolver = cloneBut(3); // was model_->continuousSolver()->clone();
    197197    //const double * colLower = newSolver->getColLower();
    198198    //const double * colUpper = newSolver->getColUpper();
     
    328328 
    329329  const double * currentSolution = solver->getColSolution();
    330   OsiSolverInterface * newSolver = model_->continuousSolver()->clone();
     330  OsiSolverInterface * newSolver = cloneBut(3); // was model_->continuousSolver()->clone();
    331331  const double * colLower = newSolver->getColLower();
    332332  const double * colUpper = newSolver->getColUpper();
     
    580580    while(status) {
    581581      status=0;
    582       OsiSolverInterface * newSolver = model_->continuousSolver()->clone();
     582      OsiSolverInterface * newSolver = cloneBut(3); // was model_->continuousSolver()->clone();
    583583      const double * colLower = solver->getColLower();
    584584      const double * colUpper = solver->getColUpper();
  • trunk/Cbc/src/CbcMessage.cpp

    r1200 r1211  
    6363  {CBC_OTHER_STATS2,41,1,"Maximum depth %d, %g variables fixed on reduced cost (%d nodes in complete fathoming taking %d iterations)"},
    6464  {CBC_RELAXED1,42,1,"Possible objective of %.18g but variable %d is %g from integer value, integer tolerance %g"},
    65   {CBC_RELAXED2,43,1,"Possible objective of %.18g but variables are up to %g away from bound (within tolerance of %g) - might be able to fudge solution - but do you want to?"},
     65  {CBC_RELAXED2,43,2,"Possible objective of %.18g but had to fudge solution with tolerance of %g - check scaling of problem?"},
    6666  {CBC_RESTART,44,1,"Reduced cost fixing - %d rows, %d columns - restarting search"},
    6767  {CBC_GENERAL,45,1,"%s"},
  • trunk/Cbc/src/CbcModel.cpp

    r1205 r1211  
    411411  double continuousMultiplier = 1.0;
    412412  double * coeffMultiplier=NULL;
     413  double largestObj=0.0;
     414  double smallestObj = COIN_DBL_MAX;
    413415  {
    414416    const double *rowLower = getRowLower() ;
     
    449451            numberContinuousObj++;
    450452          } else {
     453            largestObj = CoinMax(largestObj,fabs(objValue));
     454            smallestObj = CoinMin(smallestObj,fabs(objValue));
    451455            numberIntegerObj++;
    452456            if (cost==COIN_DBL_MAX)
     
    572576      }
    573577#endif
     578    } else if (largestObj<smallestObj*5.0&&!parentModel_&&
     579               numberIntegerObj*1.2<numberColumns) {
     580      // up priorities on costed
     581      int iPriority=-1;
     582      for (int i=0;i<numberObjects_;i++) {
     583        int k = object_[i]->priority();
     584        if (iPriority==-1)
     585          iPriority=k;
     586        else if (iPriority!=k)
     587          iPriority=-2;
     588      }
     589      if (iPriority>=100) {
     590#ifdef CLP_INVESTIGATE
     591        printf("Setting variables with obj to high priority\n");
     592#endif
     593        for (int i=0;i<numberObjects_;i++) {
     594          CbcSimpleInteger * obj =
     595            dynamic_cast <CbcSimpleInteger *>(object_[i]) ;
     596          if (obj) {
     597            int iColumn = obj->columnNumber();
     598            if (objective[iColumn])
     599              object_[i]->setPriority(iPriority-1);
     600          }
     601        }
     602      }
    574603    }
    575604    int iRow;
     
    11071136  int numberOriginalObjects=numberObjects_;
    11081137  OsiObject ** originalObject = NULL;
     1138  // Save whether there were any objects
     1139  bool noObjects = (numberObjects_==0);
    11091140  // Set up strategies
    11101141  if (strategy_) {
     
    17591790    memset(statistics_,0,maximumStatistics_*sizeof(CbcStatistics *));
    17601791  }
    1761 
     1792  // See if we can add integers
     1793  if (noObjects&&numberIntegers_<solver_->getNumCols()&&(specialOptions_&65536)!=0&&!parentModel_) {
     1794    int numberColumns = continuousSolver_->getNumCols();
     1795    int numberRows = continuousSolver_->getNumRows();
     1796    int * del = new int [CoinMax(numberColumns,numberRows)];
     1797    int * original = new int [numberColumns];
     1798    char * possibleRow = new char [numberRows];
     1799    {
     1800      const CoinPackedMatrix * rowCopy = continuousSolver_->getMatrixByRow();
     1801      const int * column = rowCopy->getIndices();
     1802      const int * rowLength = rowCopy->getVectorLengths();
     1803      const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
     1804      const double * rowLower = continuousSolver_->getRowLower();
     1805      const double * rowUpper = continuousSolver_->getRowUpper();
     1806      const double * element = rowCopy->getElements();
     1807      for (int i=0;i<numberRows;i++) {
     1808        int nLeft=0;
     1809        bool possible=false;
     1810        if (rowLower[i]<-1.0e20) {
     1811          double value = rowUpper[i];
     1812          if (fabs(value-floor(value+0.5))<1.0e-8)
     1813            possible=true;
     1814        } else if (rowUpper[i]>1.0e20) {
     1815          double value = rowLower[i];
     1816          if (fabs(value-floor(value+0.5))<1.0e-8)
     1817            possible=true;
     1818        } else {
     1819          double value = rowUpper[i];
     1820          if (rowLower[i]==rowUpper[i]&&
     1821              fabs(value-floor(value+0.5))<1.0e-8)
     1822            possible=true;
     1823        }
     1824        for (CoinBigIndex j=rowStart[i];
     1825             j<rowStart[i]+rowLength[i];j++) {
     1826          int iColumn = column[j];
     1827          if (continuousSolver_->isInteger(iColumn)) {
     1828            if (fabs(element[j])!=1.0)
     1829                possible=false;
     1830          } else {
     1831            nLeft++;
     1832          }
     1833        }
     1834        if (possible||!nLeft)
     1835          possibleRow[i]=1;
     1836        else
     1837          possibleRow[i]=0;
     1838      }
     1839    }
     1840    int nDel=0;
     1841    for (int i=0;i<numberColumns;i++) {
     1842      original[i]=i;
     1843      if (continuousSolver_->isInteger(i))
     1844        del[nDel++]=i;
     1845    }
     1846    int nExtra=0;
     1847    OsiSolverInterface * copy1 = continuousSolver_->clone();
     1848    int nPass=0;
     1849    while (nDel&&nPass<10) {
     1850      nPass++;
     1851      OsiSolverInterface * copy2 = copy1->clone();
     1852      int nLeft=0;
     1853      for (int i=0;i<nDel;i++)
     1854        original[del[i]]=-1;
     1855      for (int i=0;i<numberColumns;i++) {
     1856        int kOrig=original[i];
     1857        if (kOrig>=0)
     1858          original[nLeft++]=kOrig;
     1859      }
     1860      assert (nLeft==numberColumns-nDel);
     1861      copy2->deleteCols(nDel,del);
     1862      numberColumns = copy2->getNumCols();
     1863      const CoinPackedMatrix * rowCopy = copy2->getMatrixByRow();
     1864      numberRows = rowCopy->getNumRows();
     1865      const int * column = rowCopy->getIndices();
     1866      const int * rowLength = rowCopy->getVectorLengths();
     1867      const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
     1868      const double * rowLower = copy2->getRowLower();
     1869      const double * rowUpper = copy2->getRowUpper();
     1870      const double * element = rowCopy->getElements();
     1871      const CoinPackedMatrix * columnCopy = copy2->getMatrixByCol();
     1872      const int * columnLength = columnCopy->getVectorLengths();
     1873      nDel=0;
     1874      // Could do gcd stuff on ones with costs
     1875      for (int i=0;i<numberRows;i++) {
     1876        if (!rowLength[i]) {
     1877          del[nDel++]=i;
     1878          possibleRow[i]=1;
     1879        } else if (possibleRow[i]) {
     1880          if (rowLength[i]==1) {
     1881            int k=rowStart[i];
     1882            int iColumn = column[k];
     1883            if (!copy2->isInteger(iColumn)) {
     1884              double mult =1.0/fabs(element[k]);
     1885              if (rowLower[i]<-1.0e20) {
     1886                double value = rowUpper[i]*mult;
     1887                if (fabs(value-floor(value+0.5))<1.0e-8) {
     1888                  del[nDel++]=i;
     1889                  if (columnLength[iColumn]==1) {
     1890                    copy2->setInteger(iColumn);
     1891                    int kOrig=original[iColumn];
     1892                    setOptionalInteger(kOrig);
     1893                  }
     1894                }
     1895              } else if (rowUpper[i]>1.0e20) {
     1896                double value = rowLower[i]*mult;
     1897                if (fabs(value-floor(value+0.5))<1.0e-8) {
     1898                  del[nDel++]=i;
     1899                  if (columnLength[iColumn]==1) {
     1900                    copy2->setInteger(iColumn);
     1901                    int kOrig=original[iColumn];
     1902                    setOptionalInteger(kOrig);
     1903                  }
     1904                }
     1905              } else {
     1906                double value = rowUpper[i]*mult;
     1907                if (rowLower[i]==rowUpper[i]&&
     1908                    fabs(value-floor(value+0.5))<1.0e-8) {
     1909                  del[nDel++]=i;
     1910                  copy2->setInteger(iColumn);
     1911                  int kOrig=original[iColumn];
     1912                  setOptionalInteger(kOrig);
     1913                }
     1914              }
     1915            }
     1916          } else {
     1917            // only if all singletons
     1918            bool possible=false;
     1919            if (rowLower[i]<-1.0e20) {
     1920              double value = rowUpper[i];
     1921              if (fabs(value-floor(value+0.5))<1.0e-8)
     1922                possible=true;
     1923            } else if (rowUpper[i]>1.0e20) {
     1924              double value = rowLower[i];
     1925              if (fabs(value-floor(value+0.5))<1.0e-8)
     1926                possible=true;
     1927            } else {
     1928              double value = rowUpper[i];
     1929              if (rowLower[i]==rowUpper[i]&&
     1930                  fabs(value-floor(value+0.5))<1.0e-8)
     1931                possible=true;
     1932            }
     1933            if (possible) {
     1934              for (CoinBigIndex j=rowStart[i];
     1935                   j<rowStart[i]+rowLength[i];j++) {
     1936                int iColumn = column[j];
     1937                if (columnLength[iColumn]!=1||fabs(element[j])!=1.0) {
     1938                  possible=false;
     1939                  break;
     1940                }
     1941              }
     1942              if (possible) {
     1943                for (CoinBigIndex j=rowStart[i];
     1944                     j<rowStart[i]+rowLength[i];j++) {
     1945                  int iColumn = column[j];
     1946                  if (!copy2->isInteger(iColumn)) {
     1947                    copy2->setInteger(iColumn);
     1948                    int kOrig=original[iColumn];
     1949                    setOptionalInteger(kOrig);
     1950                  }
     1951                }
     1952                del[nDel++]=i;
     1953              }
     1954            }
     1955          }
     1956        }
     1957      }
     1958      if (nDel) {
     1959        copy2->deleteRows(nDel,del);
     1960      }
     1961      if (nDel!=numberRows) {
     1962        nDel=0;
     1963        for (int i=0;i<numberColumns;i++) {
     1964          if (copy2->isInteger(i)) {
     1965            del[nDel++]=i;
     1966            nExtra++;
     1967          }
     1968        }
     1969      }
     1970      delete copy1;
     1971      copy1=copy2->clone();
     1972      delete copy2;
     1973    }
     1974    // See if what's left is a network
     1975    bool couldBeNetwork=false;
     1976    if (copy1->getNumRows()&&copy1->getNumCols()) {
     1977#ifdef COIN_HAS_CLP
     1978      OsiClpSolverInterface * clpSolver
     1979        = dynamic_cast<OsiClpSolverInterface *> (copy1);
     1980      if (clpSolver) {
     1981        numberRows = clpSolver->getNumRows();
     1982        char * rotate = new char[numberRows];
     1983        int n = clpSolver->getModelPtr()->findNetwork(rotate,1.0);
     1984#ifdef CLP_INVESTIGATE
     1985        printf("INTA network %d rows out of %d\n",n,numberRows);
     1986#endif
     1987        if (CoinAbs(n)==numberRows) {
     1988          couldBeNetwork=true;
     1989          for (int i=0;i<numberRows;i++) {
     1990            if (!possibleRow[i]) {
     1991              couldBeNetwork=false;
     1992#ifdef CLP_INVESTIGATE
     1993              printf("but row %d is bad\n",i);
     1994#endif
     1995              break;
     1996            }
     1997          }
     1998        }
     1999      } else
     2000#endif
     2001        {
     2002          numberColumns = copy1->getNumCols();
     2003          numberRows = copy1->getNumRows();
     2004          const double * rowLower = copy1->getRowLower();
     2005          const double * rowUpper = copy1->getRowUpper();
     2006          couldBeNetwork=true;
     2007          for (int i=0;i<numberRows;i++) {
     2008            if (rowLower[i]>-1.0e20&&fabs(rowLower[i]-floor(rowLower[i]+0.5))>1.0e-12) {
     2009              couldBeNetwork=false;
     2010              break;
     2011            }
     2012            if (rowUpper[i]<1.0e20&&fabs(rowUpper[i]-floor(rowUpper[i]+0.5))>1.0e-12) {
     2013              couldBeNetwork=false;
     2014              break;
     2015            }
     2016          }
     2017          if (couldBeNetwork) {
     2018            const CoinPackedMatrix  * matrixByCol = copy1->getMatrixByCol();
     2019            const double * element = matrixByCol->getElements();
     2020            //const int * row = matrixByCol->getIndices();
     2021            const CoinBigIndex * columnStart = matrixByCol->getVectorStarts();
     2022            const int * columnLength = matrixByCol->getVectorLengths();
     2023            for (int iColumn=0;iColumn<numberColumns;iColumn++) {
     2024              CoinBigIndex start = columnStart[iColumn];
     2025              CoinBigIndex end = start + columnLength[iColumn];
     2026              if (end>start+2) {
     2027                couldBeNetwork=false;
     2028                break;
     2029              }
     2030              int type=0;
     2031              for (CoinBigIndex j=start;j<end;j++) {
     2032                double value = element[j];
     2033                if (fabs(value)!=1.0) {
     2034                  couldBeNetwork=false;
     2035                  break;
     2036                } else if (value==1.0) {
     2037                  if ((type&1)==0)
     2038                    type |= 1;
     2039                  else
     2040                    type=7;
     2041                } else if (value==-1.0) {
     2042                  if ((type&2)==0)
     2043                    type |= 2;
     2044                  else
     2045                    type=7;
     2046                }
     2047              }
     2048              if (type>3) {
     2049                couldBeNetwork=false;
     2050                break;
     2051              }
     2052            }
     2053          }
     2054        }
     2055    }
     2056    if (couldBeNetwork) {
     2057      for (int i=0;i<numberColumns;i++)
     2058        setOptionalInteger(original[i]);
     2059    }
     2060    if (nExtra||couldBeNetwork) {
     2061      numberColumns = copy1->getNumCols();
     2062      numberRows = copy1->getNumRows();
     2063      if (!numberColumns||!numberRows) {
     2064        int numberColumns = solver_->getNumCols();
     2065        for (int i=0;i<numberColumns;i++)
     2066          assert(solver_->isInteger(i));
     2067      }
     2068#ifdef CLP_INVESTIGATE
     2069      if (couldBeNetwork||nExtra)
     2070        printf("INTA %d extra integers, %d left%s\n",nExtra,
     2071               numberColumns,
     2072               couldBeNetwork ? ", all network" : "");
     2073#endif
     2074      findIntegers(true,2);
     2075      convertToDynamic();
     2076    }
     2077#ifdef CLP_INVESTIGATE
     2078    if (!couldBeNetwork&&copy1->getNumCols()&&
     2079        copy1->getNumRows()) {
     2080      printf("INTA %d rows and %d columns remain\n",
     2081             copy1->getNumRows(),copy1->getNumCols());
     2082      if (copy1->getNumCols()<200) {
     2083        copy1->writeMps("moreint");
     2084        printf("INTA Written remainder to moreint.mps.gz %d rows %d cols\n",
     2085               copy1->getNumRows(),copy1->getNumCols());
     2086      }
     2087    }
     2088#endif
     2089    delete copy1;
     2090    delete [] del;
     2091    delete [] original;
     2092    delete [] possibleRow;
     2093    // double check increment
     2094    analyzeObjective();
     2095  }
    17622096  { int iObject ;
    17632097    int preferredWay ;
     
    40504384  resolveAfterTakeOffCuts_(true),
    40514385  maximumNumberIterations_(-1),
     4386  continuousPriority_(COIN_INT_MAX),
    40524387  numberUpdateItems_(0),
    40534388  maximumNumberUpdateItems_(0),
     
    42084543  resolveAfterTakeOffCuts_(true),
    42094544  maximumNumberIterations_(-1),
     4545  continuousPriority_(COIN_INT_MAX),
    42104546  numberUpdateItems_(0),
    42114547  maximumNumberUpdateItems_(0),
     
    44464782  resolveAfterTakeOffCuts_(rhs.resolveAfterTakeOffCuts_),
    44474783  maximumNumberIterations_(rhs.maximumNumberIterations_),
     4784  continuousPriority_(rhs.continuousPriority_),
    44484785  numberUpdateItems_(rhs.numberUpdateItems_),
    44494786  maximumNumberUpdateItems_(rhs.maximumNumberUpdateItems_),
     
    47785115    resolveAfterTakeOffCuts_=rhs.resolveAfterTakeOffCuts_;
    47795116    maximumNumberIterations_ = rhs.maximumNumberIterations_;
     5117    continuousPriority_ = rhs.continuousPriority_;
    47805118    numberUpdateItems_ = rhs.numberUpdateItems_;
    47815119    maximumNumberUpdateItems_ = rhs.maximumNumberUpdateItems_;
     
    51365474  resolveAfterTakeOffCuts_ = rhs.resolveAfterTakeOffCuts_;
    51375475  maximumNumberIterations_ = rhs.maximumNumberIterations_;
     5476  continuousPriority_ = rhs.continuousPriority_;
    51385477  numberThreads_ = rhs.numberThreads_;
    51395478  threadMode_ = rhs.threadMode_;
     
    62596598  double minimumDrop = minimumDrop_ ;
    62606599  bool allowZeroIterations = false;
     6600  int maximumBadPasses=0;
    62616601#if MODEL13==0
    62626602  if (numberTries<0)
     
    64716811        }
    64726812        if (generate) {
     6813#if MODEL13
     6814          if (!node&&cut_obj[CUT_HISTORY-1]!=-COIN_DBL_MAX&&
     6815              fabs(cut_obj[CUT_HISTORY-1]-cut_obj[CUT_HISTORY-2])<1.0e-7)
     6816            generator_[i]->setIneffectualCuts(true);
     6817#endif
    64736818          bool mustResolve =
    64746819            generator_[i]->generateCuts(theseCuts,fullScan,solver_,node) ;
     6820#if MODEL13
     6821          generator_[i]->setIneffectualCuts(false);
     6822#endif
    64756823          numberRowCutsAfter = theseCuts.sizeRowCuts() ;
    64766824          if (fullScan&&generator_[i]->howOften()==1000000+SCANCUTS_PROBING) {
     
    73067654#if MODEL13
    73077655        bool badObj = (allowZeroIterations) ? thisObj < cut_obj[0]+minimumDrop
    7308           : thisObj < cut_obj[CUT_HISTORY-1]+minimumDrop;;
     7656          : thisObj < cut_obj[CUT_HISTORY-1]+minimumDrop;
     7657        // Compute maximum number of bad passes
     7658        if (minimumDrop>0.0) {
     7659          int nBadPasses=0;
     7660          double test = 0.01*minimumDrop;
     7661          double goodDrop=COIN_DBL_MAX;
     7662          for (int j=CUT_HISTORY-1;j>=0;j--) {
     7663            if (thisObj-cut_obj[j]<test) {
     7664              nBadPasses++;
     7665            } else {
     7666              goodDrop=(thisObj-cut_obj[j])/static_cast<double>(nBadPasses+1);
     7667              break;
     7668            }
     7669          }
     7670          maximumBadPasses=CoinMax(maximumBadPasses,nBadPasses);
     7671          if (nBadPasses<maximumBadPasses&&
     7672              goodDrop>minimumDrop)
     7673            badObj=false; // carry on
     7674        }
    73097675        if (numberTries==1&&currentDepth_&&currentPassNumber_<10) {
    73107676          if (thisObj-lastObjective>10.0*minimumDrop) {
     
    77358101      CglProbing * probing = dynamic_cast<CglProbing*>(generator_[i]->generator());
    77368102      if (probing&&!numberNodes_) {
     8103        if (generator_[i]->numberCutsInTotal()) {
     8104          // If large number of probing - can be biased
     8105          smallProblem = (0.2* (totalCuts - generator_[i]->numberCutsInTotal()))/
     8106            static_cast<double> (numberActiveGenerators-1) ;
     8107        }
    77378108        iProbing = i;
    77388109        if (probing->rowCuts()==-3) {
     
    90459416  OsiObject ** oldObject = object_;
    90469417  int iObject;
     9418  // also see where old ones were
     9419  char * mark = new char[numberColumns];
     9420  CoinZeroN(mark,numberColumns);
     9421  int iPriority=-100000;
    90479422  for (iObject = 0;iObject<numberObjects_;iObject++) {
     9423    iPriority= CoinMax(iPriority,object_[iObject]->priority());
    90489424    CbcSimpleInteger * obj =
    90499425      dynamic_cast <CbcSimpleInteger *>(oldObject[iObject]) ;
    9050     if (obj)
     9426    if (obj) {
     9427      int iColumn = obj->columnNumber();
     9428      if (iColumn>=0&&iColumn<numberColumns)
     9429        mark[iColumn]=1;
    90519430      delete oldObject[iObject];
    9052     else
     9431    } else {
    90539432      oldObject[nObjects++]=oldObject[iObject];
     9433    }
    90549434  }
    90559435  // See if there any SOS
     
    91109490*/
    91119491  numberIntegers_=0;
     9492  if (type==2)
     9493    continuousPriority_ = iPriority+1;
    91129494  for (iColumn=0;iColumn<numberColumns;iColumn++) {
    91139495    if(isInteger(iColumn)) {
    9114       if (!type)
     9496      if (!type) {
    91159497        object_[numberIntegers_] =
    91169498          new CbcSimpleInteger(this,iColumn);
    9117       else if (type==1)
     9499      } else if (type==1) {
    91189500        object_[numberIntegers_] =
    91199501          new CbcSimpleIntegerPseudoCost(this,iColumn,0.3);
     9502      } else if (type==2) {
     9503        object_[numberIntegers_] =
     9504          new CbcSimpleInteger(this,iColumn);
     9505        if (mark[iColumn]) {
     9506          // could up priority on costs if all costs same??
     9507        } else {
     9508          object_[numberIntegers_]->setPriority(iPriority+1);
     9509        }
     9510      }
    91209511      integerVariable_[numberIntegers_++]=iColumn;
    91219512    }
    91229513  }
     9514  delete [] mark;
    91239515  // Now append other objects
    91249516  memcpy(object_+numberIntegers_,oldObject,nObjects*sizeof(OsiObject *));
     
    973910131#endif
    974010132      if ((specialOptions_&16)==0) {
    9741         const double * rowLower = solver_->getRowLower() ;
    9742         const double * rowUpper = solver_->getRowUpper() ;
    9743         int numberRows = solver_->getNumRows() ;
    9744         double *rowActivity = new double[numberRows] ;
    9745         memset(rowActivity,0,numberRows*sizeof(double)) ;
    9746         solver_->getMatrixByCol()->times(solution,rowActivity) ;
    9747         double primalTolerance ;
    9748         solver_->getDblParam(OsiPrimalTolerance,primalTolerance) ;
     10133#if 0
     10134        // check without scaling
     10135        bool saveTakeHint;
     10136        OsiHintStrength saveStrength;
     10137        solver_->getHintParam(OsiDoScale,saveTakeHint,saveStrength);
     10138        solver_->setHintParam(OsiDoScale,false,OsiHintTry);
     10139        solver_->resolve();
     10140        solver_->setHintParam(OsiDoScale,saveTakeHint,saveStrength);
     10141#endif
    974910142        double largestInfeasibility =0.0;
    9750         for (i=0 ; i < numberRows ; i++) {
    9751           largestInfeasibility = CoinMax(largestInfeasibility,
    9752                                          rowLower[i]-rowActivity[i]);
    9753           largestInfeasibility = CoinMax(largestInfeasibility,
    9754                                          rowActivity[i]-rowUpper[i]);
    9755         }
    9756         if (largestInfeasibility>100.0*primalTolerance) {
     10143        double primalTolerance ;
     10144        solver_->getDblParam(OsiPrimalTolerance,primalTolerance) ;
     10145        const double * rowLower = solver_->getRowLower() ;
     10146        const double * rowUpper = solver_->getRowUpper() ;
     10147        int numberRows = solver_->getNumRows() ;
     10148        double *rowActivity = new double[numberRows] ;
     10149        memset(rowActivity,0,numberRows*sizeof(double)) ;
     10150        double *rowSum = new double[numberRows] ;
     10151        memset(rowSum,0,numberRows*sizeof(double)) ;
     10152        const double * element = solver_->getMatrixByCol()->getElements();
     10153        const int * row = solver_->getMatrixByCol()->getIndices();
     10154        const CoinBigIndex * columnStart = solver_->getMatrixByCol()->getVectorStarts();
     10155        const int * columnLength = solver_->getMatrixByCol()->getVectorLengths();
     10156        for (iColumn=0;iColumn<numberColumns;iColumn++) {
     10157          double value = solution[iColumn];
     10158          if (value) {
     10159            CoinBigIndex start = columnStart[iColumn];
     10160            CoinBigIndex end = start + columnLength[iColumn];
     10161            for (CoinBigIndex j=start;j<end;j++) {
     10162              int iRow = row[j];
     10163              rowActivity[iRow] += value*element[j];
     10164              rowSum[iRow] += fabs(value*element[j]);
     10165            }
     10166          }
     10167        }
     10168        for (i=0 ; i < numberRows ; i++) {
     10169#ifdef CLP_INVESTIGATE
     10170          double inf;
     10171          inf = rowLower[i]-rowActivity[i];
     10172          if (inf>primalTolerance)
     10173            printf("Row %d inf %g sum %g %g <= %g <= %g\n",
     10174                   i,inf,rowSum[i],rowLower[i],rowActivity[i],rowUpper[i]);
     10175          inf = rowActivity[i]-rowUpper[i];
     10176          if (inf>primalTolerance)
     10177            printf("Row %d inf %g sum %g %g <= %g <= %g\n",
     10178                   i,inf,rowSum[i],rowLower[i],rowActivity[i],rowUpper[i]);
     10179#endif
     10180          largestInfeasibility = CoinMax(largestInfeasibility,
     10181                                         rowLower[i]-rowActivity[i]);
     10182          largestInfeasibility = CoinMax(largestInfeasibility,
     10183                                         rowActivity[i]-rowUpper[i]);
     10184        }
     10185        delete [] rowActivity ;
     10186        delete [] rowSum;
     10187#ifdef CLP_INVESTIGATE
     10188        if (largestInfeasibility>10.0*primalTolerance)
     10189          printf("largest infeasibility is %g\n",largestInfeasibility);
     10190#endif
     10191        if (largestInfeasibility>200.0*primalTolerance) {
    975710192          handler_->message(CBC_NOTFEAS3, messages_)
    975810193            << largestInfeasibility << CoinMessageEol ;
    975910194          objectiveValue=1.0e50 ;
    976010195        }
    9761         delete [] rowActivity ;
    976210196      }
    976310197    } else {
     
    1002710461                 largestInfeasibility,iInfeas,tolerance);
    1002810462#endif
    10029         if (largestAway>integerTolerance)
     10463        if (largestAway>integerTolerance) {
    1003010464          handler_->message(CBC_RELAXED1, messages_)
    1003110465            << objectiveValue2
     
    1003410468            << integerTolerance
    1003510469            << CoinMessageEol ;
    10036         else
     10470        } else {
    1003710471          handler_->message(CBC_RELAXED2, messages_)
    1003810472            << objectiveValue2
    10039             << largestAway
    1004010473            << integerTolerance
    1004110474            << CoinMessageEol ;
     10475          // take
     10476          CoinCopyN(solution2,numberColumns,solution);
     10477          objectiveValue=objectiveValue2;
     10478        }
    1004210479      }
    1004310480      delete [] solution2;
     
    1229612733            double * down = new double[numberIntegers_];
    1229712734            double * up = new double[numberIntegers_];
     12735            int * priority = new int[numberIntegers_];
    1229812736            int * numberDown = new int[numberIntegers_];
    1229912737            int * numberUp = new int[numberIntegers_];
    1230012738            int * numberDownInfeasible = new int[numberIntegers_];
    1230112739            int * numberUpInfeasible = new int[numberIntegers_];
    12302             fillPseudoCosts(down,up,numberDown,numberUp,
     12740            fillPseudoCosts(down,up,priority,numberDown,numberUp,
    1230312741                            numberDownInfeasible,numberUpInfeasible);
    12304             info->fillPseudoCosts(down,up,numberDown,numberUp,
     12742            info->fillPseudoCosts(down,up,priority,numberDown,numberUp,
    1230512743                                  numberDownInfeasible,
    1230612744                                  numberUpInfeasible,numberIntegers_);
     
    1359414032          if (thisModel->tree()->empty()) {
    1359514033            returnCode=1+1;
    13596 #ifdef CLP_INVESTIGATE
     14034#ifdef CLP_INVESTIGATE_2
    1359714035            printf("%x tree empty - time %18.6f\n",thisModel,CoinGetTimeOfDay()-1.2348e9);
    1359814036#endif
     
    1361114049            // out of loop
    1361214050            //printf("out of loop\n");
    13613 #ifdef CLP_INVESTIGATE
     14051#ifdef CLP_INVESTIGATE2
    1361414052            printf("%x tree %d nodes left, done %d and %d its - time %18.6f\n",thisModel,
    1361514053                   thisModel->tree()->size(),nodesNow-nodesThisTime,
     
    1387314311void
    1387414312CbcModel::fillPseudoCosts(double * downCosts, double * upCosts,
     14313                          int * priority,
    1387514314                          int * numberDown, int * numberUp,
    1387614315                          int * numberDownInfeasible,
     
    1387914318  CoinFillN(downCosts,numberIntegers_,1.0);
    1388014319  CoinFillN(upCosts,numberIntegers_,1.0);
     14320  if (priority) {
     14321    CoinFillN(priority,numberIntegers_,1000000);
     14322  }
    1388114323  if (numberDown) {
    1388214324    CoinFillN(numberDown,numberIntegers_,1);
     
    1390214344    iColumn = back[iColumn];
    1390314345    assert (iColumn>=0);
     14346    if (priority)
     14347      priority[iColumn]=obj->priority();
    1390414348    downCosts[iColumn]=obj->downDynamicPseudoCost();
    1390514349    upCosts[iColumn]=obj->upDynamicPseudoCost();
     
    1446914913  synchronizeModel();
    1447014914}
     14915void
     14916CbcModel::setOptionalInteger(int index)
     14917{
     14918#ifdef COIN_HAS_CLP
     14919  OsiClpSolverInterface * clpSolver
     14920    = dynamic_cast<OsiClpSolverInterface *> (solver_);
     14921  if (clpSolver)
     14922    clpSolver->setOptionalInteger(index);
     14923  else
     14924#endif
     14925    solver_->setInteger(index);
     14926}
    1447114927// Check original model before it gets messed up
    1447214928void
  • trunk/Cbc/src/CbcModel.hpp

    r1199 r1211  
    439439  inline OsiObject * modifiableObject(int which) const { return object_[which];}
    440440
     441  void setOptionalInteger(int index);
     442
    441443  /// Delete all object information (and just back to integers if true)
    442444  void deleteObjects(bool findIntegers=true);
     
    463465    If \p startAgain is true, a new scan is forced, overwriting any existing
    464466    integer variable information.
    465     If type > 0 then 1==PseudoCost
     467    If type > 0 then 1==PseudoCost, 2 new ones low priority
    466468  */
    467469
     
    17881790  */
    17891791  void fillPseudoCosts(double * downCosts, double * upCosts,
     1792                       int * priority=NULL,
    17901793                       int * numberDown=NULL, int * numberUp=NULL,
    17911794                       int * numberDownInfeasible=NULL,
     
    18451848  inline int fastNodeDepth() const
    18461849  { return fastNodeDepth_;}
     1850  /// Get anything with priority >= this can be treated as continuous
     1851  inline int continuousPriority() const
     1852  { return continuousPriority_;}
     1853  /// Set anything with priority >= this can be treated as continuous
     1854  inline void setContinuousPriority(int value)
     1855  { continuousPriority_=value;}
    18471856  inline void incrementExtra(int nodes, int iterations)
    18481857  { numberExtraNodes_ += nodes; numberExtraIterations_ += iterations;}
     
    22742283  /// Maximum number of iterations (designed to be used in heuristics)
    22752284  int maximumNumberIterations_;
     2285  /// Anything with priority >= this can be treated as continuous
     2286  int continuousPriority_;
    22762287  /// Number of outstanding update information items
    22772288  int numberUpdateItems_;
  • trunk/Cbc/src/CbcSolver.cpp

    r1205 r1211  
    131131#define FOREIGN_BARRIER
    132132#endif
     133static int initialPumpTune=-1;
    133134#include "CoinWarmStartBasis.hpp"
    134135
     
    490491  parameters_[whichParam(TESTOSI,numberParameters_,parameters_)].setIntValue(testOsiParameters);
    491492  parameters_[whichParam(FPUMPTUNE,numberParameters_,parameters_)].setIntValue(1003);
     493  initialPumpTune=1003;
    492494#ifdef CBC_THREAD
    493495  parameters_[whichParam(THREADS,numberParameters_,parameters_)].setIntValue(0);
     
    32293231  parameters[whichParam(TESTOSI,numberParameters,parameters)].setIntValue(testOsiParameters);
    32303232  parameters[whichParam(FPUMPTUNE,numberParameters,parameters)].setIntValue(1003);
     3233  initialPumpTune=1003;
    32313234#ifdef CBC_THREAD
    32323235  parameters[whichParam(THREADS,numberParameters,parameters)].setIntValue(0);
     
    32733276*/
    32743277#if NEW_STYLE_SOLVER==0
    3275 static int doHeuristics(CbcModel * model,int type) 
     3278static int doHeuristics(CbcModel * model,int type)
    32763279#else
    32773280int
     
    32823285  CbcOrClpParam * parameters_ = parameters;
    32833286  int numberParameters_ = numberParameters;
     3287  bool noPrinting_ = noPrinting;
    32843288#endif
     3289  char generalPrint[10000];
     3290  CoinMessages generalMessages = model->messages();
     3291  CoinMessageHandler * generalMessageHandler = model->messageHandler();
     3292  //generalMessageHandler->setPrefix(false);
    32853293  bool anyToDo=false;
    32863294  int logLevel = parameters_[whichParam(LOGLEVEL,numberParameters_,parameters_)].intValue();
     
    33113319      heuristic4.setIterationRatio(1.0);
    33123320    int pumpTune=parameters_[whichParam(FPUMPTUNE,numberParameters_,parameters_)].intValue();
     3321    int pumpTune2=parameters_[whichParam(FPUMPTUNE2,numberParameters_,parameters_)].intValue();
    33133322    if (pumpTune>0) {
     3323      bool printStuff = (pumpTune!=initialPumpTune||logLevel>1)
     3324        &&!noPrinting_;
     3325      if (printStuff) {
     3326        generalMessageHandler->message(CBC_GENERAL,generalMessages)
     3327          << "Options for feasibility pump - "
     3328          <<CoinMessageEol;
     3329      }
    33143330      /*
    33153331        >=10000000 for using obj
     
    33363352        which--;
    33373353        // weights and factors
    3338         double weight[]={0.1,0.1,0.5,0.5,1.0,1.0,5.0,5.0};
    3339         double factor[] = {0.1,0.5,0.1,0.5,0.1,0.5,0.1,0.5};
     3354        double weight[]={0.01,0.01,0.1,0.1,0.5,0.5,1.0,1.0,5.0,5.0};
     3355        double factor[] = {0.1,0.5,0.1,0.5,0.1,0.5,0.1,0.5,0.1,0.5};
    33403356        heuristic4.setInitialWeight(weight[which]);
    33413357        heuristic4.setWeightFactor(factor[which]);
     3358        if (printStuff) {
     3359          sprintf(generalPrint,"Initial weight for objective %g, decay factor %g",
     3360                  weight[which],factor[which]);
     3361          generalMessageHandler->message(CBC_GENERAL,generalMessages)
     3362            << generalPrint
     3363            <<CoinMessageEol;
     3364        }
     3365         
    33423366      }
    33433367      // fake cutoff
    3344       if (logLevel>1)
    3345         printf("Setting ");
    33463368      if (c) {
    33473369        double cutoff;
     
    33523374          cutoff=fakeCutoff;
    33533375        heuristic4.setFakeCutoff(cutoff);
    3354         if (logLevel>1)
    3355           printf("fake cutoff of %g ",cutoff);
     3376        if (printStuff) {
     3377          sprintf(generalPrint,"Fake cutoff of %g",cutoff);
     3378          generalMessageHandler->message(CBC_GENERAL,generalMessages)
     3379            << generalPrint
     3380            <<CoinMessageEol;
     3381        }
     3382      }
     3383      int offRandomEtc=0;
     3384      if (pumpTune2) {
     3385        if ((pumpTune2/100)!=0) {
     3386          offRandomEtc=100*(pumpTune2/100);
     3387          if (printStuff) {
     3388            generalMessageHandler->message(CBC_GENERAL,generalMessages)
     3389              << "Not using randomized objective"
     3390              <<CoinMessageEol;
     3391          }
     3392        }
     3393        int maxAllowed=pumpTune2%100;
     3394        if (maxAllowed) {
     3395          offRandomEtc += 1000*maxAllowed;
     3396          if (printStuff) {
     3397            sprintf(generalPrint,"Fixing if same for %d passes",
     3398                    maxAllowed);
     3399            generalMessageHandler->message(CBC_GENERAL,generalMessages)
     3400              << generalPrint
     3401              <<CoinMessageEol;
     3402          }
     3403        }
    33563404      }
    33573405      if (r) {
     
    33653413        heuristic4.setAccumulate(accumulate);
    33663414        heuristic4.setMaximumRetries(r+1);
    3367         if (logLevel>1) {
    3368           printf("increment of %g ",heuristic4.absoluteIncrement());
    3369           if (accumulate)
    3370             printf("accumulate of %d ",accumulate);
    3371           printf("%d retries ",r+2);
     3415        if (printStuff) {
     3416          if (increment) {
     3417            sprintf(generalPrint,"Increment of %g",increment);
     3418            generalMessageHandler->message(CBC_GENERAL,generalMessages)
     3419              << generalPrint
     3420              <<CoinMessageEol;
     3421          }
     3422          if (accumulate) {
     3423            sprintf(generalPrint,"Accumulate of %d",accumulate);
     3424            generalMessageHandler->message(CBC_GENERAL,generalMessages)
     3425              << generalPrint
     3426              <<CoinMessageEol;
     3427          }
     3428          sprintf(generalPrint,"%d retries",r+1);
     3429          generalMessageHandler->message(CBC_GENERAL,generalMessages)
     3430            << generalPrint
     3431            <<CoinMessageEol;
    33723432        }
    33733433      }
    3374       if (i) {
    3375         heuristic4.setFeasibilityPumpOptions(i*10);
     3434      if (i+offRandomEtc) {
     3435        heuristic4.setFeasibilityPumpOptions(i*10+offRandomEtc);
     3436        if (printStuff) {
     3437          sprintf(generalPrint,"Feasibility pump options of %d",
     3438                  i*10+offRandomEtc);
     3439          generalMessageHandler->message(CBC_GENERAL,generalMessages)
     3440            << generalPrint
     3441            <<CoinMessageEol;
     3442        }
    33763443      }
    33773444      pumpTune = pumpTune%100;
    3378       if (logLevel>1)
    3379         printf("and setting when to %d\n",pumpTune+10);
    33803445      if (pumpTune==6)
    33813446        pumpTune =13;
    33823447      heuristic4.setWhen((pumpTune%10)+10);
     3448      if (printStuff) {
     3449        sprintf(generalPrint,"Tuning (fixing) %d",pumpTune%10);
     3450        generalMessageHandler->message(CBC_GENERAL,generalMessages)
     3451          << generalPrint
     3452          <<CoinMessageEol;
     3453      }
    33833454    }
    33843455    heuristic4.setHeuristicName("feasibility pump");
     
    42564327      iParam = whichParam(FPUMPTUNE,numberParameters_,parameters_);
    42574328      parameters_[iParam].setIntValue(1005043);
     4329      initialPumpTune=1005043;
    42584330      iParam = whichParam(PROCESSTUNE,numberParameters_,parameters_);
    42594331      parameters_[iParam].setIntValue(6);
     
    44564528                    // put out description as well
    44574529                    if ((verbose&1)!=0)
    4458                       std::cout<<parameters_[iParam].shortHelp();
     4530                      std::cout<<" "<<parameters_[iParam].shortHelp();
    44594531                    std::cout<<std::endl;
    44604532                    if ((verbose&2)!=0) {
     
    46724744                  iParam = whichParam(FPUMPTUNE,numberParameters_,parameters_);
    46734745                  parameters_[iParam].setIntValue(1005043);
     4746                  initialPumpTune=1005043;
    46744747                  iParam = whichParam(PROCESSTUNE,numberParameters_,parameters_);
    46754748                  parameters_[iParam].setIntValue(6);
     
    46934766                  iParam = whichParam(FPUMPTUNE,numberParameters_,parameters_);
    46944767                  parameters_[iParam].setIntValue(1003);
     4768                  initialPumpTune=1003;
    46954769                  iParam = whichParam(PROCESSTUNE,numberParameters_,parameters_);
    46964770                  parameters_[iParam].setIntValue(-1);
     
    61576231#endif
    61586232              }
     6233              if (type==BAB) {
     6234                double limit;
     6235                clpSolver->getDblParam(OsiDualObjectiveLimit,limit);
     6236                if (clpSolver->getObjValue()*clpSolver->getObjSense()>=
     6237                    limit*clpSolver->getObjSense())
     6238                  preProcess=0;
     6239              }
    61596240              if (preProcess&&type==BAB) {
    61606241#ifndef CBC_OTHER_SOLVER
     
    62166297                    generator1.setMaxProbeRoot(saveSolver->getNumCols());
    62176298                  }
     6299                  if ((babModel_->specialOptions()&65536)!=0)
     6300                    process.setOptions(1);
    62186301                  // Add in generators
    62196302                  process.addCutGenerator(&generator1);
     
    64156498                  printf("Preprocessed model (minimization) on presolved.mps\n");
    64166499                }
     6500                {
     6501                  // look at new integers
     6502                  int numberOriginalColumns =
     6503                    process.originalModel()->getNumCols();
     6504                  const int * originalColumns = process.originalColumns();
     6505                  OsiClpSolverInterface * osiclp2 = dynamic_cast< OsiClpSolverInterface*> (solver2);
     6506                  int numberColumns = osiclp2->getNumCols();
     6507                  OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (saveSolver);
     6508                  for (int i=0;i<numberColumns;i++) {
     6509                    int iColumn = originalColumns[i];
     6510                    if (iColumn<numberOriginalColumns) {
     6511                      if (osiclp2->isInteger(i)&&!osiclp->isInteger(iColumn))
     6512                        osiclp2->setOptionalInteger(i); // say optional
     6513                    }
     6514                  }
     6515                }
    64176516                // we have to keep solver2 so pass clone
    64186517                solver2 = solver2->clone();
     
    66406739                  gomoryGen.setLimit(200);
    66416740#endif
     6741                }
     6742                int cutLength=
     6743                  parameters_[whichParam(CUTLENGTH,numberParameters_,parameters_)].intValue();
     6744                if (cutLength!=-1) {
     6745                  gomoryGen.setLimitAtRoot(cutLength);
     6746                  if (cutLength<10000000) {
     6747                    gomoryGen.setLimit(cutLength);
     6748                  } else {
     6749                    gomoryGen.setLimit(cutLength%10000000);
     6750                  }
    66426751                }
    66436752                babModel_->addCutGenerator(&gomoryGen,translate[gomoryAction],"Gomory");
Note: See TracChangeset for help on using the changeset viewer.