OsiBranchingObject.hpp

Go to the documentation of this file.

// Copyright (C) 2006, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef OsiBranchingObject_H
#define OsiBranchingObject_H

#include <cassert>
#include <string>
#include <vector>

#include "CoinError.hpp"
#include "CoinTypes.hpp"

class OsiSolverInterface;
class OsiSolverBranch;

class OsiBranchingObject;
class OsiBranchingInformation;

//#############################################################################
//This contains the abstract base class for an object and for branching.
//It also contains a simple integer class
//#############################################################################

class OsiObject {

public:
  
  OsiObject ();
  
  OsiObject ( const OsiObject &);
  
  OsiObject & operator=( const OsiObject& rhs);
  
  virtual OsiObject * clone() const=0;
  
  virtual ~OsiObject ();
  
  double infeasibility(const OsiSolverInterface * solver,int &whichWay) const ;
  // Faster version when more information available
  virtual double infeasibility(const OsiBranchingInformation * info, int &whichWay) const =0;
  // This does NOT set mutable stuff
  virtual double checkInfeasibility(const OsiBranchingInformation * info) const;
  
  virtual double feasibleRegion(OsiSolverInterface * solver) const ;
  virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const =0;
  
  virtual OsiBranchingObject * createBranch(OsiSolverInterface * /*solver*/,
                                            const OsiBranchingInformation * /*info*/,
                                            int /*way*/) const {throw CoinError("Need code","createBranch","OsiBranchingObject"); return NULL; }
  
  virtual bool canDoHeuristics() const 
  {return true;}
  virtual bool canMoveToNearest() const 
  {return false;}
  virtual int columnNumber() const;
  inline int priority() const
  { return priority_;}
  inline void setPriority(int priority)
  { priority_ = priority;}
  virtual bool boundBranch() const 
  {return true;}
  virtual bool canHandleShadowPrices() const
  { return false;}
  inline int numberWays() const
  { return numberWays_;}
  inline void setNumberWays(int numberWays)
  { numberWays_ = static_cast<short int>(numberWays) ; }
  inline void setWhichWay(int way)
  { whichWay_ = static_cast<short int>(way) ; }
  inline int whichWay() const
  { return whichWay_;}
  virtual int preferredWay() const
  { return -1;}
  inline double infeasibility() const
  { return infeasibility_;}
  virtual double upEstimate() const;
  virtual double downEstimate() const;
  virtual void resetBounds(const OsiSolverInterface * ) {}
  virtual void resetSequenceEtc(int , const int * ) {}
  virtual void updateBefore(const OsiObject * ) {}
  virtual void updateAfter(const OsiObject * , const OsiObject * ) {}

protected:

  mutable double infeasibility_;
  mutable short whichWay_;
  short  numberWays_;
  int priority_;

};


class OsiObject2 : public OsiObject {

public:

  OsiObject2 ();

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

  virtual ~OsiObject2 ();
  
  inline void setPreferredWay(int value)
  {preferredWay_=value;}
  
  virtual int preferredWay() const
  { return preferredWay_;}
protected:
  int preferredWay_;
  mutable double otherInfeasibility_;
  
};

class OsiBranchingObject {

public:

  OsiBranchingObject ();

  OsiBranchingObject (OsiSolverInterface * solver, double value);
  
  OsiBranchingObject ( const OsiBranchingObject &);
   
  OsiBranchingObject & operator=( const OsiBranchingObject& rhs);

  virtual OsiBranchingObject * clone() const=0;

  virtual ~OsiBranchingObject ();

  inline int numberBranches() const
  {return numberBranches_;}

  inline int numberBranchesLeft() const
  {return numberBranches_-branchIndex_;}

  inline void incrementNumberBranchesLeft()
  { numberBranches_ ++;}

  inline void setNumberBranchesLeft(int /*value*/)
  {/*assert (value==1&&!branchIndex_);*/ numberBranches_=1;}

  inline void decrementNumberBranchesLeft()
  {branchIndex_++;}

  virtual double branch(OsiSolverInterface * solver)=0;
  virtual double branch() {return branch(NULL);}
  virtual bool boundBranch() const 
  {return true;}
  inline int branchIndex() const
  {return branchIndex_;}

  inline void setBranchingIndex(int branchIndex)
  { branchIndex_ = static_cast<short int>(branchIndex) ; }

  inline double value() const
  {return value_;}
  
  inline const OsiObject * originalObject() const
  {return  originalObject_;}
  inline void setOriginalObject(const OsiObject * object)
  {originalObject_=object;}
  virtual void checkIsCutoff(double ) {}
  int columnNumber() const;
  virtual void print(const OsiSolverInterface * =NULL) const {}

protected:

  double value_;

  const OsiObject * originalObject_;

  int numberBranches_;

