SbbNode.hpp

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef SbbNode_H
#define SbbNode_H

#include <string>
#include <vector>

#include "CoinWarmStartBasis.hpp"
#include "SbbBranchBase.hpp"

class OsiSolverInterface;

class OsiCuts;
class OsiRowCut;
class OsiRowCutDebugger;
class CoinWarmStartBasis;
class SbbCountRowCut;
class SbbModel;
class SbbNode;

//#############################################################################
class SbbNodeInfo {

public:

  SbbNodeInfo ();

  SbbNodeInfo (SbbNodeInfo * parent);
   
  SbbNodeInfo (SbbNodeInfo * parent, SbbNode * owner);

  virtual ~SbbNodeInfo();


  virtual void applyToModel (SbbModel *model, CoinWarmStartBasis *&basis,
                             SbbCountRowCut **addCuts,
                             int &currentNumberCuts) const = 0 ;

  virtual SbbNodeInfo * buildRowBasis(CoinWarmStartBasis & basis) const = 0;
  virtual SbbNodeInfo * clone() const = 0;

  inline void increment(int amount=1)
  {numberPointingToThis_+=amount;};

  inline int decrement(int amount=1)
  {numberPointingToThis_-=amount;return numberPointingToThis_;};

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

  inline int numberBranchesLeft() const
  {return numberBranchesLeft_;};

  inline int numberPointingToThis() const
  {return numberPointingToThis_;};

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

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

  SbbNodeInfo * parent() const
  {return parent_;};

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

  void deleteCut(int whichOne);

  void decrementCuts(int change=1);

  void decrementParentCuts(int change=1);

  void incrementParentCuts(int change=1);

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

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

  inline void nullOwner()
  { owner_=NULL;};
protected:

  int numberPointingToThis_;

  SbbNodeInfo * parent_;

  SbbNode * owner_;

  int numberCuts_;

  SbbCountRowCut ** cuts_;

  int numberRows_;

  int numberBranchesLeft_;
      
private:
  
  SbbNodeInfo & operator=(const SbbNodeInfo& rhs);
  
};

class SbbFullNodeInfo : public SbbNodeInfo {

public:

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

  virtual SbbNodeInfo * buildRowBasis(CoinWarmStartBasis & basis) const ;
  // Default Constructor 
  SbbFullNodeInfo ();

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



class SbbPartialNodeInfo : public SbbNodeInfo {

public:

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

  virtual SbbNodeInfo * buildRowBasis(CoinWarmStartBasis & basis ) const ;
  // Default Constructor 
  SbbPartialNodeInfo ();

  // Constructor from current state 
  SbbPartialNodeInfo (SbbNodeInfo * parent, SbbNode * owner,
                int numberChangedBounds,const int * variables,
                const double * boundChanges,
                const CoinWarmStartDiff *basisDiff) ;
  
  // Copy constructor 
  SbbPartialNodeInfo ( const SbbPartialNodeInfo &);
   
  // Destructor 
  ~SbbPartialNodeInfo ();
  
  virtual SbbNodeInfo * clone() const;
private:
  /* Data values */

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



class SbbNode  {
 
public:
    
  SbbNode ();

  SbbNode (SbbModel * model, SbbNode * lastNode);

  SbbNode (const SbbNode &);
   
  SbbNode & operator= (const SbbNode& rhs);

  ~SbbNode ();

  void
  createInfo(SbbModel * model,
             SbbNode * lastNode,
             const CoinWarmStartBasis *lastws,
             const double * lastLower, const double * lastUpper,
             int numberOldActiveCuts,int numberNewCuts);
  
  int chooseBranch (SbbModel * model,
                    SbbNode * lastNode);
  
  void decrementCuts(int change=1);

  void decrementParentCuts(int change=1);

  void nullNodeInfo();
  void initializeInfo();

  int branch();

  // Information to make basis and bounds
  inline SbbNodeInfo * 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) ; } ;

  inline int variable() const
  {if (branch_) return branch_->variable();else return -1;};

  /* Active arm of the attached SbbBranchingObject.
  
   In the simplest instance, coded -1 for the down arm of the branch, +1 for
   the up arm. But see SbbBranchingObject::way() 
     Use nodeInfo--.numberBranchesLeft_ to see how active
  */
  inline int way() const
  {if (branch_) return branch_->way();else return 0;};
  inline int depth() const
  {return depth_;};
  inline int numberUnsatisfied() const
  {return numberUnsatisfied_;};

  // Guessed objective value (for solution)
  inline double guessedObjectiveValue() const
  {return guessedObjectiveValue_;};
  inline void setGuessedObjectiveValue(double value)
  {guessedObjectiveValue_=value;};

private:
  // Data
  SbbNodeInfo * nodeInfo_;
  // Objective value
  double objectiveValue_;
  // Guessed satisfied Objective value
  double guessedObjectiveValue_;
  SbbBranchingObject * branch_;
  int depth_;
  int numberUnsatisfied_;
};


#endif

---