Changeset 1013


Ignore:
Timestamp:
Jul 18, 2008 4:46:29 PM (11 years ago)
Author:
forrest
Message:

some changes e.g. DINS added and a bit of printing

Location:
trunk/Cbc/src
Files:
11 edited

Legend:

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

    r1011 r1013  
    612612              product += value*element2[columnB[i]];
    613613            }
    614             if (product>0.0&&product*product>0.9999*norm*normB) {
     614            if (product>0.0&&product*product>0.99999*norm*normB) {
    615615              bool parallel=true;
    616616              double lbB = thisCut2->lb();
     
    660660        delete [] which;
    661661        numberRowCutsAfter = cs.sizeRowCuts() ;
    662 #ifdef CLP_INVESTIGATE
     662#if 0 //def CLP_INVESTIGATE
    663663        nEls=0;
    664664        int nCuts2= numberRowCutsAfter-numberRowCutsBefore;
  • trunk/Cbc/src/CbcHeuristic.cpp

    r961 r1013  
    256256CbcHeuristic::shouldHeurRun()
    257257{
    258 
     258  // No longer used for original purpose - so use for ever run at all JJF
     259#if 1
     260  // Don't run if hot start
     261  if (model_&&model_->hotstartSolution())
     262    return false;
     263  else
     264    return true;
     265#else
    259266#if 0
    260267  const CbcNode* currentNode = model_->currentNode();
     
    341348  ++numRuns_;
    342349  return true;
     350#endif
    343351}
    344352
     
    385393          if ((numCouldRun_%howOften_)==0&&
    386394              numberSolutionsFound_*howOften_<numCouldRun_) {
     395#ifdef COIN_DEVELOP
    387396            int old=howOften_;
     397#endif
    388398            howOften_ = CoinMin(CoinMax((int) (howOften_*1.1),howOften_+1),10000);
    389399#ifdef COIN_DEVELOP
     
    469479  model_ = model;
    470480}
    471 #ifdef COIN_DEVELOP
     481#ifdef HISTORY_STATISTICS
    472482extern bool getHistoryStatistics_;
    473483#endif
     
    479489{
    480490  // size before
    481   double before = 2*solver->getNumRows()+solver->getNumCols();
     491  double before = 4*solver->getNumRows()+solver->getNumCols();
    482492  // Use this fraction
    483493  double fractionSmall = fractionSmall_;
     
    503513    // Turn this off if you get problems
    504514    // Used to be automatically set
    505     osiclp->setSpecialOptions(osiclp->specialOptions()|(128+64));
     515    osiclp->setSpecialOptions(osiclp->specialOptions()|(128+64-128));
    506516    ClpSimplex * lpSolver = osiclp->getModelPtr();
    507517    lpSolver->setSpecialOptions(lpSolver->specialOptions()|0x01000000); // say is Cbc (and in branch and bound)
    508   }
    509 #endif
    510 #ifdef COIN_DEVELOP
     518    lpSolver->setSpecialOptions(lpSolver->specialOptions()|
     519                                16384+4096+512+128);
     520  }
     521#endif
     522#ifdef HISTORY_STATISTICS
    511523  getHistoryStatistics_=false;
    512524#endif
     
    540552      int afterCols = presolvedModel->getNumCols();
    541553      delete presolvedModel;
    542       double after = 2*afterRows+afterCols;
     554      double after = 4*afterRows+afterCols;
    543555      if (after>fractionSmall*before&&after>300&&numberNodes>=0) {
    544556        // Need code to try again to compress further using used
     
    617629  if (returnCode==-1) {
    618630    delete [] reset;
    619 #ifdef COIN_DEVELOP
     631#ifdef HISTORY_STATISTICS
    620632    getHistoryStatistics_=true;
    621633#endif
     
    693705          model.setStrategy(strategy);
    694706          model.solver()->setIntParam(OsiMaxNumIterationHotStart,10);
    695           model.setMaximumCutPassesAtRoot(CoinMin(20,model_->getMaximumCutPassesAtRoot()));
     707          model.setMaximumCutPassesAtRoot(CoinMin(20,CoinAbs(model_->getMaximumCutPassesAtRoot())));
    696708          model.setMaximumCutPasses(CoinMin(10,model_->getMaximumCutPasses()));
    697709        } else {
     
    701713          // going for full search and copy across more stuff
    702714          model.gutsOfCopy(*model_,2);
    703           for (int i=0;i<model.numberCutGenerators();i++)
     715          for (int i=0;i<model.numberCutGenerators();i++) {
    704716            model.cutGenerator(i)->setTiming(true);
     717            // Turn on if was turned on
     718            int iOften = model_->cutGenerator(i)->howOften();
     719            printf("Gen %d often %d %d\n",
     720                   i,model.cutGenerator(i)->howOften(),
     721                   iOften);
     722            if (iOften>0)
     723              model.cutGenerator(i)->setHowOften(iOften%1000000);
     724            if (model_->cutGenerator(i)->howOftenInSub()==-200)
     725              model.cutGenerator(i)->setHowOften(-100);
     726          }
    705727          model.setCutoff(cutoff);
    706728          // make sure can't do nested search! but allow heuristics
     
    840862        }
    841863        if (model.getNumCols()) {
    842           if (numberNodes>=0)
     864          if (numberNodes>=0) {
    843865            setCutAndHeuristicOptions(model);
     866            // not too many iterations
     867            model.setMaximumNumberIterations(100*(numberNodes+10));
     868            // Not fast stuff
     869            model.setFastNodeDepth(-1);
     870          }
    844871          model.branchAndBound();
     872#ifdef COIN_DEVELOP
     873          printf("sub branch %d nodes, %d iterations - max %d\n",
     874                 model.getNodeCount(),model.getIterationCount(),
     875                 100*(numberNodes+10));
     876#endif
    845877          if (numberNodes<0) {
    846878            model_->incrementIterationCount(model.getIterationCount());
     
    894926          returnCode=model.isProvenInfeasible() ? 2 : 0; // so will be infeasible
    895927        }
     928        int totalNumberIterations = model.getIterationCount()+
     929          process.numberIterationsPre()+
     930          process.numberIterationsPost();
     931        if (totalNumberIterations>100*(numberNodes+10)) {
     932          // only allow smaller problems
     933          fractionSmall = fractionSmall_;
     934          fractionSmall_ *= 0.9;
     935#ifdef CLP_INVESTIGATE
     936          printf("changing fractionSmall from %g to %g for %s as %d iterations\n",
     937                 fractionSmall,fractionSmall_,name.c_str(),totalNumberIterations);
     938#endif
     939        }
    896940        if (model.status()==5)
    897941          returnCode=-2; // stop
     
    913957    delete [] reset;
    914958  }
     959#ifdef HISTORY_STATISTICS
     960  getHistoryStatistics_=true;
     961#endif
    915962#ifdef COIN_DEVELOP
    916   getHistoryStatistics_=true;
    917963  if (returnCode==1||returnCode==2) {
    918964    if (status==1)
     
    22562302  }
    22572303}
     2304bool
     2305CbcHeuristicPartial::shouldHeurRun()
     2306{
     2307  return true;
     2308}
    22582309
    22592310// Default Constructor
  • trunk/Cbc/src/CbcHeuristic.hpp

    r961 r1013  
    187187  void setInputSolution(const double * solution, double objValue);
    188188
    189   /** Check whether the heuristic should run */
    190   bool shouldHeurRun();
     189  /** Check whether the heuristic should run at all */
     190  virtual bool shouldHeurRun();
     191  /** Check whether the heuristic should run this time */
    191192  bool shouldHeurRun_randomChoice();
    192193  void debugNodes();
     
    211212  int feasibilityPumpOptions_;
    212213  /// Fraction of new(rows+columns)/old(rows+columns) before doing small branch and bound
    213   double fractionSmall_;
     214  mutable double fractionSmall_;
    214215  /// Thread specific random number generator
    215216  CoinThreadRandom randomNumberGenerator_;
     
    397398  { fixPriority_ = value;}
    398399
     400  /** Check whether the heuristic should run at all */
     401  virtual bool shouldHeurRun();
     402
    399403protected:
    400404  // Data
  • trunk/Cbc/src/CbcHeuristicDive.cpp

    r961 r1013  
    2626  percentageToFix_ = 0.2;
    2727  maxIterations_ = 100;
     28  maxSimplexIterations_ = 10000;
    2829  maxTime_ = 600;
    2930}
     
    4647  percentageToFix_ = 0.2;
    4748  maxIterations_ = 100;
     49  maxSimplexIterations_ = 10000;
    4850  maxTime_ = 600;
    4951}
     
    7072  else
    7173    fprintf(fp,"4  %s.setMaxIterations(%d);\n",heuristic,maxIterations_);
     74  if (maxSimplexIterations_!=100)
     75    fprintf(fp,"3  %s.setMaxIterations(%d);\n",heuristic,maxSimplexIterations_);
     76  else
     77    fprintf(fp,"4  %s.setMaxIterations(%d);\n",heuristic,maxSimplexIterations_);
    7278  if (maxTime_!=600)
    7379    fprintf(fp,"3  %s.setMaxTime(%.2f);\n",heuristic,maxTime_);
     
    8490  percentageToFix_(rhs.percentageToFix_),
    8591  maxIterations_(rhs.maxIterations_),
     92  maxSimplexIterations_(rhs.maxSimplexIterations_),
    8693  maxTime_(rhs.maxTime_)
    8794{
     
    106113    percentageToFix_ = rhs.percentageToFix_;
    107114    maxIterations_ = rhs.maxIterations_;
     115    maxSimplexIterations_ = rhs.maxSimplexIterations_;
    108116    maxTime_ = rhs.maxTime_;
    109117    delete [] downLocks_;
     
    198206
    199207  double time1 = CoinCpuTime();
     208  int numberSimplexIterations=0;
    200209
    201210  OsiSolverInterface * solver = model_->solver()->clone();
     
    489498      reasonToStop = 3;
    490499#endif
     500      break;
     501    }
     502
     503    numberSimplexIterations+=solver->getIterationCount();
     504    if(numberSimplexIterations > maxSimplexIterations_) {
     505#ifdef DIVE_DEBUG
     506      reasonToStop = 4;
     507#endif
     508      // also switch off
     509      printf("switching off diving as too many iterations\n");
     510      when_=0;
    491511      break;
    492512    }
  • trunk/Cbc/src/CbcHeuristicDive.hpp

    r961 r1013  
    112112  double percentageToFix_;
    113113
    114   // Maximum number of iterations
     114  // Maximum number of major iterations
    115115  int maxIterations_;
     116
     117  // Maximum number of simplex iterations
     118  int maxSimplexIterations_;
    116119
    117120  // Maximum time allowed
  • trunk/Cbc/src/CbcHeuristicFPump.cpp

    r961 r1013  
    214214  double direction = model_->solver()->getObjSense();
    215215  cutoff *= direction;
     216  int numberBandBsolutions=0;
    216217  double firstCutoff = fabs(cutoff);
    217218  cutoff = CoinMin(cutoff,solutionValue);
     
    332333  double * roundingSolution = new double[numberColumns];
    333334  double roundingObjective = solutionValue;
     335  CbcRounding roundingHeuristic(*model_);
    334336  while (!exitAll) {
    335337    int numberPasses=0;
     
    467469      double newTrueSolutionValue=0.0;
    468470      double newSumInfeas=0.0;
     471      int newNumberInfeas=0;
    469472      returnCode=0;
    470473      if (model_->getCurrentSeconds()>model_->getMaximumSeconds()) {
     
    561564              if (returnCode!=1)
    562565                newSolutionValue=saveValue;
     566              if (returnCode&&newSolutionValue<saveValue)
     567                numberBandBsolutions++;
    563568            }
    564569          }
     
    870875          newTrueSolutionValue = -saveOffset;
    871876          newSumInfeas=0.0;
     877          newNumberInfeas=0;
    872878          {
    873879            const double * newSolution = solver->getColSolution();
     
    877883                double nearest = floor(value+0.5);
    878884                newSumInfeas += fabs(value-nearest);
     885                if (fabs(value-nearest)>1.0e-6)
     886                  newNumberInfeas++;
    879887              }
    880888              newTrueSolutionValue += saveObjective[i]*newSolution[i];
    881889            }
    882890            newTrueSolutionValue *= direction;
     891            if (newNumberInfeas&&newNumberInfeas<-20) {
     892#if 0
     893              roundingObjective=solutionValue;
     894              OsiSolverInterface * saveSolver = model_->swapSolver(solver);
     895              int ifSol = roundingHeuristic.solution(roundingObjective,roundingSolution);
     896              model_->swapSolver(saveSolver);
     897              if (ifSol>0)
     898                abort();
     899#endif
     900              int numberRows=solver->getNumRows();
     901              double * rowActivity = new double[numberRows];
     902              memset(rowActivity,0,numberRows*sizeof(double));
     903              int * which = new int[newNumberInfeas];
     904              int * stack = new int[newNumberInfeas+1];
     905              double * baseValue = new double[newNumberInfeas];
     906              int * whichRow = new int[numberRows];
     907              double * rowValue = new double[numberRows];
     908              memset(rowValue,0,numberRows*sizeof(double));
     909              int nRow=0;
     910              // Column copy
     911              const double * element = solver->getMatrixByCol()->getElements();
     912              const int * row = solver->getMatrixByCol()->getIndices();
     913              const CoinBigIndex * columnStart = solver->getMatrixByCol()->getVectorStarts();
     914              const int * columnLength = solver->getMatrixByCol()->getVectorLengths();
     915              int n=0;
     916              double contrib = 0.0;
     917              for (  i=0 ; i<numberColumns ; i++ ) {
     918                double value = newSolution[i];
     919                if (solver->isInteger(i)) {
     920                  double nearest = floor(value+0.5);
     921                  if (fabs(value-nearest)>1.0e-6) {
     922                    //printf("Column %d value %g\n",i,value);
     923                    for (CoinBigIndex j=columnStart[i];
     924                         j<columnStart[i]+columnLength[i];j++) {
     925                      int iRow=row[j];
     926                      //printf("row %d element %g\n",iRow,element[j]);
     927                      if (!rowValue[iRow]) {
     928                        rowValue[iRow]=1.0;
     929                        whichRow[nRow++]=iRow;
     930                      }
     931                    }
     932                    baseValue[n]=floor(value);
     933                    contrib += saveObjective[i]*value;
     934                    value=0.0;
     935                    stack[n]=0;
     936                    which[n++]=i;
     937                  }
     938                }
     939                for (CoinBigIndex j=columnStart[i];
     940                     j<columnStart[i]+columnLength[i];j++) {
     941                  int iRow=row[j];
     942                  rowActivity[iRow] += value*element[j];
     943                }
     944              }
     945              if (newNumberInfeas<15) {
     946                stack[n]=newNumberInfeas+100;
     947                int iStack=n;
     948                memset(rowValue,0,numberRows*sizeof(double));
     949                const double * rowLower = solver->getRowLower();
     950                const double * rowUpper = solver->getRowUpper();
     951                while (iStack>=0) {
     952                  double contrib2=0.0;
     953                  // Could do faster
     954                  for (int k=0 ; k<n ; k++ ) {
     955                    i=which[k];
     956                    double value = baseValue[k]+stack[k];
     957                    contrib2 += saveObjective[i]*value;
     958                    for (CoinBigIndex j=columnStart[i];
     959                         j<columnStart[i]+columnLength[i];j++) {
     960                      int iRow=row[j];
     961                      rowValue[iRow] += value*element[j];
     962                    }
     963                  }
     964                  // check if feasible
     965                  bool feasible=true;
     966                  for (int k=0;k<nRow;k++) {
     967                    i=whichRow[k];
     968                    double value = rowValue[i]+rowActivity[i];
     969                    rowValue[i]=0.0;
     970                    if(value<rowLower[i]-1.0e-7||
     971                       value>rowUpper[i]+1.0e-7)
     972                      feasible=false;
     973                  }
     974                  if (feasible) {
     975                    double newObj = newTrueSolutionValue * direction;
     976                    newObj += contrib2-contrib;
     977                    newObj *= direction;
     978                    printf("FFFeasible! - obj %g\n",newObj);
     979                    if (newObj<roundingObjective) {
     980                      printf("FBetter\n");
     981                      roundingObjective = newObj;
     982                      memcpy(roundingSolution,newSolution,numberColumns*sizeof(double));
     983                      for (int k=0 ; k<n ; k++ ) {
     984                        i=which[k];
     985                        double value = baseValue[k]+stack[k];
     986                        roundingSolution[i]=value;
     987                      }
     988                    }
     989                  }
     990                  while (iStack>=0&&stack[iStack]) {
     991                    stack[iStack]--;
     992                    iStack--;
     993                  }
     994                  if (iStack>=0) {
     995                    stack[iStack]=1;
     996                    iStack=n;
     997                    stack[n]=1;
     998                  }
     999                }
     1000              }
     1001              delete [] rowActivity;
     1002              delete [] which;
     1003              delete [] stack;
     1004              delete [] baseValue;
     1005              delete [] whichRow;
     1006              delete [] rowValue;
     1007            }
    8831008          }
    8841009          if (false) {
     
    9931118        totalNumberIterations += solver->getIterationCount();
    9941119        if (solver->getNumRows()<3000)
    995           sprintf(pumpPrint,"Pass %3d: suminf. %10.5f obj. %g iterations %d", numberPasses+totalNumberPasses,
    996                   newSumInfeas,newTrueSolutionValue,solver->getIterationCount());
     1120          sprintf(pumpPrint,"Pass %3d: suminf. %10.5f (%d) obj. %g iterations %d",
     1121                  numberPasses+totalNumberPasses,
     1122                  newSumInfeas,newNumberInfeas,
     1123                  newTrueSolutionValue,solver->getIterationCount());
    9971124        else
    998           sprintf(pumpPrint,"Pass %3d: (%.2f seconds) suminf. %10.5f obj. %g iterations %d", numberPasses+totalNumberPasses,
    999                   model_->getCurrentSeconds(),newSumInfeas,newTrueSolutionValue,solver->getIterationCount());
     1125          sprintf(pumpPrint,"Pass %3d: (%.2f seconds) suminf. %10.5f (%d) obj. %g iterations %d", numberPasses+totalNumberPasses,
     1126                  model_->getCurrentSeconds(),newSumInfeas,newNumberInfeas,
     1127                  newTrueSolutionValue,solver->getIterationCount());
    10001128        model_->messageHandler()->message(CBC_FPUMP1,model_->messages())
    10011129          << pumpPrint
     
    11201248      if (newSolutionValue-model_->getCutoffIncrement()
    11211249          >continuousObjectiveValue-1.0e-7) {
    1122         returnCode = smallBranchAndBound(newSolver,numberNodes_,newSolution,newSolutionValue,
    1123                                          cutoff,"CbcHeuristicLocalAfterFPump");
     1250        double saveFraction = fractionSmall_;
     1251        if (numberTries>1&&!numberBandBsolutions)
     1252          fractionSmall_ *= 0.5;
     1253        // Give branch and bound a bit more freedom
     1254        double cutoff2=newSolutionValue-model_->getCutoffIncrement();
     1255        int returnCode2 = smallBranchAndBound(newSolver,numberNodes_,newSolution,newSolutionValue,
     1256                                              cutoff2,"CbcHeuristicLocalAfterFPump");
     1257        fractionSmall_ = saveFraction;
     1258        if (returnCode2<0) {
     1259          if (returnCode2==-2)
     1260            exitAll=true;
     1261          returnCode2=0; // returned on size (or event) - could try changing
     1262        }
     1263        if ((returnCode2&2)!=0) {
     1264          // could add cut
     1265          returnCode2 &= ~2;
     1266        }
     1267        if (returnCode2)
     1268          numberBandBsolutions++;
    11241269      } else {
    11251270        // no need
    11261271        exitAll=true;
    1127         returnCode=0;
    1128       }
    1129       if (returnCode<0) {
    1130         if (returnCode==-2)
    1131           exitAll=true;
    1132         returnCode=0; // returned on size (or event) - could try changing
    1133       }
    1134       if ((returnCode&2)!=0) {
    1135         // could add cut
    1136         returnCode &= ~2;
     1272        //returnCode=0;
    11371273      }
    11381274      // recompute solution value
     
    12331369            model_->setBestSolution(betterSolution,numberColumns,newSolutionValue);
    12341370            int action = handler->event(CbcEventHandler::heuristicSolution);
    1235             printf("cutoff %g\n",model_->getCutoff());
     1371            //printf("cutoff %g\n",model_->getCutoff());
    12361372            if (saveOldSolution&&saveObjectiveValue<model_->getMinimizationObjValue())
    12371373              model_->setBestSolution(saveOldSolution,numberColumns,saveObjectiveValue);
     
    12621398        cutoff -= CoinMax(CoinMax(gap,absoluteIncrement_),model_->getCutoffIncrement());
    12631399      } else {
    1264         cutoff -= 0.1*(cutoff-continuousObjectiveValue);
     1400        double weights[10]={0.1,0.1,0.2,0.2,0.2,0.3,0.3,0.3,0.4,0.5};
     1401        cutoff -= weights[CoinMin(numberTries-1,9)]*(cutoff-continuousObjectiveValue);
    12651402      }
    12661403      if (cutoff<continuousObjectiveValue)
     
    13801517  int i;
    13811518
    1382   int numberColumns = model_->getNumCols();
    1383   // tmp contains the current obj coefficients
    1384   double * tmp = new double [numberColumns];
    1385   memcpy(tmp,solver->getObjCoefficients(),numberColumns*sizeof(double));
     1519  const double * cost = solver->getObjCoefficients();
    13861520  int flip_up = 0;
    13871521  int flip_down  = 0;
     
    13931527  for (i = 0; i < nn; i++) val[i] = .001;
    13941528
     1529  const double * rowLower = solver->getRowLower();
     1530  const double * rowUpper = solver->getRowUpper();
     1531  int numberRows = solver->getNumRows();
     1532#if 1
     1533  // Do set covering variables
     1534  const CoinPackedMatrix * matrixByRow = solver->getMatrixByRow();
     1535  const double * elementByRow = matrixByRow->getElements();
     1536  const int * column = matrixByRow->getIndices();
     1537  const CoinBigIndex * rowStart = matrixByRow->getVectorStarts();
     1538  const int * rowLength = matrixByRow->getVectorLengths();
     1539  for (i=0;i<numberRows;i++) {
     1540    if (rowLower[i]==1.0&&rowUpper[i]==1.0) {
     1541      bool cover=true;
     1542      double largest=0.0;
     1543      int jColumn=-1;
     1544      for (CoinBigIndex k=rowStart[i];k<rowStart[i]+rowLength[i];k++) {
     1545        int iColumn = column[k];
     1546        if (elementByRow[k]!=1.0||!solver->isInteger(iColumn)) {
     1547          cover=false;
     1548          break;
     1549        } else {
     1550          if (solution[iColumn]) {
     1551            double value = solution[iColumn]*
     1552              (randomNumberGenerator_.randomDouble()+5.0);
     1553            if (value>largest) {
     1554              largest=value;
     1555              jColumn=iColumn;
     1556            }
     1557          }
     1558        }
     1559      }
     1560      if (cover) {
     1561        for (CoinBigIndex k=rowStart[i];k<rowStart[i]+rowLength[i];k++) {
     1562          int iColumn = column[k];
     1563          double value=solution[iColumn];
     1564          if (iColumn==jColumn)
     1565            solution[iColumn]=1.0;
     1566           else
     1567            solution[iColumn]=0.0;
     1568          if (value!=solution[iColumn])
     1569            printf("%d sol changed from %g to %g\n",iColumn,value,solution[iColumn]);
     1570          if (value>0.5&&solution[iColumn]<0.5)
     1571            printf("why!\n");
     1572        }
     1573      }
     1574    }
     1575  }
     1576#endif
     1577#if 0
     1578  // Do set covering variables
     1579  const CoinPackedMatrix * matrixByRow = solver->getMatrixByRow();
     1580  const double * elementByRow = matrixByRow->getElements();
     1581  const int * column = matrixByRow->getIndices();
     1582  const CoinBigIndex * rowStart = matrixByRow->getVectorStarts();
     1583  const int * rowLength = matrixByRow->getVectorLengths();
     1584  int numberColumns = solver->getNumCols();
     1585  double * sortTemp = new double[numberColumns];
     1586  int * whichTemp = new int [numberColumns];
     1587  char * rowTemp = new char [numberRows];
     1588  memset(rowTemp,0,numberRows);
     1589  for (i=0;i<numberColumns;i++)
     1590    whichTemp[i]=-1;
     1591  int nSOS=0;
     1592  for (i=0;i<numberRows;i++) {
     1593    if (rowLower[i]==1.0&&rowUpper[i]==1.0) {
     1594      bool cover=true;
     1595      for (CoinBigIndex k=rowStart[i];k<rowStart[i]+rowLength[i];k++) {
     1596        int iColumn = column[k];
     1597        if (elementByRow[k]!=1.0||!solver->isInteger(iColumn)) {
     1598          cover=false;
     1599          break;
     1600        }
     1601      }
     1602      if (cover) {
     1603        rowTemp[i]=1;
     1604        nSOS++;
     1605        for (CoinBigIndex k=rowStart[i];k<rowStart[i]+rowLength[i];k++) {
     1606          int iColumn = column[k];
     1607          double value=solution[iColumn];
     1608          whichTemp[iColumn]=iColumn;
     1609        }
     1610      }
     1611    }
     1612  }
     1613  if (nSOS) {
     1614    // Column copy
     1615    const CoinPackedMatrix * matrixByColumn = solver->getMatrixByCol();
     1616    //const double * element = matrixByColumn->getElements();
     1617    const int * row = matrixByColumn->getIndices();
     1618    const CoinBigIndex * columnStart = matrixByColumn->getVectorStarts();
     1619    const int * columnLength = matrixByColumn->getVectorLengths();
     1620    int nLook = 0;
     1621    for (i=0;i<numberColumns;i++) {
     1622      if (whichTemp[i]>=0) {
     1623        whichTemp[nLook]=i;
     1624        double value=solution[i];
     1625        if (value<0.5)
     1626          value *= (0.1*randomNumberGenerator_.randomDouble()+0.3);
     1627        sortTemp[nLook++]=-value;
     1628      }
     1629    }
     1630    CoinSort_2(sortTemp,sortTemp+nLook,whichTemp);
     1631    double smallest=1.0;
     1632    int nFix=0;
     1633    int nOne=0;
     1634    for (int j=0;j<nLook;j++) {
     1635      int jColumn = whichTemp[j];
     1636      double thisValue = solution[jColumn];
     1637      if (!thisValue)
     1638        continue;
     1639      if (thisValue==1.0)
     1640        nOne++;
     1641      smallest = CoinMin(smallest,thisValue);
     1642      solution[jColumn]=1.0;
     1643      double largest=0.0;
     1644      for (CoinBigIndex jEl=columnStart[jColumn];
     1645           jEl<columnStart[jColumn]+columnLength[jColumn];jEl++) {
     1646        int jRow = row[jEl];
     1647        if (rowTemp[jRow]) {
     1648          for (CoinBigIndex k=rowStart[jRow];k<rowStart[jRow]+rowLength[jRow];k++) {
     1649            int iColumn = column[k];
     1650            if (solution[iColumn]) {
     1651              if (iColumn!=jColumn) {
     1652                double value = solution[iColumn];
     1653                if (value>largest)
     1654                  largest=value;
     1655                solution[iColumn]=0.0;
     1656              }
     1657            }
     1658          }
     1659        }
     1660      }
     1661      if (largest>thisValue)
     1662        printf("%d was at %g - chosen over a value of %g\n",
     1663               jColumn,thisValue,largest);
     1664      nFix++;
     1665    }
     1666    printf("%d fixed out of %d (%d at one already)\n",
     1667           nFix,nLook,nOne);
     1668  }
     1669  delete [] sortTemp;
     1670  delete [] whichTemp;
     1671  delete [] rowTemp;
     1672#endif
     1673  const double * columnLower = solver->getColLower();
     1674  const double * columnUpper = solver->getColUpper();
    13951675  // return rounded solution
    13961676  for (i=0;i<numberIntegers;i++) {
     
    13991679    double round = floor(value+primalTolerance);
    14001680    if (value-round > downValue) round += 1.;
    1401     if (round < integerTolerance && tmp[iColumn] < -1. + integerTolerance) flip_down++;
    1402     if (round > 1. - integerTolerance && tmp[iColumn] > 1. - integerTolerance) flip_up++;
     1681#if 1
     1682    if (round < integerTolerance && cost[iColumn] < -1. + integerTolerance) flip_down++;
     1683    if (round > 1. - integerTolerance && cost[iColumn] > 1. - integerTolerance) flip_up++;
     1684#else
     1685    if (round < columnLower[iColumn]+integerTolerance && cost[iColumn] < -1. + integerTolerance) flip_down++;
     1686    if (round > columnUpper[iColumn] - integerTolerance && cost[iColumn] > 1. - integerTolerance) flip_up++;
     1687#endif
    14031688    if (flip_up + flip_down == 0) {
    14041689       for (int k = 0; k < nn; k++) {
     
    14221707  //sprintf(pumpPrint+strlen(pumpPrint),"up = %5d , down = %5d", flip_up, flip_down);
    14231708  *flip = flip_up + flip_down;
    1424   delete [] tmp;
    1425 
    1426   const double * columnLower = solver->getColLower();
    1427   const double * columnUpper = solver->getColUpper();
     1709
    14281710  if (*flip == 0 && iter != 0) {
    14291711    //sprintf(pumpPrint+strlen(pumpPrint)," -- rand = %4d (%4d) ", nnv, nn);
     
    14491731  //iter++;
    14501732   
    1451   const double * rowLower = solver->getRowLower();
    1452   const double * rowUpper = solver->getRowUpper();
    1453 
    1454   int numberRows = solver->getNumRows();
    14551733  // get row activities
    14561734  double * rowActivity = new double[numberRows];
  • trunk/Cbc/src/CbcHeuristicRINS.cpp

    r961 r1013  
    170170    }
    171171  }
    172   if ((model_->getNodeCount()%howOften_)==0&&model_->getCurrentPassNumber()==1) {
     172  if ((model_->getNodeCount()%howOften_)==0&&(model_->getCurrentPassNumber()==1||model_->getCurrentPassNumber()==999999)) {
    173173    OsiSolverInterface * solver = model_->solver();
    174174
     
    178178    const double * currentSolution = solver->getColSolution();
    179179    OsiSolverInterface * newSolver = model_->continuousSolver()->clone();
    180     const double * colLower = newSolver->getColLower();
     180    //const double * colLower = newSolver->getColLower();
    181181    //const double * colUpper = newSolver->getColUpper();
    182182
     
    202202        double nearest=floor(valueInt+0.5);
    203203        newSolver->setColLower(iColumn,nearest);
    204         newSolver->setColUpper(iColumn,colLower[iColumn]);
     204        newSolver->setColUpper(iColumn,nearest);
    205205        nFix++;
    206206      }
     
    370370}
    371371
     372// Default Constructor
     373CbcHeuristicDINS::CbcHeuristicDINS()
     374  :CbcHeuristic()
     375{
     376  numberSolutions_=0;
     377  numberSuccesses_=0;
     378  numberTries_=0;
     379  howOften_=100;
     380  decayFactor_ = 0.5;
     381  maximumKeepSolutions_=5;
     382  numberKeptSolutions_=0;
     383  numberIntegers_=-1;
     384  localSpace_ = 10;
     385  values_=NULL;
     386}
     387
     388// Constructor with model - assumed before cuts
     389
     390CbcHeuristicDINS::CbcHeuristicDINS(CbcModel & model)
     391  :CbcHeuristic(model)
     392{
     393  numberSolutions_=0;
     394  numberSuccesses_=0;
     395  numberTries_=0;
     396  howOften_=100;
     397  decayFactor_ = 0.5;
     398  assert(model.solver());
     399  maximumKeepSolutions_=5;
     400  numberKeptSolutions_=0;
     401  numberIntegers_=-1;
     402  localSpace_ = 10;
     403  values_=NULL;
     404}
     405
     406// Destructor
     407CbcHeuristicDINS::~CbcHeuristicDINS ()
     408{
     409  for (int i=0;i<numberKeptSolutions_;i++)
     410    delete [] values_[i];
     411  delete [] values_;
     412}
     413
     414// Clone
     415CbcHeuristic *
     416CbcHeuristicDINS::clone() const
     417{
     418  return new CbcHeuristicDINS(*this);
     419}
     420
     421// Assignment operator
     422CbcHeuristicDINS &
     423CbcHeuristicDINS::operator=( const CbcHeuristicDINS& rhs)
     424{
     425  if (this!=&rhs) {
     426    CbcHeuristic::operator=(rhs);
     427    numberSolutions_ = rhs.numberSolutions_;
     428    howOften_ = rhs.howOften_;
     429    decayFactor_ = rhs.decayFactor_;
     430    numberSuccesses_ = rhs.numberSuccesses_;
     431    numberTries_ = rhs.numberTries_;
     432    for (int i=0;i<numberKeptSolutions_;i++)
     433      delete [] values_[i];
     434    delete [] values_;
     435    maximumKeepSolutions_ = rhs.maximumKeepSolutions_;
     436    numberKeptSolutions_ = rhs.numberKeptSolutions_;
     437    numberIntegers_ = rhs.numberIntegers_;
     438    localSpace_ = rhs.localSpace_;
     439    if (model_&&rhs.values_) {
     440      assert (numberIntegers_>=0);
     441      values_ = new int * [maximumKeepSolutions_];
     442      for (int i=0;i<maximumKeepSolutions_;i++)
     443        values_[i]=CoinCopyOfArray(rhs.values_[i],numberIntegers_);
     444    } else {
     445      values_=NULL;
     446    }
     447  }
     448  return *this;
     449}
     450
     451// Create C++ lines to get to current state
     452void
     453CbcHeuristicDINS::generateCpp( FILE * fp)
     454{
     455  CbcHeuristicDINS other;
     456  fprintf(fp,"0#include \"CbcHeuristicDINS.hpp\"\n");
     457  fprintf(fp,"3  CbcHeuristicDINS heuristicDINS(*cbcModel);\n");
     458  CbcHeuristic::generateCpp(fp,"heuristicDINS");
     459  if (howOften_!=other.howOften_)
     460    fprintf(fp,"3  heuristicDINS.setHowOften(%d);\n",howOften_);
     461  else
     462    fprintf(fp,"4  heuristicDINS.setHowOften(%d);\n",howOften_);
     463  fprintf(fp,"3  cbcModel->addHeuristic(&heuristicDINS);\n");
     464}
     465
     466// Copy constructor
     467CbcHeuristicDINS::CbcHeuristicDINS(const CbcHeuristicDINS & rhs)
     468:
     469  CbcHeuristic(rhs),
     470  numberSolutions_(rhs.numberSolutions_),
     471  howOften_(rhs.howOften_),
     472  decayFactor_(rhs.decayFactor_),
     473  numberSuccesses_(rhs.numberSuccesses_),
     474  numberTries_(rhs.numberTries_),
     475  maximumKeepSolutions_(rhs.maximumKeepSolutions_),
     476  numberKeptSolutions_(rhs.numberKeptSolutions_),
     477  numberIntegers_(rhs.numberIntegers_),
     478  localSpace_(rhs.localSpace_)
     479{
     480  if (model_&&rhs.values_) {
     481    assert (numberIntegers_>=0);
     482    values_ = new int * [maximumKeepSolutions_];
     483    for (int i=0;i<maximumKeepSolutions_;i++)
     484      values_[i]=CoinCopyOfArray(rhs.values_[i],numberIntegers_);
     485  } else {
     486    values_=NULL;
     487  }
     488}
     489// Resets stuff if model changes
     490void
     491CbcHeuristicDINS::resetModel(CbcModel * model)
     492{
     493  //CbcHeuristic::resetModel(model);
     494  for (int i=0;i<numberKeptSolutions_;i++)
     495    delete [] values_[i];
     496  delete [] values_;
     497  numberKeptSolutions_=0;
     498  numberIntegers_=-1;
     499  numberSolutions_=0;
     500  values_=NULL;
     501}
     502/*
     503  First tries setting a variable to better value.  If feasible then
     504  tries setting others.  If not feasible then tries swaps
     505  Returns 1 if solution, 0 if not */
     506int
     507CbcHeuristicDINS::solution(double & solutionValue,
     508                         double * betterSolution)
     509{
     510  numCouldRun_++;
     511  int returnCode=0;
     512  const double * bestSolution = model_->bestSolution();
     513  if (!bestSolution)
     514    return 0; // No solution found yet
     515  if (numberSolutions_<model_->getSolutionCount()) {
     516    // new solution - add info
     517    numberSolutions_=model_->getSolutionCount();
     518
     519    int numberIntegers = model_->numberIntegers();
     520    const int * integerVariable = model_->integerVariable();
     521    if (numberIntegers_<0) {
     522      numberIntegers_ = numberIntegers;
     523      assert (!values_);
     524      values_ = new int * [maximumKeepSolutions_];
     525      for (int i=0;i<maximumKeepSolutions_;i++)
     526        values_[i]=NULL;
     527    } else {
     528      assert (numberIntegers==numberIntegers_);
     529    }
     530    // move solutions (0 will be most recent)
     531    {
     532      int * temp = values_[maximumKeepSolutions_-1];
     533      for (int i = maximumKeepSolutions_-1;i>0;i--)
     534        values_[i]=values_[i-1];
     535      if (!temp)
     536        temp = new int [numberIntegers_];
     537      values_[0]=temp;
     538    }
     539    int i;
     540    for (i=0;i<numberIntegers;i++) {
     541      int iColumn = integerVariable[i];
     542      double value=bestSolution[iColumn];
     543      double nearest=floor(value+0.5);
     544      values_[0][i]=(int) nearest;
     545    }
     546    numberKeptSolutions_ = CoinMin(numberKeptSolutions_+1,maximumKeepSolutions_);
     547  }
     548  int finalReturnCode=0;
     549  if (((model_->getNodeCount()%howOften_)==howOften_/2||!model_->getNodeCount())&&(model_->getCurrentPassNumber()==1||model_->getCurrentPassNumber()==999999)) {
     550    OsiSolverInterface * solver = model_->solver();
     551
     552    int numberIntegers = model_->numberIntegers();
     553    const int * integerVariable = model_->integerVariable();
    372554 
     555    const double * currentSolution = solver->getColSolution();
     556    int localSpace = localSpace_;
     557    // 0 means finished but no solution, 1 solution, 2 node limit
     558    int status=-1;
     559    double cutoff = model_->getCutoff();
     560    while(status) {
     561      status=0;
     562      OsiSolverInterface * newSolver = model_->continuousSolver()->clone();
     563      const double * colLower = solver->getColLower();
     564      const double * colUpper = solver->getColUpper();
     565     
     566      double primalTolerance;
     567      solver->getDblParam(OsiPrimalTolerance,primalTolerance);
     568      const double * continuousSolution = newSolver->getColSolution();
     569      // Space for added constraint
     570      double * element = new double [numberIntegers];
     571      int * column = new int [numberIntegers];
     572      int i;
     573      int nFix=0;
     574      int nCouldFix=0;
     575      int nCouldFix2=0;
     576      int nBound=0;
     577      int nEl=0;
     578      double bias=localSpace;
     579      int okSame = numberKeptSolutions_-1;
     580      for (i=0;i<numberIntegers;i++) {
     581        int iColumn=integerVariable[i];
     582        const OsiObject * object = model_->object(i);
     583        // get original bounds
     584        double originalLower;
     585        double originalUpper;
     586        getIntegerInformation( object,originalLower, originalUpper);
     587        double valueInt=bestSolution[iColumn];
     588        if (valueInt<originalLower) {
     589          valueInt=originalLower;
     590        } else if (valueInt>originalUpper) {
     591          valueInt=originalUpper;
     592        }
     593        int intValue = (int) floor(valueInt+0.5);
     594        double currentValue = currentSolution[iColumn];
     595        double currentLower = colLower[iColumn];
     596        double currentUpper = colUpper[iColumn];
     597        if (fabs(valueInt-currentValue)>=0.5) {
     598          // Re-bound
     599          nBound++;
     600          if (intValue>=currentValue) {
     601            currentLower = CoinMax(currentLower,ceil(2*currentValue-intValue));
     602            currentUpper = intValue;
     603          } else {
     604            currentLower = intValue;
     605            currentUpper = CoinMin(currentUpper,floor(2*currentValue-intValue));
     606          }
     607          newSolver->setColLower(iColumn,currentLower);
     608          newSolver->setColUpper(iColumn,currentUpper);
     609        } else {
     610          // See if can fix
     611          bool canFix=false;
     612          double continuousValue = continuousSolution[iColumn];
     613          if (fabs(currentValue-valueInt)<10.0*primalTolerance) {
     614            if (currentUpper-currentLower>1.0) {
     615              // General integer variable
     616              canFix=true;
     617            } else if(fabs(continuousValue-valueInt)<10.0*primalTolerance) {
     618              int nSame=1;
     619              //assert (intValue==values_[0][i]);
     620              for (int k=1;k<numberKeptSolutions_;k++) {
     621                if (intValue==values_[k][i])
     622                  nSame++;
     623              }
     624              if (nSame>=okSame) {
     625                // can fix
     626                canFix=true;
     627              } else {
     628                nCouldFix++;
     629              }
     630            } else {
     631              nCouldFix2++;
     632            }
     633          }
     634          if (canFix) {
     635            newSolver->setColLower(iColumn,intValue);
     636            newSolver->setColUpper(iColumn,intValue);
     637            nFix++;
     638          } else {
     639            if (currentUpper-currentLower>1.0) {
     640              // General integer variable
     641              currentLower = floor(currentValue);
     642              if (intValue>=currentLower&&intValue<=currentLower+1) {
     643                newSolver->setColLower(iColumn,currentLower);
     644                newSolver->setColUpper(iColumn,currentLower+1.0);
     645              } else {
     646                // fix
     647                double value;
     648                if (intValue<currentLower)
     649                  value = currentLower;
     650                else
     651                  value = currentLower+1;
     652                newSolver->setColLower(iColumn,value);
     653                newSolver->setColUpper(iColumn,value);
     654                nFix++;
     655              }
     656            } else {
     657              // 0-1 (ish)
     658              column[nEl]=iColumn;
     659              if (intValue==currentLower) {
     660                bias += currentLower;
     661                element[nEl++]=1.0;
     662              } else if (intValue==currentUpper) {
     663                bias += currentUpper;
     664                element[nEl++]=-1.0;
     665              } else {
     666                printf("bad DINS logic\n");
     667                abort();
     668              }
     669            }
     670          }
     671        }
     672      }
     673      printf("%d fixed, %d same as cont/int, %d same as int - %d bounded %d in cut\n",
     674             nFix,nCouldFix,nCouldFix2,nBound,nEl);
     675      if (nFix>numberIntegers/10) {
     676#if 0
     677        newSolver->initialSolve();
     678        printf("obj %g\n",newSolver->getObjValue());
     679        for (i=0;i<numberIntegers;i++) {
     680          int iColumn=integerVariable[i];
     681          printf("%d new bounds %g %g - solutions %g %g\n",
     682                 iColumn,newSolver->getColLower()[iColumn],
     683                 newSolver->getColUpper()[iColumn],
     684                 bestSolution[iColumn],
     685                 currentSolution[iColumn]);
     686        }
     687#endif
     688        if (nEl>0)
     689          newSolver->addRow(nEl,column,element,-COIN_DBL_MAX,bias);
     690        //printf("%d integers have same value\n",nFix);
     691        returnCode = smallBranchAndBound(newSolver,numberNodes_,betterSolution,solutionValue,
     692                                         cutoff,"CbcHeuristicDINS");
     693        if (returnCode<0) {
     694          returnCode=0; // returned on size
     695          status=0;
     696        } else {
     697          numRuns_++;
     698          if ((returnCode&2)!=0) {
     699            // could add cut as complete search
     700            returnCode &= ~2;
     701            if ((returnCode&1)!=0) {
     702              numberSuccesses_++;
     703              status=1;
     704            } else {
     705              // no solution
     706              status=0;
     707            }
     708          } else {
     709            if ((returnCode&1)!=0) {
     710              numberSuccesses_++;
     711              status=1;
     712            } else {
     713              // no solution but node limit
     714              status=2;
     715              if (nEl)
     716                localSpace -= 5;
     717              else
     718                localSpace = -1;
     719              if (localSpace<0)
     720                status=0;
     721            }
     722          }
     723          if ((returnCode&1)!=0) {
     724            cutoff = CoinMin(cutoff,solutionValue-model_->getCutoffIncrement());
     725            finalReturnCode=1;
     726          }
     727        }
     728      }
     729      delete [] element;
     730      delete [] column;
     731      delete newSolver;
     732    }
     733    numberTries_++;
     734    if ((numberTries_%10)==0&&numberSuccesses_*3<numberTries_)
     735      howOften_ += (int) (howOften_*decayFactor_);
     736  }
     737  return finalReturnCode;
     738}
     739// update model
     740void CbcHeuristicDINS::setModel(CbcModel * model)
     741{
     742  model_ = model;
     743  // Get a copy of original matrix
     744  assert(model_->solver());
     745  for (int i=0;i<numberKeptSolutions_;i++)
     746    delete [] values_[i];
     747  delete [] values_;
     748  numberKeptSolutions_=0;
     749  numberIntegers_=-1;
     750  numberSolutions_=0;
     751  values_=NULL;
     752}
     753
     754 
  • trunk/Cbc/src/CbcHeuristicRINS.hpp

    r838 r1013  
    127127};
    128128
     129class CbcHeuristicDINS : public CbcHeuristic {
     130public:
     131
     132  // Default Constructor
     133  CbcHeuristicDINS ();
     134
     135  /* Constructor with model - assumed before cuts
     136     Initial version does not do Lps
     137  */
     138  CbcHeuristicDINS (CbcModel & model);
     139 
     140  // Copy constructor
     141  CbcHeuristicDINS ( const CbcHeuristicDINS &);
     142   
     143  // Destructor
     144  ~CbcHeuristicDINS ();
     145 
     146  /// Clone
     147  virtual CbcHeuristic * clone() const;
     148
     149
     150  /// Assignment operator
     151  CbcHeuristicDINS & operator=(const CbcHeuristicDINS& rhs);
     152
     153  /// Create C++ lines to get to current state
     154  virtual void generateCpp( FILE * fp) ;
     155
     156  /// Resets stuff if model changes
     157  virtual void resetModel(CbcModel * model);
     158
     159  /// update model (This is needed if cliques update matrix etc)
     160  virtual void setModel(CbcModel * model);
     161 
     162  using CbcHeuristic::solution ;
     163  /** returns 0 if no solution, 1 if valid solution.
     164      Sets solution values if good, sets objective value (only if good)
     165      This does Relaxation Induced Neighborhood Search
     166  */
     167  virtual int solution(double & objectiveValue,
     168                       double * newSolution);
     169  /// This version fixes stuff and does IP
     170  int solutionFix(double & objectiveValue,
     171                  double * newSolution,
     172                  const int * keep);
     173
     174  /// Sets how often to do it
     175  inline void setHowOften(int value)
     176  { howOften_=value;}
     177  /// Sets decay factor (for howOften) on failure
     178  inline void setDecayFactor(double value)
     179  { decayFactor_=value;}
     180  /// Sets maximum number of solutions kept
     181  inline void setMaximumKeep(int value)
     182  { maximumKeepSolutions_=value;}
     183  /// Sets tightness of extra constraint
     184  inline void setConstraint(int value)
     185  { localSpace_=value;}
     186
     187protected:
     188  // Data
     189
     190  /// Number of solutions so we can do something at solution
     191  int numberSolutions_;
     192  /// How often to do (code can change)
     193  int howOften_;
     194  /// How much to increase how often
     195  double decayFactor_;
     196  /// Number of successes
     197  int numberSuccesses_;
     198  /// Number of tries
     199  int numberTries_;
     200  /// Maximum number of solutions to keep
     201  int maximumKeepSolutions_;
     202  /// Number of solutions kept
     203  int numberKeptSolutions_;
     204  /// Number of integer variables
     205  int numberIntegers_;
     206  /// Local parameter
     207  int localSpace_;
     208  /// Values of integer variables
     209  int ** values_;
     210};
    129211
    130212#endif
  • trunk/Cbc/src/CbcModel.cpp

    r1009 r1013  
    63386338      }
    63396339# endif
     6340      int whenCuts = (continuousSolver_->getNumRows()+continuousSolver_->getNumCols()<=500) ? -1 :0;
     6341      if (parentModel_)
     6342        whenCuts=0;
    63406343      for (i = 0;i<numberCutGenerators_;i++) {
    63416344        int numberRowCutsBefore = theseCuts.sizeRowCuts() ;
     
    63516354        if (generator_[i]->switchedOff())
    63526355          generate=false;;
    6353         if (node&&node->depth()>10&&(node->depth()&1)==0&&!fullScan) {
     6356        if (node&&node->depth()>10&&(node->depth()&1)==whenCuts&&!fullScan) {
    63546357          // switch off if default
    63556358          if (generator_[i]->howOften()==1&&generator_[i]->whatDepth()<0)
     
    87408743// Set numberBeforeTrust in all objects
    87418744void
    8742 CbcModel::synchronizeNumberBeforeTrust()
     8745CbcModel::synchronizeNumberBeforeTrust(int type)
    87438746{
    87448747  int iObject;
     
    87488751    if (obj2) {
    87498752      // synchronize trust
    8750       obj2->setNumberBeforeTrust(numberBeforeTrust_);
     8753      if (!type) {
     8754        obj2->setNumberBeforeTrust(numberBeforeTrust_);
     8755      } else {
     8756        int value = obj2->numberBeforeTrust();
     8757        value = (value*11)/10 + 1;
     8758        value = CoinMax(numberBeforeTrust_,value);
     8759        obj2->setNumberBeforeTrust(value);
     8760      }
    87518761    }
    87528762  }
  • trunk/Cbc/src/CbcModel.hpp

    r983 r1013  
    685685  inline int getPreferredWay() const
    686686  { return preferredWay_;}
     687  /// Get at which depths to do cuts
     688  inline int whenCuts() const
     689  { return whenCuts_;}
     690  /// Set at which depths to do cuts
     691  inline void setWhenCuts(int value)
     692  { whenCuts_ = value;}
     693  /** Return true if we want to do cuts
     694      If allowForTopOfTree zero then just does on multiples of depth
     695      if 1 then allows for doing at top of tree
     696      if 2 then says if cuts allowed anywhere apart from root
     697  */
     698  bool doCutsNow(int allowForTopOfTree) const;
    687699  /** Set size of mini - tree.  If > 1 then does total enumeration of
    688700      tree given by this best variables to branch on
     
    15421554 
    15431555    /** Copy constructor .
    1544       If noTree is true then tree and cuts are not copied
     1556      If cloneHandler is true then message handler is cloned
    15451557    */ 
    1546     CbcModel(const CbcModel & rhs, bool noTree=false);
     1558    CbcModel(const CbcModel & rhs, bool cloneHandler=false);
    15471559 
    15481560    /// Assignment operator
     
    16981710  void convertToDynamic();
    16991711  /// Set numberBeforeTrust in all objects
    1700   void synchronizeNumberBeforeTrust();
     1712  void synchronizeNumberBeforeTrust(int type=0);
    17011713  /// Zap integer information in problem (may leave object info)
    17021714  void zapIntegerInformation(bool leaveObjects=true);
     
    17731785  void incrementStrongInfo(int numberTimes, int numberIterations,
    17741786                           int numberFixed, bool ifInfeasible);
     1787  /// Return strong info
     1788  inline const int * strongInfo() const
     1789  { return strongInfo_;}
     1790
     1791  /// Return mutable strong info
     1792  inline int * mutableStrongInfo()
     1793  { return strongInfo_;}
     1794
    17751795  /// Says whether all dynamic integers
    17761796  inline bool allDynamic () const { return ((ownership_&0x40000000)!=0) ; }
     
    18821902  */
    18831903  int stateOfSearch_;
     1904  /// At which depths to do cuts
     1905  int whenCuts_;
    18841906  /// Hotstart solution
    18851907  double * hotstartSolution_;
     
    21612183  /// Number of iterations in strong branching
    21622184  int numberStrongIterations_;
    2163   /** 0 - number times strong branching done, 1 - number fixed, 2 - number infeasible */
    2164   int strongInfo_[3];
     2185  /** 0 - number times strong branching done, 1 - number fixed, 2 - number infeasible
     2186      Second group of three is a snapshot at node [6] */
     2187  int strongInfo_[7];
    21652188  /**
    21662189      For advanced applications you may wish to modify the behavior of Cbc
  • trunk/Cbc/src/CbcSolver.cpp

    r1008 r1013  
    509509  parameters_[whichParam(COMBINE,numberParameters_,parameters_)].setCurrentOption("on");
    510510  parameters_[whichParam(RINS,numberParameters_,parameters_)].setCurrentOption("off");
     511  parameters_[whichParam(DINS,numberParameters_,parameters_)].setCurrentOption("off");
    511512  parameters_[whichParam(RENS,numberParameters_,parameters_)].setCurrentOption("off");
    512513  parameters_[whichParam(LOCALTREE,numberParameters_,parameters_)].setCurrentOption("off");
     
    32063207  parameters[whichParam(COMBINE,numberParameters,parameters)].setCurrentOption("on");
    32073208  parameters[whichParam(RINS,numberParameters,parameters)].setCurrentOption("off");
     3209  parameters[whichParam(DINS,numberParameters,parameters)].setCurrentOption("off");
    32083210  parameters[whichParam(RENS,numberParameters,parameters)].setCurrentOption("off");
    32093211  parameters[whichParam(LOCALTREE,numberParameters,parameters)].setCurrentOption("off");
     
    32343236  int useRINS = parameters_[whichParam(RINS,numberParameters_,parameters_)].currentOptionAsInteger();
    32353237  int useRENS = parameters_[whichParam(RENS,numberParameters_,parameters_)].currentOptionAsInteger();
     3238  int useDINS = parameters_[whichParam(DINS,numberParameters_,parameters_)].currentOptionAsInteger();
    32363239  int useDIVING2 = parameters_[whichParam(DIVINGS,numberParameters_,parameters_)].currentOptionAsInteger();
    32373240  // FPump done first as it only works if no solution
     
    33783381      heuristic5.setDecayFactor(1.5);
    33793382    model->addHeuristic(&heuristic5) ;
     3383    anyToDo=true;
     3384  }
     3385  if (useDINS>=kType) {
     3386    CbcHeuristicDINS heuristic5a(*model);
     3387    heuristic5a.setHeuristicName("DINS");
     3388    heuristic5a.setFractionSmall(0.6);
     3389    if (useDINS==1)
     3390      heuristic5a.setDecayFactor(5.0);
     3391    else
     3392      heuristic5a.setDecayFactor(1.5);
     3393    heuristic5a.setNumberNodes(1000);
     3394    model->addHeuristic(&heuristic5a) ;
    33803395    anyToDo=true;
    33813396  }
     
    46804695              break;
    46814696            case RINS:
     4697              break;
     4698            case DINS:
    46824699              break;
    46834700            case RENS:
     
    93249341              }
    93259342              if (fp) {
     9343                if (printMode!=5) {
     9344                  // Write solution header (suggested by Luigi Poderico)
     9345                  double objValue = lpSolver->getObjValue()*lpSolver->getObjSense();
     9346                  int iStat = lpSolver->status();
     9347                  if (iStat==0) {
     9348                    fprintf(fp, "Optimal" );
     9349                  } else if (iStat==1) {
     9350                    // infeasible
     9351                    fprintf(fp, "Infeasible" );
     9352                  } else if (iStat==2) {
     9353                    // unbounded
     9354                    fprintf(fp, "Unbounded" );
     9355                  } else if (iStat==3) {
     9356                    fprintf(fp, "Stopped on iterations or time" );
     9357                  } else if (iStat==4) {
     9358                    fprintf(fp, "Stopped on difficulties" );
     9359                  } else if (iStat==5) {
     9360                    fprintf(fp, "Stopped on ctrl-c" );
     9361                  } else {
     9362                    fprintf(fp, "Status unknown" );
     9363                  }
     9364                  fprintf(fp, " - objective value %15.8g\n", objValue);
     9365                }
    93269366                // make fancy later on
    93279367                int iRow;
Note: See TracChangeset for help on using the changeset viewer.