/home/coin/SVN-release/CoinAll-1.1.0/Cbc/src/CbcNode.hpp

Go to the documentation of this file.

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

class OsiSolverInterface;
class OsiSolverBranch;

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

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

public:

  CbcNodeInfo ();

  CbcNodeInfo ( const CbcNodeInfo &);
   
#if 0

  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() {}
#if 1
  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 int numberPointingToThis() const
  {return numberPointingToThis_;}

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

  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);
  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_;}
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();
};

class CbcFullNodeInfo : public CbcNodeInfo {

public:

  virtual void applyToModel (CbcModel *model, CoinWarmStartBasis *&basis,
                             CbcCountRowCut **addCuts,
                             int &currentNumberCuts) const ;

  virtual int applyBounds(int iColumn, double & lower, double & upper,int force) ;

  virtual CbcNodeInfo * buildRowBasis(CoinWarmStartBasis & basis) const ;
  // Default Constructor 
  CbcFullNodeInfo ();

  CbcFullNodeInfo (CbcModel * model,
                   int numberRowsAtContinuous);
  
  // Copy constructor 
  CbcFullNodeInfo ( const CbcFullNodeInfo &);
   
  // Destructor 
  ~CbcFullNodeInfo ();
  
  virtual CbcNodeInfo * clone() const;
protected:
  // Data
  CoinWarmStartBasis *basis_;
  int numberIntegers_;
  // Bounds stored in full
  double * lower_;
  double * upper_;
private:
  CbcFullNodeInfo & operator=(const CbcFullNodeInfo& rhs);
};



class CbcPartialNodeInfo : public CbcNodeInfo {

public:

  virtual void applyToModel (CbcModel *model, CoinWarmStartBasis *&basis,
                             CbcCountRowCut **addCuts,
                             int &currentNumberCuts) const ;

  virtual int applyBounds(int iColumn, double & lower, double & upper,int force) ;
  virtual CbcNodeInfo * buildRowBasis(CoinWarmStartBasis & basis ) const ;
  // Default Constructor 
  CbcPartialNodeInfo ();

  // Constructor from current state 
  CbcPartialNodeInfo (CbcNodeInfo * parent, CbcNode * owner,
                int numberChangedBounds,const int * variables,
                const double * boundChanges,
                const CoinWarmStartDiff *basisDiff) ;
  
  // Copy constructor 
  CbcPartialNodeInfo ( const CbcPartialNodeInfo &);
   
  // Destructor 
  ~CbcPartialNodeInfo ();
  
  virtual CbcNodeInfo * clone() const;
  inline const CoinWarmStartDiff *basisDiff() const
  { return basisDiff_ ;}
  inline const int * variables() const
  { return variables_;}
  // New bound
  inline const double * newBounds() const
  { return newBounds_;}
  inline int numberChangedBounds() const
  { return numberChangedBounds_;}
protected:
  /* Data values */

  CoinWarmStartDiff *basisDiff_ ;
  int * variables_;
  // New bound
  double * newBounds_;
  int numberChangedBounds_;
private:
  
  CbcPartialNodeInfo & operator=(const CbcPartialNodeInfo& rhs);
};



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 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);

  // 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 int numberUnsatisfied() const
  {return numberUnsatisfied_;}
  inline double sumInfeasibilities() const
  { return sumInfeasibilities_;}
  // 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;

private:
  // Data
  CbcNodeInfo * nodeInfo_;
  double objectiveValue_;
  double guessedObjectiveValue_;
  double sumInfeasibilities_;
  OsiBranchingObject * branch_;
  int depth_;
  int numberUnsatisfied_;
  int nodeNumber_;
  int state_;
};


#endif

---