CbcNodeInfo.hpp

Go to the documentation of this file.

// Edwin 11/24/09 carved from CbcNode
#ifndef CbcNodeInfo_H
#define CbcNodeInfo_H

#include <string>
#include <vector>

#include "CoinWarmStartBasis.hpp"
#include "CoinSearchTree.hpp"
#include "CbcBranchBase.hpp"

class OsiSolverInterface;
class OsiSolverBranch;

class OsiCuts;
class OsiRowCut;
class OsiRowCutDebugger;
class CoinWarmStartBasis;
class CbcCountRowCut;
class CbcModel;
class CbcNode;
class CbcSubProblem;
class CbcGeneralBranchingObject;

//#############################################################################
class CbcNodeInfo {

public:

    CbcNodeInfo ();

    CbcNodeInfo ( const CbcNodeInfo &);

#ifdef JJF_ZERO

    CbcNodeInfo (CbcNodeInfo * parent);
#endif

    CbcNodeInfo (CbcNodeInfo * parent, CbcNode * owner);

    virtual ~CbcNodeInfo();


    virtual void applyToModel (CbcModel *model, CoinWarmStartBasis *&basis,
                               CbcCountRowCut **addCuts,
                               int &currentNumberCuts) const = 0 ;
    virtual int applyBounds(int iColumn, double & lower, double & upper, int force) = 0;

    virtual CbcNodeInfo * buildRowBasis(CoinWarmStartBasis & basis) const = 0;
    virtual CbcNodeInfo * clone() const = 0;
    virtual void allBranchesGone() {}
#ifndef JJF_ONE
    inline void increment(int amount = 1) {
        numberPointingToThis_ += amount;/*printf("CbcNodeInfo %x incremented by %d to %d\n",this,amount,numberPointingToThis_);*/
    }

    inline int decrement(int amount = 1) {
        numberPointingToThis_ -= amount;/*printf("CbcNodeInfo %x decremented by %d to %d\n",this,amount,numberPointingToThis_);*/
        return numberPointingToThis_;
    }
#else
    void increment(int amount = 1);
    int decrement(int amount = 1);
#endif

    inline void initializeInfo(int number) {
        numberPointingToThis_ = number;
        numberBranchesLeft_ = number;
    }

    inline int numberBranchesLeft() const {
        return numberBranchesLeft_;
    }

    inline void setNumberBranchesLeft(int value) {
        numberBranchesLeft_ = value;
    }

    inline int numberPointingToThis() const {
        return numberPointingToThis_;
    }

    inline void setNumberPointingToThis(int number) {
        numberPointingToThis_ = number;
    }

    inline void incrementNumberPointingToThis() {
        numberPointingToThis_ ++;
    }

    inline int branchedOn() {
        numberPointingToThis_--;
        numberBranchesLeft_--;
        return numberBranchesLeft_;
    }

    inline void throwAway() {
        numberPointingToThis_ -= numberBranchesLeft_;
        numberBranchesLeft_ = 0;
    }

    CbcNodeInfo * parent() const {
        return parent_;
    }
    inline void nullParent() {
        parent_ = NULL;
    }

    void addCuts(OsiCuts & cuts, int numberToBranch, //int * whichGenerator,
                 int numberPointingToThis);
    void addCuts(int numberCuts, CbcCountRowCut ** cuts, int numberToBranch);
    void deleteCuts(int numberToDelete, CbcCountRowCut ** cuts);
    void deleteCuts(int numberToDelete, int * which);

    void deleteCut(int whichOne);

    void decrementCuts(int change = 1);

    void incrementCuts(int change = 1);

    void decrementParentCuts(CbcModel * model, int change = 1);

    void incrementParentCuts(CbcModel * model, int change = 1);

    inline CbcCountRowCut ** cuts() const {
        return cuts_;
    }

    inline int numberCuts() const {
        return numberCuts_;
    }
    inline void setNumberCuts(int value) {
        numberCuts_ = value;
    }

    inline void nullOwner() {
        owner_ = NULL;
    }
    const inline CbcNode * owner() const {
        return owner_;
    }
    inline CbcNode * mutableOwner() const {
        return owner_;
    }
    inline int nodeNumber() const {
        return nodeNumber_;
    }
    inline void setNodeNumber(int node) {
        nodeNumber_ = node;
    }
    void deactivate(int mode = 3);
    inline bool allActivated() const {
        return (active_ == 7);
    }
    inline bool marked() const {
        return ((active_&8) != 0);
    }
    inline void mark() {
        active_ |= 8;
    }
    inline void unmark() {
        active_ &= ~8;
    }

    inline const OsiBranchingObject * parentBranch() const {
        return parentBranch_;
    }
    void unsetParentBasedData();
protected:

    int numberPointingToThis_;

    CbcNodeInfo * parent_;

    OsiBranchingObject * parentBranch_;

    CbcNode * owner_;

    int numberCuts_;

    int nodeNumber_;

    CbcCountRowCut ** cuts_;

    int numberRows_;

    int numberBranchesLeft_;
    int active_;

private:

    CbcNodeInfo & operator=(const CbcNodeInfo& rhs);

    void setParentBasedData();
};

#endif // CbcNodeInfo_H