Changeset 1263


Ignore:
Timestamp:
Oct 31, 2009 2:47:55 PM (10 years ago)
Author:
lou
Message:

Sync with cbc trunk r1262.

Location:
branches/reeng/Cbc/src
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • branches/reeng/Cbc/src/CbcCutGenerator.cpp

    r1230 r1263  
    246246    if (fullScan<0)
    247247      info.options |= 128;
     248    // See if we want alternate set of cuts
     249    if ((model_->moreSpecialOptions()&16384)!=0)
     250      info.options |=256;
     251    if(model_->parentModel())
     252      info.options |=512;
     253    // above had &&!model_->parentModel()&&depth<2)
    248254    incrementNumberTimesEntered();
    249255    CglProbing* generator =
     
    625631          nReasonable += nElsNow/2;
    626632        }
     633        //if (!depth&&ineffectualCuts())
     634        //nReasonable *= 2;
    627635      } else {
    628636        nAdd = 200;
  • branches/reeng/Cbc/src/CbcHeuristic.cpp

    r1224 r1263  
    10951095            //printf("added seren\n");
    10961096          } else {
     1097            double value = model_->getMinimizationObjValue();
     1098            model.setCutoff(value+1.0e-7*(1.0+fabs(value)));
    10971099#ifdef CLP_INVESTIGATE
    10981100            printf("NOT added seren\n");
  • branches/reeng/Cbc/src/CbcHeuristicLocal.cpp

    r1212 r1263  
    4141  }
    4242  int numberColumns = model.solver()->getNumCols();
    43   used_ = new char[numberColumns];
    44   memset(used_,0,numberColumns);
     43  used_ = new int[numberColumns];
     44  memset(used_,0,numberColumns*sizeof(int));
    4545}
    4646
     
    8282  if (model_&&rhs.used_) {
    8383    int numberColumns = model_->solver()->getNumCols();
    84     used_ = new char[numberColumns];
    85     memcpy(used_,rhs.used_,numberColumns);
     84    used_ = CoinCopyOfArray(rhs.used_,numberColumns);
    8685  } else {
    8786    used_=NULL;
     
    101100    if (model_&&rhs.used_) {
    102101      int numberColumns = model_->solver()->getNumCols();
    103       used_ = new char[numberColumns];
    104       memcpy(used_,rhs.used_,numberColumns);
     102      used_ = CoinCopyOfArray(rhs.used_,numberColumns);
    105103    } else {
    106104      used_=NULL;
     
    118116  if (model_&&used_) {
    119117    int numberColumns = model_->solver()->getNumCols();
    120     used_ = new char[numberColumns];
    121     memset(used_,0,numberColumns);
     118    used_ = new int[numberColumns];
     119    memset(used_,0,numberColumns*sizeof(int));
    122120  } else {
    123121    used_=NULL;
     
    159157    }
    160158  }
    161   int returnCode = smallBranchAndBound(newSolver,numberNodes_,newSolution,objectiveValue,
    162                                          objectiveValue,"CbcHeuristicLocal");
    163   if (returnCode<0)
    164     returnCode=0; // returned on size
     159  int returnCode = 0;
     160  if (nFix*10>numberIntegers) {
     161    returnCode = smallBranchAndBound(newSolver,numberNodes_,newSolution,objectiveValue,
     162                                     objectiveValue,"CbcHeuristicLocal");
     163    if (returnCode<0) {
     164      returnCode=0; // returned on size
     165      int numberColumns=newSolver->getNumCols();
     166      int numberContinuous = numberColumns-numberIntegers;
     167      if (numberContinuous>2*numberIntegers&&
     168          nFix*10<numberColumns) {
     169#define LOCAL_FIX_CONTINUOUS
     170#ifdef LOCAL_FIX_CONTINUOUS
     171        //const double * colUpper = newSolver->getColUpper();
     172        const double * colLower = newSolver->getColLower();
     173        int nAtLb=0;
     174        //double sumDj=0.0;
     175        const double * dj = newSolver->getReducedCost();
     176        double direction=newSolver->getObjSense();
     177        for (int iColumn=0;iColumn<numberColumns;iColumn++) {
     178          if (!newSolver->isInteger(iColumn)) {
     179            if (!used_[iColumn]) {
     180              //double djValue = dj[iColumn]*direction;
     181              nAtLb++;
     182              //sumDj += djValue;
     183            }
     184          }
     185        }
     186        if (nAtLb) {
     187          // fix some continuous
     188          double * sort = new double[nAtLb];
     189          int * which = new int [nAtLb];
     190          //double threshold = CoinMax((0.01*sumDj)/static_cast<double>(nAtLb),1.0e-6);
     191          int nFix2=0;
     192          for (int iColumn=0;iColumn<numberColumns;iColumn++) {
     193            if (!newSolver->isInteger(iColumn)) {
     194              if (!used_[iColumn]) {
     195                double djValue = dj[iColumn]*direction;
     196                if (djValue>1.0e-6) {
     197                  sort[nFix2]=-djValue;
     198                  which[nFix2++]=iColumn;
     199                }
     200              }
     201            }
     202          }
     203          CoinSort_2(sort,sort+nFix2,which);
     204          int divisor=2;
     205          nFix2=CoinMin(nFix2,(numberColumns-nFix)/divisor);
     206          for (int i=0;i<nFix2;i++) {
     207            int iColumn = which[i];
     208            newSolver->setColUpper(iColumn,colLower[iColumn]);
     209          }
     210          delete [] sort;
     211          delete [] which;
     212#ifdef CLP_INVESTIGATE2
     213          printf("%d integers have zero value, and %d continuous fixed at lb\n",
     214                 nFix,nFix2);
     215#endif
     216          returnCode = smallBranchAndBound(newSolver,
     217                                           numberNodes_,newSolution,
     218                                           objectiveValue,
     219                                           objectiveValue,"CbcHeuristicLocal");
     220          if (returnCode<0)
     221            returnCode=0; // returned on size
     222        }
     223#endif
     224      }
     225    }
     226  }
    165227  if ((returnCode&2)!=0) {
    166228    // could add cut
     
    219281  double * newSolution = new double [numberColumns];
    220282  memcpy(newSolution,solution,numberColumns*sizeof(double));
     283#ifdef LOCAL_FIX_CONTINUOUS
     284  // mark continuous used
     285  const double * columnLower = solver->getColLower();
     286  for (int iColumn=0;iColumn<numberColumns;iColumn++) {
     287    if (!solver->isInteger(iColumn)) {
     288      if (solution[iColumn]>columnLower[iColumn]+1.0e-8)
     289        used_[iColumn]=numberSolutions_;
     290    }
     291  }
     292#endif
    221293
    222294  // way is 1 if down possible, 2 if up possible, 3 if both possible
     
    252324    // if away from lower bound mark that fact
    253325    if (nearest>originalLower) {
    254       used_[iColumn]=1;
     326      used_[iColumn]=numberSolutions_;
    255327    }
    256328    cost[i] = direction*objective[iColumn];
     
    550622          // if away from lower bound mark that fact
    551623          if (value>originalLower) {
    552             used_[iColumn]=1;
     624            used_[iColumn]=numberSolutions_;
    553625          }
    554626        }
     
    577649  delete [] mark;
    578650  if (numberSolutions_>1&&swap_==1) {
    579     int i;
    580     for ( i=0;i<numberColumns;i++) {
    581       if (used_[i]>1)
    582         break;
    583     }
    584     if (i==numberColumns) {
    585       // modify used_ if just one
    586       const int * used = model_->usedInSolution();
    587       for (int i=0;i<numberColumns;i++)
    588         used_[i]= static_cast<char>(CoinMin(used[i],255));
    589     }
    590651    // try merge
    591652    int returnCode2=solutionFix( solutionValue, betterSolution,NULL);
     
    606667  delete [] used_;
    607668  int numberColumns = model->solver()->getNumCols();
    608   used_ = new char[numberColumns];
    609   memset(used_,0,numberColumns);
     669  used_ = new int[numberColumns];
     670  memset(used_,0,numberColumns*sizeof(int));
    610671}
    611672// Default Constructor
  • branches/reeng/Cbc/src/CbcHeuristicLocal.hpp

    r1212 r1263  
    6464  { swap_=value;}
    6565  /// Used array so we can set
    66   inline char * used() const
     66  inline int * used() const
    6767  { return used_;}
    6868
     
    7777  // Type of search 0=normal, 1=BAB
    7878  int swap_;
    79   /// Whether a variable has been in a solution
    80   char * used_;
     79  /// Whether a variable has been in a solution (also when)
     80  int * used_;
    8181};
    8282
  • branches/reeng/Cbc/src/CbcHeuristicRINS.cpp

    r1240 r1263  
    2626  numberSuccesses_=0;
    2727  numberTries_=0;
     28  stateOfFixing_ =0;
    2829  lastNode_=-999999;
    2930  howOften_=100;
     
    4142  numberSuccesses_=0;
    4243  numberTries_=0;
     44  stateOfFixing_ =0;
    4345  lastNode_=-999999;
    4446  howOften_=100;
     
    7476    numberSuccesses_ = rhs.numberSuccesses_;
    7577    numberTries_ = rhs.numberTries_;
     78    stateOfFixing_ = rhs.stateOfFixing_;
    7679    lastNode_=rhs.lastNode_;
    7780    delete [] used_;
     
    110113  numberSuccesses_(rhs.numberSuccesses_),
    111114  numberTries_(rhs.numberTries_),
     115  stateOfFixing_(rhs.stateOfFixing_),
    112116  lastNode_(rhs.lastNode_)
    113117{
     
    126130  //CbcHeuristic::resetModel(model);
    127131  delete [] used_;
     132  stateOfFixing_ = 0;
    128133  if (model_&&used_) {
    129134    int numberColumns = model_->solver()->getNumCols();
     
    193198    const double * currentSolution = solver->getColSolution();
    194199    OsiSolverInterface * newSolver = cloneBut(3); // was model_->continuousSolver()->clone();
    195     //const double * colLower = newSolver->getColLower();
    196     //const double * colUpper = newSolver->getColUpper();
     200    int numberColumns=newSolver->getNumCols();
     201    int numberContinuous = numberColumns-numberIntegers;
    197202
    198203    double primalTolerance;
     
    221226      }
    222227    }
    223     if (nFix>numberIntegers/5) {
     228    int divisor=0;
     229    if (5*nFix>numberIntegers) {
     230      if (numberContinuous>2*numberIntegers&&nFix*10<numberColumns&&
     231          ((!numRuns_&&numberTries_>2)||stateOfFixing_)) {
     232#define RINS_FIX_CONTINUOUS
     233#ifdef RINS_FIX_CONTINUOUS
     234        const double * colLower = newSolver->getColLower();
     235        //const double * colUpper = newSolver->getColUpper();
     236        int nAtLb=0;
     237        //double sumDj=0.0;
     238        const double * dj = newSolver->getReducedCost();
     239        double direction=newSolver->getObjSense();
     240        for (int iColumn=0;iColumn<numberColumns;iColumn++) {
     241          if (!newSolver->isInteger(iColumn)) {
     242            double value=bestSolution[iColumn];
     243            if (value<colLower[iColumn]+1.0e-8) {
     244              //double djValue = dj[iColumn]*direction;
     245              nAtLb++;
     246              //sumDj += djValue;
     247            }
     248          }
     249        }
     250        if (nAtLb) {
     251          // fix some continuous
     252          double * sort = new double[nAtLb];
     253          int * which = new int [nAtLb];
     254          //double threshold = CoinMax((0.01*sumDj)/static_cast<double>(nAtLb),1.0e-6);
     255          int nFix2=0;
     256          for (int iColumn=0;iColumn<numberColumns;iColumn++) {
     257            if (!newSolver->isInteger(iColumn)) {
     258              double value=bestSolution[iColumn];
     259              if (value<colLower[iColumn]+1.0e-8) {
     260                double djValue = dj[iColumn]*direction;
     261                if (djValue>1.0e-6) {
     262                  sort[nFix2]=-djValue;
     263                  which[nFix2++]=iColumn;
     264                }
     265              }
     266            }
     267          }
     268          CoinSort_2(sort,sort+nFix2,which);
     269          divisor=4;
     270          if (stateOfFixing_>0)
     271            divisor=stateOfFixing_;
     272          else if (stateOfFixing_<-1)
     273            divisor=(-stateOfFixing_)-1;
     274          nFix2=CoinMin(nFix2,(numberColumns-nFix)/divisor);
     275          for (int i=0;i<nFix2;i++) {
     276            int iColumn = which[i];
     277            newSolver->setColUpper(iColumn,colLower[iColumn]);
     278          }
     279          delete [] sort;
     280          delete [] which;
     281#ifdef CLP_INVESTIGATE2
     282          printf("%d integers have same value, and %d continuous fixed at lb\n",
     283                 nFix,nFix2);
     284#endif
     285        }
     286#endif
     287      }
    224288      //printf("%d integers have same value\n",nFix);
    225289      returnCode = smallBranchAndBound(newSolver,numberNodes_,betterSolution,solutionValue,
    226290                                         model_->getCutoff(),"CbcHeuristicRINS");
    227       if (returnCode<0)
     291      if (returnCode<0) {
    228292        returnCode=0; // returned on size
    229       else
     293        if (divisor)
     294          stateOfFixing_ = - divisor; // say failed
     295      } else {
    230296        numRuns_++;
     297        if (divisor)
     298          stateOfFixing_ =  divisor; // say small enough
     299      }
    231300      if ((returnCode&1)!=0)
    232301        numberSuccesses_++;
     
    239308        //printf("\n");
    240309      }
    241       numberTries_++;
    242       if ((numberTries_%10)==0&&numberSuccesses_*3<numberTries_)
    243         howOften_ += static_cast<int> (howOften_*decayFactor_);
    244     }
    245 
     310    }
     311
     312    numberTries_++;
     313    if ((numberTries_%10)==0&&numberSuccesses_*3<numberTries_)
     314      howOften_ += static_cast<int> (howOften_*decayFactor_);
    246315    delete newSolver;
    247316  }
     
    337406  int numberTightened=0;
    338407  int numberAtBound=0;
     408  int numberColumns=newSolver->getNumCols();
     409  int numberContinuous = numberColumns-numberIntegers;
    339410
    340411  for (i=0;i<numberIntegers;i++) {
     
    345416    value = CoinMax(value,lower);
    346417    value = CoinMin(value,upper);
     418#define RENS_FIX_ONLY_LOWER
     419#ifndef RENS_FIX_ONLY_LOWER
    347420    if (fabs(value-floor(value+0.5))<1.0e-8) {
    348421      value = floor(value+0.5);
     
    357430      newSolver->setColUpper(iColumn,ceil(value));
    358431    }
     432#else
     433    if (fabs(value-floor(value+0.5))<1.0e-8&&
     434        floor(value+0.5)==lower) {
     435      value = floor(value+0.5);
     436      numberAtBound++;
     437      newSolver->setColLower(iColumn,value);
     438      newSolver->setColUpper(iColumn,value);
     439      numberFixed++;
     440    } else if (colUpper[iColumn]-colLower[iColumn]>=2.0) {
     441      numberTightened++;
     442      if (fabs(value-floor(value+0.5))<1.0e-8) {
     443        value = floor(value+0.5);
     444        if (value<upper) {
     445          newSolver->setColLower(iColumn,CoinMax(value-1.0,lower));
     446          newSolver->setColUpper(iColumn,CoinMin(value+1.0,upper));
     447        } else {
     448          newSolver->setColLower(iColumn,upper-1.0);
     449        }
     450      } else {
     451        newSolver->setColLower(iColumn,floor(value));
     452        newSolver->setColUpper(iColumn,ceil(value));
     453      }
     454    }
     455#endif
    359456  }
    360457  if (numberFixed>numberIntegers/5) {
     458      if (numberContinuous>numberIntegers&&numberFixed<numberColumns/5) {
     459#define RENS_FIX_CONTINUOUS
     460#ifdef RENS_FIX_CONTINUOUS
     461        const double * colLower = newSolver->getColLower();
     462        //const double * colUpper = newSolver->getColUpper();
     463        int nAtLb=0;
     464        double sumDj=0.0;
     465        const double * dj = newSolver->getReducedCost();
     466        double direction=newSolver->getObjSense();
     467        for (int iColumn=0;iColumn<numberColumns;iColumn++) {
     468          if (!newSolver->isInteger(iColumn)) {
     469            double value=currentSolution[iColumn];
     470            if (value<colLower[iColumn]+1.0e-8) {
     471              double djValue = dj[iColumn]*direction;
     472              nAtLb++;
     473              sumDj += djValue;
     474            }
     475          }
     476        }
     477        if (nAtLb) {
     478          // fix some continuous
     479          double * sort = new double[nAtLb];
     480          int * which = new int [nAtLb];
     481          double threshold = CoinMax((0.01*sumDj)/static_cast<double>(nAtLb),1.0e-6);
     482          int nFix2=0;
     483          for (int iColumn=0;iColumn<numberColumns;iColumn++) {
     484            if (!newSolver->isInteger(iColumn)) {
     485              double value=currentSolution[iColumn];
     486              if (value<colLower[iColumn]+1.0e-8) {
     487                double djValue = dj[iColumn]*direction;
     488                if (djValue>threshold) {
     489                  sort[nFix2]=-djValue;
     490                  which[nFix2++]=iColumn;
     491                }
     492              }
     493            }
     494          }
     495          CoinSort_2(sort,sort+nFix2,which);
     496          nFix2=CoinMin(nFix2,(numberColumns-numberFixed)/2);
     497          for (int i=0;i<nFix2;i++) {
     498            int iColumn = which[i];
     499            newSolver->setColUpper(iColumn,colLower[iColumn]);
     500          }
     501          delete [] sort;
     502          delete [] which;
     503#ifdef CLP_INVESTIGATE2
     504          printf("%d integers fixed (%d tightened) (%d at bound), and %d continuous fixed at lb\n",
     505                 numberFixed,numberTightened,numberAtBound,nFix2);
     506#endif
     507        }
     508#endif
     509      }
    361510#ifdef COIN_DEVELOP
    362511    printf("%d integers fixed and %d tightened\n",numberFixed,numberTightened);
  • branches/reeng/Cbc/src/CbcHeuristicRINS.hpp

    r1240 r1263  
    7272  /// Number of tries
    7373  int numberTries_;
     74  /** State of fixing continuous variables -
     75      0 - not tried
     76      +n - this divisor makes small enough
     77      -n - this divisor still not small enough
     78  */
     79  int stateOfFixing_;
    7480  /// Node when last done
    7581  int lastNode_;
  • branches/reeng/Cbc/src/CbcModel.cpp

    r1255 r1263  
    1 
    21/* $Id$ */
    32// Copyright (C) 2002, International Business Machines
     
    76#  pragma warning(disable:4786)
    87#endif
    9 #define MODEL2 0
    10 #define MODEL4 0
    11 #define MODEL13 1
    128
    139#include "CbcConfig.h"
     
    521517      if (iPriority>=0) {
    522518        char general[200];
    523         if (cost==-COIN_DBL_MAX)
     519        if (cost==-COIN_DBL_MAX) {
    524520          sprintf(general,"%d integer variables out of %d objects (%d integer) have costs - high priority",
    525521                  numberIntegerObj,numberObjects_,numberInteger);
    526         else
     522        } else if (cost==COIN_DBL_MAX) {
     523          sprintf(general,"No integer variables out of %d objects (%d integer) have costs",
     524                  numberObjects_,numberInteger);
     525          branchOnSatisfied=false;
     526        } else {
    527527          sprintf(general,"%d integer variables out of %d objects (%d integer) have cost of %g - high priority",
    528528                  numberIntegerObj,numberObjects_,numberInteger,cost);
     529        }
    529530        messageHandler()->message(CBC_GENERAL,
    530531                                  messages())
     
    579580        }
    580581#endif
     582        CoinDrand48(true,1234567);
    581583        for (int i=0;i<numberColumns;i++) {
    582584          double lowerValue=lower[i];
     
    11431145  numberStrongIterations_ = 0;
    11441146  currentNode_ = NULL;
    1145   CoinThreadRandom randomGenerator(1234567);
    11461147  // See if should do cuts old way
    11471148  if (parallelMode()<0) {
     
    35963597      if (redoTree)
    35973598        tree_->setComparison(*nodeCompare_) ;
    3598 #if MODEL2
    3599       if (searchStrategy_==2) {
    3600         // may be time to tweak numberBeforeTrust
    3601         if (numberStrongIterations_*5<numberIterations_&&numberNodes_<10000) {
    3602           int numberDone = strongInfo_[0]-strongInfo_[3];
    3603           int numberFixed = strongInfo_[1]-strongInfo_[4];
    3604           int numberInfeasible = strongInfo_[2]-strongInfo_[5];
    3605           int numberNodes=numberNodes_-strongInfo_[6];
    3606           for (int i=0;i<7;i++)
    3607             printf("%d ",strongInfo_[i]);
    3608           printf("its %d strong %d\n",
    3609                  numberIterations_,numberStrongIterations_);
    3610           printf("done %d fixed %d inf %d in %d nodes\n",
    3611                  numberDone,numberFixed,numberInfeasible,numberNodes);
    3612           if (numberInfeasible*500+numberFixed*10>numberDone) {
    3613             synchronizeNumberBeforeTrust(1);
    3614             strongInfo_[3]=strongInfo_[0];
    3615             strongInfo_[4]=strongInfo_[1];
    3616             strongInfo_[5]=strongInfo_[2];
    3617             strongInfo_[6]=numberNodes_;
    3618           }
    3619         }
    3620       }
    3621 #endif
    36223599      if (parallelMode()>0)
    36233600        unlockThread();
     
    36513628          printf("model cutoff in status %g, best %g, increment %g\n",
    36523629                 getCutoff(),bestObjective_,getCutoffIncrement());
    3653         assert (getCutoff()<bestObjective_-getCutoffIncrement()+1.0e-6);
     3630        assert (getCutoff()<bestObjective_-getCutoffIncrement()+
     3631                1.0e-6+1.0e-10*fabs(bestObjective_));
    36543632      }
    36553633#endif
     
    66406618
    66416619{
    6642 #if MODEL4
     6620#if 0
    66436621  if (node&&numberTries>1) {
    66446622    if (currentDepth_<5)
     
    66486626  }
    66496627#endif
    6650 #if MODEL13
    66516628#define CUT_HISTORY 7
    66526629  double cut_obj[CUT_HISTORY];
    66536630  for (int j=0;j<CUT_HISTORY;j++)
    66546631         cut_obj[j]=-COIN_DBL_MAX;
    6655 #endif
    66566632# ifdef COIN_HAS_CLP
    66576633  OsiClpSolverInterface * clpSolver
     
    67456721#endif
    67466722  double lastObjective = solver_->getObjValue()*solver_->getObjSense();
    6747 #if MODEL13
    67486723  cut_obj[CUT_HISTORY-1]=lastObjective;
    6749 #endif
    67506724  //double firstObjective = lastObjective+1.0e-8+1.0e-12*fabs(lastObjective);
    67516725  if (node&&node->nodeInfo()&&!node->nodeInfo()->numberBranchesLeft())
     
    69396913  bool allowZeroIterations = false;
    69406914  int maximumBadPasses=0;
    6941 #if MODEL13==0
    6942   if (numberTries<0)
    6943   { numberTries = -numberTries ;
    6944     if (numberTries>100)
    6945       allowZeroIterations=true;
    6946     minimumDrop = -1.0 ; }
    6947 #else
    69486915  if (numberTries<0) {
    69496916    numberTries = -numberTries ;
     
    69536920      minimumDrop=-1.0;
    69546921    }
    6955     numberTries=CoinMax(numberTries,100);
     6922    //numberTries=CoinMax(numberTries,100);
    69566923    allowZeroIterations=true;
    69576924  }
    6958 #endif
    69596925/*
    69606926  Is it time to scan the cuts in order to remove redundant cuts? If so, set
     
    69766942  // We may need to keep going on
    69776943  bool keepGoing=false;
     6944  // Say we have not tried one last time
     6945  int numberLastAttempts=0;
     6946  /* Get experimental option as to when to stop adding cuts
     6947     0 - old style
     6948     1 - new style
     6949     2 - new style plus don't break if zero cuts first time
     6950     3 - as 2 but last drop has to be >0.1*min to say OK
     6951  */
     6952  int experimentBreak = (moreSpecialOptions_>>11)&3;
     6953  // Whether to increase minimum drop
     6954  bool increaseDrop = (moreSpecialOptions_&8192)!=0;
    69786955/*
    69796956  Begin cut generation loop. Cuts generated during each iteration are
     
    71567133        }
    71577134        if (generate) {
    7158 #if MODEL13
    71597135          if (!node&&cut_obj[CUT_HISTORY-1]!=-COIN_DBL_MAX&&
    71607136              fabs(cut_obj[CUT_HISTORY-1]-cut_obj[CUT_HISTORY-2])<1.0e-7)
    71617137            generator_[i]->setIneffectualCuts(true);
    7162 #endif
    71637138          bool mustResolve =
    71647139            generator_[i]->generateCuts(theseCuts,fullScan,solver_,node) ;
    7165 #if MODEL13
    71667140          generator_[i]->setIneffectualCuts(false);
    7167 #endif
    71687141          numberRowCutsAfter = theseCuts.sizeRowCuts() ;
    71697142          if (fullScan&&generator_[i]->howOften()==1000000+SCANCUTS_PROBING) {
     
    79497922  No cuts. Cut short the cut generation (numberTries) loop.
    79507923*/
    7951     else
     7924    else if (numberLastAttempts>2||experimentBreak<2)
    79527925      { numberTries = 0 ;}
    79537926/*
     
    79997972        lastNumberCuts = numberNewCuts_ ;
    80007973        double thisObj = direction*solver_->getObjValue();
    8001 #if MODEL13
    80027974        bool badObj = (allowZeroIterations) ? thisObj < cut_obj[0]+minimumDrop
    80037975          : thisObj < cut_obj[CUT_HISTORY-1]+minimumDrop;
     7976#if 0 // probably not a good idea
     7977        if (!badObj)
     7978          numberLastAttempts=CoinMax(0,numberLastAttempts-1);
     7979#endif
    80047980        // Compute maximum number of bad passes
    80057981        if (minimumDrop>0.0) {
     7982          if (increaseDrop) {
     7983            // slowly increase minimumDrop
     7984            if (currentPassNumber_==13)
     7985              minimumDrop = CoinMax(1.5*minimumDrop,1.0e-5*fabs(thisObj));
     7986            else if (currentPassNumber_>20&&(currentPassNumber_%5)==0)
     7987              minimumDrop = CoinMax(1.1*minimumDrop,1.0e-5*fabs(thisObj));
     7988            else if (currentPassNumber_>50)
     7989              minimumDrop = CoinMax(1.1*minimumDrop,1.0e-5*fabs(thisObj));
     7990          }
    80067991          int nBadPasses=0;
    8007           double test = 0.01*minimumDrop;
    8008           double goodDrop=COIN_DBL_MAX;
    8009           for (int j=CUT_HISTORY-1;j>=0;j--) {
    8010             if (thisObj-cut_obj[j]<test) {
    8011               nBadPasses++;
    8012             } else {
    8013               goodDrop=(thisObj-cut_obj[j])/static_cast<double>(nBadPasses+1);
    8014               break;
     7992          if (!experimentBreak) {
     7993            double test = 0.01*minimumDrop;
     7994            double goodDrop=COIN_DBL_MAX;
     7995            for (int j=CUT_HISTORY-1;j>=0;j--) {
     7996              if (thisObj-cut_obj[j]<test) {
     7997                nBadPasses++;
     7998              } else {
     7999                goodDrop=(thisObj-cut_obj[j])/static_cast<double>(nBadPasses+1);
     8000                break;
     8001              }
    80158002            }
     8003            maximumBadPasses=CoinMax(maximumBadPasses,nBadPasses);
     8004            if (nBadPasses<maximumBadPasses&&
     8005                goodDrop>minimumDrop)
     8006              badObj=false; // carry on
     8007          } else {
     8008            //if (currentPassNumber_==13||currentPassNumber_>50)
     8009            //minimumDrop = CoinMax(1.5*minimumDrop,1.0e-5*fabs(thisObj));
     8010            double test = 0.1*minimumDrop;
     8011            double goodDrop=(thisObj-cut_obj[0])/static_cast<double>(CUT_HISTORY);
     8012            double objValue = thisObj;
     8013            for (int j=CUT_HISTORY-1;j>=0;j--) {
     8014              if (objValue-cut_obj[j]<test) {
     8015                nBadPasses++;
     8016                objValue = cut_obj[j];
     8017              } else {
     8018                break;
     8019              }
     8020            }
     8021#ifdef CLP_INVESTIGATE2
     8022            if (!parentModel_&&!numberNodes_)
     8023              printf("badObj %s nBad %d maxBad %d goodDrop %g minDrop %g thisDrop %g obj %g\n",
     8024                     badObj ? "true" : "false",
     8025                     nBadPasses,maximumBadPasses,goodDrop,minimumDrop,
     8026                     thisObj-cut_obj[CUT_HISTORY-1],
     8027                     solver_->getObjValue());
     8028#endif
     8029            maximumBadPasses=CoinMax(maximumBadPasses,nBadPasses);
     8030            if (nBadPasses<2||goodDrop>2.0*minimumDrop) {
     8031              if (experimentBreak<=2||goodDrop>0.1*minimumDrop)
     8032                badObj=false; // carry on
     8033            }
     8034            if (experimentBreak>1&&goodDrop<minimumDrop)
     8035              numberLastAttempts++;
    80168036          }
    8017           maximumBadPasses=CoinMax(maximumBadPasses,nBadPasses);
    8018           if (nBadPasses<maximumBadPasses&&
    8019               goodDrop>minimumDrop)
    8020             badObj=false; // carry on
    80218037        }
    80228038        if (numberTries==1&&currentDepth_&&currentPassNumber_<10) {
     
    80318047          cut_obj[j] = cut_obj[j+1];
    80328048        cut_obj[CUT_HISTORY-1]=thisObj;
    8033 #else
    8034         bool badObj = thisObj < lastObjective+minimumDrop;
    8035 #endif
    80368049        bool allowEarlyTermination = currentPassNumber_ >= 10;
    80378050        if (currentDepth_>10||(currentDepth_>5&&numberColumns>200))
     
    80438056          { numberTries = 0 ; }
    80448057        if (numberRowCuts+numberColumnCuts == 0 ||
    8045             (cutIterations == 0 && !allowZeroIterations) )
    8046           { break ; }
     8058            (cutIterations == 0 && !allowZeroIterations) ) {
     8059          // maybe give it one more try
     8060          if(numberLastAttempts>2||currentDepth_||experimentBreak<2)
     8061            break ;
     8062          else
     8063            numberLastAttempts++;
     8064        }
    80478065        if (numberTries > 0) {
    80488066          reducedCostFix() ;
     
    84878505          // Allow on smaller number if <-1
    84888506          if (generator_[i]->switchOffIfLessThan()<0) {
    8489             double multiplier = -generator_[i]->switchOffIfLessThan()+1.0;
    8490             thisCuts *= multiplier;
     8507            double multiplier[]={2.0,5.0};
     8508            int iSwitch=-generator_[i]->switchOffIfLessThan()-1;
     8509            assert (iSwitch>=0&&iSwitch<2);
     8510            thisCuts *= multiplier[iSwitch];
    84918511          }
    84928512          if (!thisCuts||howOften == -99) {
  • branches/reeng/Cbc/src/CbcModel.hpp

    r1240 r1263  
    15951595      at present bottom 6 bits used for shadow price mode
    15961596      1024 for experimental hotstart
     1597      2048,4096 breaking out of cuts
     1598      8192 slowly increase minimum drop
     1599      16384 gomory
    15971600  */
    15981601  inline void setMoreSpecialOptions(int value)
  • branches/reeng/Cbc/src/CbcSolver.cpp

    r1255 r1263  
    43644364      twomirGen.setAwayAtRoot(0.005);
    43654365      twomirGen.setAway(0.01);
     4366      //twomirGen.setMirScale(1,1);
     4367      //twomirGen.setTwomirScale(1,1);
     4368      //twomirGen.setAMax(2);
    43664369#else
    43674370      gomoryGen.setAwayAtRoot(0.01);
     
    47734776                  if (!noPrinting_) {
    47744777                    generalMessageHandler->message(CLP_GENERAL,generalMessages)
    4775                       <<"switching on dense factorization if small, and maybe fast fathoming"
     4778                      <<"switching on global root cuts for gomory and knapsack"
    47764779                      <<CoinMessageEol;
    47774780                    generalMessageHandler->message(CLP_GENERAL,generalMessages)
    4778                       <<"Gomory cuts using tolerance of 0.01 at root"
     4781                      <<"using OSL factorization"
    47794782                      <<CoinMessageEol;
    47804783                    generalMessageHandler->message(CLP_GENERAL,generalMessages)
    4781                       <<"Possible restart after 100 nodes if can fix many"
     4784                      <<"only 10 iterations for strong branching"
    47824785                      <<CoinMessageEol;
    47834786                    generalMessageHandler->message(CLP_GENERAL,generalMessages)
    4784                       <<"extra options - -diving C -diveopt 3 -rins on -tune 6 -probing on -passf 30!"
     4787                      <<"extra options - -rens on -extra4 24003 -passc 1000!"
    47854788                      <<CoinMessageEol;
    47864789                  }
    4787                   // try changing tolerance at root
    4788                   //gomoryGen.setAwayAtRoot(0.01);
    4789                   int iParam;
    4790                   iParam = whichParam(DIVEOPT,numberParameters_,parameters_);
    4791                   parameters_[iParam].setIntValue(3);
    4792                   iParam = whichParam(FPUMPITS,numberParameters_,parameters_);
    4793                   parameters_[iParam].setIntValue(30);
    4794                   iParam = whichParam(FPUMPTUNE,numberParameters_,parameters_);
    4795                   parameters_[iParam].setIntValue(1005043);
    4796                   initialPumpTune=1005043;
    4797                   iParam = whichParam(PROCESSTUNE,numberParameters_,parameters_);
    4798                   parameters_[iParam].setIntValue(6);
    4799                   tunePreProcess=6;
    4800                   iParam = whichParam(DIVINGC,numberParameters_,parameters_);
    4801                   parameters_[iParam].setCurrentOption("on");
    4802                   iParam = whichParam(RINS,numberParameters_,parameters_);
    4803                   parameters_[iParam].setCurrentOption("on");
    4804                   iParam = whichParam(PROBINGCUTS,numberParameters_,parameters_);
    4805                   parameters_[iParam].setCurrentOption("on");
    4806                   probingAction=1;
     4790                  parameters[whichParam(PROBINGCUTS,numberParameters,parameters)].setCurrentOption("forceOnStrong");
     4791                  probingAction=8;
     4792                  parameters_[whichParam(GOMORYCUTS,numberParameters_,parameters_)].setCurrentOption("onGlobal");
     4793                  gomoryAction=5;
     4794                  parameters_[whichParam(KNAPSACKCUTS,numberParameters_,parameters_)].setCurrentOption("onGlobal");
     4795                  knapsackAction=5;
     4796                  parameters_[whichParam(FACTORIZATION,numberParameters_,parameters_)].setCurrentOption("osl");
     4797                  lpSolver->factorization()->forceOtherFactorization(3);
     4798                  parameters_[whichParam(MAXHOTITS,numberParameters_,parameters_)].setIntValue(10);
     4799                  parameters[whichParam(CUTPASS,numberParameters,parameters)].setIntValue(1000);
     4800                  cutPass=1000;
     4801                  parameters[whichParam(EXTRA4,numberParameters,parameters)].setIntValue(24003);
     4802                  parameters[whichParam(RENS,numberParameters,parameters)].setCurrentOption("on");
    48074803                }
    48084804              } else if (parameters_[iParam].type()==STRATEGY) {
     
    53975393                if (iStatus==0) {
    53985394                  iStatus2=0;
     5395                  // set best solution in model
     5396                  model_.setBestSolution(model2->primalColumnSolution(),
     5397                                         model2->numberColumns(),
     5398                                         model2->getObjValue()*
     5399                                         model2->getObjSense());
    53995400                } else if (iStatus==1) {
    54005401                  iStatus=0;
     
    56595660                extra[1] = parameters_[whichParam(EXTRA1,numberParameters_,parameters_)].intValue();
    56605661                if (parameters_[whichParam(EXPERIMENT,numberParameters_,
    5661                                            parameters_)].intValue()>=1&&
     5662                                           parameters_)].intValue()>=2&&
    56625663                    extra[1]==-1)
    56635664                  extra[1]=999998;
     
    67286729                  babModel_->setNumberBeforeTrust(10);
    67296730              }
    6730               int experimentFlag = parameters_[whichParam(EXPERIMENT,numberParameters_,
    6731                                                           parameters_)].intValue();
     6731              int experimentFlag = CoinMax(parameters_[whichParam(EXPERIMENT,numberParameters_,
     6732                                                                  parameters_)].intValue()-1,0);
    67326733              int strategyFlag = parameters_[whichParam(STRATEGY,numberParameters_,
    67336734                                                          parameters_)].intValue();
     
    67376738              int accuracyFlag[20];
    67386739              int numberGenerators=0;
    6739               int translate[]={-100,-1,-99,-98,1,-1098,-1099,1,1,1,-1};
     6740              int translate[]={-100,-1,-99,-98,1,-1098,-999,1,1,1,-1};
    67406741              if (probingAction) {
    67416742                int numberColumns=babModel_->solver()->getNumCols();
     
    69216922                else
    69226923                  babModel_->setMaximumCutPasses(cutPassInTree);
    6923               }
     6924              } else if (cutPass!=-1234567) {
     6925                babModel_->setMaximumCutPassesAtRoot(cutPass);
     6926              }
    69246927              // Do more strong branching if small
    69256928              //if (babModel_->getNumCols()<5000)
     
    70567059                  int method = extra4 % 100;
    70577060                  extra4 /=100;
    7058                   extra4 = strategy + method*8 + extra4*8*32;
     7061                  extra4 = strategy + method*8 + extra4*1024;
    70597062                  babModel_->setMoreSpecialOptions(extra4);
    70607063                }
     
    83208323                stuff[6]=parameters_[whichParam(EXTRA3,numberParameters_,parameters_)].intValue();
    83218324                stuff[7]=parameters_[whichParam(DEPTHMINIBAB,numberParameters_,parameters_)].intValue();
    8322                 stuff[8]=parameters_[whichParam(EXPERIMENT,numberParameters_,parameters_)].intValue();
    83238325                stuff[8]=bothFlags;
    83248326                stuff[9]=doVector;
  • branches/reeng/Cbc/src/CbcStrategy.cpp

    r1200 r1263  
    261261  int currentPasses = model.getMaximumCutPassesAtRoot();
    262262  if (currentPasses>=0) {
    263     if (model.getNumCols()<500)
    264       model.setMaximumCutPassesAtRoot(-CoinMax(100,currentPasses)); // always do 100 if possible
    265     else if (model.getNumCols()<5000)
    266       model.setMaximumCutPassesAtRoot(CoinMax(100,currentPasses)); // use minimum drop
     263    if (model.getNumCols()<5000)
     264      model.setMaximumCutPassesAtRoot(CoinMax(50,currentPasses)); // use minimum drop
    267265    else
    268266      model.setMaximumCutPassesAtRoot(CoinMax(20,currentPasses));
     
    847845  }
    848846#endif
    849   if (model.getNumCols()<500)
     847  if (model.getNumCols()<-500)
    850848    model.setMaximumCutPassesAtRoot(-100); // always do 100 if possible
    851849  else if (model.getNumCols()<5000)
  • branches/reeng/Cbc/src/unitTestClp.cpp

    r1232 r1263  
    220220  double timeTakenFac=0.0;
    221221#endif
     222  // Normally do in order
     223  int which[100];
     224  int nLoop=static_cast<int>(mpsName.size());
     225  assert (nLoop<=100);
     226  for (int i=0;i<nLoop;i++)
     227    which[i]=i;
     228  //#define RANDOM_ORDER
     229#ifdef RANDOM_ORDER
     230  unsigned int iTime = static_cast<unsigned int>(CoinGetTimeOfDay()-1.256e9);
     231  printf("Time %d\n",iTime);
     232  double sort[100];
     233  CoinDrand48(true,iTime);
     234  for (int i=0;i<nLoop;i++)
     235    sort[i]=CoinDrand48();
     236  CoinSort_2(sort,sort+nLoop,which);
     237#endif
    222238  int numberFailures=0;
    223239  int numberAttempts=0;
     
    232248    Open the main loop to step through the MPS problems.
    233249  */
    234   for (m = 0 ; m < mpsName.size() ; m++) {
     250  for (unsigned int mw = 0 ; mw < mpsName.size() ; mw++) {
     251    m=which[mw];
    235252    int test = testSet[m];
    236253    if(testSwitch>=test&&loSwitch<=test) {
Note: See TracChangeset for help on using the changeset viewer.