Changeset 983


Ignore:
Timestamp:
Jun 17, 2008 3:48:28 AM (11 years ago)
Author:
forrest
Message:

random number generator to CbcModel? and allow cut pruning on size

Location:
trunk/Cbc/src
Files:
3 edited

Legend:

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

    r931 r983  
    244244        generator->generateCutsAndModify(*solver,cs,info2);
    245245      } else {
    246         generator->generateCutsAndModify(*solver,cs,&info);
     246        if ((numberTimes_==200||(numberTimes_>200&&(numberTimes_%2000)==0))
     247             &&!model_->parentModel()&&false) {
     248          // in tree, maxStack, maxProbe
     249          int test[]= {
     250            100123,
     251            199999,
     252            200123,
     253            299999,
     254            500123,
     255            599999,
     256            1000123,
     257            1099999,
     258            2000123,
     259            2099999};
     260          int n = (int) (sizeof(test)/sizeof(int));
     261          int saveStack = generator->getMaxLook();
     262          int saveNumber = generator->getMaxProbe();
     263          int kr1=0;
     264          int kc1=0;
     265          int bestStackTree=-1;
     266          int bestNumberTree=-1;
     267          for (int i=0;i<n;i++) {
     268            OsiCuts cs2 = cs;
     269            int stack = test[i]/100000;
     270            int number = test[i] - 100000*stack;
     271            generator->setMaxLook(stack);
     272            generator->setMaxProbe(number);
     273            generator_->generateCuts(*solver,cs2,info);
     274            int numberRowCuts = cs2.sizeRowCuts()-numberRowCutsBefore ;
     275            int numberColumnCuts= cs2.sizeColCuts()-numberColumnCutsBefore ;
     276            if (numberRowCuts<kr1||numberColumnCuts<kc1)
     277              printf("Odd ");
     278            if (numberRowCuts>kr1||numberColumnCuts>kc1) {
     279              printf("*** ");
     280              kr1=numberRowCuts;
     281              kc1=numberColumnCuts;
     282              bestStackTree=stack;
     283              bestNumberTree=number;
     284            }
     285            printf("maxStack %d number %d gives %d row cuts and %d column cuts\n",
     286                   stack,number,numberRowCuts,numberColumnCuts);
     287          }
     288          generator->setMaxLook(saveStack);
     289          generator->setMaxProbe(saveNumber);
     290          if (bestStackTree>0) {
     291            generator->setMaxLook(bestStackTree);
     292            generator->setMaxProbe(bestNumberTree);
     293            printf("RRNumber %d -> %d, stack %d -> %d\n",
     294                   saveNumber,bestNumberTree,saveStack,bestStackTree);
     295          } else {
     296            // no good
     297            generator->setMaxLook(1);
     298            printf("RRSwitching off number %d -> %d, stack %d -> %d\n",
     299                   saveNumber,saveNumber,saveStack,1);
     300          }
     301        }
     302        if (generator->getMaxLook()>0)
     303          generator->generateCutsAndModify(*solver,cs,&info);
    247304      }
    248305      const double * tightLower = generator->tightLower();
     
    414471#endif
    415472        numberColumnCuts_ += numberColumnCutsAfter-numberColumnCutsBefore;
     473      }
     474    }
     475    {
     476      int numberRowCutsAfter = cs.sizeRowCuts() ;
     477      int k ;
     478      int nEls=0;
     479      int nCuts= numberRowCutsAfter-numberRowCutsBefore;
     480      for (k = numberRowCutsBefore;k<numberRowCutsAfter;k++) {
     481        OsiRowCut thisCut = cs.rowCut(k) ;
     482        int n=thisCut.row().getNumElements();
     483        nEls+= n;
     484      }
     485      //printf("%s has %d cuts and %d elements\n",generatorName_,
     486      //     nCuts,nEls);
     487      int nElsNow = solver->getMatrixByCol()->getNumElements();
     488      if (nEls*8>nElsNow+8000+10000000) {
     489        //printf("need to remove cuts\n");
     490        // just add most effective
     491        int numberColumns = solver->getNumCols();
     492        int nReasonable = CoinMax(5*numberColumns,nElsNow/8);
     493        int nDelete = nEls - nReasonable;
     494        nElsNow = nEls;
     495        const double * solution = solver->getColSolution();
     496        double * sort = new double [nCuts];
     497        int * which = new int [nCuts];
     498        for (k = numberRowCutsBefore;k<numberRowCutsAfter;k++) {
     499          OsiRowCut thisCut = cs.rowCut(k) ;
     500          double sum=0.0;
     501          if (thisCut.lb()<=thisCut.ub()) {
     502            int n=thisCut.row().getNumElements();
     503            const int * column = thisCut.row().getIndices();
     504            const double * element = thisCut.row().getElements();
     505            assert (n);
     506            for (int i=0;i<n;i++) {
     507              double value = element[i];
     508              sum += value*solution[column[i]];
     509            }
     510            if (sum>thisCut.ub()) {
     511              sum= sum-thisCut.ub();
     512            } else if (sum<thisCut.lb()) {
     513              sum= thisCut.lb()-sum;
     514            } else {
     515              printf("ffffffffffffffff odd\n");
     516              sum=0.0;
     517            }
     518          } else {
     519            // keep
     520            sum=COIN_DBL_MAX;
     521          }
     522          sort[k-numberRowCutsBefore]=sum;
     523          which[k-numberRowCutsBefore]=k;
     524        }
     525        CoinSort_2(sort,sort+nCuts,which);
     526        k=0;
     527        while (nDelete>0) {
     528          int iCut=which[k];
     529          OsiRowCut thisCut = cs.rowCut(iCut) ;
     530          int n=thisCut.row().getNumElements();
     531          nDelete-=n;
     532          k++;
     533        }
     534        std::sort(which,which+k);
     535        k--;
     536        for (;k>=0;k--) {
     537          cs.eraseRowCut(which[k]);
     538        }
     539        delete [] sort;
     540        delete [] which;
     541        int numberRowCutsAfter = cs.sizeRowCuts() ;
     542        nEls=0;
     543        nCuts= numberRowCutsAfter-numberRowCutsBefore;
     544        for (k = numberRowCutsBefore;k<numberRowCutsAfter;k++) {
     545          OsiRowCut thisCut = cs.rowCut(k) ;
     546          int n=thisCut.row().getNumElements();
     547          nEls+= n;
     548        }
     549        printf("%s NOW has %d cuts and %d elements( down from %d els)\n",
     550               generatorName_,
     551               nCuts,nEls,nElsNow);
    416552      }
    417553    }
  • trunk/Cbc/src/CbcModel.cpp

    r979 r983  
    24172417          numberSolutions_ < intParam_[CbcMaxNumSol] &&
    24182418          totalTime < maxSeconds &&
    2419           !stoppedOnGap_&&!eventHappened_)) {
     2419          !stoppedOnGap_&&!eventHappened_&&(maximumNumberIterations_<0||
     2420                                            numberIterations_<maximumNumberIterations_))) {
    24202421      // out of loop
    24212422      break;
     
    39933994  numberStrongIterations_(0),
    39943995  resolveAfterTakeOffCuts_(true),
     3996  maximumNumberIterations_(-1),
    39953997#if NEW_UPDATE_OBJECT>1
    39963998  numberUpdateItems_(0),
     
    41394141  numberStrongIterations_(0),
    41404142  resolveAfterTakeOffCuts_(true),
     4143  maximumNumberIterations_(-1),
    41414144#if NEW_UPDATE_OBJECT>1
    41424145  numberUpdateItems_(0),
     
    43714374  numberStrongIterations_(rhs.numberStrongIterations_),
    43724375  resolveAfterTakeOffCuts_(rhs.resolveAfterTakeOffCuts_),
     4376  maximumNumberIterations_(rhs.maximumNumberIterations_),
    43734377#if NEW_UPDATE_OBJECT>1
    43744378  numberUpdateItems_(rhs.numberUpdateItems_),
     
    44974501  messageHandler()->setLogLevel(rhs.messageHandler()->logLevel());
    44984502  numberIntegers_=rhs.numberIntegers_;
     4503  randomNumberGenerator_ = rhs.randomNumberGenerator_;
    44994504  if (numberIntegers_) {
    45004505    integerVariable_ = new int [numberIntegers_];
     
    46944699    maximumRows_=0;
    46954700    currentDepth_ = 0;
     4701    randomNumberGenerator_ = rhs.randomNumberGenerator_;
    46964702    workingBasis_ = CoinWarmStartBasis();
    46974703    for (i=0;i<maximumStatistics_;i++)
     
    47104716    numberNewCuts_ = rhs.numberNewCuts_;
    47114717    resolveAfterTakeOffCuts_=rhs.resolveAfterTakeOffCuts_;
     4718    maximumNumberIterations_ = rhs.maximumNumberIterations_;
    47124719#if NEW_UPDATE_OBJECT>1
    47134720    numberUpdateItems_ = rhs.numberUpdateItems_;
     
    50475054  preferredWay_ = rhs.preferredWay_;
    50485055  resolveAfterTakeOffCuts_ = rhs.resolveAfterTakeOffCuts_;
     5056  maximumNumberIterations_ = rhs.maximumNumberIterations_;
    50495057  numberThreads_ = rhs.numberThreads_;
    50505058  threadMode_ = rhs.threadMode_;
  • trunk/Cbc/src/CbcModel.hpp

    r961 r983  
    17451745  inline CglTreeProbingInfo * probingInfo() const
    17461746  { return probingInfo_;}
     1747  /// Thread specific random number generator
     1748  inline CoinThreadRandom * randomNumberGenerator()
     1749  { return &randomNumberGenerator_;}
    17471750  /// Set the number of iterations done in strong branching.
    17481751  inline void setNumberStrongIterations(int number)
     
    17511754  inline int numberStrongIterations() const
    17521755  { return numberStrongIterations_;}
     1756  /// Get maximum number of iterations (designed to be used in heuristics)
     1757  inline int maximumNumberIterations() const
     1758  { return maximumNumberIterations_;}
     1759  /// Set maximum number of iterations (designed to be used in heuristics)
     1760  inline void setMaximumNumberIterations(int value)
     1761  { maximumNumberIterations_ = value;}
    17531762# ifdef COIN_HAS_CLP
    17541763  /// Set depth for fast nodes
     
    21162125  /// Current depth
    21172126  int currentDepth_;
     2127  /// Thread specific random number generator
     2128  mutable CoinThreadRandom randomNumberGenerator_;
    21182129  /// Work basis for temporary use
    21192130  CoinWarmStartBasis workingBasis_;
     
    21612172  /// Whether to force a resolve after takeOffCuts
    21622173  bool resolveAfterTakeOffCuts_;
     2174  /// Maximum number of iterations (designed to be used in heuristics)
     2175  int maximumNumberIterations_;
    21632176#if NEW_UPDATE_OBJECT>1
    21642177  /// Number of outstanding update information items
Note: See TracChangeset for help on using the changeset viewer.