CbcHeuristicGreedy.hpp

Go to the documentation of this file.

/* $Id: CbcHeuristicGreedy.hpp 2465 2019-01-03 19:26:52Z unxusr $ */
// 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
*/