SbbBranchBase.hpp

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

#include <string>
#include <vector>

class OsiSolverInterface;

class SbbModel;
class SbbNode;
class SbbNodeInfo;
class SbbBranchingObject;

//#############################################################################

class SbbObject {

public:

  // Default Constructor 
  SbbObject ();

  // Useful constructor
  SbbObject (SbbModel * model);
  
  // Copy constructor 
  SbbObject ( const SbbObject &);
   
  // Assignment operator 
  SbbObject & operator=( const SbbObject& rhs);

  virtual SbbObject * clone() const=0;

  virtual ~SbbObject ();

  virtual double infeasibility(int &preferredWay, double &otherWay) const = 0;

  virtual void feasibleRegion() = 0;

  virtual SbbBranchingObject * createBranch(int way) const = 0;
  
  virtual SbbBranchingObject * preferredNewFeasible() const 
  { return NULL;};
  
  virtual SbbBranchingObject * notPreferredNewFeasible() const 
  { return NULL;};

  virtual void resetBounds() {};
  
  inline int id() const
  { return id_;};
  
  inline void setModel(SbbModel * model)
  { model_ = model;};
  
  inline SbbModel * model() const
  {return  model_;};
  
protected:

  // Model
  SbbModel * model_;
  // Id
  int id_;

};

class SbbBranchingObject {

public:

  SbbBranchingObject ();

  SbbBranchingObject (SbbModel * model, int variable, int way , double value);
  
  SbbBranchingObject ( const SbbBranchingObject &);
   
  SbbBranchingObject & operator=( const SbbBranchingObject& rhs);

  virtual SbbBranchingObject * clone() const=0;

  virtual ~SbbBranchingObject ();
  
  virtual int numberBranches() const
  {return 2;};

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

  virtual void branch()=0;

  inline int variable() const
  {return variable_;};

  inline int way() const
  {return way_;};

  inline void way(int way)
  {way_=way;};

  inline double value() const
  {return value_;};
  
  inline SbbModel * model() const
  {return  model_;};

protected:

  SbbModel * model_;

  int variable_;
  // was - Way to branch - -1 down (first), 1 up, -2 down (second), 2 up (second)
  int way_;

  double value_;

  int numberBranchesLeft_;

};


class SbbBranchDecision {
public:
  SbbBranchDecision ();

  virtual ~SbbBranchDecision();

  virtual SbbBranchDecision * clone() const = 0;

  virtual void initialize(SbbModel * model) = 0;

  virtual int
  betterBranch (SbbBranchingObject * thisOne,
                SbbBranchingObject * bestSoFar,
                double changeUp, int numberInfeasibilitiesUp,
                double changeDown, int numberInfeasibilitiesDown) = 0 ;

  virtual int
  bestBranch (SbbBranchingObject ** objects, int numberObjects, int numberUnsatisfied,
              double * changeUp, int * numberInfeasibilitiesUp,
              double * changeDown, int * numberInfeasibilitiesDown,
              double objectiveValue) ;



private:
  
  SbbBranchDecision & operator=(const SbbBranchDecision& rhs);
  
};

#endif

---