  short branchIndex_;

};
/* This contains information
   This could also contain pseudo shadow prices
   or information for dealing with computing and trusting pseudo-costs
*/
class OsiBranchingInformation {

public:
  
  OsiBranchingInformation ();
  
  OsiBranchingInformation (const OsiSolverInterface * solver, bool normalSolver,bool copySolution=false);
  
  OsiBranchingInformation ( const OsiBranchingInformation &);
  
  OsiBranchingInformation & operator=( const OsiBranchingInformation& rhs);
  
  virtual OsiBranchingInformation * clone() const;
  
  virtual ~OsiBranchingInformation ();
  
  // Note public
public:

  int stateOfSearch_;
  double objectiveValue_;
  double cutoff_;
  double direction_;
  double integerTolerance_;
  double primalTolerance_;
  double timeRemaining_;
  double defaultDual_;
  mutable const OsiSolverInterface * solver_;
  int numberColumns_;
  mutable const double * lower_;
  mutable const double * solution_;
  mutable const double * upper_;
  const double * hotstartSolution_;
  const double * pi_;
  const double * rowActivity_;
  const double * objective_;
  const double * rowLower_;
  const double * rowUpper_;
  const double * elementByColumn_;
  const CoinBigIndex * columnStart_;
  const int * columnLength_;
  const int * row_;
  double * usefulRegion_;
  int * indexRegion_;
  int numberSolutions_;
  int numberBranchingSolutions_;
  int depth_;
  bool owningSolution_;
};


class OsiTwoWayBranchingObject : public OsiBranchingObject {

public:

  OsiTwoWayBranchingObject ();

  OsiTwoWayBranchingObject (OsiSolverInterface *solver,const OsiObject * originalObject,
                             int way , double value) ;
    
  OsiTwoWayBranchingObject ( const OsiTwoWayBranchingObject &);
   
  OsiTwoWayBranchingObject & operator= (const OsiTwoWayBranchingObject& rhs);

  virtual ~OsiTwoWayBranchingObject ();

  using OsiBranchingObject::branch ;
  virtual double branch(OsiSolverInterface * solver)=0;

  inline int firstBranch() const { return firstBranch_; }
  inline int way() const
  { return !branchIndex_ ? firstBranch_ : -firstBranch_;}
protected:
  int firstBranch_;
};


class OsiSimpleInteger : public OsiObject2 {

public:

  OsiSimpleInteger ();

  OsiSimpleInteger (const OsiSolverInterface * solver, int iColumn);
  
  OsiSimpleInteger (int iColumn, double lower, double upper);
  
  OsiSimpleInteger ( const OsiSimpleInteger &);
   
  virtual OsiObject * clone() const;

  OsiSimpleInteger & operator=( const OsiSimpleInteger& rhs);

  virtual ~OsiSimpleInteger ();
  
  using OsiObject::infeasibility ;
  virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;

  using OsiObject::feasibleRegion ;
  virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;

  virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;


  inline void setColumnNumber(int value)
  {columnNumber_=value;}
  
  virtual int columnNumber() const;

  inline double originalLowerBound() const
  { return originalLower_;}
  inline void setOriginalLowerBound(double value)
  { originalLower_=value;}
  inline double originalUpperBound() const
  { return originalUpper_;}
  inline void setOriginalUpperBound(double value)
  { originalUpper_=value;}
  virtual void resetBounds(const OsiSolverInterface * solver) ;
  virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);
  
  virtual double upEstimate() const;
  virtual double downEstimate() const;
  virtual bool canHandleShadowPrices() const
  { return false;}
protected:
  double originalLower_;
  double originalUpper_;
  int columnNumber_;
  
};
class OsiIntegerBranchingObject : public OsiTwoWayBranchingObject {

public:

  OsiIntegerBranchingObject ();

  OsiIntegerBranchingObject (OsiSolverInterface *solver,const OsiSimpleInteger * originalObject,
                             int way , double value) ;
  OsiIntegerBranchingObject (OsiSolverInterface *solver,const OsiSimpleInteger * originalObject,
                             int way , double value, double downUpperBound, double upLowerBound) ;
    
  OsiIntegerBranchingObject ( const OsiIntegerBranchingObject &);
   
  OsiIntegerBranchingObject & operator= (const OsiIntegerBranchingObject& rhs);

  virtual OsiBranchingObject * clone() const;

  virtual ~OsiIntegerBranchingObject ();
  
  using OsiBranchingObject::branch ;
  virtual double branch(OsiSolverInterface * solver);

  using OsiBranchingObject::print ;
  virtual void print(const OsiSolverInterface * solver=NULL);

protected:
  // Probably could get away with just value which is already stored 
  double down_[2];
  double up_[2];
};


class OsiSOS : public OsiObject2 {

public:

  // Default Constructor 
  OsiSOS ();

