OsiRowCut.hpp

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

#include "CoinPackedVector.hpp"

#include "OsiCollections.hpp"
#include "OsiCut.hpp"

//#define OSI_INLINE_ROWCUT_METHODS
#ifdef OSI_INLINE_ROWCUT_METHODS
#define OsiRowCut_inline inline
#else
#define OsiRowCut_inline
#endif

class OsiRowCut : public OsiCut {
   friend void OsiRowCutUnitTest(const OsiSolverInterface * baseSiP,    
                                 const std::string & mpsDir);

public:
  

    OsiRowCut_inline double lb() const;
    OsiRowCut_inline void setLb(double lb);
    OsiRowCut_inline double ub() const;
    OsiRowCut_inline void setUb(double ub);


    char sense() const;
    double rhs() const;
    double range() const;

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

    OsiRowCut_inline void setRow( 
      int size, 
      const int * colIndices, 
      const double * elements );
    OsiRowCut_inline void setRow( const CoinPackedVector & v );
    OsiRowCut_inline const CoinPackedVector & row() const;

    OsiRowCut_inline bool operator==(const OsiRowCut& rhs) const; 
    OsiRowCut_inline bool operator!=(const OsiRowCut& rhs) const; 
  
    
  //----------------------------------------------------------------
    OsiRowCut_inline bool consistent() const; 

    OsiRowCut_inline bool consistent(const OsiSolverInterface& im) const;

    OsiRowCut_inline bool infeasible(const OsiSolverInterface &im) const;
    virtual double violated(const double * solution) const;



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

    virtual OsiRowCut * clone() const;
  
    OsiRowCut ();
  
    virtual ~OsiRowCut ();


  virtual void print() const ;
   
private:
  
 

    CoinPackedVector row_;
    double lb_;
    double ub_;
};

#ifdef OSI_INLINE_ROWCUT_METHODS

//-------------------------------------------------------------------
// Set/Get lower & upper bounds
//-------------------------------------------------------------------
double OsiRowCut::lb() const { return lb_; }
void OsiRowCut::setLb(double lb) { lb_ = lb; }
double OsiRowCut::ub() const { return ub_; }
void OsiRowCut::setUb(double ub) { ub_ = ub; }

//-------------------------------------------------------------------
// Set row elements
//------------------------------------------------------------------- 
void OsiRowCut::setRow(int size, 
                       const int * colIndices, const double * elements)
{
  row_.setVector(size,colIndices,elements);
}
void OsiRowCut::setRow( const CoinPackedVector & v )
{
  row_ = v;
}

//-------------------------------------------------------------------
// Get the row
//-------------------------------------------------------------------
const CoinPackedVector & OsiRowCut::row() const 
{ 
  return row_; 
}

//----------------------------------------------------------------
// == operator 
//-------------------------------------------------------------------
bool
OsiRowCut::operator==(const OsiRowCut& rhs) const
{
  if ( this->OsiCut::operator!=(rhs) ) return false;
  if ( row() != rhs.row() ) return false;
  if ( lb() != rhs.lb() ) return false;
  if ( ub() != rhs.ub() ) return false;
  return true;
}
bool
OsiRowCut::operator!=(const OsiRowCut& rhs) const
{
  return !( (*this)==rhs );
}


//----------------------------------------------------------------
// consistent & infeasible 
//-------------------------------------------------------------------
bool OsiRowCut::consistent() const
{
  const CoinPackedVector & r=row();
  r.duplicateIndex("consistent", "OsiRowCut");
  if ( r.getMinIndex() < 0 ) return false;
  return true;
}
bool OsiRowCut::consistent(const OsiSolverInterface& im) const
{  
  const CoinPackedVector & r=row();
  if ( r.getMaxIndex() >= im.getNumCols() ) return false;

  return true;
}
bool OsiRowCut::infeasible(const OsiSolverInterface &im) const
{
  if ( lb() > ub() ) return true;

  return false;
}

#endif

//#############################################################################
void
OsiRowCutUnitTest(const OsiSolverInterface * baseSiP,    
                  const std::string & mpsDir);

#endif

---