CbcGeneralDepth.hpp

Go to the documentation of this file.

// 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 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