CbcHeuristicGreedy.hpp

Go to the documentation of this file.

/* $Id$ */
// Copyright (C) 2005, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef CbcHeuristicGreedy_H
#define CbcHeuristicGreedy_H
 
#include "CbcHeuristic.hpp"
class CbcHeuristicGreedyCover : public CbcHeuristic {
public:
  // Default Constructor
  CbcHeuristicGreedyCover();
 
  /* Constructor with model - assumed before cuts
       Initial version does not do Lps
    */
  CbcHeuristicGreedyCover(CbcModel &model);
 
  // Copy constructor
  CbcHeuristicGreedyCover(const CbcHeuristicGreedyCover &);
 
  // Destructor
  ~CbcHeuristicGreedyCover();
 
  virtual CbcHeuristic *clone() const;
  CbcHeuristicGreedyCover &operator=(const CbcHeuristicGreedyCover &rhs);
  virtual void generateCpp(FILE *fp);
 
  virtual void setModel(CbcModel *model);
 
  using CbcHeuristic::solution;
  virtual int solution(double &objectiveValue,
    double *newSolution);
  virtual void validate();
  virtual void resetModel(CbcModel *model);
  /* Algorithm
       0 - use current upper bounds
       1 - use original upper bounds
       If 10 added perturb ratios more
       if 100 added round up all >=0.5
    */
  inline int algorithm() const
  {
    return algorithm_;
  }
  inline void setAlgorithm(int value)
  {
    algorithm_ = value;
  }
  // Only do this many times
  inline int numberTimes() const
  {
    return numberTimes_;
  }
  inline void setNumberTimes(int value)
  {
    numberTimes_ = value;
  }
 
protected:
  void gutsOfConstructor(CbcModel *model);
  // Data
 
  // Original matrix by column
  CoinPackedMatrix matrix_;
  // original number of rows
  int originalNumberRows_;
  /* Algorithm
       0 - use current upper bounds
       1 - use original upper bounds
       If 10 added perturb ratios more
    */
  int algorithm_;
  int numberTimes_;
};
 
class CbcHeuristicGreedyEquality : public CbcHeuristic {
public:
  // Default Constructor
  CbcHeuristicGreedyEquality();
 
  /* Constructor with model - assumed before cuts
       Initial version does not do Lps
    */
  CbcHeuristicGreedyEquality(CbcModel &model);
 
  // Copy constructor
  CbcHeuristicGreedyEquality(const CbcHeuristicGreedyEquality &);
 
  // Destructor
  ~CbcHeuristicGreedyEquality();
 
  virtual CbcHeuristic *clone() const;
  CbcHeuristicGreedyEquality &operator=(const CbcHeuristicGreedyEquality &rhs);
  virtual void generateCpp(FILE *fp);
 
  virtual void setModel(CbcModel *model);
 
  using CbcHeuristic::solution;
  virtual int solution(double &objectiveValue,
    double *newSolution);
  virtual void validate();
  virtual void resetModel(CbcModel *model);
  /* Algorithm
       0 - use current upper bounds
       1 - use original upper bounds
       If 10 added perturb ratios more
       if 100 added round up all >=0.5
    */
  inline int algorithm() const
  {
    return algorithm_;
  }
  inline void setAlgorithm(int value)
  {
    algorithm_ = value;
  }
  // Fraction of rhs to cover before branch and cut
  inline void setFraction(double value)
  {
    fraction_ = value;
  }
  inline double fraction() const
  {
    return fraction_;
  }
  // Only do this many times
  inline int numberTimes() const
  {
    return numberTimes_;
  }
  inline void setNumberTimes(int value)
  {
    numberTimes_ = value;
  }
 
protected:
  void gutsOfConstructor(CbcModel *model);
  // Data
 
  // Original matrix by column
  CoinPackedMatrix matrix_;
  // Fraction of rhs to cover before branch and cut
  double fraction_;
  // original number of rows
  int originalNumberRows_;
  /* Algorithm
       0 - use current upper bounds
       1 - use original upper bounds
       If 10 added perturb ratios more
    */
  int algorithm_;
  int numberTimes_;
};
 
class CbcHeuristicGreedySOS : public CbcHeuristic {
public:
  // Default Constructor
  CbcHeuristicGreedySOS();
 
  /* Constructor with model - assumed before cuts
       Initial version does not do Lps
    */
  CbcHeuristicGreedySOS(CbcModel &model);
 
  // Copy constructor
  CbcHeuristicGreedySOS(const CbcHeuristicGreedySOS &);
 
  // Destructor
  ~CbcHeuristicGreedySOS();
 
  virtual CbcHeuristic *clone() const;
  CbcHeuristicGreedySOS &operator=(const CbcHeuristicGreedySOS &rhs);
  virtual void generateCpp(FILE *fp);
 
  virtual void setModel(CbcModel *model);
 
  using CbcHeuristic::solution;
  virtual int solution(double &objectiveValue,
    double *newSolution);
  virtual void validate();
  virtual void resetModel(CbcModel *model);
  /* Algorithm
       Bits
       1 bit - use current model, otherwise original
       2 - use current solution as starting point, otherwise pure greedy
       4 - as 2 but use merit not merit/size
       8 - use duals to modify greedy
       16 - use duals on GUB/SOS in special way
    */
  inline int algorithm() const
  {
    return algorithm_;
  }
  inline void setAlgorithm(int value)
  {
    algorithm_ = value;
  }
  // Only do this many times
  inline int numberTimes() const
  {
    return numberTimes_;
  }
  inline void setNumberTimes(int value)
  {
    numberTimes_ = value;
  }
 
protected:
  void gutsOfConstructor(CbcModel *model);
  // Data
 
  // Original RHS - if -1.0 then SOS otherwise <= value
  double *originalRhs_;
  // Original matrix by column
  CoinPackedMatrix matrix_;
  // original number of rows
  int originalNumberRows_;
  /* Algorithm
    */
  int algorithm_;
  int numberTimes_;
};
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/