OsiCut.hpp

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

#include "OsiCollections.hpp"
#include "OsiSolverInterface.hpp"

#if 0
/ // count of how many times the cut has been used
/ // count of how many times the cut has been tested
#endif


class OsiCut  {
  
public:
    
  //-------------------------------------------------------------------

  inline void setEffectiveness( double e ); 
  inline double effectiveness() const; 


  inline void setGloballyValid( bool trueFalse ) 
  { globallyValid_=trueFalse;};
  inline void setGloballyValid( ) 
  { globallyValid_=true;};
  inline void setNotGloballyValid( ) 
  { globallyValid_=false;};
  inline bool globallyValid() const
  { return globallyValid_;};


  virtual void print() const {};
   
#if 0
  / **@name Times used */
  / /@{
  / // Set times used
  inline void setTimesUsed( int t );
  / // Increment times used
  inline void incrementTimesUsed();
  / // Get times used
  inline int timesUsed() const;
  / /@}
  
  / **@name Times tested */
  / /@{
  / // Set times tested
  inline void setTimesTested( int t );
  / // Increment times tested
  inline void incrementTimesTested();
  / // Get times tested
  inline int timesTested() const;
  / /@}
#endif

  //----------------------------------------------------------------


    inline virtual bool operator==(const OsiCut& rhs) const; 
    inline virtual bool operator!=(const OsiCut& rhs) const; 
    inline virtual bool operator< (const OsiCut& rhs) const; 
    inline virtual bool operator> (const OsiCut& rhs) const; 

  //----------------------------------------------------------------
  // consistent() - returns true if the cut is consistent with repect to itself.
  //         This might include checks to ensure that a packed vector
  //         itself does not have a negative index.
  // consistent(const OsiSolverInterface& si) - returns true if cut is consistent with
  //         respect to the solver interface's model. This might include a check to 
  //         make sure a column index is not greater than the number
  //         of columns in the problem.
  // infeasible(const OsiSolverInterface& si) - returns true if the cut is infeasible 
  //         "with respect to itself". This might include a check to ensure 
  //         the lower bound is greater than the upper bound, or if the
  //         cut simply replaces bounds that the new bounds are feasible with 
  //         respect to the old bounds.
  //-----------------------------------------------------------------
  inline virtual bool consistent() const=0; 

  inline virtual bool consistent(const OsiSolverInterface& si) const=0;

  inline virtual bool infeasible(const OsiSolverInterface &si) const=0;

  virtual double violated(const double * solution) const=0;

protected:


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

  virtual ~OsiCut ();
  
private:
  

  double effectiveness_;
  bool globallyValid_;
#if 0

  int timesUsed_;
  int timesTested_;
#endif

};


//-------------------------------------------------------------------
// Set/Get member data
//-------------------------------------------------------------------
void OsiCut::setEffectiveness(double e)  { effectiveness_=e; }
double OsiCut::effectiveness() const { return effectiveness_; }

#if 0
void OsiCut::setTimesUsed( int t ) { timesUsed_=t; }
void OsiCut::incrementTimesUsed() { timesUsed_++; }
int OsiCut::timesUsed() const { return timesUsed_; }

void OsiCut::setTimesTested( int t ) { timesTested_=t; }
void OsiCut::incrementTimesTested() { timesTested_++; }
int OsiCut::timesTested() const{ return timesTested_; }
#endif

//----------------------------------------------------------------
// == operator 
//-------------------------------------------------------------------
bool
OsiCut::operator==(const OsiCut& rhs) const
{
  return effectiveness()==rhs.effectiveness();
}
bool
OsiCut::operator!=(const OsiCut& rhs) const
{
  return !( (*this)==rhs );
}
bool
OsiCut::operator< (const OsiCut& rhs) const
{
  return effectiveness()<rhs.effectiveness();
}
bool
OsiCut::operator> (const OsiCut& rhs) const
{
  return effectiveness()>rhs.effectiveness();
}
#endif

---