CbcNode.hpp

Go to the documentation of this file.

/* $Id: CbcNode.hpp 1400 2009-12-11 14:14:06Z lou $ */
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
#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;
    }
    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