/home/coin/SVN-release/CoinAll-1.1.0/Cbc/src/CbcFathomDynamicProgramming.hpp

Go to the documentation of this file.

// Copyright (C) 2004, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CbcFathomDynamicProgramming_H
#define CbcFathomDynamicProgramming_H

#include "CbcFathom.hpp"

//#############################################################################
class CbcFathomDynamicProgramming : public CbcFathom {
public:
  // Default Constructor 
  CbcFathomDynamicProgramming ();

  // Constructor with model - assumed before cuts
  CbcFathomDynamicProgramming (CbcModel & model);
  // Copy constructor 
  CbcFathomDynamicProgramming(const CbcFathomDynamicProgramming & rhs);

  virtual ~CbcFathomDynamicProgramming();

  virtual void setModel(CbcModel * model);
  
  virtual CbcFathom * clone() const;

  virtual void resetModel(CbcModel * model);

  virtual int fathom(double *& newSolution);

  inline int maximumSize() const
  { return maximumSizeAllowed_;}
  inline void setMaximumSize(int value)
  { maximumSizeAllowed_=value;}
  int checkPossible(int allowableSize=0);
  // set algorithm
  inline void setAlgorithm(int value)
  { algorithm_=value;}
  bool tryColumn(int numberElements, const int * rows,
                    const double * coefficients, double cost,
                    int upper=COIN_INT_MAX);
  inline const double * cost() const
  { return cost_;}
  inline const int * back() const
  { return back_;}
  inline int target() const
  { return target_;}
  inline void setTarget(int value)
  { target_=value;}
private:
  void gutsOfDelete();

  bool addOneColumn0(int numberElements, const int * rows,
                     double cost);
  bool addOneColumn1(int numberElements, const int * rows,
                     const int * coefficients, double cost);
  bool addOneColumn1A(int numberElements, const int * rows,
                     const int * coefficients, double cost);
  int bitPattern(int numberElements, const int * rows,
                     const int * coefficients);
  int bitPattern(int numberElements, const int * rows,
                     const double * coefficients);
  int decodeBitPattern(int bitPattern, int * values, int numberRows);

protected:

  int size_;
  int type_;
  double * cost_;
  int * back_;
  int * lookup_;
  int * indices_;
  int numberActive_;
  int maximumSizeAllowed_;
  int * startBit_;
  int * numberBits_;
  int * rhs_;
  int * coefficients_;
  int target_;
  int numberNonOne_;
  int bitPattern_;
  int algorithm_;
private:
  
  CbcFathomDynamicProgramming & operator=(const CbcFathomDynamicProgramming& rhs);
  
};

#endif

---