CbcNode.hpp

Go to the documentation of this file.

/* $Id: CbcNode.hpp 1957 2013-08-27 15:19:55Z 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).
 
#ifndef CbcNode_H
#define CbcNode_H
 
#include <string>
#include <vector>
 
#include "CoinWarmStartBasis.hpp"
#include "CoinSearchTree.hpp"
#include "CbcBranchBase.hpp"
#include "CbcNodeInfo.hpp"
#include "CbcFullNodeInfo.hpp"
#include "CbcPartialNodeInfo.hpp"
 
class OsiSolverInterface;
class OsiSolverBranch;
 
class OsiCuts;
class OsiRowCut;
class OsiRowCutDebugger;
class CoinWarmStartBasis;
class CbcCountRowCut;
class CbcModel;
class CbcNode;
class CbcSubProblem;
class CbcGeneralBranchingObject;
 
class CbcNode : public CoinTreeNode {
 
public:
 
    CbcNode ();
 
    CbcNode (CbcModel * model, CbcNode * lastNode);
 
    CbcNode (const CbcNode &);
 
    CbcNode & operator= (const CbcNode& rhs);
 
    ~CbcNode ();
 
    void
    createInfo(CbcModel * model,
               CbcNode * lastNode,
               const CoinWarmStartBasis *lastws,
               const double * lastLower, const double * lastUpper,
               int numberOldActiveCuts, int numberNewCuts);
 
    int chooseBranch (CbcModel * model,
                      CbcNode * lastNode,
                      int numberPassesLeft);
    int chooseDynamicBranch (CbcModel * model,
                             CbcNode * lastNode,
                             OsiSolverBranch * & branches,
                             int numberPassesLeft);
    int chooseOsiBranch (CbcModel * model,
                         CbcNode * lastNode,
                         OsiBranchingInformation * usefulInfo,
                         int branchState);
    int chooseClpBranch (CbcModel * model,
                         CbcNode * lastNode);
    int analyze(CbcModel * model, double * results);
    void decrementCuts(int change = 1);
 
    void decrementParentCuts(CbcModel * model, int change = 1);
 
    void nullNodeInfo();
    void initializeInfo();
 
    int branch(OsiSolverInterface * solver);
 
    double checkIsCutoff(double cutoff);
    // Information to make basis and bounds
    inline CbcNodeInfo * nodeInfo() const {
        return nodeInfo_;
    }
 
    // Objective value
    inline double objectiveValue() const {
        return objectiveValue_;
    }
    inline void setObjectiveValue(double value) {
        objectiveValue_ = value;
    }
    inline int numberBranches() const {
        if (branch_)
            return (branch_->numberBranches()) ;
        else
            return (-1) ;
    }
 
    /* Active arm of the attached OsiBranchingObject.
 
     In the simplest instance, coded -1 for the down arm of the branch, +1 for
     the up arm. But see OsiBranchingObject::way()
       Use nodeInfo--.numberBranchesLeft_ to see how active
    */
    int way() const;
    inline int depth() const {
        return depth_;
    }
    inline void setDepth(int value) {
        depth_ = value;
    }
    inline int numberUnsatisfied() const {
        return numberUnsatisfied_;
    }
    inline void setNumberUnsatisfied(int value) {
        numberUnsatisfied_ = value;
    }
    inline double sumInfeasibilities() const {
        return sumInfeasibilities_;
    }
    inline void setSumInfeasibilities(double value) {
        sumInfeasibilities_ = value;
    }
    // Guessed objective value (for solution)
    inline double guessedObjectiveValue() const {
        return guessedObjectiveValue_;
    }
    inline void setGuessedObjectiveValue(double value) {
        guessedObjectiveValue_ = value;
    }
    inline const OsiBranchingObject * branchingObject() const {
        return branch_;
    }
    inline OsiBranchingObject * modifiableBranchingObject() const {
        return branch_;
    }
    inline void setBranchingObject(OsiBranchingObject * branchingObject) {
        branch_ = branchingObject;
    }
    inline int nodeNumber() const {
        return nodeNumber_;
    }
    inline void setNodeNumber(int node) {
        nodeNumber_ = node;
    }
    inline bool onTree() const {
        return (state_&1) != 0;
    }
    inline void setOnTree(bool yesNo) {
        if (yesNo) state_ |= 1;
        else state_ &= ~1;
    }
    inline bool active() const {
        return (state_&2) != 0;
    }
    inline void setActive(bool yesNo) {
        if (yesNo) state_ |= 2;
        else state_ &= ~2;
    }
    inline int getState() const
    { return state_;}
    inline void setState(int value)
    { state_ = value;}
    void print() const;
    inline void checkInfo() const {
        assert (nodeInfo_->numberBranchesLeft() ==
                branch_->numberBranchesLeft());
    }
 
private:
    // Data
    CbcNodeInfo * nodeInfo_;
    double objectiveValue_;
    double guessedObjectiveValue_;
    double sumInfeasibilities_;
    OsiBranchingObject * branch_;
    int depth_;
    int numberUnsatisfied_;
    int nodeNumber_;
    int state_;
};
 
 
#endif