CbcGeneralDepth.hpp

Go to the documentation of this file.

// $Id$
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
// Edwin 11/10/2009-- carved out of CbcBranchActual
 
#ifndef CbcGeneralDepth_H
#define CbcGeneralDepth_H
 
#include "CbcGeneral.hpp"
#include "CbcBranchBase.hpp"
#include "CbcSubProblem.hpp"
 
#ifdef COIN_HAS_CLP
 
#include "ClpSimplex.hpp"
#include "ClpNode.hpp"
 
class CbcGeneralDepth : public CbcGeneral {
 
public:
  // Default Constructor
  CbcGeneralDepth();
 
  CbcGeneralDepth(CbcModel *model, int maximumDepth);
 
  // Copy constructor
  CbcGeneralDepth(const CbcGeneralDepth &);
 
  virtual CbcObject *clone() const;
 
  // Assignment operator
  CbcGeneralDepth &operator=(const CbcGeneralDepth &rhs);
 
  // Destructor
  ~CbcGeneralDepth();
 
  virtual double infeasibility(const OsiBranchingInformation *info,
    int &preferredWay) const;
 
  using CbcObject::feasibleRegion;
  virtual void feasibleRegion();
 
  virtual CbcBranchingObject *createCbcBranch(OsiSolverInterface *solver, const OsiBranchingInformation *info, int way);
  inline int maximumNodes() const
  {
    return maximumNodes_;
  }
  inline int maximumDepth() const
  {
    return maximumDepth_;
  }
  inline void setMaximumDepth(int value)
  {
    maximumDepth_ = value;
  }
  inline int numberNodes() const
  {
    return numberNodes_;
  }
  inline int whichSolution() const
  {
    return whichSolution_;
  }
  inline ClpNode *nodeInfo(int which)
  {
    return nodeInfo_->nodeInfo_[which];
  }
 
  virtual void redoSequenceEtc(CbcModel *model, int numberColumns, const int *originalColumns);
 
protected:
  int maximumDepth_;
  int maximumNodes_;
  mutable int whichSolution_;
  mutable int numberNodes_;
  mutable ClpNodeStuff *nodeInfo_;
};
class CbcNode;
class CbcGeneralBranchingObject : public CbcBranchingObject {
 
public:
  // Default Constructor
  CbcGeneralBranchingObject();
 
  // Useful constructor
  CbcGeneralBranchingObject(CbcModel *model);
 
  // Copy constructor
  CbcGeneralBranchingObject(const CbcGeneralBranchingObject &);
 
  // Assignment operator
  CbcGeneralBranchingObject &operator=(const CbcGeneralBranchingObject &rhs);
 
  virtual CbcBranchingObject *clone() const;
 
  // Destructor
  virtual ~CbcGeneralBranchingObject();
 
  using CbcBranchingObject::branch;
  virtual double branch();
  virtual void checkIsCutoff(double cutoff);
 
  using CbcBranchingObject::print;
  virtual void print();
  void state(double &objectiveValue, double &sumInfeasibilities,
    int &numberUnsatisfied, int which) const;
  inline void setNode(CbcNode *node)
  {
    node_ = node;
  }
  virtual CbcBranchObjType type() const
  {
    return GeneralDepthBranchObj;
  }
 
  virtual int compareOriginalObject(const CbcBranchingObject *brObj) const;
 
  virtual CbcRangeCompare compareBranchingObject(const CbcBranchingObject *brObj, const bool replaceIfOverlap = false);
  inline int numberSubProblems() const
  {
    return numberSubProblems_;
  }
  inline int decrementNumberLeft()
  {
    numberSubLeft_--;
    return numberSubLeft_;
  }
  inline int whichNode() const
  {
    return whichNode_;
  }
  inline void setWhichNode(int value)
  {
    whichNode_ = value;
  }
  // Sub problem
  const CbcSubProblem *subProblem(int which) const
  {
    return subProblems_ + which;
  }
 
public:
  // Sub problems
  CbcSubProblem *subProblems_;
  CbcNode *node_;
  int numberSubProblems_;
  int numberSubLeft_;
  int whichNode_;
  int numberRows_;
};
class CbcOneGeneralBranchingObject : public CbcBranchingObject {
 
public:
  // Default Constructor
  CbcOneGeneralBranchingObject();
 
  // Useful constructor
  CbcOneGeneralBranchingObject(CbcModel *model,
    CbcGeneralBranchingObject *object,
    int whichOne);
 
  // Copy constructor
  CbcOneGeneralBranchingObject(const CbcOneGeneralBranchingObject &);
 
  // Assignment operator
  CbcOneGeneralBranchingObject &operator=(const CbcOneGeneralBranchingObject &rhs);
 
  virtual CbcBranchingObject *clone() const;
 
  // Destructor
  virtual ~CbcOneGeneralBranchingObject();
 
  using CbcBranchingObject::branch;
  virtual double branch();
  virtual void checkIsCutoff(double cutoff);
 
  using CbcBranchingObject::print;
  virtual void print();
  virtual CbcBranchObjType type() const
  {
    return OneGeneralBranchingObj;
  }
 
  virtual int compareOriginalObject(const CbcBranchingObject *brObj) const;
 
  virtual CbcRangeCompare compareBranchingObject(const CbcBranchingObject *brObj, const bool replaceIfOverlap = false);
 
public:
  CbcGeneralBranchingObject *object_;
  int whichOne_;
};
#endif //COIN_HAS_CLP
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/