SbbBranchActual.hpp

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

#include "SbbBranchBase.hpp"




class SbbClique : public SbbObject {

public:

  // Default Constructor 
  SbbClique ();

  // Useful constructor (which are integer indices)
  // slack can denote a slack in set
  SbbClique (SbbModel * model, int cliqueType, int numberMembers,
             const int * which, const char * type,
             int identifier,int slack=-1);
  
  // Copy constructor 
  SbbClique ( const SbbClique &);
   
  virtual SbbObject * clone() const;

  // Assignment operator 
  SbbClique & operator=( const SbbClique& rhs);

  // Destructor 
  ~SbbClique ();
  
  virtual double infeasibility(int & preferredWay, double & otherWay) const;

  virtual void feasibleRegion();
  virtual SbbBranchingObject * createBranch(int way) const;
  inline int numberMembers() const
  {return numberMembers_;};

  inline int numberNonSOSMembers() const
  {return numberNonSOSMembers_;};

  inline const int * members() const
  {return members_;};

  inline const char type(int index) const
  {if (type_) return type_[index]; else return 1;};

  inline int cliqueType() const
  {return cliqueType_;};

private:
  int numberMembers_;

  int numberNonSOSMembers_;

  int * members_;

  char * type_;

   int cliqueType_;

  int slack_;
};



class SbbSimpleInteger : public SbbObject {

public:

  // Default Constructor 
  SbbSimpleInteger ();

  // Useful constructor - passed integer index and model index
  SbbSimpleInteger (SbbModel * model, int sequence, int iColumn);
  
  // Copy constructor 
  SbbSimpleInteger ( const SbbSimpleInteger &);
   
  virtual SbbObject * clone() const;

  // Assignment operator 
  SbbSimpleInteger & operator=( const SbbSimpleInteger& rhs);

  // Destructor 
  ~SbbSimpleInteger ();
  
  virtual double infeasibility(int & preferredWay, double & otherWay) const;

  virtual void feasibleRegion();

  virtual SbbBranchingObject * createBranch(int way) const;

  virtual SbbBranchingObject * preferredNewFeasible() const;
  
  virtual SbbBranchingObject * notPreferredNewFeasible() const ;
  
  virtual void resetBounds();
  
  inline int sequence() const
  {return sequence_;};

  inline int modelSequence() const
  {return columnNumber_;};

  inline double originalLowerBound() const
  { return originalLower_;};
  inline double originalUpperBound() const
  { return originalUpper_;};


private:

  int sequence_;
  int columnNumber_;
  double originalLower_;
  double originalUpper_;
};


class SbbIntegerBranchingObject : public SbbBranchingObject {

public:

  SbbIntegerBranchingObject ();

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

  virtual SbbBranchingObject * clone() const;

  virtual ~SbbIntegerBranchingObject ();
  
  virtual void branch();

private:
  double down_[2];
  double up_[2];
};


class SbbCliqueBranchingObject : public SbbBranchingObject {

public:

  // Default Constructor 
  SbbCliqueBranchingObject ();

  // Useful constructor
  SbbCliqueBranchingObject (SbbModel * model,  const SbbClique * clique,
                            int way,
                            int numberOnDownSide, const int * down,
                            int numberOnUpSide, const int * up);
  
  // Copy constructor 
  SbbCliqueBranchingObject ( const SbbCliqueBranchingObject &);
   
  // Assignment operator 
  SbbCliqueBranchingObject & operator=( const SbbCliqueBranchingObject& rhs);

  virtual SbbBranchingObject * clone() const;

  // Destructor 
  virtual ~SbbCliqueBranchingObject ();
  
  virtual void branch();
private:
  const SbbClique * clique_;
  unsigned int downMask_[2];
  unsigned int upMask_[2];
};


class SbbLongCliqueBranchingObject : public SbbBranchingObject {

public:

  // Default Constructor 
  SbbLongCliqueBranchingObject ();

  // Useful constructor
  SbbLongCliqueBranchingObject (SbbModel * model,  const SbbClique * clique,
                                 int way,
                            int numberOnDownSide, const int * down,
                            int numberOnUpSide, const int * up);
  
  // Copy constructor 
  SbbLongCliqueBranchingObject ( const SbbLongCliqueBranchingObject &);
   
  // Assignment operator 
  SbbLongCliqueBranchingObject & operator=( const SbbLongCliqueBranchingObject& rhs);

  virtual SbbBranchingObject * clone() const;

  // Destructor 
  virtual ~SbbLongCliqueBranchingObject ();
  
  virtual void branch();
private:
  const SbbClique * clique_;
  unsigned int * downMask_;
  unsigned int * upMask_;
};

class SbbBranchDefaultDecision : public SbbBranchDecision {
public:
  // Default Constructor 
  SbbBranchDefaultDecision ();

  // Copy constructor 
  SbbBranchDefaultDecision ( const SbbBranchDefaultDecision &);

  virtual ~SbbBranchDefaultDecision();

  virtual SbbBranchDecision * clone() const;

  virtual void initialize(SbbModel * model);

  virtual int betterBranch(SbbBranchingObject * thisOne,
                            SbbBranchingObject * bestSoFar,
                            double changeUp, int numInfUp,
                            double changeDn, int numInfDn);

private:
  
  SbbBranchDefaultDecision & operator=(const SbbBranchDefaultDecision& rhs);


  double bestCriterion_;

  double bestChangeUp_;

  int bestNumberUp_;

  double bestChangeDown_;

  int bestNumberDown_;

  SbbBranchingObject * bestObject_;

};

#endif

---