CbcNodeInfo.hpp

Go to the documentation of this file.

// $Id: CbcNodeInfo.hpp 2048 2014-07-16 09:29:16Z forrest $
// 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/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) == 7);
    }
    inline bool marked() const {
        return ((active_&8) != 0);
    }
    inline void mark() {
        active_ |= 8;
    }
    inline void unmark() {
        active_ &= ~8;
    }
    inline bool symmetryWorked() const
    { return (active_&16) !=0;}
    inline void setSymmetryWorked()
    { active_ |= 16;}
 
    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