  OsiSOS (const OsiSolverInterface * solver, int numberMembers,
           const int * which, const double * weights, int type=1);
  
  // Copy constructor 
  OsiSOS ( const OsiSOS &);
   
  virtual OsiObject * clone() const;

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

  // Destructor 
  virtual ~OsiSOS ();
  
  using OsiObject::infeasibility ;
  virtual double infeasibility(const OsiBranchingInformation * info,int & whichWay) const;

  using OsiObject::feasibleRegion ;
  virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;

  virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
  virtual double upEstimate() const;
  virtual double downEstimate() const;
  
  virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);
  
  inline int numberMembers() const
  {return numberMembers_;}

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

  inline int sosType() const
  {return sosType_;}

  inline int setType() const
  {return sosType_;}

  inline const double * weights() const
  { return weights_;}

  virtual bool canDoHeuristics() const 
  {return (sosType_==1&&integerValued_);}
  inline void setIntegerValued(bool yesNo)
  { integerValued_=yesNo;}
  virtual bool canHandleShadowPrices() const
  { return true;}
  inline void setNumberMembers(int value)
  {numberMembers_=value;}

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

  inline void setSosType(int value)
  {sosType_=value;}

  inline  double * mutableWeights() const
  { return weights_;}
protected:

  int * members_;
  double * weights_;

  int numberMembers_;
  int sosType_;
  bool integerValued_;
};

class OsiSOSBranchingObject : public OsiTwoWayBranchingObject {

public:

  // Default Constructor 
  OsiSOSBranchingObject ();

  // Useful constructor
  OsiSOSBranchingObject (OsiSolverInterface * solver,  const OsiSOS * originalObject,
                            int way,
                         double separator);
  
  // Copy constructor 
  OsiSOSBranchingObject ( const OsiSOSBranchingObject &);
   
  // Assignment operator 
  OsiSOSBranchingObject & operator=( const OsiSOSBranchingObject& rhs);

  virtual OsiBranchingObject * clone() const;

  // Destructor 
  virtual ~OsiSOSBranchingObject ();
  
  using OsiBranchingObject::branch ;
  virtual double branch(OsiSolverInterface * solver);

  using OsiBranchingObject::print ;
  virtual void print(const OsiSolverInterface * solver=NULL);
private:
};
class OsiLotsize : public OsiObject2 {

public:

  // Default Constructor 
  OsiLotsize ();

  /* Useful constructor - passed model index.
     Also passed valid values - if range then pairs
  */
  OsiLotsize (const OsiSolverInterface * solver, int iColumn,
              int numberPoints, const double * points, bool range=false);
  
  // Copy constructor 
  OsiLotsize ( const OsiLotsize &);
   
  virtual OsiObject * clone() const;

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

  // Destructor 
  virtual ~OsiLotsize ();
  
  using OsiObject::infeasibility ;
  virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;

  using OsiObject::feasibleRegion ;
  virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;

  virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;


  inline void setColumnNumber(int value)
  {columnNumber_=value;}
  
  virtual int columnNumber() const;
  virtual void resetBounds(const OsiSolverInterface * solver);

  bool findRange(double value, double integerTolerance) const;
  
  virtual void floorCeiling(double & floorLotsize, double & ceilingLotsize, double value,
                            double tolerance) const;
  
  inline double originalLowerBound() const
  { return bound_[0];}
  inline double originalUpperBound() const
  { return bound_[rangeType_*numberRanges_-1];}
  inline int rangeType() const
  { return rangeType_;}
  inline int numberRanges() const
  { return numberRanges_;}
  inline double * bound() const
  { return bound_;}
  virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);
  
  virtual double upEstimate() const;
  virtual double downEstimate() const;
  virtual bool canHandleShadowPrices() const
  { return true;}
  virtual bool canDoHeuristics() const 
  {return false;}

private:

  int columnNumber_;
  int rangeType_;
  int numberRanges_;
  // largest gap
  double largestGap_;
  double * bound_;
  mutable int range_;
};


class OsiLotsizeBranchingObject : public OsiTwoWayBranchingObject {

public:

  OsiLotsizeBranchingObject ();

  OsiLotsizeBranchingObject (OsiSolverInterface *solver,const OsiLotsize * originalObject, 
                             int way , double value) ;
  
  OsiLotsizeBranchingObject ( const OsiLotsizeBranchingObject &);
   
  OsiLotsizeBranchingObject & operator= (const OsiLotsizeBranchingObject& rhs);

  virtual OsiBranchingObject * clone() const;

  virtual ~OsiLotsizeBranchingObject ();

  using OsiBranchingObject::branch ;
  virtual double branch(OsiSolverInterface * solver);

  using OsiBranchingObject::print ;
  virtual void print(const OsiSolverInterface * solver=NULL);

protected:
  double down_[2];
  double up_[2];
};
#endif