Changeset 424


Ignore:
Timestamp:
Sep 15, 2006 4:55:05 PM (13 years ago)
Author:
forrest
Message:

many changes

Location:
branches/devel/Cbc
Files:
23 edited

Legend:

Unmodified
Added
Removed
  • branches/devel/Cbc/examples/CbcBranchLink.cpp

    r134 r424  
    2222    numberMembers_(0),
    2323    numberLinks_(0),
    24     first_(-1)
     24    which_(NULL)
    2525{
    2626}
     
    3232    numberMembers_(numberMembers),
    3333    numberLinks_(numberLinks),
    34     first_(first)
     34    which_(NULL)
    3535{
    3636  id_=identifier;
    3737  if (numberMembers_) {
    3838    weights_ = new double[numberMembers_];
     39    which_ = new int[numberMembers_*numberLinks_];
    3940    if (weights) {
    4041      memcpy(weights_,weights,numberMembers_*sizeof(double));
     
    5051      last=weights_[i];
    5152    }
     53    for (i=0;i<numberMembers_*numberLinks_;i++) {
     54      which_[i]=first+i;
     55    }
     56  } else {
     57    weights_ = NULL;
     58  }
     59}
     60
     61// Useful constructor (which are indices)
     62CbcLink::CbcLink (CbcModel * model,  int numberMembers,
     63           int numberLinks, const int * which , const double * weights, int identifier)
     64  : CbcObject(model),
     65    numberMembers_(numberMembers),
     66    numberLinks_(numberLinks),
     67    which_(NULL)
     68{
     69  id_=identifier;
     70  if (numberMembers_) {
     71    weights_ = new double[numberMembers_];
     72    which_ = new int[numberMembers_*numberLinks_];
     73    if (weights) {
     74      memcpy(weights_,weights,numberMembers_*sizeof(double));
     75    } else {
     76      for (int i=0;i<numberMembers_;i++)
     77        weights_[i]=i;
     78    }
     79    // weights must be increasing
     80    int i;
     81    double last=-COIN_DBL_MAX;
     82    for (i=0;i<numberMembers_;i++) {
     83      assert (weights_[i]>last+1.0e-12);
     84      last=weights_[i];
     85    }
     86    for (i=0;i<numberMembers_*numberLinks_;i++) {
     87      which_[i]= which[i];
     88    }
    5289  } else {
    5390    weights_ = NULL;
     
    6198  numberMembers_ = rhs.numberMembers_;
    6299  numberLinks_ = rhs.numberLinks_;
    63   first_ = rhs.first_;
    64100  if (numberMembers_) {
    65     weights_ = new double[numberMembers_];
    66     memcpy(weights_,rhs.weights_,numberMembers_*sizeof(double));
     101    weights_ = CoinCopyOfArray(rhs.weights_,numberMembers_);
     102    which_ = CoinCopyOfArray(rhs.which_,numberMembers_*numberLinks_);
    67103  } else {
    68104    weights_ = NULL;
     105    which_ = NULL;
    69106  }
    70107}
     
    84121    CbcObject::operator=(rhs);
    85122    delete [] weights_;
     123    delete [] which_;
    86124    numberMembers_ = rhs.numberMembers_;
    87125    numberLinks_ = rhs.numberLinks_;
    88     first_ = rhs.first_;
    89126    if (numberMembers_) {
    90       weights_ = new double[numberMembers_];
    91       memcpy(weights_,rhs.weights_,numberMembers_*sizeof(double));
     127      weights_ = CoinCopyOfArray(rhs.weights_,numberMembers_);
     128      which_ = CoinCopyOfArray(rhs.which_,numberMembers_*numberLinks_);
    92129    } else {
    93130      weights_ = NULL;
     131      which_ = NULL;
    94132    }
    95133  }
     
    101139{
    102140  delete [] weights_;
     141  delete [] which_;
    103142}
    104143
     
    112151  OsiSolverInterface * solver = model_->solver();
    113152  const double * solution = model_->testSolution();
    114   const double * lower = solver->getColLower();
     153  //const double * lower = solver->getColLower();
    115154  const double * upper = solver->getColUpper();
    116155  double integerTolerance =
     
    121160  // check bounds etc
    122161  double lastWeight=-1.0e100;
    123   int base=first_;
     162  int base=0;
    124163  for (j=0;j<numberMembers_;j++) {
    125164    for (int k=0;k<numberLinks_;k++) {
    126       int iColumn = base+k;
    127       if (lower[iColumn])
    128         throw CoinError("Non zero lower bound in CBCLink","infeasibility","CbcLink");
     165      int iColumn = which_[base+k];
     166      //if (lower[iColumn])
     167      //throw CoinError("Non zero lower bound in CBCLink","infeasibility","CbcLink");
    129168      if (lastWeight>=weights_[j]-1.0e-7)
    130169        throw CoinError("Weights too close together in CBCLink","infeasibility","CbcLink");
     
    177216  double sum =0.0;
    178217
    179   int base=first_;
     218  int base=0;
    180219  for (j=0;j<numberMembers_;j++) {
    181220    for (int k=0;k<numberLinks_;k++) {
    182       int iColumn = base+k;
     221      int iColumn = which_[base+k];
    183222      double value = CoinMax(0.0,solution[iColumn]);
    184223      sum += value;
     
    193232  }
    194233  assert (lastNonZero-firstNonZero==0) ;
    195   base=first_;
     234  base=0;
    196235  for (j=0;j<firstNonZero;j++) {
    197236    for (int k=0;k<numberLinks_;k++) {
    198       int iColumn = base+k;
     237      int iColumn = which_[base+k];
    199238      solver->setColUpper(iColumn,0.0);
    200239    }
     
    205244  for (j=lastNonZero+1;j<numberMembers_;j++) {
    206245    for (int k=0;k<numberLinks_;k++) {
    207       int iColumn = base+k;
     246      int iColumn = which_[base+k];
    208247      solver->setColUpper(iColumn,0.0);
    209248    }
     
    229268  double weight = 0.0;
    230269  double sum =0.0;
    231   int base=first_;
     270  int base=0;
    232271  for (j=0;j<numberMembers_;j++) {
    233272    for (int k=0;k<numberLinks_;k++) {
    234       int iColumn = base+k;
     273      int iColumn = which_[base+k];
    235274      if (upper[iColumn]) {
    236275        double value = CoinMax(0.0,solution[iColumn]);
     
    313352  int numberLinks = set_->numberLinks();
    314353  const double * weights = set_->weights();
     354  const int * which = set_->which();
    315355  OsiSolverInterface * solver = model_->solver();
    316356  //const double * lower = solver->getColLower();
     
    324364    }
    325365    assert (i<numberMembers);
    326     int base=set_->first()+i*numberLinks;;
     366    int base=i*numberLinks;;
    327367    for (;i<numberMembers;i++) {
    328368      for (int k=0;k<numberLinks;k++) {
    329         int iColumn = base+k;
     369        int iColumn = which[base+k];
    330370        solver->setColUpper(iColumn,0.0);
    331371      }
     
    335375  } else {
    336376    int i;
    337     int base=set_->first();
     377    int base=0;
    338378    for ( i=0;i<numberMembers;i++) {
    339379      if (weights[i] >= separator_) {
     
    341381      } else {
    342382        for (int k=0;k<numberLinks;k++) {
    343           int iColumn = base+k;
     383          int iColumn = which[base+k];
    344384          solver->setColUpper(iColumn,0.0);
    345385        }
     
    359399  int numberLinks = set_->numberLinks();
    360400  const double * weights = set_->weights();
     401  const int * which = set_->which();
    361402  OsiSolverInterface * solver = model_->solver();
    362403  const double * upper = solver->getColUpper();
     
    366407  int numberOther=0;
    367408  int i;
    368   int base=set_->first();
     409  int base=0;
    369410  for ( i=0;i<numberMembers;i++) {
    370411    for (int k=0;k<numberLinks;k++) {
    371       int iColumn = base+k;
     412      int iColumn = which[base+k];
    372413      double bound = upper[iColumn];
    373414      if (bound) {
     
    379420  }
    380421  // *** for way - up means fix all those in down section
    381   base=set_->first();
     422  base=0;
    382423  if (way_<0) {
    383424    printf("SOS Down");
    384425    for ( i=0;i<numberMembers;i++) {
     426      if (weights[i] > separator_)
     427        break;
    385428      for (int k=0;k<numberLinks;k++) {
    386         int iColumn = base+k;
     429        int iColumn = which[base+k];
    387430        double bound = upper[iColumn];
    388         if (weights[i] > separator_)
    389           break;
    390         else if (bound)
     431        if (bound)
    391432          numberOther++;
    392433      }
     
    396437    for (;i<numberMembers;i++) {
    397438      for (int k=0;k<numberLinks;k++) {
    398         int iColumn = base+k;
     439        int iColumn = which[base+k];
    399440        double bound = upper[iColumn];
    400441        if (bound)
     
    406447    printf("SOS Up");
    407448    for ( i=0;i<numberMembers;i++) {
     449      if (weights[i] >= separator_)
     450        break;
    408451      for (int k=0;k<numberLinks;k++) {
    409         int iColumn = base+k;
     452        int iColumn = which[base+k];
    410453        double bound = upper[iColumn];
    411         if (weights[i] >= separator_)
    412           break;
    413         else if (bound)
     454        if (bound)
    414455          numberFixed++;
    415456      }
     
    419460    for (;i<numberMembers;i++) {
    420461      for (int k=0;k<numberLinks;k++) {
    421         int iColumn = base+k;
     462        int iColumn = which[base+k];
    422463        double bound = upper[iColumn];
    423464        if (bound)
     
    428469  }
    429470  assert ((numberFixed%numberLinks)==0);
    430   assert ((numberFixed%numberOther)==0);
     471  assert ((numberOther%numberLinks)==0);
    431472  printf(" - at %g, free range %d (%g) => %d (%g), %d would be fixed, %d other way\n",
    432473         separator_,first,weights[first],last,weights[last],numberFixed/numberLinks,
  • branches/devel/Cbc/examples/CbcBranchLink.hpp

    r129 r424  
    2121      apart from k*numberLink to (k+1)*numberLink-1 where k is 0 through
    2222      numberInSet-1.  The length of weights array is numberInSet.
    23       For this simple version the variables in matrix are the numberInSet*numberLink
     23      For this constructor the variables in matrix are the numberInSet*numberLink
    2424      starting at first. If weights null then 0,1,2..
    2525  */
    2626  CbcLink (CbcModel * model, int numberMembers,
    2727           int numberLinks, int first,
     28           const double * weights, int setNumber);
     29  /** Useful constructor - A valid solution is if all variables are zero
     30      apart from k*numberLink to (k+1)*numberLink-1 where k is 0 through
     31      numberInSet-1.  The length of weights array is numberInSet.
     32      For this constructor the variables are given by list - grouped.
     33      If weights null then 0,1,2..
     34  */
     35  CbcLink (CbcModel * model, int numberMembers,
     36           int numberLinks, const int * which,
    2837           const double * weights, int setNumber);
    2938 
     
    5665  {return numberLinks_;};
    5766
    58   /// First variable in matrix
    59   inline int first() const
    60   {return first_;};
     67  /// Which variables
     68  inline const int * which() const
     69  {return which_;};
    6170
    6271  /** Array of weights */
     
    7483  /// Number of links
    7584   int numberLinks_;
    76   /// First member
    77   int first_;
     85  /// Members
     86  int * which_;
    7887};
    7988/** Branching object for Special ordered sets
  • branches/devel/Cbc/examples/CbcCompareUser.cpp

    r180 r424  
    8282{
    8383}
    84 
     84// For moment go to default
     85#if 0
    8586// Returns true if y better than x
    8687bool
     
    179180  }
    180181}
     182#else
     183
     184// Returns true if y better than x
     185bool
     186CbcCompareUser::test (CbcNode * x, CbcNode * y)
     187{
     188  if (weight_==-1.0&&(y->depth()>7||x->depth()>7)) {
     189    // before solution
     190    /* printf("x %d %d %g, y %d %d %g\n",
     191       x->numberUnsatisfied(),x->depth(),x->objectiveValue(),
     192       y->numberUnsatisfied(),y->depth(),y->objectiveValue()); */
     193    if (x->numberUnsatisfied() > y->numberUnsatisfied()) {
     194      return true;
     195    } else if (x->numberUnsatisfied() < y->numberUnsatisfied()) {
     196      return false;
     197    } else {
     198      int testX = x->depth();
     199      int testY = y->depth();
     200      if (testX!=testY)
     201        return testX < testY;
     202      else
     203        return equalityTest(x,y); // so ties will be broken in consistent manner
     204    }
     205  } else {
     206    // after solution
     207    double weight = CoinMax(weight_,0.0);
     208    double testX =  x->objectiveValue()+ weight*x->numberUnsatisfied();
     209    double testY = y->objectiveValue() + weight*y->numberUnsatisfied();
     210    if (testX!=testY)
     211      return testX > testY;
     212    else
     213      return equalityTest(x,y); // so ties will be broken in consistent manner
     214  }
     215}
     216// This allows method to change behavior as it is called
     217// after each solution
     218void
     219CbcCompareUser::newSolution(CbcModel * model,
     220                               double objectiveAtContinuous,
     221                               int numberInfeasibilitiesAtContinuous)
     222{
     223  if (model->getSolutionCount()==model->getNumberHeuristicSolutions()&&
     224      model->getSolutionCount()<5&&model->getNodeCount()<500)
     225    return; // solution was got by rounding
     226  // set to get close to this solution
     227  double costPerInteger =
     228    (model->getObjValue()-objectiveAtContinuous)/
     229    ((double) numberInfeasibilitiesAtContinuous);
     230  weight_ = 0.95*costPerInteger;
     231  saveWeight_ = 0.95*weight_;
     232  numberSolutions_++;
     233  if (numberSolutions_>5)
     234    weight_ =0.0; // this searches on objective
     235}
     236// This allows method to change behavior
     237bool
     238CbcCompareUser::every1000Nodes(CbcModel * model, int numberNodes)
     239{
     240  double saveWeight=weight_;
     241  int numberNodes1000 = numberNodes/1000;
     242  if (numberNodes>10000) {
     243    weight_ =0.0; // this searches on objective
     244    // but try a bit of other stuff
     245    if ((numberNodes1000%4)==1)
     246      weight_=saveWeight_;
     247  } else if (numberNodes==1000&&weight_==-2.0) {
     248    weight_=-1.0; // Go to depth first
     249  }
     250  // get size of tree
     251  treeSize_ = model->tree()->size();
     252  if (treeSize_>10000) {
     253    int n1 = model->solver()->getNumRows()+model->solver()->getNumCols();
     254    int n2 = model->numberObjects();
     255    double size = n1*0.1 + n2*2.0;
     256    // set weight to reduce size most of time
     257    if (treeSize_*size>5.0e7)
     258      weight_=-1.0;
     259    else if ((numberNodes1000%4)==0&&treeSize_*size>1.0e6)
     260      weight_=-1.0;
     261    else if ((numberNodes1000%4)==1)
     262      weight_=0.0;
     263    else
     264      weight_=saveWeight_;
     265  }
     266  return (weight_!=saveWeight);
     267}
     268// Returns true if wants code to do scan with alternate criterion
     269bool
     270CbcCompareUser::fullScan() const
     271{
     272  return false;
     273}
     274// This is alternate test function
     275bool
     276CbcCompareUser::alternateTest (CbcNode * x, CbcNode * y)
     277{
     278  // not used
     279  abort();
     280  return false;
     281}
     282#endif
  • branches/devel/Cbc/src/CbcBranchActual.cpp

    r416 r424  
    338338    weights_(NULL),
    339339    numberMembers_(0),
    340     sosType_(-1)
     340    sosType_(-1),
     341    integerValued_(false)
    341342{
    342343}
     
    350351{
    351352  id_=identifier;
     353  integerValued_ = type==1;
    352354  if (numberMembers_) {
    353355    members_ = new int[numberMembers_];
     
    362364    // sort so weights increasing
    363365    CoinSort_2(weights_,weights_+numberMembers_,members_);
     366    double last = -COIN_DBL_MAX;
     367    int i;
     368    for (i=0;i<numberMembers_;i++) {
     369      double possible = CoinMax(last+1.0e-10,weights_[i]);
     370      weights_[i] = possible;
     371      last=possible;
     372    }
    364373  } else {
    365374    members_ = NULL;
     
    375384  numberMembers_ = rhs.numberMembers_;
    376385  sosType_ = rhs.sosType_;
     386  integerValued_ = rhs.integerValued_;
    377387  if (numberMembers_) {
    378388    members_ = new int[numberMembers_];
     
    403413    numberMembers_ = rhs.numberMembers_;
    404414    sosType_ = rhs.sosType_;
     415    integerValued_ = rhs.integerValued_;
    405416    if (numberMembers_) {
    406417      members_ = new int[numberMembers_];
  • branches/devel/Cbc/src/CbcBranchActual.hpp

    r416 r424  
    154154  { return weights_;};
    155155
     156  /** \brief Return true if object can take part in normal heuristics
     157  */
     158  virtual bool canDoHeuristics() const
     159  {return (sosType_==1&&integerValued_);};
     160  /// Set whether set is integer valued or not
     161  inline void setIntegerValued(bool yesNo)
     162  { integerValued_=yesNo;};
    156163private:
    157164  /// data
     
    166173  /// SOS type
    167174   int sosType_;
     175  /// Whether integer valued
     176  bool integerValued_;
    168177};
    169178
  • branches/devel/Cbc/src/CbcBranchBase.hpp

    r356 r424  
    147147  virtual bool boundBranch() const
    148148  {return true;};
     149  /** \brief Return true if object can take part in normal heuristics
     150  */
     151  virtual bool canDoHeuristics() const
     152  {return true;};
    149153  /** Returns floor and ceiling i.e. closest valid points
    150154  */
  • branches/devel/Cbc/src/CbcBranchDynamic.cpp

    r310 r424  
    4444    numberTimesUpInfeasible_(0),
    4545    numberBeforeTrust_(0),
     46    numberTimesDownLocalFixed_(0),
     47    numberTimesUpLocalFixed_(0),
     48    numberTimesDownTotalFixed_(0.0),
     49    numberTimesUpTotalFixed_(0.0),
     50    numberTimesProbingTotal_(0),
    4651    method_(0)
    4752{
     
    7378    numberTimesUpInfeasible_(0),
    7479    numberBeforeTrust_(0),
     80    numberTimesDownLocalFixed_(0),
     81    numberTimesUpLocalFixed_(0),
     82    numberTimesDownTotalFixed_(0.0),
     83    numberTimesUpTotalFixed_(0.0),
     84    numberTimesProbingTotal_(0),
    7585    method_(0)
    7686{
     
    132142    numberTimesUpInfeasible_(0),
    133143    numberBeforeTrust_(0),
     144    numberTimesDownLocalFixed_(0),
     145    numberTimesUpLocalFixed_(0),
     146    numberTimesDownTotalFixed_(0.0),
     147    numberTimesUpTotalFixed_(0.0),
     148    numberTimesProbingTotal_(0),
    134149    method_(0)
    135150{
     
    185200   numberTimesUpInfeasible_(rhs.numberTimesUpInfeasible_),
    186201   numberBeforeTrust_(rhs.numberBeforeTrust_),
     202   numberTimesDownLocalFixed_(rhs.numberTimesDownLocalFixed_),
     203   numberTimesUpLocalFixed_(rhs.numberTimesUpLocalFixed_),
     204   numberTimesDownTotalFixed_(rhs.numberTimesDownTotalFixed_),
     205   numberTimesUpTotalFixed_(rhs.numberTimesUpTotalFixed_),
     206   numberTimesProbingTotal_(rhs.numberTimesProbingTotal_),
    187207   method_(rhs.method_)
    188208
     
    223243    numberTimesUpInfeasible_ = rhs.numberTimesUpInfeasible_;
    224244    numberBeforeTrust_ = rhs.numberBeforeTrust_;
     245    numberTimesDownLocalFixed_ = rhs.numberTimesDownLocalFixed_;
     246    numberTimesUpLocalFixed_ = rhs.numberTimesUpLocalFixed_;
     247    numberTimesDownTotalFixed_ = rhs.numberTimesDownTotalFixed_;
     248    numberTimesUpTotalFixed_ = rhs.numberTimesUpTotalFixed_;
     249    numberTimesProbingTotal_ = rhs.numberTimesProbingTotal_;
    225250    method_=rhs.method_;
    226251  }
     
    326351    below = above -1;
    327352  }
    328 #define INFEAS
    329 #ifdef INFEAS
     353#define INFEAS 1
     354#if INFEAS==1
    330355  double distanceToCutoff=0.0;
    331356  double objectiveValue = model_->getCurrentMinimizationObjValue();
     
    341366  sum = sumDownCost_;
    342367  number = numberTimesDown_;
    343 #ifdef INFEAS
     368#if INFEAS==1
    344369  sum += numberTimesDownInfeasible_*(distanceToCutoff/(downCost+1.0e-12));
     370  number += numberTimesDownInfeasible_;
    345371#endif
    346372  if (number>0)
     
    351377  sum = sumUpCost_;
    352378  number = numberTimesUp_;
    353 #ifdef INFEAS
     379#if INFEAS==1
    354380  sum += numberTimesUpInfeasible_*(distanceToCutoff/(upCost+1.0e-12));
     381  number += numberTimesUpInfeasible_;
    355382#endif
    356383  if (number>0)
     
    399426    //returnValue = 2.0*returnValue + 0.1;
    400427    //}
     428    if (method_==1) {
     429      // probing
     430      // average
     431      double up=1.0e-15;
     432      double down=1.0e-15;
     433      if (numberTimesProbingTotal_) {
     434        up += numberTimesUpTotalFixed_/((double) numberTimesProbingTotal_);
     435        down += numberTimesDownTotalFixed_/((double) numberTimesProbingTotal_);
     436      }
     437      returnValue = 1 + 10.0*CoinMin(numberTimesDownLocalFixed_,numberTimesUpLocalFixed_) +
     438        CoinMin(down,up);
     439      returnValue *= 1.0e-3;
     440    }
    401441    return CoinMax(returnValue,1.0e-15);
    402442  }
     
    452492  double downCost = CoinMax((value-below)*downDynamicPseudoCost_,0.0);
    453493  return downCost;
     494}
     495// Pass in probing information
     496void
     497CbcSimpleIntegerDynamicPseudoCost::setProbingInformation(int fixedDown, int fixedUp)
     498{
     499  numberTimesProbingTotal_++;
     500  numberTimesDownLocalFixed_ = fixedDown;
     501  numberTimesDownTotalFixed_ += fixedDown;
     502  numberTimesUpLocalFixed_ = fixedUp;
     503  numberTimesUpTotalFixed_ += fixedUp;
    454504}
    455505// Print
     
    712762  CbcDynamicPseudoCostBranchingObject * branchingObject =
    713763    dynamic_cast<CbcDynamicPseudoCostBranchingObject *>(object_);
    714   assert (branchingObject);
     764  if (!branchingObject) {
     765    delete object_;
     766    object_=NULL;
     767    return;
     768  }
    715769  CbcSimpleIntegerDynamicPseudoCost *  object = branchingObject->object();
    716770  double change = CoinMax(0.0,objectiveValue-originalValue);
     
    740794  int way = object_->way();
    741795  double value = object_->value();
    742 #define TYPE2
     796#define TYPE2 1
     797#define TYPERATIO 0.9
    743798  if (way<0) {
    744799    // down
    745800    if (feasible) {
     801      //printf("(down change %g value down %g ",change,value-floor(value));
    746802      object->incrementNumberTimesDown();
    747803      object->addToSumDownChange(1.0e-30+value-floor(value));
    748804      object->addToSumDownDecrease(originalUnsatisfied-unsatisfied);
    749 #ifndef TYPE2
     805#if TYPE2==0
    750806      object->addToSumDownCost(change/(1.0e-30+(value-floor(value))));
    751807      object->setDownDynamicPseudoCost(object->sumDownCost()/(double) object->numberTimesDown());
    752 #else
     808#elif TYPE2==1
    753809      object->addToSumDownCost(change);
    754810      object->setDownDynamicPseudoCost(object->sumDownCost()/object->sumDownChange());
     811#elif TYPE2==2
     812      object->addToSumDownCost(change*TYPERATIO+(1.0-TYPERATIO)*change/(1.0e-30+(value-floor(value))));
     813      object->setDownDynamicPseudoCost(object->sumDownCost()*(TYPERATIO/object->sumDownChange()+(1.0-TYPERATIO)/(double) object->numberTimesDown()));
    755814#endif
    756815    } else {
     816      //printf("(down infeasible value down %g ",change,value-floor(value));
    757817      object->incrementNumberTimesDownInfeasible();
     818#if INFEAS==2
     819      double distanceToCutoff=0.0;
     820      double objectiveValue = model->getCurrentMinimizationObjValue();
     821      distanceToCutoff =  model->getCutoff()  - originalValue;
     822      if (distanceToCutoff<1.0e20)
     823        change = distanceToCutoff*2.0;
     824      else
     825        change = object->downDynamicPseudoCost()*(value-floor(value))*10.0;
     826      change = CoinMax(1.0e-12*(1.0+fabs(originalValue)),change);
     827      object->incrementNumberTimesDown();
     828      object->addToSumDownChange(1.0e-30+value-floor(value));
     829      object->addToSumDownDecrease(originalUnsatisfied-unsatisfied);
     830#if TYPE2==0
     831      object->addToSumDownCost(change/(1.0e-30+(value-floor(value))));
     832      object->setDownDynamicPseudoCost(object->sumDownCost()/(double) object->numberTimesDown());
     833#elif TYPE2==1
     834      object->addToSumDownCost(change);
     835      object->setDownDynamicPseudoCost(object->sumDownCost()/object->sumDownChange());
     836#elif TYPE2==2
     837      object->addToSumDownCost(change*TYPERATIO+(1.0-TYPERATIO)*change/(1.0e-30+(value-floor(value))));
     838      object->setDownDynamicPseudoCost(object->sumDownCost()*(TYPERATIO/object->sumDownChange()+(1.0-TYPERATIO)/(double) object->numberTimesDown()));
     839#endif
     840#endif
    758841    }
    759842  } else {
    760843    // up
    761844    if (feasible) {
     845      //printf("(up change %g value down %g ",change,ceil(value)-value);
    762846      object->incrementNumberTimesUp();
    763847      object->addToSumUpChange(1.0e-30+ceil(value)-value);
    764848      object->addToSumUpDecrease(unsatisfied-originalUnsatisfied);
    765 #ifndef TYPE2
     849#if TYPE2==0
    766850      object->addToSumUpCost(change/(1.0e-30+(ceil(value)-value)));
    767851      object->setUpDynamicPseudoCost(object->sumUpCost()/(double) object->numberTimesUp());
    768 #else
     852#elif TYPE2==1
    769853      object->addToSumUpCost(change);
    770854      object->setUpDynamicPseudoCost(object->sumUpCost()/object->sumUpChange());
     855#elif TYPE2==2
     856      object->addToSumUpCost(change*TYPERATIO+(1.0-TYPERATIO)*change/(1.0e-30+(ceil(value)-value)));
     857      object->setUpDynamicPseudoCost(object->sumUpCost()*(TYPERATIO/object->sumUpChange()+(1.0-TYPERATIO)/(double) object->numberTimesUp()));
    771858#endif
    772859    } else {
     860      //printf("(up infeasible value down %g ",change,ceil(value)-value);
    773861      object->incrementNumberTimesUpInfeasible();
    774     }
    775   }
     862#if INFEAS==2
     863      double distanceToCutoff=0.0;
     864      double objectiveValue = model->getCurrentMinimizationObjValue();
     865      distanceToCutoff =  model->getCutoff()  - originalValue;
     866      if (distanceToCutoff<1.0e20)
     867        change = distanceToCutoff*2.0;
     868      else
     869        change = object->upDynamicPseudoCost()*(ceil(value)-value)*10.0;
     870      change = CoinMax(1.0e-12*(1.0+fabs(originalValue)),change);
     871      object->incrementNumberTimesUp();
     872      object->addToSumUpChange(1.0e-30+ceil(value)-value);
     873      object->addToSumUpDecrease(unsatisfied-originalUnsatisfied);
     874#if TYPE2==0
     875      object->addToSumUpCost(change/(1.0e-30+(ceil(value)-value)));
     876      object->setUpDynamicPseudoCost(object->sumUpCost()/(double) object->numberTimesUp());
     877#elif TYPE2==1
     878      object->addToSumUpCost(change);
     879      object->setUpDynamicPseudoCost(object->sumUpCost()/object->sumUpChange());
     880#elif TYPE2==2
     881      object->addToSumUpCost(change*TYPERATIO+(1.0-TYPERATIO)*change/(1.0e-30+(ceil(value)-value)));
     882      object->setUpDynamicPseudoCost(object->sumUpCost()*(TYPERATIO/object->sumUpChange()+(1.0-TYPERATIO)/(double) object->numberTimesUp()));
     883#endif
     884#endif
     885    }
     886  }
     887  //object->print();
    776888  delete object_;
    777889  object_=NULL;
     
    875987    CbcDynamicPseudoCostBranchingObject * branchingObject =
    876988      dynamic_cast<CbcDynamicPseudoCostBranchingObject *>(thisOne);
    877     assert (branchingObject);
    878     CbcSimpleIntegerDynamicPseudoCost *  object = branchingObject->object();
    879     double separator = object->upDownSeparator();
    880     if (separator>0.0) {
    881       const double * solution = thisOne->model()->testSolution();
    882       double valueVariable = solution[object->columnNumber()];
    883       betterWay = (valueVariable-floor(valueVariable)>=separator) ? 1 : -1;
     989    if (branchingObject) {
     990      CbcSimpleIntegerDynamicPseudoCost *  object = branchingObject->object();
     991      double separator = object->upDownSeparator();
     992      if (separator>0.0) {
     993        const double * solution = thisOne->model()->testSolution();
     994        double valueVariable = solution[object->columnNumber()];
     995        betterWay = (valueVariable-floor(valueVariable)>=separator) ? 1 : -1;
     996      }
    884997    }
    885998    bestCriterion_ = value;
  • branches/devel/Cbc/src/CbcBranchDynamic.hpp

    r231 r424  
    199199  /// Pass in information on a up branch
    200200  void setUpInformation(double changeObjectiveUp, int changeInfeasibilityUp);
     201  /// Pass in probing information
     202  void setProbingInformation(int fixedDown, int fixedUp);
    201203
    202204  /// Print - 0 -summary, 1 just before strong
     
    248250  /// Number of branches before we trust
    249251  int numberBeforeTrust_;
     252  /// Number of local probing fixings going down
     253  int numberTimesDownLocalFixed_;
     254  /// Number of local probing fixings going up
     255  int numberTimesUpLocalFixed_;
     256  /// Number of total probing fixings going down
     257  double numberTimesDownTotalFixed_;
     258  /// Number of total probing fixings going up
     259  double numberTimesUpTotalFixed_;
     260  /// Number of times probing done
     261  int numberTimesProbingTotal_;
    250262  /** Method -
    251       ??
     263      0 - pseudo costs
     264      1 - probing
    252265  */
    253266  int method_;
  • branches/devel/Cbc/src/CbcBranchLotsize.hpp

    r213 r424  
    113113  inline double * bound() const
    114114  { return bound_;};
     115  /** \brief Return true if object can take part in normal heuristics
     116  */
     117  virtual bool canDoHeuristics() const
     118  {return false;};
    115119
    116120private:
  • branches/devel/Cbc/src/CbcCompareActual.cpp

    r356 r424  
    5959CbcCompareDepth::test (CbcNode * x, CbcNode * y)
    6060{
    61   return x->depth() < y->depth();
     61  int testX = x->depth();
     62  int testY = y->depth();
     63  if (testX!=testY)
     64    return testX < testY;
     65  else
     66    return equalityTest(x,y); // so ties will be broken in consistent manner
    6267}
    6368// Create C++ lines to get to current state
     
    112117CbcCompareObjective::test (CbcNode * x, CbcNode * y)
    113118{
    114   return x->objectiveValue() > y->objectiveValue();
     119  double testX = x->objectiveValue();
     120  double testY = y->objectiveValue();
     121  if (testX!=testY)
     122    return testX > testY;
     123  else
     124    return equalityTest(x,y); // so ties will be broken in consistent manner
    115125}
    116126// Create C++ lines to get to current state
     
    214224       x->numberUnsatisfied(),x->depth(),x->objectiveValue(),
    215225       y->numberUnsatisfied(),y->depth(),y->objectiveValue()); */
    216     if (x->numberUnsatisfied() > y->numberUnsatisfied())
     226    if (x->numberUnsatisfied() > y->numberUnsatisfied()) {
    217227      return true;
    218     else if (x->numberUnsatisfied() < y->numberUnsatisfied())
     228    } else if (x->numberUnsatisfied() < y->numberUnsatisfied()) {
    219229      return false;
    220     else
    221       return x->depth() < y->depth();
     230    } else {
     231      int testX = x->depth();
     232      int testY = y->depth();
     233      if (testX!=testY)
     234        return testX < testY;
     235      else
     236        return equalityTest(x,y); // so ties will be broken in consistent manner
     237    }
    222238  } else {
    223239    // after solution
    224240    double weight = CoinMax(weight_,0.0);
    225     return x->objectiveValue()+ weight*x->numberUnsatisfied() >
    226       y->objectiveValue() + weight*y->numberUnsatisfied();
     241    double testX =  x->objectiveValue()+ weight*x->numberUnsatisfied();
     242    double testY = y->objectiveValue() + weight*y->numberUnsatisfied();
     243    if (testX!=testY)
     244      return testX > testY;
     245    else
     246      return equalityTest(x,y); // so ties will be broken in consistent manner
    227247  }
    228248#endif
     
    344364CbcCompareEstimate::test (CbcNode * x, CbcNode * y)
    345365{
    346   return x->guessedObjectiveValue() >  y->guessedObjectiveValue() ;
     366  double testX = x->guessedObjectiveValue();
     367  double testY = y->guessedObjectiveValue();
     368  if (testX!=testY)
     369    return testX > testY;
     370  else
     371    return equalityTest(x,y); // so ties will be broken in consistent manner
    347372}
    348373
     
    355380  fprintf(fp,"3  cbcModel->setNodeComparison(compare);\n");
    356381}
    357 
  • branches/devel/Cbc/src/CbcCompareBase.hpp

    r356 r424  
    4141  virtual bool every1000Nodes(CbcModel * model,int numberNodes) {return false;};
    4242
    43   /// Returns true if wants code to do scan with alternate criterion
     43  /** Returns true if wants code to do scan with alternate criterion
     44      NOTE - this is temporarily disabled
     45  */
    4446  virtual bool fullScan() const { return false;};
    4547
     
    7072    return test(x,y);
    7173  }
     74  /// Further test if everything else equal
     75  inline bool equalityTest (CbcNode * x, CbcNode * y) const
     76  {
     77    assert (x);
     78    CbcNodeInfo * infoX = x->nodeInfo();
     79    assert (infoX);
     80    int nodeNumberX = infoX->nodeNumber();
     81    assert (y);
     82    CbcNodeInfo * infoY = y->nodeInfo();
     83    assert (infoY);
     84    int nodeNumberY = infoY->nodeNumber();
     85    assert (nodeNumberX!=nodeNumberY);
     86    return (nodeNumberX>nodeNumberY);
     87  };
    7288protected:
    7389  CbcCompareBase * test_;
  • branches/devel/Cbc/src/CbcCutGenerator.cpp

    r395 r424  
    1313#include "CbcMessage.hpp"
    1414#include "CbcCutGenerator.hpp"
     15#include "CbcBranchDynamic.hpp"
    1516#include "CglProbing.hpp"
    1617#include "CoinTime.hpp"
     
    188189    if (timing_)
    189190      time1 = CoinCpuTime();
     191    //#define CBC_DEBUG
     192#ifdef CBC_DEBUG
     193    int numberRowCutsBefore = cs.sizeRowCuts() ;
     194#endif
    190195    int cutsBefore = cs.sizeCuts();
    191196    CglTreeInfo info;
     
    206211    } else {
    207212      // Probing - return tight column bounds
    208       generator->generateCutsAndModify(*solver,cs,info);
     213      CglTreeProbingInfo * info2 = model_->probingInfo();
     214      if (info2) {
     215        info2->level = depth;
     216        info2->pass = pass;
     217        info2->formulation_rows = model_->numberRowsAtContinuous();
     218        info2->inTree = node!=NULL;
     219        generator->generateCutsAndModify(*solver,cs,info2);
     220      } else {
     221        generator->generateCutsAndModify(*solver,cs,&info);
     222      }
    209223      const double * tightLower = generator->tightLower();
    210224      const double * lower = solver->getColLower();
     
    265279      assert (!returnCode);
    266280#else
     281      const char * tightenBounds = generator->tightenBounds();
    267282      for (j=0;j<numberColumns;j++) {
    268283        if (solver->isInteger(j)) {
    269284          if (tightUpper[j]<upper[j]) {
    270285            double nearest = floor(tightUpper[j]+0.5);
    271             assert (fabs(tightUpper[j]-nearest)<1.0e-7);
     286            //assert (fabs(tightUpper[j]-nearest)<1.0e-5); may be infeasible
    272287            solver->setColUpper(j,nearest);
    273288            if (nearest<solution[j]-primalTolerance)
     
    276291          if (tightLower[j]>lower[j]) {
    277292            double nearest = floor(tightLower[j]+0.5);
    278             assert (fabs(tightLower[j]-nearest)<1.0e-7);
     293            //assert (fabs(tightLower[j]-nearest)<1.0e-5); may be infeasible
    279294            solver->setColLower(j,nearest);
    280295            if (nearest>solution[j]+primalTolerance)
     
    282297          }
    283298        } else {
    284           if (tightUpper[j]==tightLower[j]&&
    285               upper[j]>lower[j]) {
    286             // fix
    287             solver->setColLower(j,tightLower[j]);
    288             solver->setColUpper(j,tightUpper[j]);
    289             if (tightLower[j]>solution[j]+primalTolerance||
    290                 tightUpper[j]<solution[j]-primalTolerance)
    291               returnCode=true;
    292           }
     299          if (upper[j]>lower[j]) {
     300            if (tightUpper[j]==tightLower[j]) {
     301              // fix
     302              solver->setColLower(j,tightLower[j]);
     303              solver->setColUpper(j,tightUpper[j]);
     304              if (tightLower[j]>solution[j]+primalTolerance||
     305                  tightUpper[j]<solution[j]-primalTolerance)
     306                returnCode=true;
     307            } else if (tightenBounds&&tightenBounds[j]) {
     308              solver->setColLower(j,CoinMax(tightLower[j],lower[j]));
     309              solver->setColUpper(j,CoinMin(tightUpper[j],upper[j]));
     310              if (tightLower[j]>solution[j]+primalTolerance||
     311                  tightUpper[j]<solution[j]-primalTolerance)
     312                returnCode=true;
     313            }
     314          }
    293315        }
    294316      }
     
    296318      //returnCode=true;
    297319#endif
     320#if 0
     321      // Pass across info to pseudocosts
     322      char * mark = new char[numberColumns];
     323      memset(mark,0,numberColumns);
     324      int nLook = generator->numberThisTime();
     325      const int * lookedAt = generator->lookedAt();
     326      const int * fixedDown = generator->fixedDown();
     327      const int * fixedUp = generator->fixedUp();
     328      for (j=0;j<nLook;j++)
     329        mark[lookedAt[j]]=1;
     330      int numberObjects = model_->numberObjects();
     331      for (int i=0;i<numberObjects;i++) {
     332        CbcSimpleIntegerDynamicPseudoCost * obj1 =
     333          dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(model_->modifiableObject(i)) ;
     334        if (obj1) {
     335          int iColumn = obj1->columnNumber();
     336          if (mark[iColumn])
     337            obj1->setProbingInformation(fixedDown[iColumn],fixedUp[iColumn]);
     338        }
     339      }
     340      delete [] mark;
     341#endif
    298342    }
     343#ifdef CBC_DEBUG
     344    {
     345      int numberRowCutsAfter = cs.sizeRowCuts() ;
     346      int k ;
     347      int nBad=0;
     348      for (k = numberRowCutsBefore;k<numberRowCutsAfter;k++) {
     349        OsiRowCut thisCut = cs.rowCut(k) ;
     350        if (thisCut.lb()<=thisCut.ub()) {
     351          /* check size of elements.
     352             We can allow smaller but this helps debug generators as it
     353             is unsafe to have small elements */
     354          int n=thisCut.row().getNumElements();
     355          const int * column = thisCut.row().getIndices();
     356          const double * element = thisCut.row().getElements();
     357          assert (n);
     358          for (int i=0;i<n;i++) {
     359            double value = element[i];
     360            if (fabs(value)<=1.0e-12||fabs(value)>=1.0e20)
     361              nBad++;
     362          }
     363        }
     364        if (nBad)
     365          printf("Cut generator %s produced %d cuts of which %d had tiny or large elements\n",
     366                 generatorName_,numberRowCutsAfter-numberRowCutsBefore,nBad);
     367      }
     368    }
     369#endif
    299370    if (timing_)
    300371      timeInCutGenerator_ += CoinCpuTime()-time1;
  • branches/devel/Cbc/src/CbcMessage.cpp

    r407 r424  
    5353  {CBC_STRONG_STATS,32,1,"Strong branching done %d times (%d iterations), fathomed %d nodes and fixed %d variables"},
    5454  {CBC_UNBOUNDED,34,1,"The LP relaxation is unbounded!"},
     55  {CBC_OTHER_STATS,35,1,"Maximum depth %d, %g variables fixed on reduced cost"},
     56  {CBC_HEURISTICS_OFF,36,1,"Heuristics switched off as %d branching objects are of wrong type"},
    5557  {CBC_DUMMY_END,999999,0,""}
    5658};
  • branches/devel/Cbc/src/CbcMessage.hpp

    r407 r424  
    5858  CBC_STRONG_STATS,
    5959  CBC_UNBOUNDED,
     60  CBC_OTHER_STATS,
     61  CBC_HEURISTICS_OFF,
    6062  CBC_DUMMY_END
    6163};
  • branches/devel/Cbc/src/CbcModel.cpp

    r416 r424  
    5050// include preprocessing
    5151#include "CglPreProcess.hpp"
     52#include "CglDuplicateRow.hpp"
     53#include "CglStored.hpp"
    5254
    5355#include "CoinTime.hpp"
     
    546548  eventHappened_=false;
    547549  CbcEventHandler *eventHandler = getEventHandler() ;
    548  
     550  // set up for probing
     551  probingInfo_ = new CglTreeProbingInfo(solver_);
     552
     553  // Try for dominated columns
     554  if ((specialOptions_&64)!=0) {
     555    CglDuplicateRow dupcuts(solver_);
     556    dupcuts.setMode(2);
     557    CglStored * storedCuts = dupcuts.outDuplicates(solver_);
     558    addCutGenerator(storedCuts,1,"StoredCuts from dominated");
     559  }
    549560  if (!nodeCompare_)
    550561    nodeCompare_=new CbcCompareDefault();;
     
    601612  if (numberBeforeTrust_)
    602613    convertToDynamic();
     614  // take off heuristics if have to
     615  if (numberHeuristics_) {
     616    int numberOdd=0;
     617    for (int i=0;i<numberObjects_;i++) {
     618      if (!object_[i]->canDoHeuristics())
     619        numberOdd++;
     620    }
     621    if (numberOdd) {
     622      for (int i=0;i<numberHeuristics_;i++)
     623        delete heuristic_[i];
     624      delete [] heuristic_;
     625      heuristic_=NULL;
     626      numberHeuristics_=0;
     627      handler_->message(CBC_HEURISTICS_OFF,messages_)<< numberOdd<<CoinMessageEol ;
     628    }
     629  }
    603630  // Set up char array to say if integer
    604631  delete [] integerInfo_;
     
    730757  continuousSolver_ = solver_->clone() ;
    731758#ifdef COIN_HAS_CLP
    732   if ((specialOptions_&32)==0) {
    733     OsiClpSolverInterface * clpSolver
    734       = dynamic_cast<OsiClpSolverInterface *> (solver_);
    735     if (clpSolver) {
    736       ClpSimplex * clpSimplex = clpSolver->getModelPtr();
    737       // take off names
    738       clpSimplex->dropNames();
    739     }
    740   }
     759 {
     760   OsiClpSolverInterface * clpSolver
     761     = dynamic_cast<OsiClpSolverInterface *> (solver_);
     762   if (clpSolver) {
     763     if ((specialOptions_&32)==0) {
     764       ClpSimplex * clpSimplex = clpSolver->getModelPtr();
     765       // take off names
     766       clpSimplex->dropNames();
     767     }
     768     // no crunch if mostly continuous
     769     int numberColumns = solver_->getNumCols();
     770     if (numberColumns>1000&&numberIntegers_*4<numberColumns)
     771       clpSolver->setSpecialOptions(clpSolver->specialOptions()&(~1));
     772   }
     773 }
    741774#endif
    742775
     
    818851  numberNodes2_ = 0 ;
    819852  maximumStatistics_=0;
     853  maximumDepthActual_=0;
     854  numberDJFixed_=0.0;
    820855  statistics_ = NULL;
    821856  // Do on switch
     
    14051440                // again
    14061441                std::cout<<solver_<<std::endl;
    1407                 solver_->resolve();
     1442                resolve(solver_);
    14081443                double objval = solver_->getObjValue();
    14091444                setBestSolution(CBC_SOLUTION, objval,
     
    14871522                                numberOldActiveCuts_,numberNewCuts_) ;
    14881523            if (newNode->numberUnsatisfied()) {
     1524              maximumDepthActual_ = CoinMax(maximumDepthActual_,newNode->depth());
    14891525              newNode->initializeInfo() ;
    14901526              newNode->nodeInfo()->addCuts(cuts,newNode->numberBranches(),
     
    15561592            // need to check if any cuts would do anything
    15571593            OsiCuts theseCuts;
     1594            // reset probing info
     1595            if (probingInfo_)
     1596              probingInfo_->initializeFixing();
    15581597            for (int i = 0;i<numberCutGenerators_;i++) {
    15591598              bool generate = generator_[i]->normal();
     
    17541793      << strongInfo_[0] << numberStrongIterations_ << strongInfo_[2]
    17551794      << strongInfo_[1] << CoinMessageEol ;
     1795  handler_->message(CBC_OTHER_STATS,messages_)
     1796      << maximumDepthActual_
     1797      << numberDJFixed_ << CoinMessageEol ;
    17561798  if (statistics_) {
    17571799    // report in some way
     
    21742216  maximumStatistics_(0),
    21752217  statistics_(NULL),
     2218  maximumDepthActual_(0),
     2219  numberDJFixed_(0.0),
     2220  probingInfo_(NULL),
    21762221  numberFixedAtRoot_(0),
    21772222  numberFixedNow_(0),
     
    22972342  maximumStatistics_(0),
    22982343  statistics_(NULL),
     2344  maximumDepthActual_(0),
     2345  numberDJFixed_(0.0),
     2346  probingInfo_(NULL),
    22992347  numberFixedAtRoot_(0),
    23002348  numberFixedNow_(0),
     
    25052553  maximumStatistics_(0),
    25062554  statistics_(NULL),
     2555  maximumDepthActual_(0),
     2556  numberDJFixed_(0.0),
     2557  probingInfo_(NULL),
    25072558  numberFixedAtRoot_(rhs.numberFixedAtRoot_),
    25082559  numberFixedNow_(rhs.numberFixedNow_),
     
    26022653  problemFeasibility_=rhs.problemFeasibility_->clone();
    26032654  tree_= rhs.tree_->clone();
    2604   branchingMethod_=rhs.branchingMethod_;
     2655  if (rhs.branchingMethod_)
     2656    branchingMethod_=rhs.branchingMethod_->clone();
     2657  else
     2658    branchingMethod_=NULL;
    26052659  cbcColLower_ = NULL;
    26062660  cbcColUpper_ = NULL;
     
    28152869    maximumStatistics_ = 0;
    28162870    statistics_ = NULL;
     2871    delete probingInfo_;
     2872    probingInfo_=NULL;
    28172873    numberFixedAtRoot_ = rhs.numberFixedAtRoot_;
    28182874    numberFixedNow_ = rhs.numberFixedNow_;
     
    28832939    delete tree_;
    28842940    tree_= rhs.tree_->clone();
    2885     branchingMethod_=rhs.branchingMethod_;
     2941    if (rhs.branchingMethod_)
     2942      branchingMethod_=rhs.branchingMethod_->clone();
     2943    else
     2944      branchingMethod_=NULL;
    28862945    delete strategy_;
    28872946    if (rhs.strategy_)
     
    30273086  delete [] statistics_;
    30283087  statistics_=NULL;
     3088  maximumDepthActual_ = 0;
     3089  numberDJFixed_ =0.0;
     3090  delete probingInfo_;
     3091  probingInfo_ = NULL;
    30293092  maximumStatistics_=0;
    30303093  delete [] analyzeResults_;
     
    30543117  nextRowCut_=NULL;
    30553118  currentNode_=NULL;
     3119  delete branchingMethod_;
     3120  branchingMethod_=NULL;
    30563121  // clear out tree
    30573122  if (tree_&&tree_->size())
     
    35773642#endif
    35783643      numberFixed++ ; } } }
     3644  numberDJFixed_ += numberFixed;
    35793645 
    35803646  return numberFixed; }
     
    36203686
    36213687{
     3688# ifdef COIN_HAS_CLP
     3689  OsiClpSolverInterface * clpSolver
     3690    = dynamic_cast<OsiClpSolverInterface *> (solver_);
     3691  int saveClpOptions=0;
     3692  if (clpSolver)
     3693    saveClpOptions = clpSolver->specialOptions();
     3694# endif
    36223695  bool feasible = true ;
    36233696  int lastNumberCuts = 0 ;
     
    36983771  if (!feasible) {
    36993772    numberInfeasibleNodes_++;
     3773# ifdef COIN_HAS_CLP
     3774    if (clpSolver)
     3775    clpSolver->setSpecialOptions(saveClpOptions);
     3776# endif
    37003777    return (false) ;
    37013778  }
     
    37113788    cuts=OsiCuts();
    37123789    numberNewCuts_=0;
     3790# ifdef COIN_HAS_CLP
     3791    if (clpSolver)
     3792    clpSolver->setSpecialOptions(saveClpOptions);
     3793# endif
    37133794    return true;
    37143795  }
     
    38603941    int found = -1; // no solution found
    38613942
     3943    // reset probing info
     3944    if (probingInfo_)
     3945      probingInfo_->initializeFixing();
    38623946    for (int i = 0;i<numberCutGenerators_+numberHeuristics_;i++) {
    38633947      int numberRowCutsBefore = theseCuts.sizeRowCuts() ;
     
    45254609#endif
    45264610    }
     4611    int iProbing=-1;
    45274612    double small = (0.5* totalCuts) /
    45284613      ((double) numberActiveGenerators) ;
    45294614    for (i = 0;i<numberCutGenerators_;i++) {
    45304615      int howOften = generator_[i]->howOften() ;
     4616      /*  Probing can be set to just do column cuts in treee.
     4617          But if doing good then leave as on */
     4618      bool probingWasOnBut=false;
     4619      CglProbing * probing = dynamic_cast<CglProbing*>(generator_[i]->generator());
     4620      if (probing&&!numberNodes_) {
     4621        iProbing = i;
     4622        if (probing->rowCuts()==-3) {
     4623          probingWasOnBut=true;
     4624          howOften = -98;
     4625          probing->setRowCuts(3);
     4626        }
     4627      }
    45314628      if (willBeCutsInTree<0&&howOften==-98)
    45324629        howOften =-99;
     
    45544651              howOften = 1000000+SCANCUTS; // wait until next time
    45554652          } else if (thisCuts<small) {
    4556             int k = (int) sqrt(small/thisCuts) ;
    4557             if (howOften!=-98)
    4558               howOften = k+1000000 ;
    4559             else
    4560               howOften=-100;
     4653            if (howOften!=1&&!probingWasOnBut) {
     4654              if (generator_[i]->whatDepth()<0||howOften!=-1) {
     4655                int k = (int) sqrt(small/thisCuts) ;
     4656                if (howOften!=-98)
     4657                  howOften = k+1000000 ;
     4658                else
     4659                  howOften=-100;
     4660              } else {
     4661                howOften=1;
     4662              }
     4663            } else {
     4664              howOften=1;
     4665              // allow cuts
     4666              probingWasOnBut=false;
     4667            }
    45614668          } else {
     4669            if (thisObjective-startObjective<0.1*fabs(startObjective)+1.0e-5&&generator_[i]->whatDepth()<0)
     4670              generator_[i]->setWhatDepth(5);
    45624671            howOften = 1+1000000 ;
    4563             if (thisObjective-startObjective<0.1*fabs(startObjective)+1.0e-5)
    4564               generator_[i]->setWhatDepth(5);
    45654672          }
    45664673        }
     
    45714678        }
    45724679      }
    4573       if (howOften>=0&&generator_[i]->generator()->mayGenerateRowCutsInTree())
    4574         willBeCutsInTree=1;
     4680      if (!numberNodes_) {
     4681        if (probingWasOnBut&&howOften==-100) {
     4682          probing->setRowCuts(-3);
     4683          howOften=1;
     4684        }
     4685        if (howOften==1)
     4686          generator_[i]->setWhatDepth(1);
    45754687       
     4688        if (howOften>=0&&generator_[i]->generator()->mayGenerateRowCutsInTree())
     4689          willBeCutsInTree=1;
     4690      }
    45764691      generator_[i]->setHowOften(howOften) ;
    45774692      if (howOften>=1000000&&howOften<2000000&&0) {
     
    46044719    delete [] count ;
    46054720    if( !numberNodes_) {
     4721      // decide on pseudo cost strategy
     4722      int howOften = iProbing>=0 ? generator_[iProbing]->howOften() : 0;
     4723      if ((howOften %1000000)!=1)
     4724        howOften = 0;
     4725      //if (howOften) {
     4726      //CglProbing * probing = dynamic_cast<CglProbing*>(generator_[iProbing]->generator());
     4727      //}
     4728      howOften = 0;
     4729      if (howOften) {
     4730        printf("** method 1\n");
     4731        //CglProbing * probing = dynamic_cast<CglProbing*>(generator_[iProbing]->generator());
     4732        generator_[iProbing]->setWhatDepth(1);
     4733        // could set no row cuts
     4734        //if (thisObjective-startObjective<0.001*fabs(startObjective)+1.0e-5)
     4735        // probing->setRowCuts(0);
     4736        for (int i=0;i<numberObjects_;i++) {
     4737          CbcSimpleIntegerDynamicPseudoCost * obj =
     4738            dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object_[i]) ;
     4739          if (obj)
     4740            obj->setMethod(1);
     4741        }
     4742      }
    46064743      if (willBeCutsInTree==-2)
    46074744        willBeCutsInTree=0;
     
    46244761            delete [] added;
    46254762            // resolve so optimal
    4626             solver_->resolve();
     4763            resolve(solver_);
    46274764          }
    46284765        }
     
    46804817    assert(feasible) ;
    46814818#endif
     4819# ifdef COIN_HAS_CLP
     4820  if (clpSolver)
     4821    clpSolver->setSpecialOptions(saveClpOptions);
     4822# endif
    46824823
    46834824  return feasible ; }
     
    48294970        int easy=2;
    48304971        solver_->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,&easy) ;
    4831         solver_->resolve() ;
     4972        resolve(solver_) ;
    48324973        setPointers(solver_);
    48334974        solver_->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,NULL) ;
     
    49105051  if (feasible)
    49115052    {
    4912       solver_->resolve() ;
     5053      resolve(solver_) ;
    49135054      numberIterations_ += solver_->getIterationCount() ;
    49145055      feasible = (solver_->isProvenOptimal() &&
     
    49355076    if (saveTakeHint||saveStrength==OsiHintIgnore) {
    49365077      solver_->setHintParam(OsiDoDualInResolve,false,OsiHintDo) ;
    4937       solver_->resolve();
     5078      resolve(solver_);
    49385079      solver_->setHintParam(OsiDoDualInResolve,saveTakeHint,saveStrength);
    49395080      numberIterations_ += solver_->getIterationCount() ;
     
    54515592*/
    54525593  object_ = new CbcObject * [numberIntegers_+nObjects];
    5453   numberObjects_=numberIntegers_+nObjects;;
     5594  numberObjects_=numberIntegers_+nObjects;
    54545595  integerVariable_ = new int [numberIntegers_];
    54555596/*
     
    54865627  int iObject;
    54875628  const double * cost = solver_->getObjCoefficients();
     5629  bool allDynamic=true;
    54885630  for (iObject = 0;iObject<numberObjects_;iObject++) {
    54895631    CbcSimpleInteger * obj1 =
     
    55095651      }
    55105652      CbcSimpleIntegerDynamicPseudoCost * newObject =
    5511         new CbcSimpleIntegerDynamicPseudoCost(this,iObject,iColumn,downCost,upCost);
     5653        new CbcSimpleIntegerDynamicPseudoCost(this,iObject,iColumn,1.0e0*downCost,1.0e0*upCost);
    55125654      newObject->setNumberBeforeTrust(numberBeforeTrust_);
    55135655      newObject->setPriority(priority);
    55145656      newObject->setPreferredWay(preferredWay);
    55155657      object_[iObject] = newObject;
     5658    } else if (!obj2) {
     5659      allDynamic=false;
    55165660    }
    55175661  }
    55185662  if (branchingMethod_&&(branchingMethod_->whichMethod()&1)==0) {
    55195663    // Need a method which can do better
     5664    delete branchingMethod_;
    55205665    branchingMethod_=NULL;
     5666  }
     5667  if (!branchingMethod_&&allDynamic) {
     5668    // create one
     5669    branchingMethod_ = new CbcBranchDynamicDecision();
    55215670  }
    55225671}
     
    57735922      Perhaps an opportunity for a sanity check?
    57745923    */
     5924    if (objectiveValue>cutoff&&objectiveValue<cutoff+1.0e-8+1.0e-8*fabs(cutoff))
     5925      cutoff = objectiveValue; // relax
    57755926    if ((solver_->isProvenOptimal()||(specialOptions_&4)!=0) && objectiveValue <= cutoff) {
    57765927      double * solution = new double[numberColumns];
     
    58656016              object_[i]->feasibleRegion();
    58666017            testSolution_ = save;
    5867             solver_->resolve();
     6018            resolve(solver_);
    58686019          }
    58696020       
     
    58776028        int i;
    58786029        int lastNumberCuts=0;
     6030        // reset probing info
     6031        if (probingInfo_)
     6032          probingInfo_->initializeFixing();
    58796033        for (i=0;i<numberCutGenerators_;i++)
    58806034          {
     
    59796133    */
    59806134    objectiveValue =checkSolution(cutoff,solution,fixVariables,objectiveValue);
     6135    if (objectiveValue>cutoff&&objectiveValue<cutoff+1.0e-8+1.0e-8*fabs(cutoff))
     6136      cutoff = objectiveValue; // relax
    59816137    if (objectiveValue > cutoff) {
    59826138      if (objectiveValue>1.0e30)
     
    60246180      int i;
    60256181      int lastNumberCuts=0;
     6182      // reset probing info
     6183      if (probingInfo_)
     6184        probingInfo_->initializeFixing();
    60266185      for (i=0;i<numberCutGenerators_;i++) {
    60276186        bool generate = generator_[i]->atSolution();
     
    63586517  CglProbing* generator = NULL;
    63596518  int iGen;
     6519  // reset probing info
     6520  if (probingInfo_)
     6521    probingInfo_->initializeFixing();
    63606522  for (iGen=0;iGen<numberCutGenerators_;iGen++) {
    63616523    generator = dynamic_cast<CglProbing*>(generator_[iGen]->generator());
     
    63816543   
    63826544    // Probing - return tight column bounds
    6383     generator->generateCutsAndModify(*solver,cuts);
     6545    CglTreeInfo info;
     6546    generator->generateCutsAndModify(*solver,cuts,&info);
    63846547    const double * tightLower = generator->tightLower();
    63856548    const double * lower = solver->getColLower();
     
    64856648          // Probing - return tight column bounds
    64866649          cuts = OsiCuts();
    6487           generator->generateCutsAndModify(*solver,cuts);
     6650          CglTreeInfo info;
     6651          generator->generateCutsAndModify(*solver,cuts,&info);
    64886652          const double * tightLower = generator->tightLower();
    64896653          const double * lower = solver->getColLower();
     
    76617825*/
    76627826
     7827// Encapsulates solver resolve
     7828int
     7829CbcModel::resolve(OsiSolverInterface * solver)
     7830{
     7831#ifdef COIN_HAS_CLP
     7832  OsiClpSolverInterface * clpSolver
     7833    = dynamic_cast<OsiClpSolverInterface *> (solver);
     7834  if (clpSolver) {
     7835    /*bool takeHint;
     7836    OsiHintStrength strength;
     7837    bool gotHint = (clpSolver->getHintParam(OsiDoDualInResolve,takeHint,strength));
     7838    assert (gotHint);
     7839    int algorithm=-1;
     7840    if (strength!=OsiHintIgnore)
     7841      algorithm = takeHint ? -1 : 1;
     7842      assert (algorithm==-1);*/
     7843    clpSolver->setHintParam(OsiDoDualInResolve,true,OsiHintTry);
     7844    ClpSimplex * clpSimplex = clpSolver->getModelPtr();
     7845    int save = clpSimplex->specialOptions();
     7846    clpSimplex->setSpecialOptions(save|0x01000000); // say is Cbc (and in branch and bound)
     7847    clpSolver->resolve();
     7848    clpSimplex->setSpecialOptions(save);
     7849  } else {
     7850    solver->resolve();
     7851  }
     7852#else
     7853  solver->resolve();
     7854#endif
     7855  return solver->isProvenOptimal() ? 1 : 0;
     7856}
    76637857
    76647858// Set log level
  • branches/devel/Cbc/src/CbcModel.hpp

    r407 r424  
    2020class OsiRowCutDebugger;
    2121class CglCutGenerator;
     22class CglTreeProbingInfo;
    2223class CbcHeuristic;
    2324class CbcObject;
     
    11051106  /// Set the branching decision method.
    11061107  inline void setBranchingMethod(CbcBranchDecision * method)
    1107   { branchingMethod_ = method;};
     1108  { branchingMethod_ = method->clone();};
    11081109  /** Set the branching method
    11091110 
     
    11111112  */
    11121113  inline void setBranchingMethod(CbcBranchDecision & method)
    1113   { branchingMethod_ = &method;};
     1114  { branchingMethod_ = method.clone();};
    11141115  //@}
    11151116
     
    13011302      4 bit (16) - non-linear model and someone too lazy to code "times" correctly - so skip row check
    13021303      5 bit (32) - keep names
     1304      6 bit (64) - try for dominated columns
    13031305  */
    13041306  /// Set special options
     
    13821384  */
    13831385  int reducedCostFix() ;
     1386  /// Encapsulates solver resolve
     1387  int resolve(OsiSolverInterface * solver);
    13841388
    13851389  /** Return an empty basis object of the specified size
     
    14691473  inline CbcNode * currentNode() const
    14701474  { return currentNode_;};
     1475  /// Get a pointer to probing info
     1476  inline CglTreeProbingInfo * probingInfo() const
     1477  { return probingInfo_;};
    14711478  /// Set the number of iterations done in strong branching.
    14721479  inline void setNumberStrongIterations(int number)
     
    17931800  /// statistics
    17941801  CbcStatistics ** statistics_;
     1802  /// Maximum depth reached
     1803  int maximumDepthActual_;
     1804  /// Number of reduced cost fixings
     1805  double numberDJFixed_;
     1806  /// Probing info
     1807  CglTreeProbingInfo * probingInfo_;
    17951808  /// Number of fixed by analyze at root
    17961809  int numberFixedAtRoot_;
  • branches/devel/Cbc/src/CbcNode.cpp

    r395 r424  
    682682
    683683  if (lastNode)
     684    if (lastNode->nodeInfo_)
    684685    lastNode->nodeInfo_->increment();
    685686}
     
    932933  */
    933934  CbcBranchDecision *decision = model->branchingMethod();
    934   if (!decision)
     935  CbcDynamicPseudoCostBranchingObject * dynamicBranchingObject =
     936    dynamic_cast<CbcDynamicPseudoCostBranchingObject *>(decision);
     937  if (!decision||dynamicBranchingObject)
    935938    decision = new CbcBranchDefaultDecision();
    936939
     
    18261829  Cleanup, then we're outta here.
    18271830*/
    1828   if (!model->branchingMethod())
     1831  if (!model->branchingMethod()||dynamicBranchingObject)
    18291832    delete decision;
    18301833   
     
    19601963  double estimatedDegradation=0.0;
    19611964  int numberNodes=model->getNodeCount();
     1965  int saveLogLevel = model->logLevel();
     1966  if ((numberNodes%500)==0&&false) {
     1967    model->setLogLevel(6);
     1968    // Get average up and down costs
     1969    double averageUp=0.0;
     1970    double averageDown=0.0;
     1971    int numberUp=0;
     1972    int numberDown=0;
     1973    int i;
     1974    for ( i=0;i<numberObjects;i++) {
     1975      CbcObject * object = model->modifiableObject(i);
     1976      CbcSimpleIntegerDynamicPseudoCost * dynamicObject =
     1977        dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object) ;
     1978      assert(dynamicObject);
     1979      int  numberUp2=0;
     1980      int numberDown2=0;
     1981      double up=0.0;
     1982      double down=0.0;
     1983      if (dynamicObject->numberTimesUp()) {
     1984        numberUp++;
     1985        averageUp += dynamicObject->upDynamicPseudoCost();
     1986        numberUp2 += dynamicObject->numberTimesUp();
     1987        up = dynamicObject->upDynamicPseudoCost();
     1988      }
     1989      if (dynamicObject->numberTimesDown()) {
     1990        numberDown++;
     1991        averageDown += dynamicObject->downDynamicPseudoCost();
     1992        numberDown2 += dynamicObject->numberTimesDown();
     1993        down = dynamicObject->downDynamicPseudoCost();
     1994      }
     1995      if (numberUp2||numberDown2)
     1996        printf("col %d - up %d times cost %g, - down %d times cost %g\n",
     1997               dynamicObject->columnNumber(),numberUp2,up,numberDown2,down);
     1998    }
     1999    if (numberUp)
     2000      averageUp /= (double) numberUp;
     2001    else
     2002      averageUp=1.0;
     2003    if (numberDown)
     2004      averageDown /= (double) numberDown;
     2005    else
     2006      averageDown=1.0;
     2007    printf("total - up %d vars average %g, - down %d vars average %g\n",
     2008           numberUp,averageUp,numberDown,averageDown);
     2009  }
    19622010  int numberBeforeTrust = model->numberBeforeTrust();
    19632011  int numberPenalties = model->numberPenalties();
     
    19832031  OsiSolverInterface *osiclp = 0 ;
    19842032# endif
     2033  const CglTreeProbingInfo * probingInfo = model->probingInfo();
    19852034  int saveSearchStrategy2 = model->searchStrategy();
    19862035  if (saveSearchStrategy2<999) {
     
    20672116    int * which = objectMark+numberObjects+1;
    20682117    int neededPenalties;
     2118    int branchingMethod=-1;
    20692119    // We may go round this loop three times (only if we think we have solution)
    20702120    for (int iPass=0;iPass<3;iPass++) {
     
    20802130      numberUnsatisfied_ = 0;
    20812131      int bestPriority=INT_MAX;
     2132      int number01 = 0;
     2133      const fixEntry * entry = NULL;
     2134      const int * toZero = NULL;
     2135      const int * toOne = NULL;
     2136      const int * backward = NULL;
     2137      int numberUnsatisProbed=0;
     2138      int numberUnsatisNotProbed=0; // 0-1
     2139      if (probingInfo) {
     2140        number01 = probingInfo->numberIntegers();
     2141        entry = probingInfo->fixEntries();
     2142        toZero = probingInfo->toZero();
     2143        toOne = probingInfo->toOne();
     2144        backward = probingInfo->backward();
     2145        if (!toZero[number01]) {
     2146          // no info
     2147          probingInfo=NULL;
     2148        }
     2149      }
    20822150      /*
    20832151        Scan for branching objects that indicate infeasibility. Choose candidates
     
    21172185#endif
    21182186        if (infeasibility) {
     2187          // check branching method
     2188          if (branchingMethod!=dynamicObject->method()) {
     2189            if (branchingMethod==-1)
     2190              branchingMethod = dynamicObject->method();
     2191            else
     2192              branchingMethod = 100;
     2193          }
    21192194          int iColumn = dynamicObject->columnNumber();
     2195          if (probingInfo) {
     2196            int iSeq = backward[iColumn];
     2197            if (iSeq>=0) {
     2198              if (toZero[iSeq+1]>toZero[iSeq]) {
     2199                numberUnsatisProbed++;
     2200              } else {
     2201                numberUnsatisNotProbed++;
     2202              }
     2203            }
     2204          }
    21202205          //double gap = saveUpper[iColumn]-saveLower[iColumn];
    21212206          // Give precedence to ones with gap of 1.0
     
    21842269      }
    21852270      if (numberUnsatisfied_) {
     2271        if (probingInfo&&false)
     2272          printf("nunsat %d, %d probed, %d other 0-1\n",numberUnsatisfied_,
     2273                 numberUnsatisProbed,numberUnsatisNotProbed);
    21862274        // some infeasibilities - go to next steps
    21872275        break;
     
    22522340    bool skipAll = numberNotTrusted==0;
    22532341    bool doneHotStart=false;
     2342    int searchStrategy = saveSearchStrategy>=0 ? (saveSearchStrategy%10) : -1;
    22542343#ifndef CBC_WEAK_STRONG
    2255     if ((numberNodes%20)==0||(model->specialOptions()&8)!=0)
     2344    if (((numberNodes%20)==0&&searchStrategy!=2)||(model->specialOptions()&8)!=0)
    22562345      skipAll=false;
    22572346#endif
    2258     int searchStrategy = saveSearchStrategy>=0 ? (saveSearchStrategy%10) : -1;
    22592347    if (!newWay) {
    22602348    // 10 up always use %10, 20 up as 10 and allow penalties
     
    22632351      if (numberBeforeTrust>=5&&numberBeforeTrust<=10) {
    22642352        if (searchStrategy!=2) {
    2265           int numberIterations = model->getIterationCount();
    2266           int numberStrongIterations = model->numberStrongIterations();
    2267           if (numberStrongIterations>numberIterations+10000) {
    2268             searchStrategy=2;
    2269             //skipAll=true;
    2270           } else if (numberStrongIterations*4+1000<numberIterations||depth_<5) {
    2271             searchStrategy=3;
    2272             skipAll=false;
    2273           }
     2353          if (depth_>5) {
     2354            int numberIterations = model->getIterationCount();
     2355            int numberStrongIterations = model->numberStrongIterations();
     2356            if (numberStrongIterations>numberIterations+10000) {
     2357              searchStrategy=2;
     2358              //skipAll=true;
     2359            } else if (numberStrongIterations*4+1000<numberIterations||depth_<5) {
     2360              searchStrategy=3;
     2361              skipAll=false;
     2362            }
     2363          } else {
     2364            searchStrategy=3;
     2365            skipAll=false;
     2366          }
    22742367        } else {
    2275           skipAll=true;
     2368          //skipAll=true;
    22762369        }
    22772370      }
     
    23382431                        model->getDblParam(CbcModel::CbcMaximumSeconds));
    23392432    // also give up if we are looping round too much
    2340     if (hitMaxTime||numberPassesLeft<=0||(!numberNotTrusted&&false)) {
     2433    if (hitMaxTime||numberPassesLeft<=0||(!numberNotTrusted&&false)||branchingMethod==11) {
    23412434      int iObject = whichObject[bestChoice];
    23422435      CbcObject * object = model->modifiableObject(iObject);
     
    24722565      solver->getIntParam(OsiMaxNumIterationHotStart,saveLimit2);
    24732566      bool doQuickly = false; // numberToDo>2*numberStrong;
     2567      if (searchStrategy==2)
     2568        doQuickly=true;
    24742569      //printf("todo %d, strong %d\n",numberToDo,numberStrong);
    24752570      int numberTest=numberNotTrusted>0 ? numberStrong : (numberStrong+1)/2;
    24762571      int numberTest2 = 2*numberStrong;
     2572      double distanceToCutoff2 = model->getCutoff()-objectiveValue_;
    24772573      if (!newWay) {
    24782574      if (searchStrategy==3) {
     
    25122608        if (searchStrategy!=2) {
    25132609          doQuickly=false;
    2514           if (depth_<7)
    2515             numberStrong *=3;
    2516           if (!depth_)
    2517             numberStrong=CoinMin(6*numberStrong,numberToDo);
     2610          int numberRows = solver->getNumRows();
     2611          // whether to do this or not is important - think
     2612          if (numberRows<300||numberRows+numberColumns<2500) {
     2613            if (depth_<7)
     2614              numberStrong = CoinMin(3*numberStrong,numberToDo);
     2615            if (!depth_)
     2616              numberStrong=CoinMin(6*numberStrong,numberToDo);
     2617          }
    25182618          numberTest=numberStrong;
    25192619          skipAll=false;
     
    26122712      px[2]= doQuickly ? 1 : -1;
    26132713      px[3]=numberStrong;
     2714      if (!newWay) {
     2715        if (numberColumns>8*solver->getNumRows()&&false) {
     2716          printf("skipAll %c doQuickly %c numberTest %d numberTest2 %d numberNot %d\n",
     2717                 skipAll ? 'Y' : 'N',doQuickly ? 'Y' : 'N',numberTest,numberTest2,numberNotTrusted);
     2718          numberTest = CoinMin(numberTest,model->numberStrong());
     2719          numberTest2 = CoinMin(numberTest2,model->numberStrong());
     2720          printf("new test,test2 %d %d\n",numberTest,numberTest2);
     2721        }
     2722      }
    26142723      //printf("skipAll %c doQuickly %c numberTest %d numberTest2 %d numberNot %d\n",
    26152724      //     skipAll ? 'Y' : 'N',doQuickly ? 'Y' : 'N',numberTest,numberTest2,numberNotTrusted);
     
    26222731      //numberToDo = 1; // trust previous stuff
    26232732      bool couldChooseFirst = false ; //(skipAll&&numberTest==0&&doQuickly);
     2733      //skipAll=false;
    26242734      for ( iDo=0;iDo<numberToDo;iDo++) {
    26252735        CbcStrongInfo choice;
     
    26412751        assert (choice.downMovement>=0.0);
    26422752        choice.fix=0; // say not fixed
     2753        double maxChange = 0.5*(choice.upMovement+choice.downMovement);
     2754        maxChange = CoinMin(choice.upMovement,choice.downMovement);
     2755        maxChange = CoinMax(choice.upMovement,choice.downMovement);
     2756        if (searchStrategy==2)
     2757          maxChange = COIN_DBL_MAX;
     2758        //maxChange *= 5.0;
     2759        if (dynamicObject->method()==1)
     2760          maxChange *= 0.1; // probing
    26432761        // see if can skip strong branching
    26442762        int canSkip = choice.possibleBranch->fillStrongInfo(choice);
    26452763        if (!newWay) {
    2646         if (!doQuickly||(numberTest>0&&searchStrategy!=2))
     2764          if ((maxChange>distanceToCutoff2)&&(!doQuickly||(numberTest>0&&searchStrategy!=2)))
    26472765          canSkip=0;
    26482766        } else {
     
    32723390  delete [] saveSolution;
    32733391  model->setStateOfSearch(saveStateOfSearch);
     3392  model->setLogLevel(saveLogLevel);
    32743393  return anyAction;
    32753394}
     
    36803799  if (this != &rhs) {
    36813800    delete nodeInfo_;
    3682     if (nodeInfo_)
     3801    if (rhs.nodeInfo_)
    36833802      nodeInfo_ = rhs.nodeInfo_->clone();
    36843803    else
  • branches/devel/Cbc/src/CbcStrategy.cpp

    r404 r424  
    330330    // Add in generators
    331331    process->addCutGenerator(&generator1);
    332     int translate[]={9999,0,2,3};
     332    int translate[]={9999,0,3,2,-1,-2};
    333333    OsiSolverInterface * solver2 =
    334334      process->preProcessNonDefault(*solver,
  • branches/devel/Cbc/src/CbcStrategy.hpp

    r356 r424  
    176176      1 - ordinary
    177177      2 - find sos
     178      3 - find cliques
     179      4 - more aggressive sos
     180      5 - add integer slacks
    178181  */
    179182  int desiredPreProcess_;
  • branches/devel/Cbc/src/CbcTree.cpp

    r421 r424  
    7676    best = nodes_.front();
    7777    if (best)
     78      assert(best->objectiveValue()!=COIN_DBL_MAX&&best->nodeInfo());
     79    if (best&&best->objectiveValue()!=COIN_DBL_MAX&&best->nodeInfo())
    7880      assert (best->nodeInfo()->numberBranchesLeft());
    7981    if (!best||best->objectiveValue()>=cutoff) {
     
    8486    }
    8587  }
    86   if (best&&comparison_.test_->fullScan()) {
     88  // switched off for now
     89  if (best&&comparison_.test_->fullScan()&&false) {
    8790    CbcNode * saveBest=best;
    8891    int n=nodes_.size();
    8992    int iBest=-1;
    9093    for (int i=0;i<n;i++) {
    91       if (nodes_[i])
     94      // temp
     95      assert (nodes_[i]);
     96      assert (nodes_[i]->nodeInfo());
     97      if (nodes_[i]&&nodes_[i]->objectiveValue()!=COIN_DBL_MAX&&nodes_[i]->nodeInfo())
    9298        assert (nodes_[i]->nodeInfo()->numberBranchesLeft());
    9399      if (nodes_[i]&&nodes_[i]->objectiveValue()<cutoff
     
    105111      // make impossible
    106112      nodes_[iBest]=NULL;
    107       //printf("needs coding CbcTree::bestNode\n");
    108       //abort();
    109113    }
    110114  } else if (best) {
     
    188192    model->addCuts1(node,lastws);
    189193    // Decrement cut counts
    190     int numberLeft = node->nodeInfo()->numberBranchesLeft();
     194    assert (node);
     195    //assert (node->nodeInfo());
     196    int numberLeft = (node->nodeInfo()) ? node->nodeInfo()->numberBranchesLeft() : 0;
    191197    int i;
    192198    for (i=0;i<model->currentNumberCuts();i++) {
     
    201207    }
    202208    // node should not have anything pointing to it
    203     node->nodeInfo()->throwAway();
     209    if (node->nodeInfo())   
     210      node->nodeInfo()->throwAway();
    204211    delete node ;
    205212    delete lastws ;
  • branches/devel/Cbc/src/CoinSolve.cpp

    r417 r424  
    6666#include "CglTwomir.hpp"
    6767#include "CglDuplicateRow.hpp"
     68#include "CglStored.hpp"
     69#include "CglLandP.hpp"
    6870
    6971#include "CbcModel.hpp"
     
    8991                        std::string & check);
    9092static void generateCode(const char * fileName,int type,int preProcess);
    91 //#############################################################################
    92 
    9393#ifdef NDEBUG
    9494#undef NDEBUG
    9595#endif
     96//#############################################################################
     97//  Start any fake main program
     98//  End any fake main program
     99//#############################################################################
     100
    96101// Allow for interrupts
    97102// But is this threadsafe ? (so switched off by option)
     
    110115
    111116int mainTest (int argc, const char *argv[],int algorithm,
    112               ClpSimplex empty, bool doPresolve,int switchOff);
     117              ClpSimplex empty, bool doPresolve,int switchOff,bool doVector);
    113118void CbcClpUnitTest (const CbcModel & saveModel);
    114119int CbcOrClpRead_mode=1;
     
    462467  return numberDrop;
    463468}
     469void checkSOS(CbcModel * babModel, const OsiSolverInterface * solver)
     470{
     471#ifdef COIN_DEVELOP
     472  //const double *objective = solver->getObjCoefficients() ;
     473  const double *columnLower = solver->getColLower() ;
     474  const double * columnUpper = solver->getColUpper() ;
     475  const double * solution = solver->getColSolution();
     476  //int numberColumns = solver->getNumCols() ;
     477  //int numberRows = solver->getNumRows();
     478  //double direction = solver->getObjSense();
     479  //int iRow,iColumn;
     480
     481  // Row copy
     482  CoinPackedMatrix matrixByRow(*solver->getMatrixByRow());
     483  //const double * elementByRow = matrixByRow.getElements();
     484  //const int * column = matrixByRow.getIndices();
     485  //const CoinBigIndex * rowStart = matrixByRow.getVectorStarts();
     486  const int * rowLength = matrixByRow.getVectorLengths();
     487
     488  // Column copy
     489  CoinPackedMatrix  matrixByCol(*solver->getMatrixByCol());
     490  const double * element = matrixByCol.getElements();
     491  const int * row = matrixByCol.getIndices();
     492  const CoinBigIndex * columnStart = matrixByCol.getVectorStarts();
     493  const int * columnLength = matrixByCol.getVectorLengths();
     494
     495  const double * rowLower = solver->getRowLower();
     496  const double * rowUpper = solver->getRowUpper();
     497  CbcObject ** objects = babModel->objects();
     498  int numberObjects = babModel->numberObjects();
     499  for (int iObj = 0;iObj<numberObjects;iObj++) {
     500    CbcSOS * objSOS =
     501      dynamic_cast <CbcSOS *>(objects[iObj]) ;
     502    if (objSOS) {
     503      int n=objSOS->numberMembers();
     504      const int * which = objSOS->members();
     505      const double * weight = objSOS->weights();
     506      int type = objSOS->sosType();
     507      // convexity row?
     508      int iColumn;
     509      iColumn=which[0];
     510      int j;
     511      int convex=-1;
     512      for (j=columnStart[iColumn];j<columnStart[iColumn]+columnLength[iColumn];j++) {
     513        int iRow = row[j];
     514        double value = element[j];
     515        if (rowLower[iRow]==1.0&&rowUpper[iRow]==1.0&&
     516            value==1.0) {
     517          // possible
     518          if (rowLength[iRow]==n) {
     519            if (convex==-1)
     520              convex=iRow;
     521            else
     522              convex=-2;
     523          }
     524        }
     525      }
     526      printf ("set %d of type %d has %d members - possible convexity row %d\n",
     527              iObj,type,n,convex);
     528      for (int i=0;i<n;i++) {
     529        iColumn = which[i];
     530        int convex2=-1;
     531        for (j=columnStart[iColumn];j<columnStart[iColumn]+columnLength[iColumn];j++) {
     532          int iRow = row[j];
     533          if (iRow==convex) {
     534            double value = element[j];
     535            if (value==1.0) {
     536              convex2=iRow;
     537            }
     538          }
     539        }
     540        if (convex2<0&&convex>=0) {
     541          printf("odd convexity row\n");
     542          convex=-2;
     543        }
     544        printf("col %d has weight %g and value %g, bounds %g %g\n",
     545               iColumn,weight[i],solution[iColumn],columnLower[iColumn],
     546               columnUpper[iColumn]);
     547      }
     548    }
     549  }
     550#endif
     551}
    464552int main (int argc, const char *argv[])
    465553{
     
    480568    model.setNumberBeforeTrust(21);
    481569    int cutPass=-1234567;
     570    int tunePreProcess=5;
    482571    OsiSolverInterface * solver = model.solver();
    483572    OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
     
    500589#ifdef COIN_HAS_ASL
    501590    ampl_info info;
     591    memset(&info,0,sizeof(info));
    502592    if (argc>2&&!strcmp(argv[2],"-AMPL")) {
    503593      usingAmpl=true;
     
    570660    int dualize=0;
    571661    int doCrash=0;
     662    int doVector=0;
    572663    int doSprint=-1;
    573664    int doScaling=1;
    574665    // set reasonable defaults
    575666    int preSolve=5;
    576     int preProcess=4;
     667    int preProcess=1;
    577668    bool useStrategy=false;
    578669    bool preSolveFile=false;
     
    645736    parameters[whichParam(INCREMENT,numberParameters,parameters)].setDoubleValue(model.getDblParam(CbcModel::CbcCutoffIncrement));
    646737    // Set up likely cut generators and defaults
    647     parameters[whichParam(PREPROCESS,numberParameters,parameters)].setCurrentOption("sos");
     738    parameters[whichParam(PREPROCESS,numberParameters,parameters)].setCurrentOption("on");
    648739    parameters[whichParam(MIPOPTIONS,numberParameters,parameters)].setIntValue(128|64|1);
    649740    parameters[whichParam(MOREMIPOPTIONS,numberParameters,parameters)].setIntValue(-1);
     
    676767    probingGen.setRowCuts(3);
    677768    // set default action (0=off,1=on,2=root)
    678     int probingAction=3;
     769    int probingAction=1;
    679770    parameters[whichParam(PROBINGCUTS,numberParameters,parameters)].setCurrentOption("ifmove");
    680771
     
    715806    int twomirAction=2;
    716807    parameters[whichParam(TWOMIRCUTS,numberParameters,parameters)].setCurrentOption("root");
     808    CglLandP landpGen;
     809    // set default action (0=off,1=on,2=root)
     810    int landpAction=0;
     811    parameters[whichParam(LANDPCUTS,numberParameters,parameters)].setCurrentOption("off");
     812    // Stored cuts
     813    bool storedCuts = false;
    717814
    718815    bool useRounding=true;
     
    815912        if (type==BAB&&goodModel) {
    816913          // check if any integers
    817           if (!lpSolver->integerInformation())
     914#ifdef COIN_HAS_ASL
     915          if (info.numberSos&&doSOS&&usingAmpl) {
     916            // SOS
     917            numberSOS = info.numberSos;
     918          }
     919#endif
     920          if (!lpSolver->integerInformation()&&!numberSOS&&
     921              !clpSolver->numberSOS())
    818922            type=DUALSIMPLEX;
    819923        }
     
    9951099              else if (parameters[iParam].type()==CUTPASS)
    9961100                cutPass = value;
     1101              else if (parameters[iParam].type()==PROCESSTUNE)
     1102                tunePreProcess = value;
    9971103              else if (parameters[iParam].type()==VERBOSE)
    9981104                verbose = value;
     
    11251231              doCrash=action;
    11261232              break;
     1233            case VECTOR:
     1234              doVector=action;
     1235              break;
    11271236            case MESSAGES:
    11281237              lpSolver->messageHandler()->setPrefix(action!=0);
     
    11781287              twomirAction = action;
    11791288              break;
     1289            case LANDPCUTS:
     1290              defaultSettings=false; // user knows what she is doing
     1291              landpAction = action;
     1292              break;
    11801293            case ROUNDING:
    11811294              defaultSettings=false; // user knows what she is doing
     
    11941307              mixedAction = action;
    11951308              twomirAction = action;
     1309              landpAction = action;
    11961310              parameters[whichParam(GOMORYCUTS,numberParameters,parameters)].setCurrentOption(action);
    11971311              parameters[whichParam(PROBINGCUTS,numberParameters,parameters)].setCurrentOption(action);
     
    12051319              parameters[whichParam(MIXEDCUTS,numberParameters,parameters)].setCurrentOption(action);
    12061320              parameters[whichParam(TWOMIRCUTS,numberParameters,parameters)].setCurrentOption(action);
     1321              if (!action) {
     1322                landpAction = action;
     1323                parameters[whichParam(LANDPCUTS,numberParameters,parameters)].setCurrentOption(action);
     1324              }
    12071325              break;
    12081326            case HEURISTICSTRATEGY:
     
    13471465              solveOptions.setSpecialOption(4,presolveOptions);
    13481466              solveOptions.setSpecialOption(5,printOptions);
     1467              if (doVector) {
     1468                ClpMatrixBase * matrix = lpSolver->clpMatrix();
     1469                if (dynamic_cast< ClpPackedMatrix*>(matrix)) {
     1470                  ClpPackedMatrix * clpMatrix = dynamic_cast< ClpPackedMatrix*>(matrix);
     1471                  clpMatrix->makeSpecialColumnCopy();
     1472                }
     1473              }
    13491474              if (method==ClpSolve::useDual) {
    13501475                // dual
     
    15371662          case OUTDUPROWS:
    15381663            if (goodModel) {
    1539               int nOut = outDupRow(clpSolver);
     1664              int numberRows = clpSolver->getNumRows();
     1665              //int nOut = outDupRow(clpSolver);
     1666              CglDuplicateRow dupcuts(clpSolver);
     1667              storedCuts = dupcuts.outDuplicates(clpSolver)!=0;
     1668              int nOut = numberRows-clpSolver->getNumRows();
    15401669              if (nOut&&!noPrinting)
    15411670                printf("%d rows eliminated\n",nOut);
     
    15661695            break;
    15671696          case MIPLIB:
    1568             // User can set options - main differenec is lack of model and CglPreProcess
     1697            // User can set options - main difference is lack of model and CglPreProcess
    15691698            goodModel=true;
    15701699/*
     
    15951724                OsiClpSolverInterface * si =
    15961725                  dynamic_cast<OsiClpSolverInterface *>(solver) ;
    1597                 if (si->getModelPtr()->tightenPrimalBounds()!=0) {
     1726                ClpSimplex * clpSolver = si->getModelPtr();
     1727                if (clpSolver->tightenPrimalBounds()!=0) {
    15981728                  std::cout<<"Problem is infeasible - tightenPrimalBounds!"<<std::endl;
    15991729                  exit(1);
    16001730                }
    1601                 si->getModelPtr()->dual();  // clean up
     1731                if (clpSolver->dualBound()==1.0e10) {
     1732                  // user did not set - so modify
     1733                  // get largest scaled away from bound
     1734                  double largest=1.0e-12;
     1735                  int numberRows = clpSolver->numberRows();
     1736                  const double * rowPrimal = clpSolver->primalRowSolution();
     1737                  const double * rowLower = clpSolver->rowLower();
     1738                  const double * rowUpper = clpSolver->rowUpper();
     1739                  const double * rowScale = clpSolver->rowScale();
     1740                  int iRow;
     1741                  for (iRow=0;iRow<numberRows;iRow++) {
     1742                    double value = rowPrimal[iRow];
     1743                    double above = value-rowLower[iRow];
     1744                    double below = rowUpper[iRow]-value;
     1745                    if (rowScale) {
     1746                      double multiplier = rowScale[iRow];
     1747                      above *= multiplier;
     1748                      below *= multiplier;
     1749                    }
     1750                    if (above<1.0e12)
     1751                      largest = CoinMax(largest,above);
     1752                    if (below<1.0e12)
     1753                      largest = CoinMax(largest,below);
     1754                  }
     1755                 
     1756                  int numberColumns = clpSolver->numberColumns();
     1757                  const double * columnPrimal = clpSolver->primalColumnSolution();
     1758                  const double * columnLower = clpSolver->columnLower();
     1759                  const double * columnUpper = clpSolver->columnUpper();
     1760                  const double * columnScale = clpSolver->columnScale();
     1761                  int iColumn;
     1762                  for (iColumn=0;iColumn<numberColumns;iColumn++) {
     1763                    double value = columnPrimal[iColumn];
     1764                    double above = value-columnLower[iColumn];
     1765                    double below = columnUpper[iColumn]-value;
     1766                    if (columnScale) {
     1767                      double multiplier = 1.0/columnScale[iColumn];
     1768                      above *= multiplier;
     1769                      below *= multiplier;
     1770                    }
     1771                    if (above<1.0e12)
     1772                      largest = CoinMax(largest,above);
     1773                    if (below<1.0e12)
     1774                      largest = CoinMax(largest,below);
     1775                  }
     1776                  //if (!noPrinting)
     1777                  //std::cout<<"Largest (scaled) away from bound "<<largest<<std::endl;
     1778                  clpSolver->setDualBound(CoinMin(1000.0*largest,1.00001e10));
     1779                }
     1780                clpSolver->dual();  // clean up
    16021781              }
    16031782              // If user made settings then use them
     
    16871866              double timeLeft = babModel->getMaximumSeconds();
    16881867              int numberOriginalColumns = babModel->solver()->getNumCols();
    1689               if (preProcess==6) {
     1868              if (preProcess==7) {
    16901869                // use strategy instead
    16911870                preProcess=0;
     
    16931872              }
    16941873              if (preProcess&&type==BAB) {
     1874                // See if sos from mps file
     1875                if (numberSOS==0&&clpSolver->numberSOS()&&doSOS) {
     1876                  // SOS
     1877                  numberSOS = clpSolver->numberSOS();
     1878                  const CoinSet * setInfo = clpSolver->setInfo();
     1879                  sosStart = new int [numberSOS+1];
     1880                  sosType = new char [numberSOS];
     1881                  int i;
     1882                  int nTotal=0;
     1883                  sosStart[0]=0;
     1884                  for ( i=0;i<numberSOS;i++) {
     1885                    int type = setInfo[i].setType();
     1886                    int n=setInfo[i].numberEntries();
     1887                    sosType[i]=type;
     1888                    nTotal += n;
     1889                    sosStart[i+1] = nTotal;
     1890                  }
     1891                  sosIndices = new int[nTotal];
     1892                  sosReference = new double [nTotal];
     1893                  for (i=0;i<numberSOS;i++) {
     1894                    int n=setInfo[i].numberEntries();
     1895                    const int * which = setInfo[i].which();
     1896                    const double * weights = setInfo[i].weights();
     1897                    int base = sosStart[i];
     1898                    for (int j=0;j<n;j++) {
     1899                      int k=which[j];
     1900                      sosIndices[j+base]=k;
     1901                      sosReference[j+base] = weights ? weights[j] : (double) j;
     1902                    }
     1903                  }
     1904                }
    16951905                saveSolver=babModel->solver()->clone();
    16961906                /* Do not try and produce equality cliques and
     
    17101920                  // Add in generators
    17111921                  process.addCutGenerator(&generator1);
    1712                   int translate[]={9999,0,0,-1,2,3};
     1922                  int translate[]={9999,0,0,-1,2,3,-2};
    17131923                  process.messageHandler()->setLogLevel(babModel->logLevel());
    17141924#ifdef COIN_HAS_ASL
     
    17331943                    delete [] prohibited;
    17341944                  }
    1735                   solver2 = process.preProcessNonDefault(*saveSolver,translate[preProcess],10);
     1945                  solver2 = process.preProcessNonDefault(*saveSolver,translate[preProcess],10,
     1946                                                         tunePreProcess);
    17361947                  // Tell solver we are not in Branch and Cut
    17371948                  saveSolver->setHintParam(OsiDoInBranchAndCut,false,OsiHintDo) ;
     
    17912002                std::string problemName ;
    17922003                babModel->solver()->getStrParam(OsiProbName,problemName) ;
    1793                 //babModel->solver()->activateRowCutDebugger(problemName.c_str()) ;
     2004                babModel->solver()->activateRowCutDebugger(problemName.c_str()) ;
    17942005                twomirGen.probname_=strdup(problemName.c_str());
    17952006                // checking seems odd
     
    18032014                int * priority = new int [numberColumns];
    18042015                const double * objective = babModel->getObjCoefficients();
     2016                const double * lower = babModel->getColLower() ;
     2017                const double * upper = babModel->getColUpper() ;
     2018                const CoinPackedMatrix * matrix = babModel->solver()->getMatrixByCol();
     2019                const int * columnLength = matrix->getVectorLengths();
    18052020                int iColumn;
    18062021                int n=0;
     
    18092024                    sort[n]=n;
    18102025                    if (useCosts==1)
    1811                       dsort[n++]=-objective[iColumn];
    1812                     else
     2026                      dsort[n++]=-fabs(objective[iColumn]);
     2027                    else if (useCosts==2)
    18132028                      dsort[n++]=iColumn;
     2029                    else if (useCosts==3)
     2030                      dsort[n++]=upper[iColumn]-lower[iColumn];
     2031                    else if (useCosts==4)
     2032                      dsort[n++]=-(upper[iColumn]-lower[iColumn]);
     2033                    else if (useCosts==5)
     2034                      dsort[n++]=-columnLength[iColumn];
    18142035                  }
    18152036                }
     
    18582079              int switches[20];
    18592080              int numberGenerators=0;
    1860               if (probingAction==1) {
    1861                 babModel->addCutGenerator(&probingGen,-1,"Probing");
     2081              int translate[6]={-100,-1,-99,-98,1,1};
     2082              if (probingAction) {
     2083                if (probingAction==5)
     2084                  probingGen.setRowCuts(-3); // strengthening etc just at root
     2085                babModel->addCutGenerator(&probingGen,translate[probingAction],"Probing");
    18622086                switches[numberGenerators++]=0;
    1863               } else if (probingAction>=2) {
    1864                 babModel->addCutGenerator(&probingGen,-101+probingAction,"Probing");
     2087              }
     2088              if (gomoryAction) {
     2089                babModel->addCutGenerator(&gomoryGen,translate[gomoryAction],"Gomory");
     2090                switches[numberGenerators++]=-1;
     2091              }
     2092              if (knapsackAction) {
     2093                babModel->addCutGenerator(&knapsackGen,translate[knapsackAction],"Knapsack");
    18652094                switches[numberGenerators++]=0;
    18662095              }
    1867               if (gomoryAction==1) {
    1868                 babModel->addCutGenerator(&gomoryGen,-1,"Gomory");
     2096              if (redsplitAction) {
     2097                babModel->addCutGenerator(&redsplitGen,translate[redsplitAction],"Reduce-and-split");
    18692098                switches[numberGenerators++]=1;
    1870               } else if (gomoryAction>=2) {
    1871                 babModel->addCutGenerator(&gomoryGen,-101+gomoryAction,"Gomory");
     2099              }
     2100              if (cliqueAction) {
     2101                babModel->addCutGenerator(&cliqueGen,translate[cliqueAction],"Clique");
     2102                switches[numberGenerators++]=0;
     2103              }
     2104              if (mixedAction) {
     2105                babModel->addCutGenerator(&mixedGen,translate[mixedAction],"MixedIntegerRounding2");
    18722106                switches[numberGenerators++]=-1;
    18732107              }
    1874               if (knapsackAction==1) {
    1875                 babModel->addCutGenerator(&knapsackGen,-1,"Knapsack");
    1876                 switches[numberGenerators++]=0;
    1877               } else if (knapsackAction>=2) {
    1878                 babModel->addCutGenerator(&knapsackGen,-101+knapsackAction,"Knapsack");
    1879                 switches[numberGenerators++]=0;
    1880               }
    1881               if (redsplitAction==1) {
    1882                 babModel->addCutGenerator(&redsplitGen,-1,"Reduce-and-split");
     2108              if (flowAction) {
     2109                babModel->addCutGenerator(&flowGen,translate[flowAction],"FlowCover");
    18832110                switches[numberGenerators++]=1;
    1884               } else if (redsplitAction>=2) {
    1885                 babModel->addCutGenerator(&redsplitGen,-101+redsplitAction,"Reduce-and-split");
     2111              }
     2112              if (twomirAction) {
     2113                babModel->addCutGenerator(&twomirGen,translate[twomirAction],"TwoMirCuts");
    18862114                switches[numberGenerators++]=1;
    18872115              }
    1888               if (cliqueAction==1) {
    1889                 babModel->addCutGenerator(&cliqueGen,-1,"Clique");
     2116              if (landpAction) {
     2117                babModel->addCutGenerator(&landpGen,translate[landpAction],"LiftAndProject");
    18902118                switches[numberGenerators++]=1;
    1891               } else if (cliqueAction>=2) {
    1892                 babModel->addCutGenerator(&cliqueGen,-101+cliqueAction,"Clique");
    1893                 switches[numberGenerators++]=-1;
    1894               }
    1895               if (mixedAction==1) {
    1896                 babModel->addCutGenerator(&mixedGen,-1,"MixedIntegerRounding2");
    1897                 switches[numberGenerators++]=1;
    1898               } else if (mixedAction>=2) {
    1899                 babModel->addCutGenerator(&mixedGen,-101+mixedAction,"MixedIntegerRounding2");
    1900                 switches[numberGenerators++]=-1;
    1901               }
    1902               if (flowAction==1) {
    1903                 babModel->addCutGenerator(&flowGen,-1,"FlowCover");
    1904                 switches[numberGenerators++]=1;
    1905               } else if (flowAction>=2) {
    1906                 babModel->addCutGenerator(&flowGen,-101+flowAction,"FlowCover");
    1907                 switches[numberGenerators++]=1;
    1908               }
    1909               if (twomirAction==1) {
    1910                 babModel->addCutGenerator(&twomirGen,-1,"TwoMirCuts");
    1911                 switches[numberGenerators++]=1;
    1912               } else if (twomirAction>=2) {
    1913                 babModel->addCutGenerator(&twomirGen,-101+twomirAction,"TwoMirCuts");
    1914                 switches[numberGenerators++]=1;
    1915               }
     2119              }
     2120              if (storedCuts)
     2121                babModel->setSpecialOptions(babModel->specialOptions()|64);
    19162122              // Say we want timings
    19172123              numberGenerators = babModel->numberCutGenerators();
     
    19942200              }
    19952201              // probably faster to use a basis to get integer solutions
    1996               babModel->setSpecialOptions(2);
     2202              babModel->setSpecialOptions(babModel->specialOptions()|2);
    19972203              currentBranchModel = babModel;
    19982204              OsiSolverInterface * strengthenedModel=NULL;
    19992205              if (type==BAB||type==MIPLIB) {
    2000                 int moreMipOptions = parameters[whichParam(MOREMIPOPTIONS,numberParameters,parameters)].intValue();
     2206                int moreMipOptions = parameters[whichParam(MOREMIPOPTIONS,numberParameters,parameters)].intValue();
    20012207                if (moreMipOptions>=0) {
    20022208                  printf("more mip options %d\n",moreMipOptions);
    2003                   babModel->setSearchStrategy(moreMipOptions);
     2209                  if (((moreMipOptions+1)%1000000)!=0)
     2210                    babModel->setSearchStrategy(moreMipOptions%1000000);
     2211                  OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
     2212                  // go faster stripes
     2213                  if( moreMipOptions >=999999) {
     2214                    if (osiclp) {
     2215                      int save = osiclp->specialOptions();
     2216                      osiclp->setupForRepeatedUse(2,0);
     2217                      osiclp->setSpecialOptions(save|osiclp->specialOptions());
     2218                    }
     2219                  }
    20042220                }
    20052221              }
     
    22512467                  babModel->setStrategy(strategy);
    22522468                }
     2469                checkSOS(babModel, babModel->solver());
    22532470                babModel->branchAndBound(statistics);
     2471                checkSOS(babModel, babModel->solver());
    22542472              } else if (type==MIPLIB) {
    22552473                CbcStrategyDefault strategy(true,5,5);
    2256                 // Set up pre-processing to find sos if wanted
     2474                // Set up pre-processing
     2475                int translate2[]={9999,1,1,3,2,4,5};
    22572476                if (preProcess)
    2258                   strategy.setupPreProcessing(2);
     2477                  strategy.setupPreProcessing(translate2[preProcess]);
    22592478                babModel->setStrategy(strategy);
    22602479                CbcClpUnitTest(*babModel);
     
    22782497                         <<" to "<<babModel->rootObjectiveAfterCuts()<<std::endl;
    22792498               
     2499                numberGenerators = babModel->numberCutGenerators();
    22802500                for (iGenerator=0;iGenerator<numberGenerators;iGenerator++) {
    22812501                  CbcCutGenerator * generator = babModel->cutGenerator(iGenerator);
     
    23082528                  memcpy(bestSolution,babModel->solver()->getColSolution(),n*sizeof(double));
    23092529                }
     2530                checkSOS(babModel, babModel->solver());
    23102531              }
    23112532              if (type==STRENGTHEN&&strengthenedModel)
     
    24872708              }
    24882709              if (canOpen) {
    2489                 int status =lpSolver->readMps(fileName.c_str(),
     2710                int status =clpSolver->readMps(fileName.c_str(),
    24902711                                                   keepImportNames!=0,
    24912712                                                   allowImportErrors!=0);
     
    25762797                bool deleteModel2=false;
    25772798                ClpSimplex * model2 = lpSolver;
     2799#ifdef COIN_HAS_ASL
     2800                if (info.numberSos&&doSOS&&usingAmpl) {
     2801                  // SOS
     2802                  numberSOS = info.numberSos;
     2803                  sosStart = info.sosStart;
     2804                  sosIndices = info.sosIndices;
     2805                  sosReference = info.sosReference;
     2806                  preSolve=false;
     2807                  clpSolver->setSOSData(numberSOS,info.sosType,sosStart,sosIndices,sosReference);
     2808                }
     2809#endif
    25782810                if (preSolve) {
    25792811                  ClpPresolve pinfo;
     
    25992831
    26002832                  }
     2833                  model2->writeMps(fileName.c_str(),(outputFormat-1)/2,1+((outputFormat-1)&1));
     2834                  if (deleteModel2)
     2835                    delete model2;
    26012836                } else {
    26022837                  printf("Saving model on %s\n",
    26032838                           fileName.c_str());
    2604                 }
    2605 #if 0
    2606                 // Convert names
    2607                 int iRow;
    2608                 int numberRows=model2->numberRows();
    2609                 int iColumn;
    2610                 int numberColumns=model2->numberColumns();
    2611 
    2612                 char ** rowNames = NULL;
    2613                 char ** columnNames = NULL;
    2614                 if (model2->lengthNames()) {
    2615                   rowNames = new char * [numberRows];
    2616                   for (iRow=0;iRow<numberRows;iRow++) {
    2617                     rowNames[iRow] =
    2618                       strdup(model2->rowName(iRow).c_str());
    2619 #ifdef STRIPBLANKS
    2620                     char * xx = rowNames[iRow];
    2621                     int i;
    2622                     int length = strlen(xx);
    2623                     int n=0;
    2624                     for (i=0;i<length;i++) {
    2625                       if (xx[i]!=' ')
    2626                         xx[n++]=xx[i];
     2839                  if (numberSOS) {
     2840                    // Convert names
     2841                    int iRow;
     2842                    int numberRows=model2->numberRows();
     2843                    int iColumn;
     2844                    int numberColumns=model2->numberColumns();
     2845                   
     2846                    char ** rowNames = NULL;
     2847                    char ** columnNames = NULL;
     2848                    if (model2->lengthNames()) {
     2849                      rowNames = new char * [numberRows];
     2850                      for (iRow=0;iRow<numberRows;iRow++) {
     2851                        rowNames[iRow] =
     2852                          strdup(model2->rowName(iRow).c_str());
     2853                      }
     2854                     
     2855                      columnNames = new char * [numberColumns];
     2856                      for (iColumn=0;iColumn<numberColumns;iColumn++) {
     2857                        columnNames[iColumn] =
     2858                          strdup(model2->columnName(iColumn).c_str());
     2859                      }
    26272860                    }
    2628                     xx[n]='\0';
    2629 #endif
    2630                   }
    2631                  
    2632                   columnNames = new char * [numberColumns];
    2633                   for (iColumn=0;iColumn<numberColumns;iColumn++) {
    2634                     columnNames[iColumn] =
    2635                       strdup(model2->columnName(iColumn).c_str());
    2636 #ifdef STRIPBLANKS
    2637                     char * xx = columnNames[iColumn];
    2638                     int i;
    2639                     int length = strlen(xx);
    2640                     int n=0;
    2641                     for (i=0;i<length;i++) {
    2642                       if (xx[i]!=' ')
    2643                         xx[n++]=xx[i];
     2861                    clpSolver->writeMpsNative(fileName.c_str(),(const char **) rowNames,(const char **) columnNames,
     2862                                              (outputFormat-1)/2,1+((outputFormat-1)&1));
     2863                    if (rowNames) {
     2864                      for (iRow=0;iRow<numberRows;iRow++) {
     2865                        free(rowNames[iRow]);
     2866                      }
     2867                      delete [] rowNames;
     2868                      for (iColumn=0;iColumn<numberColumns;iColumn++) {
     2869                        free(columnNames[iColumn]);
     2870                      }
     2871                      delete [] columnNames;
    26442872                    }
    2645                     xx[n]='\0';
    2646 #endif
     2873                  } else {
     2874                    model2->writeMps(fileName.c_str(),(outputFormat-1)/2,1+((outputFormat-1)&1));
    26472875                  }
    26482876                }
    2649                 CoinMpsIO writer;
    2650                 writer.setMpsData(*model2->matrix(), COIN_DBL_MAX,
    2651                                   model2->getColLower(), model2->getColUpper(),
    2652                                   model2->getObjCoefficients(),
    2653                                   (const char*) 0 /*integrality*/,
    2654                                   model2->getRowLower(), model2->getRowUpper(),
    2655                                   columnNames, rowNames);
    2656                 // Pass in array saying if each variable integer
    2657                 writer.copyInIntegerInformation(model2->integerInformation());
    2658                 writer.setObjectiveOffset(model2->objectiveOffset());
    2659                 writer.writeMps(fileName.c_str(),0,1,1);
    2660                 if (rowNames) {
    2661                   for (iRow=0;iRow<numberRows;iRow++) {
    2662                     free(rowNames[iRow]);
    2663                   }
    2664                   delete [] rowNames;
    2665                   for (iColumn=0;iColumn<numberColumns;iColumn++) {
    2666                     free(columnNames[iColumn]);
    2667                   }
    2668                   delete [] columnNames;
    2669                 }
    2670 #else
    2671                 model2->writeMps(fileName.c_str(),(outputFormat-1)/2,1+((outputFormat-1)&1));
    2672 #endif
    2673                 if (deleteModel2)
    2674                   delete model2;
    26752877                time2 = CoinCpuTime();
    26762878                totalTime += time2-time1;
     
    33353537              lpSolver->setSpecialOptions(0);
    33363538              mainTest(nFields,fields,algorithm,*lpSolver,
    3337                        (preSolve!=0),specialOptions);
     3539                       (preSolve!=0),specialOptions,doVector!=0);
    33383540            }
    33393541            break;
     
    33503552              }
    33513553              mainTest(nFields,fields,false,*lpSolver,(preSolve!=0),
    3352                        false);
     3554                       false,doVector!=0);
    33533555            }
    33543556            break;
     
    34093611            // Replace the sample code by whatever you want
    34103612            if (goodModel) {
     3613#if 1
    34113614              printf("Dummy user cbc code - model has %d rows and %d columns\n",
    34123615                     model.getNumRows(),model.getNumCols());
    3413   // Reduce printout
    3414   //solver1.setHintParam(OsiDoReducePrint,true,OsiHintTry);
    3415   OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (model.solver());
    3416   // go faster stripes
    3417   if (osiclp&&0) {
    3418     // Turn this off if you get problems
    3419     // Used to be automatically set
    3420     osiclp->setSpecialOptions(128);
    3421     if(osiclp->getNumRows()<300&&osiclp->getNumCols()<500) {
    3422       //osiclp->setupForRepeatedUse(2,0);
    3423       osiclp->setupForRepeatedUse(0,0);
    3424     }
    3425   }
    3426   // Allow rounding heuristic
    3427 
    3428   CbcRounding heuristic1(model);
    3429   model.addHeuristic(&heuristic1);
    3430 
    3431   // Do initial solve to continuous
    3432   ClpPrimalColumnSteepest steepest(5);
    3433   osiclp->getModelPtr()->setPrimalColumnPivotAlgorithm(steepest);
    3434   osiclp->getModelPtr()->setPerturbation(50);
    3435   osiclp->getModelPtr()->setInfeasibilityCost(1.0e9);
    3436   osiclp->setHintParam(OsiDoPresolveInInitial,false,OsiHintTry);
    3437   osiclp->setHintParam(OsiDoDualInInitial,false,OsiHintTry);
    3438   //osiclp->setHintParam(OsiDoDualInResolve,false,OsiHintTry);
    3439   model.setSpecialOptions(model.specialOptions()|4);
    3440   osiclp->getModelPtr()->defaultFactorizationFrequency();
    3441   {
    3442     ClpSimplex * clp = osiclp->getModelPtr();
    3443     // fix integers to 1
    3444     int numberColumns = clp->numberColumns();
    3445     double * lower = clp->columnLower();
    3446     int i;
    3447     for (i=0;i<numberColumns;i++) {
    3448       if (osiclp->isInteger(i))
    3449         lower[i]=1.0;
    3450     }
    3451     clp->primal();
    3452     double objValue = clp->objectiveValue();
    3453     osiclp->setDblParam(OsiDualObjectiveLimit,objValue+1.0e-4);
    3454     // unfix integers
    3455     for (i=0;i<numberColumns;i++) {
    3456       if (osiclp->isInteger(i))
    3457         lower[i]=0.0;
    3458     }
    3459     clp->primal();
    3460     //clp->dual();
    3461     int nArt=0;
    3462     int nFixed0=0,nFixed1=0;
    3463     double gap=objValue-clp->objectiveValue();
    3464     // for those at one fix anyway
    3465     double gap2=1.0;
    3466     const double * solution = clp->primalColumnSolution();
    3467     const double * dj = clp->dualColumnSolution();
    3468     const double * objective = clp->objective();
    3469     double * upper = clp->columnUpper();
    3470     for (i=0;i<numberColumns;i++) {
    3471       if (objective[i]>1.0e5&&solution[i]>1.0e-8)
    3472         nArt++;
    3473       if (osiclp->isInteger(i)) {
    3474         if(dj[i]>gap+1.0e-4) {
    3475           nFixed0++;
    3476           upper[i]=0.0;
    3477         }
    3478         if(-dj[i]>gap2+1.0e-4) {
    3479           nFixed1++;
    3480         lower[i]=1.0;
    3481         }
    3482       }
    3483     }
    3484     printf("%d artificials, %d fixed to 0, %d fixed to 1\n",nArt,nFixed0,nFixed1);
    3485     //osiclp->getModelPtr()->setPerturbation(100);
    3486     osiclp->setWarmStart(NULL); // set basis in osiclp
    3487   }
    3488   osiclp->initialSolve();
    3489 
    3490   // Switch off strong branching if wanted
    3491   // model.setNumberStrong(0);
    3492   // Do more strong branching if small
    3493   model.setNumberStrong(0);
    3494   model.setNumberBeforeTrust(0);
    3495 
    3496   // TEMP - set gap - better to see if no improvement in last few nodes
    3497   model.setAllowableGap(600.0);
    3498   // message levels
    3499   model.messageHandler()->setLogLevel(2);
    3500   model.solver()->messageHandler()->setLogLevel(2);
    3501   // Do complete search
    3502  
    3503   model.branchAndBound();
     3616              // Reduce printout
     3617              model.solver()->setHintParam(OsiDoReducePrint,true,OsiHintTry);
     3618              // Do complete search
     3619              model.branchAndBound();
     3620              double objectiveValue=model.getMinimizationObjValue();
     3621              int iStat = model.status();
     3622              int iStat2 = model.secondaryStatus();
     3623#else
     3624              // Way of using an existing piece of code
     3625              OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model.solver());
     3626              ClpSimplex * lpSolver = clpSolver->getModelPtr();
     3627              // set time from integer model
     3628              double timeToGo = model.getMaximumSeconds();
     3629              lpSolver->setMaximumSeconds(timeToGo);
     3630              fakeMain(*lpSolver,*clpSolver,model);
     3631              // My actual usage has objective only in clpSolver
     3632              double objectiveValue=clpSolver->getObjValue();
     3633              int iStat = lpSolver->status();
     3634              int iStat2 = lpSolver->secondaryStatus();
     3635#endif
     3636              // make sure solution back in correct place
     3637              clpSolver = dynamic_cast< OsiClpSolverInterface*> (model.solver());
     3638              lpSolver = clpSolver->getModelPtr();
     3639#ifdef COIN_HAS_ASL
     3640              if (usingAmpl) {
     3641                int n = clpSolver->getNumCols();
     3642                double value = objectiveValue*lpSolver->getObjSense();
     3643                char buf[300];
     3644                int pos=0;
     3645                std::string minor[]={"","","gap","nodes","time","","solutions","user ctrl-c"};
     3646                if (iStat==0) {
     3647                  if (objectiveValue<1.0e40) {
     3648                    pos += sprintf(buf+pos,"optimal," );
     3649                  } else {
     3650                    // infeasible
     3651                    iStat=1;
     3652                    pos += sprintf(buf+pos,"infeasible,");
     3653                  }
     3654                } else if (iStat==1) {
     3655                  if (iStat2!=6)
     3656                    iStat=3;
     3657                  else
     3658                    iStat=4;
     3659                  pos += sprintf(buf+pos,"stopped on %s,",minor[iStat2].c_str());
     3660                } else if (iStat==2) {
     3661                  iStat = 7;
     3662                  pos += sprintf(buf+pos,"stopped on difficulties,");
     3663                } else if (iStat==5) {
     3664                  iStat = 3;
     3665                  pos += sprintf(buf+pos,"stopped on ctrl-c,");
     3666                } else {
     3667                  pos += sprintf(buf+pos,"status unknown,");
     3668                  iStat=6;
     3669                }
     3670                info.problemStatus=iStat;
     3671                info.objValue = value;
     3672                if (objectiveValue<1.0e40)
     3673                  pos += sprintf(buf+pos," objective %.*g",ampl_obj_prec(),
     3674                                 value);
     3675                sprintf(buf+pos,"\n%d nodes, %d iterations",
     3676                        model.getNodeCount(),
     3677                        model.getIterationCount());
     3678                if (objectiveValue<1.0e50) {
     3679                  free(info.primalSolution);
     3680                  info.primalSolution = (double *) malloc(n*sizeof(double));
     3681                  CoinCopyN(lpSolver->primalColumnSolution(),n,info.primalSolution);
     3682                  int numberRows = lpSolver->numberRows();
     3683                  free(info.dualSolution);
     3684                  info.dualSolution = (double *) malloc(numberRows*sizeof(double));
     3685                  CoinCopyN(lpSolver->dualRowSolution(),numberRows,info.dualSolution);
     3686                } else {
     3687                  info.primalSolution=NULL;
     3688                  info.dualSolution=NULL;
     3689                }
     3690                // put buffer into info
     3691                strcpy(info.buffer,buf);
     3692#endif
     3693              }
    35043694            }
    35053695            break;
     
    42764466    }
    42774467  } else {
    4278     int translate[]={9999,0,0,-1,2,3};
     4468    int translate[]={9999,0,0,-1,2,3,-2};
    42794469    strcpy(line[numberLines++],"5  // Hand coded preprocessing");
    42804470    strcpy(line[numberLines++],"5  CglPreProcess process;");
  • branches/devel/Cbc/src/unitTest.cpp

    r325 r424  
    309309// where:
    310310//   -miplibDir: directory containing miplib files
    311 //       Default value V2="./Samples/miplib3"
     311//       Default value V2="./examples/miplib3"
    312312//
    313313// All parameters are optional.
     
    349349      std::cerr <<"  where:\n";
    350350      std::cerr <<"    -miplibDir: directory containing miplib files\n";
    351       std::cerr <<"        Default value V2=\"./Samples/miplib3\"\n";
     351      std::cerr <<"        Default value V2=\"./Data/miplib3\"\n";
    352352      return 1;
    353353    }
     
    362362    miplibDir=parms["-miplibDir"] + dirsep;
    363363  else
    364     miplibDir = dirsep == '/' ? "./Samples/miplib3/" : ".\\Samples\\miplib3\\";
     364    miplibDir = dirsep == '/' ? "./Data/miplib3/" : ".\\Data\\miplib3\\";
    365365#ifdef COIN_HAS_CBC
    366366
  • branches/devel/Cbc/src/unitTestClp.cpp

    r406 r424  
    1616#include "CoinTime.hpp"
    1717#include "CbcModel.hpp"
     18#include "CbcCutGenerator.hpp"
    1819#include "OsiClpSolverInterface.hpp"
    1920#include "ClpFactorization.hpp"
     
    200201//----------------------------------------------------------------
    201202int mainTest (int argc, const char *argv[],int algorithm,
    202               ClpSimplex empty, bool doPresolve, int switchOffValue)
     203              ClpSimplex empty, bool doPresolve, int switchOffValue,bool doVector)
    203204{
    204205  int i;
     
    462463            if (solution.maximumSeconds()<0.0)
    463464              solution.setMaximumSeconds(120.0);
     465            if (doVector) {
     466              ClpMatrixBase * matrix = solution.clpMatrix();
     467              if (dynamic_cast< ClpPackedMatrix*>(matrix)) {
     468                ClpPackedMatrix * clpMatrix = dynamic_cast< ClpPackedMatrix*>(matrix);
     469                clpMatrix->makeSpecialColumnCopy();
     470              }
     471            }
    464472            solution.initialSolve(solveOptions);
    465473            double time2 = CoinCpuTime()-time1;
     
    549557        if (presolveOff)
    550558          solveOptions.setPresolveType(ClpSolve::presolveOff);
     559      }
     560      if (doVector) {
     561        ClpMatrixBase * matrix = solution.clpMatrix();
     562        if (dynamic_cast< ClpPackedMatrix*>(matrix)) {
     563          ClpPackedMatrix * clpMatrix = dynamic_cast< ClpPackedMatrix*>(matrix);
     564          clpMatrix->makeSpecialColumnCopy();
     565        }
    551566      }
    552567      solution.initialSolve(solveOptions);
     
    14151430    FILE * fp = fopen(fn.c_str(),"r");
    14161431    if (!fp) {
    1417       // Try in Samples
    1418       fn = "Samples/input.130";
     1432      // Try in Data
     1433      fn = "Data/Sample/input.130";
    14191434      fp = fopen(fn.c_str(),"r");
    14201435    }
    14211436    if (!fp) {
    1422       fprintf(stderr,"Unable to open file input.130 in mpsDir or Samples directory\n");
     1437      fprintf(stderr,"Unable to open file input.130 in mpsDir or Data/Sample directory\n");
    14231438    } else {
    14241439      int problem;
     
    19371952
    19381953    double startTime = CoinCpuTime();
    1939     model->setMaximumNodes(100000);
     1954    model->setMaximumNodes(200000);
    19401955    OsiClpSolverInterface * si =
    19411956      dynamic_cast<OsiClpSolverInterface *>(model->solver()) ;
     
    19451960    modelC->tightenPrimalBounds();
    19461961    model->initialSolve();
     1962    if (modelC->dualBound()==1.0e10) {
     1963      // user did not set - so modify
     1964      // get largest scaled away from bound
     1965      double largest=1.0e-12;
     1966      int numberRows = modelC->numberRows();
     1967      const double * rowPrimal = modelC->primalRowSolution();
     1968      const double * rowLower = modelC->rowLower();
     1969      const double * rowUpper = modelC->rowUpper();
     1970      const double * rowScale = modelC->rowScale();
     1971      int iRow;
     1972      for (iRow=0;iRow<numberRows;iRow++) {
     1973        double value = rowPrimal[iRow];
     1974        double above = value-rowLower[iRow];
     1975        double below = rowUpper[iRow]-value;
     1976        if (rowScale) {
     1977          double multiplier = rowScale[iRow];
     1978          above *= multiplier;
     1979          below *= multiplier;
     1980        }
     1981        if (above<1.0e12)
     1982          largest = CoinMax(largest,above);
     1983        if (below<1.0e12)
     1984          largest = CoinMax(largest,below);
     1985      }
     1986     
     1987      int numberColumns = modelC->numberColumns();
     1988      const double * columnPrimal = modelC->primalColumnSolution();
     1989      const double * columnLower = modelC->columnLower();
     1990      const double * columnUpper = modelC->columnUpper();
     1991      const double * columnScale = modelC->columnScale();
     1992      int iColumn;
     1993      for (iColumn=0;iColumn<numberColumns;iColumn++) {
     1994        double value = columnPrimal[iColumn];
     1995        double above = value-columnLower[iColumn];
     1996        double below = columnUpper[iColumn]-value;
     1997        if (columnScale) {
     1998          double multiplier = 1.0/columnScale[iColumn];
     1999          above *= multiplier;
     2000          below *= multiplier;
     2001        }
     2002        if (above<1.0e12)
     2003          largest = CoinMax(largest,above);
     2004        if (below<1.0e12)
     2005          largest = CoinMax(largest,below);
     2006      }
     2007      //std::cout<<"Largest (scaled) away from bound "<<largest<<std::endl;
     2008      modelC->setDualBound(CoinMin(1000.0*largest,1.00001e10));
     2009    }
    19472010    model->setMinimumDrop(min(5.0e-2,
    19482011                                 fabs(model->getMinimizationObjValue())*1.0e-3+1.0e-4));
     
    19562019     
    19572020    double timeOfSolution = CoinCpuTime()-startTime;
     2021    // Print more statistics
     2022    std::cout<<"Cuts at root node changed objective from "<<model->getContinuousObjective()
     2023             <<" to "<<model->rootObjectiveAfterCuts()<<std::endl;
     2024    int numberGenerators = model->numberCutGenerators();
     2025    for (int iGenerator=0;iGenerator<numberGenerators;iGenerator++) {
     2026      CbcCutGenerator * generator = model->cutGenerator(iGenerator);
     2027      std::cout<<generator->cutGeneratorName()<<" was tried "
     2028               <<generator->numberTimesEntered()<<" times and created "
     2029               <<generator->numberCutsInTotal()<<" cuts of which "
     2030               <<generator->numberCutsActive()<<" were active after adding rounds of cuts";
     2031      if (generator->timing())
     2032        std::cout<<" ( "<<generator->timeInCutGenerator()<<" seconds)"<<std::endl;
     2033      else
     2034        std::cout<<std::endl;
     2035    }
    19582036    if (!model->status()) {
    19592037      double soln = model->getObjValue();       
Note: See TracChangeset for help on using the changeset viewer.