Ignore:
Timestamp:
Nov 1, 2007 4:12:08 PM (13 years ago)
Author:
forrest
Message:

changes to heuristics and allow collection of more statistics

File:
1 edited

Legend:

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

    r822 r833  
    6161#include "CglDuplicateRow.hpp"
    6262#include "CglStored.hpp"
     63#include "CglClique.hpp"
    6364
    6465#include "CoinTime.hpp"
     
    603604        printf("Problem type is %d\n",problemType_);
    604605#endif
     606      }
     607    }
     608    // But try again
     609    if (continuousMultiplier<1.0) {
     610      memset(rhs,0,numberRows*sizeof(double));
     611      int * count = new int [numberRows];
     612      memset(count,0,numberRows*sizeof(int));
     613      for (iColumn=0;iColumn<numberColumns;iColumn++) {
     614        CoinBigIndex start = columnStart[iColumn];
     615        CoinBigIndex end = start + columnLength[iColumn];
     616        if (upper[iColumn]==lower[iColumn]) {
     617          for (CoinBigIndex j=start;j<end;j++) {
     618            int iRow = row[j];
     619            rhs[iRow] += lower[iColumn]*element[j];
     620          }
     621        } else if (solver_->isInteger(iColumn)) {
     622          for (CoinBigIndex j=start;j<end;j++) {
     623            int iRow = row[j];
     624            if (fabs(element[j]-floor(element[j]+0.5))>1.0e-10)
     625              rhs[iRow]  = COIN_DBL_MAX;
     626          }
     627        } else {
     628          for (CoinBigIndex j=start;j<end;j++) {
     629            int iRow = row[j];
     630            count[iRow]++;
     631            if (fabs(element[j])!=1.0)
     632              rhs[iRow]  = COIN_DBL_MAX;
     633          }
     634        }
     635      }
     636      // now look at continuous
     637      bool allGood=true;
     638      double direction = solver_->getObjSense() ;
     639      int numberObj=0;
     640      for (iColumn=0;iColumn<numberColumns;iColumn++) {
     641        if (upper[iColumn]>lower[iColumn]) {
     642          double objValue = objective[iColumn]*direction;
     643          if (objValue&&!solver_->isInteger(iColumn)) {
     644            numberObj++;
     645            CoinBigIndex start = columnStart[iColumn];
     646            CoinBigIndex end = start + columnLength[iColumn];
     647            if (objValue>0.0) {
     648              // wants to be as low as possible
     649              if (lower[iColumn]<-1.0e10||fabs(lower[iColumn]-floor(lower[iColumn]+0.5))>1.0e-10) {
     650                allGood=false;
     651                break;
     652              } else if (upper[iColumn]<1.0e10&&fabs(upper[iColumn]-floor(upper[iColumn]+0.5))>1.0e-10) {
     653                allGood=false;
     654                break;
     655              }
     656              bool singletonRow=true;
     657              bool equality=false;
     658              for (CoinBigIndex j=start;j<end;j++) {
     659                int iRow = row[j];
     660                if (count[iRow]>1)
     661                  singletonRow=false;
     662                else if (rowLower[iRow]==rowUpper[iRow])
     663                  equality=true;
     664                if (fabs(rhs[iRow])>1.0e20||fabs(rhs[iRow]-floor(rhs[iRow]+0.5))>1.0e-10
     665                    ||fabs(element[j])!=1.0) {
     666                  // no good
     667                  allGood=false;
     668                  break;
     669                }
     670                if (element[j]>0.0) {
     671                  if (rowLower[iRow]>-1.0e20&&fabs(rowLower[iRow]-floor(rowLower[iRow]+0.5))>1.0e-10) {
     672                    // no good
     673                    allGood=false;
     674                    break;
     675                  }
     676                } else {
     677                  if (rowUpper[iRow]<1.0e20&&fabs(rowUpper[iRow]-floor(rowUpper[iRow]+0.5))>1.0e-10) {
     678                    // no good
     679                    allGood=false;
     680                    break;
     681                  }
     682                }
     683              }
     684              if (!singletonRow&&end>start+1&&!equality)
     685                allGood=false;
     686              if (!allGood)
     687                break;
     688            } else {
     689              // wants to be as high as possible
     690              if (upper[iColumn]>1.0e10||fabs(upper[iColumn]-floor(upper[iColumn]+0.5))>1.0e-10) {
     691                allGood=false;
     692                break;
     693              } else if (lower[iColumn]>-1.0e10&&fabs(lower[iColumn]-floor(lower[iColumn]+0.5))>1.0e-10) {
     694                allGood=false;
     695                break;
     696              }
     697              bool singletonRow=true;
     698              bool equality=false;
     699              for (CoinBigIndex j=start;j<end;j++) {
     700                int iRow = row[j];
     701                if (count[iRow]>1)
     702                  singletonRow=false;
     703                else if (rowLower[iRow]==rowUpper[iRow])
     704                  equality=true;
     705                if (fabs(rhs[iRow])>1.0e20||fabs(rhs[iRow]-floor(rhs[iRow]+0.5))>1.0e-10
     706                    ||fabs(element[j])!=1.0) {
     707                  // no good
     708                  allGood=false;
     709                  break;
     710                }
     711                if (element[j]<0.0) {
     712                  if (rowLower[iRow]>-1.0e20&&fabs(rowLower[iRow]-floor(rowLower[iRow]+0.5))>1.0e-10) {
     713                    // no good
     714                    allGood=false;
     715                    break;
     716                  }
     717                } else {
     718                  if (rowUpper[iRow]<1.0e20&&fabs(rowUpper[iRow]-floor(rowUpper[iRow]+0.5))>1.0e-10) {
     719                    // no good
     720                    allGood=false;
     721                    break;
     722                  }
     723                }
     724              }
     725              if (!singletonRow&&end>start+1&&!equality)
     726                allGood=false;
     727              if (!allGood)
     728                break;
     729            }
     730          }
     731        }
     732      }
     733      if (allGood) {
     734        if (numberObj)
     735          printf("YYYY analysis says all continuous with costs will be integer\n");
     736        continuousMultiplier=1.0;
    605737      }
    606738    }
     
    9211053  if (eventHandler)
    9221054    eventHandler->setModel(this);
     1055#ifdef CLIQUE_ANALYSIS
    9231056  // set up for probing
    924   //probingInfo_ = new CglTreeProbingInfo(solver_);
     1057  probingInfo_ = new CglTreeProbingInfo(solver_);
     1058#else
    9251059  probingInfo_=NULL;
     1060#endif
    9261061
    9271062  // Try for dominated columns
     
    14021537  //solverCharacteristics_->setSolver(solver_);
    14031538  if (feasible) {
     1539    if (probingInfo_) {
     1540      int number01 = probingInfo_->numberIntegers();
     1541      //const fixEntry * entry = probingInfo_->fixEntries();
     1542      const int * toZero = probingInfo_->toZero();
     1543      //const int * toOne = probingInfo_->toOne();
     1544      //const int * integerVariable = probingInfo_->integerVariable();
     1545      if (toZero[number01]) {
     1546        for (int i = 0;i<numberCutGenerators_;i++) {
     1547          CglFakeClique * clique = dynamic_cast<CglFakeClique*>(generator_[i]->generator());
     1548          if (clique) {
     1549            OsiSolverInterface * fakeSolver = probingInfo_->analyze(*solver_,1);
     1550            if (fakeSolver) {
     1551              printf("Probing fake solver has %d rows\n",fakeSolver->getNumRows());
     1552              //if (fakeSolver)
     1553              //fakeSolver->writeMps("bad");
     1554              if (generator_[i]->numberCutsInTotal())
     1555                generator_[i]->setHowOften(1);
     1556            }
     1557            clique->assignSolver(fakeSolver);
     1558            //stored->setProbingInfo(probingInfo_);
     1559            break;
     1560          }
     1561        }
     1562      }
     1563      delete probingInfo_;
     1564      probingInfo_=NULL;
     1565    }
    14041566    newNode = new CbcNode ;
    14051567    // Set objective value (not so obvious if NLP etc)
     
    19002062      }
    19012063    }
    1902     // If no solution but many nodes - signal change in strategy
    1903     if (numberNodes_>2*numberObjects_+1000&&stateOfSearch_!=2)
    1904       stateOfSearch_=3;
    19052064    // See if can stop on gap
    19062065    double testGap = CoinMax(dblParam_[CbcAllowableGap],
     
    21992358            OsiCuts theseCuts;
    22002359            // reset probing info
    2201             if (probingInfo_)
    2202               probingInfo_->initializeFixing();
     2360            //if (probingInfo_)
     2361            //probingInfo_->initializeFixing();
    22032362            for (int i = 0;i<numberCutGenerators_;i++) {
    22042363              bool generate = generator_[i]->normal();
     
    60726231      generator_[i]->incrementNumberCutsInTotal(countRowCuts[i]);
    60736232      generator_[i]->incrementNumberCutsActive(count[i]);
     6233      CglStored * stored = dynamic_cast<CglStored*>(generator_[i]->generator());
     6234      if (stored&&!countRowCuts[i])
     6235        continue;
    60746236      if (handler_->logLevel()>1||!numberNodes_) {
    60756237        handler_->message(CBC_GENERATOR,messages_)
     
    77597921        int lastNumberCuts=0;
    77607922        // reset probing info
    7761         if (probingInfo_)
    7762           probingInfo_->initializeFixing();
     7923        //if (probingInfo_)
     7924        //probingInfo_->initializeFixing();
    77637925        for (i=0;i<numberCutGenerators_;i++)
    77647926          {
     
    79098071        numberHeuristicSolutions_++;
    79108072      numberSolutions_++;
    7911       if (numberHeuristicSolutions_==numberSolutions_)
    7912         stateOfSearch_ = 1;
    7913       else
    7914         stateOfSearch_ = 2;
    79158073
    79168074      if (how!=CBC_ROUNDING) {
     
    79398097      int lastNumberCuts=0;
    79408098      // reset probing info
    7941       if (probingInfo_)
    7942         probingInfo_->initializeFixing();
     8099      //if (probingInfo_)
     8100      //probingInfo_->initializeFixing();
    79438101      for (i=0;i<numberCutGenerators_;i++) {
    79448102        bool generate = generator_[i]->atSolution();
     
    80798237     
    80808238        numberSolutions_++;
    8081         if (numberNodes_== 0 || numberHeuristicSolutions_==numberSolutions_)
    8082           stateOfSearch_ = 1;
    8083         else
    8084           stateOfSearch_ = 2;
    80858239       
    80868240        if (how!=CBC_ROUNDING) {
     
    82958449  int iGen;
    82968450  // reset probing info
    8297   if (probingInfo_)
    8298     probingInfo_->initializeFixing();
     8451  //if (probingInfo_)
     8452  //probingInfo_->initializeFixing();
    82998453  for (iGen=0;iGen<numberCutGenerators_;iGen++) {
    83008454    generator = dynamic_cast<CglProbing*>(generator_[iGen]->generator());
     
    97539907                       OsiSolverBranch * & branches)
    97549908{
     9909  // Set state of search
     9910  /*
     9911    0 - outside CbcNode
     9912    1 - no solutions
     9913    2 - all heuristic solutions
     9914    3 - a solution reached by branching (could be strong)
     9915    4 - no solution but many nodes
     9916       add 10 if depth >= K
     9917  */
     9918  stateOfSearch_=1;
     9919  if (numberSolutions_>0) {
     9920    if (numberHeuristicSolutions_==numberSolutions_)
     9921      stateOfSearch_ = 3;
     9922    else
     9923      stateOfSearch_ = 3;
     9924  } if (numberNodes_>2*numberObjects_+1000) {
     9925    stateOfSearch_=4;
     9926  }
     9927  //stateOfSearch_=3;
     9928  if (currentNode_&&currentNode_->depth()>=8)
     9929    stateOfSearch_ +=10;
    97559930  int anyAction =-1 ;
    97569931  resolved = false ;
     
    990110076    }
    990210077  }
     10078  stateOfSearch_ =0; // outside chooseBranch
    990310079  return anyAction;
    990410080}
     
    1076410940        OsiCuts theseCuts;
    1076510941        // reset probing info
    10766         if (probingInfo_)
    10767           probingInfo_->initializeFixing();
     10942        //if (probingInfo_)
     10943        //probingInfo_->initializeFixing(solver_);
    1076810944        for (int i = 0;i<numberCutGenerators_;i++) {
    1076910945          bool generate = generator_[i]->normal();
Note: See TracChangeset for help on using the changeset viewer.