Changeset 502 for branches


Ignore:
Timestamp:
Dec 18, 2006 9:39:29 AM (13 years ago)
Author:
forrest
Message:

mostly for rins

Location:
branches/devel/Cbc/src
Files:
2 added
11 edited

Legend:

Unmodified
Added
Removed
  • branches/devel/Cbc/src/CbcHeuristic.cpp

    r439 r502  
    2525CbcHeuristic::CbcHeuristic()
    2626  :model_(NULL),
    27    when_(2)
    28 {
     27   when_(2),
     28   numberNodes_(200),
     29   fractionSmall_(1.0)
     30{
     31  // As CbcHeuristic virtual need to modify .cpp if above change
    2932}
    3033
     
    3336:
    3437  model_(&model),
    35   when_(2)
    36 {
    37 }
     38  when_(2),
     39  numberNodes_(200),
     40  fractionSmall_(1.0)
     41{
     42  // As CbcHeuristic virtual need to modify .cpp if above change
     43}
     44// Copy constructor
     45CbcHeuristic::CbcHeuristic(const CbcHeuristic & rhs)
     46:
     47  model_(rhs.model_),
     48  when_(rhs.when_),
     49  numberNodes_(rhs.numberNodes_),
     50  fractionSmall_(rhs.fractionSmall_)
     51{
     52}
     53// Assignment operator
     54CbcHeuristic &
     55CbcHeuristic::operator=( const CbcHeuristic& rhs)
     56{
     57  if (this!=&rhs) {
     58    model_ = rhs.model_;
     59    when_ = rhs.when_;
     60    numberNodes_ = rhs.numberNodes_;
     61    fractionSmall_ = rhs.fractionSmall_;
     62  }
     63  return *this;
     64}
     65
    3866// Resets stuff if model changes
    3967void
     
    4371}
    4472
     73// Create C++ lines to get to current state
     74void
     75CbcHeuristic::generateCpp( FILE * fp, const char * heuristic)
     76{
     77  // hard coded as CbcHeuristic virtual
     78  if (when_!=2)
     79    fprintf(fp,"3  %s.setWhen(%d);\n",heuristic,when_);
     80  else
     81    fprintf(fp,"4  %s.setWhen(%d);\n",heuristic,when_);
     82  if (numberNodes_!=200)
     83    fprintf(fp,"3  %s.setNumberNodes(%d);\n",heuristic,numberNodes_);
     84  else
     85    fprintf(fp,"4  %s.setNumberNodes(%d);\n",heuristic,numberNodes_);
     86  if (fractionSmall_!=1.0)
     87    fprintf(fp,"3  %s.setFractionSmall(%g);\n",heuristic,fractionSmall_);
     88  else
     89    fprintf(fp,"4  %s.setFractionSmall(%g);\n",heuristic,fractionSmall_);
     90}
    4591// Destructor
    4692CbcHeuristic::~CbcHeuristic ()
     
    90136      if (logLevel>1)
    91137        printf("Pre-processing says infeasible\n");
    92       returnCode=0; // so will be infeasible
     138      returnCode=2; // so will be infeasible
    93139    } else {
     140      // see if too big
     141      double before = solver->getNumRows()+solver->getNumCols();
     142      double after = solver2->getNumRows()+solver2->getNumCols();
     143      printf("before %d rows %d columns, after %d rows %d columns\n",
     144             solver->getNumRows(),solver->getNumCols(),
     145             solver2->getNumRows(),solver2->getNumCols());
     146      if (after>fractionSmall_*before)
     147        return 0;
    94148      solver2->resolve();
    95149      CbcModel model(*solver2);
     
    120174      if (model.getMinimizationObjValue()<CoinMin(cutoff,1.0e30)) {
    121175        // solution
    122         returnCode=1;
     176        returnCode=model.isProvenOptimal() ? 3 : 1;
    123177        // post process
    124178        process.postProcess(*model.solver());
     
    135189      } else {
    136190        // no good
    137         returnCode=0; // so will be infeasible
     191        returnCode=model.isProvenInfeasible() ? 2 : 0; // so will be infeasible
    138192      }
    139193    }
    140194  } else {
    141     returnCode=0;
     195    returnCode=2; // infeasible finished
    142196  }
    143197  return returnCode;
     
    181235  fprintf(fp,"0#include \"CbcHeuristic.hpp\"\n");
    182236  fprintf(fp,"3  CbcRounding rounding(*cbcModel);\n");
     237  CbcHeuristic::generateCpp(fp,"rounding");
    183238  if (seed_!=other.seed_)
    184239    fprintf(fp,"3  rounding.setSeed(%d);\n",seed_);
     
    196251  seed_(rhs.seed_)
    197252{
    198   setWhen(rhs.when());
     253}
     254
     255// Assignment operator
     256CbcRounding &
     257CbcRounding::operator=( const CbcRounding& rhs)
     258{
     259  if (this!=&rhs) {
     260    CbcHeuristic::operator=(rhs);
     261    matrix_ = rhs.matrix_;
     262    matrixByRow_ = rhs.matrixByRow_;
     263    seed_ = rhs.seed_;
     264  }
     265  return *this;
    199266}
    200267
     
    907974  fprintf(fp,"0#include \"CbcHeuristic.hpp\"\n");
    908975  fprintf(fp,"3  CbcSerendipity serendipity(*cbcModel);\n");
     976  CbcHeuristic::generateCpp(fp,"serendipity");
    909977  fprintf(fp,"3  cbcModel->addHeuristic(&serendipity);\n");
    910978}
     
    915983  CbcHeuristic(rhs)
    916984{
     985}
     986
     987// Assignment operator
     988CbcSerendipity &
     989CbcSerendipity::operator=( const CbcSerendipity& rhs)
     990{
     991  if (this!=&rhs) {
     992    CbcHeuristic::operator=(rhs);
     993  }
     994  return *this;
    917995}
    918996
  • branches/devel/Cbc/src/CbcHeuristic.hpp

    r491 r502  
    2424  CbcHeuristic (CbcModel & model);
    2525
     26  // Copy constructor
     27  CbcHeuristic ( const CbcHeuristic &);
     28   
    2629  virtual ~CbcHeuristic();
     30
     31  /// Clone
     32  virtual CbcHeuristic * clone() const=0;
     33
     34  /// Assignment operator
     35  CbcHeuristic & operator=(const CbcHeuristic& rhs);
    2736
    2837  /// update model (This is needed if cliques update matrix etc)
    2938  virtual void setModel(CbcModel * model);
    3039 
    31   /// Clone
    32   virtual CbcHeuristic * clone() const=0;
    33 
    3440  /// Resets stuff if model changes
    3541  virtual void resetModel(CbcModel * model)=0;
     
    6773  { return when_;};
    6874
    69   /// Do mini branch and bound (return 1 if solution)
     75  /// Sets number of nodes in subtree (default 200)
     76  inline void setNumberNodes(int value)
     77  { numberNodes_=value;};
     78  /// Gets number of nodes in a subtree (default 200)
     79  inline int numberNodes() const
     80  { return numberNodes_;};
     81
     82  /// Sets fraction of new(rows+columns)/old(rows+columns) before doing small branch and bound (default 1.0)
     83  inline void setFractionSmall(double value)
     84  { fractionSmall_=value;};
     85  /// Gets fraction of new(rows+columns)/old(rows+columns) before doing small branch and bound (default 1.0)
     86  inline double fractionSmall() const
     87  { return fractionSmall_;};
     88
     89  /** Do mini branch and bound - return
     90      0 not finished - no solution
     91      1 not finished - solution
     92      2 finished - no solution
     93      3 finished - solution
     94      (could add global cut if finished)
     95  */
    7096  int smallBranchAndBound(OsiSolverInterface * solver,int numberNodes,
    7197                          double * newSolution, double & newSolutionValue,
     
    7399  /// Create C++ lines to get to current state
    74100  virtual void generateCpp( FILE * fp) {};
     101  /// Create C++ lines to get to current state - does work for base class
     102  void generateCpp( FILE * fp,const char * heuristic) ;
    75103  /// Returns true if can deal with "odd" problems e.g. sos type 2
    76104  virtual bool canDealWithOdd() const
     
    83111  /// When flag - 0 off, 1 at root, 2 other than root, 3 always
    84112  int when_;
    85 private:
    86  
    87   /// Illegal Assignment operator
    88   CbcHeuristic & operator=(const CbcHeuristic& rhs);
     113  /// Number of nodes in any sub tree
     114  int numberNodes_;
     115  /// Fraction of new(rows+columns)/old(rows+columns) before doing small branch and bound
     116  double fractionSmall_;
    89117 
    90118};
     
    107135  ~CbcRounding ();
    108136 
     137  /// Assignment operator
     138  CbcRounding & operator=(const CbcRounding& rhs);
     139
    109140  /// Clone
    110141  virtual CbcHeuristic * clone() const;
     
    144175  // Seed for random stuff
    145176  int seed_;
    146 
    147 private:
    148   /// Illegal Assignment operator
    149   CbcRounding & operator=(const CbcRounding& rhs);
    150177};
    151178
     
    170197  ~CbcSerendipity ();
    171198 
     199  /// Assignment operator
     200  CbcSerendipity & operator=(const CbcSerendipity& rhs);
     201
    172202  /// Clone
    173203  virtual CbcHeuristic * clone() const;
     
    194224
    195225protected:
    196 private:
    197   /// Illegal Assignment operator
    198   CbcSerendipity & operator=(const CbcSerendipity& rhs);
    199226};
    200227
  • branches/devel/Cbc/src/CbcHeuristicFPump.cpp

    r496 r502  
    7575  fprintf(fp,"0#include \"CbcHeuristicFPump.hpp\"\n");
    7676  fprintf(fp,"3  CbcHeuristicFPump heuristicFPump(*cbcModel);\n");
    77   if (when_!=other.when_)
    78     fprintf(fp,"3  heuristicFPump.setWhen(%d);\n",when_);
    79   else
    80     fprintf(fp,"4  heuristicFPump.setWhen(%d);\n",when_);
     77  CbcHeuristic::generateCpp(fp,"heuristicFPump");
    8178  if (maximumPasses_!=other.maximumPasses_)
    8279    fprintf(fp,"3  heuristicFPump.setMaximumPasses(%d);\n",maximumPasses_);
     
    139136  roundExpensive_(rhs.roundExpensive_)
    140137{
    141   setWhen(rhs.when());
    142 }
     138}
     139
     140// Assignment operator
     141CbcHeuristicFPump &
     142CbcHeuristicFPump::operator=( const CbcHeuristicFPump& rhs)
     143{
     144  if (this!=&rhs) {
     145    CbcHeuristic::operator=(rhs);
     146    startTime_ = rhs.startTime_;
     147    maximumTime_ = rhs.maximumTime_;
     148    fakeCutoff_ = rhs.fakeCutoff_;
     149    absoluteIncrement_ = rhs.absoluteIncrement_;
     150    relativeIncrement_ = rhs.relativeIncrement_;
     151    defaultRounding_ = rhs.defaultRounding_;
     152    initialWeight_ = rhs.initialWeight_;
     153    weightFactor_ = rhs.weightFactor_;
     154    maximumPasses_ = rhs.maximumPasses_;
     155    maximumRetries_ = rhs.maximumRetries_;
     156    accumulate_ = rhs.accumulate_;
     157    roundExpensive_ = rhs.roundExpensive_;
     158  }
     159  return *this;
     160}
     161
    143162// Resets stuff if model changes
    144163void
     
    377396            }
    378397            if (numberLeft) {
    379               returnCode = smallBranchAndBound(solver,200,newSolution,newSolutionValue,
     398              returnCode = smallBranchAndBound(solver,numberNodes_,newSolution,newSolutionValue,
    380399                                               solutionValue,"CbcHeuristicFpump");
     400              if ((returnCode&2)!=0) {
     401                // could add cut
     402                returnCode &= ~2;
     403              }
    381404            }
    382405          }
     
    708731             nFixI,nFixC2);
    709732      double saveValue = newSolutionValue;
    710       returnCode = smallBranchAndBound(newSolver,200,newSolution,newSolutionValue,
     733      returnCode = smallBranchAndBound(newSolver,numberNodes_,newSolution,newSolutionValue,
    711734                                       newSolutionValue,"CbcHeuristicLocalAfterFPump");
     735      if ((returnCode&2)!=0) {
     736        // could add cut
     737        returnCode &= ~2;
     738      }
    712739      if (returnCode) {
    713740        printf("old sol of %g new of %g\n",saveValue,newSolutionValue);
     
    787814    double saveValue = newSolutionValue;
    788815    newSolver->writeMps("sub");
    789     int returnCode = smallBranchAndBound(newSolver,200,newSolution,newSolutionValue,
     816    int returnCode = smallBranchAndBound(newSolver,numberNodes_,newSolution,newSolutionValue,
    790817                                     newSolutionValue,"CbcHeuristicLocalAfterFPump");
     818    if ((returnCode&2)!=0) {
     819      // could add cut
     820      returnCode &= ~2;
     821    }
    791822    if (returnCode) {
    792823      printf("old sol of %g new of %g\n",saveValue,newSolutionValue);
  • branches/devel/Cbc/src/CbcHeuristicFPump.hpp

    r496 r502  
    2525  ~CbcHeuristicFPump ();
    2626 
     27  /// Assignment operator
     28  CbcHeuristicFPump & operator=(const CbcHeuristicFPump& rhs);
    2729  /// Clone
    2830  virtual CbcHeuristic * clone() const;
     
    157159
    158160private:
    159   /// Illegal Assignment operator
    160   CbcHeuristicFPump & operator=(const CbcHeuristicFPump& rhs);
    161161  /** Rounds solution - down if < downValue
    162162      If roundExpensive then always to more expnsive.
  • branches/devel/Cbc/src/CbcHeuristicGreedy.cpp

    r356 r502  
    5555  fprintf(fp,"0#include \"CbcHeuristicGreedy.hpp\"\n");
    5656  fprintf(fp,"3  CbcHeuristicGreedyCover heuristicGreedyCover(*cbcModel);\n");
     57  CbcHeuristic::generateCpp(fp,"heuristicGreedyCover");
    5758  if (algorithm_!=other.algorithm_)
    5859    fprintf(fp,"3  heuristicGreedyCover.setAlgorithm(%d);\n",algorithm_);
     
    7576  numberTimes_(rhs.numberTimes_)
    7677{
    77   this->setWhen(rhs.when());
    7878}
    7979
     
    8383{
    8484  if (this != &rhs) {
    85     setWhen(rhs.when());
     85    CbcHeuristic::operator=(rhs);
    8686    matrix_=rhs.matrix_;
    8787    originalNumberRows_=rhs.originalNumberRows_;
     
    461461  fprintf(fp,"0#include \"CbcHeuristicGreedy.hpp\"\n");
    462462  fprintf(fp,"3  CbcHeuristicGreedyEquality heuristicGreedyEquality(*cbcModel);\n");
     463  CbcHeuristic::generateCpp(fp,"heuristicGreedyEquality");
    463464  if (algorithm_!=other.algorithm_)
    464465    fprintf(fp,"3  heuristicGreedyEquality.setAlgorithm(%d);\n",algorithm_);
     
    486487  numberTimes_(rhs.numberTimes_)
    487488{
    488   this->setWhen(rhs.when());
    489489}
    490490
     
    494494{
    495495  if (this != &rhs) {
    496     setWhen(rhs.when());
     496    CbcHeuristic::operator=(rhs);
    497497    matrix_=rhs.matrix_;
    498498    fraction_ = rhs.fraction_;
     
    731731    int returnCode = smallBranchAndBound(newSolver,200,newSolution,newSolutionValue,
    732732                                         solutionValue,"CbcHeuristicGreedy");
     733    if ((returnCode&2)!=0) {
     734      // could add cut
     735      returnCode &= ~2;
     736    }
    733737    rhsNeeded = 1.0-returnCode;
    734738    delete newSolver;
  • branches/devel/Cbc/src/CbcHeuristicGreedy.hpp

    r356 r502  
    2727  /// Clone
    2828  virtual CbcHeuristic * clone() const;
     29  /// Assignment operator
     30  CbcHeuristicGreedyCover & operator=(const CbcHeuristicGreedyCover& rhs);
    2931  /// Create C++ lines to get to current state
    3032  virtual void generateCpp( FILE * fp) ;
     
    8183  int numberTimes_;
    8284
    83 private:
    84   /// Illegal Assignment operator
    85   CbcHeuristicGreedyCover & operator=(const CbcHeuristicGreedyCover& rhs);
    8685};
    8786
     
    106105  /// Clone
    107106  virtual CbcHeuristic * clone() const;
     107  /// Assignment operator
     108  CbcHeuristicGreedyEquality & operator=(const CbcHeuristicGreedyEquality& rhs);
    108109  /// Create C++ lines to get to current state
    109110  virtual void generateCpp( FILE * fp) ;
     
    166167  int numberTimes_;
    167168
    168 private:
    169   /// Illegal Assignment operator
    170   CbcHeuristicGreedyEquality & operator=(const CbcHeuristicGreedyEquality& rhs);
    171169};
    172170
  • branches/devel/Cbc/src/CbcHeuristicLocal.cpp

    r439 r502  
    6060  fprintf(fp,"0#include \"CbcHeuristicLocal.hpp\"\n");
    6161  fprintf(fp,"3  CbcHeuristicLocal heuristicLocal(*cbcModel);\n");
     62  CbcHeuristic::generateCpp(fp,"heuristicLocal");
    6263  if (swap_!=other.swap_)
    6364    fprintf(fp,"3  heuristicLocal.setSearchType(%d);\n",swap_);
     
    7576  swap_(rhs.swap_)
    7677{
    77   setWhen(rhs.when());
    7878  if (model_&&rhs.used_) {
    7979    int numberColumns = model_->solver()->getNumCols();
     
    8484  }
    8585}
     86
     87// Assignment operator
     88CbcHeuristicLocal &
     89CbcHeuristicLocal::operator=( const CbcHeuristicLocal& rhs)
     90{
     91  if (this!=&rhs) {
     92    CbcHeuristic::operator=(rhs);
     93    matrix_ = rhs.matrix_;
     94    numberSolutions_ = rhs.numberSolutions_;
     95    swap_ = rhs.swap_;
     96    delete [] used_;
     97    if (model_&&rhs.used_) {
     98      int numberColumns = model_->solver()->getNumCols();
     99      used_ = new char[numberColumns];
     100      memcpy(used_,rhs.used_,numberColumns);
     101    } else {
     102      used_=NULL;
     103    }
     104  }
     105  return *this;
     106}
     107
    86108// Resets stuff if model changes
    87109void
     
    132154    }
    133155  }
    134   int returnCode = smallBranchAndBound(newSolver,200,newSolution,objectiveValue,
     156  int returnCode = smallBranchAndBound(newSolver,numberNodes_,newSolution,objectiveValue,
    135157                                         objectiveValue,"CbcHeuristicLocal");
     158  if ((returnCode&2)!=0) {
     159    // could add cut
     160    returnCode &= ~2;
     161  }
    136162
    137163  delete newSolver;
  • branches/devel/Cbc/src/CbcHeuristicLocal.hpp

    r356 r502  
    2727  /// Clone
    2828  virtual CbcHeuristic * clone() const;
     29
     30  /// Assignment operator
     31  CbcHeuristicLocal & operator=(const CbcHeuristicLocal& rhs);
    2932
    3033  /// Create C++ lines to get to current state
     
    7477  /// Whether a variable has been in a solution
    7578  char * used_;
    76 
    77 private:
    78   /// Illegal Assignment operator
    79   CbcHeuristicLocal & operator=(const CbcHeuristicLocal& rhs);
    8079};
    8180
  • branches/devel/Cbc/src/CbcLinked.cpp

    r501 r502  
    255255    writeMps(temp);
    256256    printf("wrote bb%d\n",xxxxxx);
    257 #if 0
    258     const double * lower = getColLower();
    259     const double * upper = getColUpper();
    260     for (int i=0;i<8;i++) {
    261       printf("%d bounds %g %g\n",i,lower[i],upper[i]);
    262     }
    263     if (lower[2]<=3.0&&upper[2]>=3) {
    264       if (lower[3]<=2.0&&upper[3]>=2.0) {
    265         if (lower[4]==0.0) {
    266           if (lower[7]==0.0) {
    267             if (lower[5]<=4.0&&upper[5]>=4.0) {
    268               if (lower[6]<=3.0&&upper[6]>=3.0) {
    269                 printf("writemps contains solution\n");
    270                 for (int i=8;i<24;i++) {
    271                   printf("%d bounds %g %g\n",i,lower[i],upper[i]);
    272                   if (false&&((!lower[i]&&upper[i]>lower[i]))) {
    273                     setColLower(i,0.0);
    274                     setColUpper(i,10.0);
    275                   }
    276                 }
    277               }
    278             }
    279           }
    280         }
    281       }
    282     }
    283 #endif
    284257  }
    285258#endif
     
    356329    }
    357330    if (isProvenOptimal()) {
     331      if (satisfied)
     332        printf("satisfied %d\n",satisfied);
    358333      if (satisfied&&(specialOptions2_&2)!=0) {
    359334        assert (quadraticModel_);
     
    586561              for ( i=rowStart[objectiveRow_];i<rowStart[objectiveRow_+1];i++)
    587562                gradient[column2[i]] = element[i];
     563              const double * columnLower = modelPtr_->columnLower();
     564              const double * columnUpper = modelPtr_->columnUpper();
    588565              for ( i =0;i<numberObjects_;i++) {
    589566                OsiBiLinear * obj = dynamic_cast<OsiBiLinear *> (object_[i]);
     
    591568                  int xColumn = obj->xColumn();
    592569                  int yColumn = obj->yColumn();
     570                  // We can do better if one fixed
     571                  assert (columnUpper[xColumn]>columnLower[xColumn]);
     572                  assert (columnUpper[yColumn]>columnLower[yColumn]);
    593573                  if (xColumn!=yColumn) {
    594574                    double coefficient = 2.0*obj->coefficient();
     
    648628            double * gradient = new double [numberColumns2];
    649629            int * column = new int[numberColumns2];
     630            const double * columnLower = modelPtr_->columnLower();
     631            const double * columnUpper = modelPtr_->columnUpper();
    650632            for (int iNon=0;iNon<numberNonLinearRows_;iNon++) {
    651633              int iRow = rowNonLinear_[iNon];
     
    666648                int xColumn = obj->xColumn();
    667649                int yColumn = obj->yColumn();
     650                // We can do better if one fixed
     651                assert (columnUpper[xColumn]>columnLower[xColumn]);
     652                assert (columnUpper[yColumn]>columnLower[yColumn]);
    668653                if (xColumn!=yColumn) {
    669654                  double coefficient = 2.0*obj->coefficient();
  • branches/devel/Cbc/src/Makefile.am

    r499 r502  
    3838        CbcHeuristicGreedy.cpp CbcHeuristicGreedy.hpp \
    3939        CbcHeuristicLocal.cpp CbcHeuristicLocal.hpp \
     40        CbcHeuristicRINS.cpp CbcHeuristicRINS.hpp \
    4041        CbcMessage.cpp CbcMessage.hpp \
    4142        CbcModel.cpp CbcModel.hpp \
     
    263264        CbcHeuristicGreedy.hpp \
    264265        CbcHeuristicLocal.hpp \
     266        CbcHeuristicRINS.hpp \
    265267        CbcMessage.hpp \
    266268        CbcModel.hpp \
  • branches/devel/Cbc/src/Makefile.in

    r499 r502  
    158158        CbcHeuristicFPump.hpp CbcHeuristicGreedy.cpp \
    159159        CbcHeuristicGreedy.hpp CbcHeuristicLocal.cpp \
    160         CbcHeuristicLocal.hpp CbcMessage.cpp CbcMessage.hpp \
     160        CbcHeuristicLocal.hpp CbcHeuristicRINS.cpp \
     161        CbcHeuristicRINS.hpp CbcMessage.cpp CbcMessage.hpp \
    161162        CbcModel.cpp CbcModel.hpp CbcNode.cpp CbcNode.hpp \
    162163        CbcStatistics.cpp CbcStatistics.hpp CbcStrategy.cpp \
     
    171172        CbcFathomDynamicProgramming.lo CbcHeuristic.lo \
    172173        CbcHeuristicFPump.lo CbcHeuristicGreedy.lo \
    173         CbcHeuristicLocal.lo CbcMessage.lo CbcModel.lo CbcNode.lo \
    174         CbcStatistics.lo CbcStrategy.lo CbcTree.lo CbcLinked.lo \
    175         CbcTreeLocal.lo $(am__objects_1)
     174        CbcHeuristicLocal.lo CbcHeuristicRINS.lo CbcMessage.lo \
     175        CbcModel.lo CbcNode.lo CbcStatistics.lo CbcStrategy.lo \
     176        CbcTree.lo CbcLinked.lo CbcTreeLocal.lo $(am__objects_1)
    176177libCbc_la_OBJECTS = $(am_libCbc_la_OBJECTS)
    177178@COIN_HAS_CLP_TRUE@am__EXEEXT_1 = cbc$(EXEEXT)
     
    476477        CbcHeuristicFPump.hpp CbcHeuristicGreedy.cpp \
    477478        CbcHeuristicGreedy.hpp CbcHeuristicLocal.cpp \
    478         CbcHeuristicLocal.hpp CbcMessage.cpp CbcMessage.hpp \
     479        CbcHeuristicLocal.hpp CbcHeuristicRINS.cpp \
     480        CbcHeuristicRINS.hpp CbcMessage.cpp CbcMessage.hpp \
    479481        CbcModel.cpp CbcModel.hpp CbcNode.cpp CbcNode.hpp \
    480482        CbcStatistics.cpp CbcStatistics.hpp CbcStrategy.cpp \
     
    588590        CbcHeuristicGreedy.hpp \
    589591        CbcHeuristicLocal.hpp \
     592        CbcHeuristicRINS.hpp \
    590593        CbcMessage.hpp \
    591594        CbcModel.hpp \
     
    722725@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcHeuristicGreedy.Plo@am__quote@
    723726@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcHeuristicLocal.Plo@am__quote@
     727@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcHeuristicRINS.Plo@am__quote@
    724728@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcLinked.Plo@am__quote@
    725729@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/CbcMain.Po@am__quote@
Note: See TracChangeset for help on using the changeset viewer.