OsiRowCut.hpp

Go to the documentation of this file.

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

#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,
      bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE);
    OsiRowCut_inline void setRow( const CoinPackedVector & v );
    OsiRowCut_inline const CoinPackedVector & row() const;
    OsiRowCut_inline CoinPackedVector & mutableRow() ;

#if __GNUC__ != 2 
    using OsiCut::operator== ;
#endif

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

#if __GNUC__ != 2 
    using OsiCut::operator!= ;
#endif
    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;

    void operator+=(double value)
        { row_ += value; }

    void operator-=(double value)
        { row_ -= value; }

    void operator*=(double value)
        { row_ *= value; }

    void operator/=(double value)
        { row_ /= value; }

  void sortIncrIndex()
        {row_.sortIncrIndex();}

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

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

    OsiRowCut(double cutlb, double cutub,
                     int capacity, int size,
                     int *&colIndices, double *&elements);
  
    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_; 
}

//-------------------------------------------------------------------
// Get the row so we can change
//-------------------------------------------------------------------
CoinPackedVector & OsiRowCut::mutableRow() 
{ 
  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

class OsiRowCut2 : public OsiRowCut {

public:
  
  inline int whichRow() const
  { return whichRow_;}
  inline void setWhichRow(int row)
  { whichRow_=row;}
  
  OsiRowCut2 & operator=( const OsiRowCut2& rhs);
  
  OsiRowCut2 ( const OsiRowCut2 &);  
  
  virtual OsiRowCut * clone() const;
  
  OsiRowCut2 (int row=-1);
  
  virtual ~OsiRowCut2 ();

private:
  
 
  int whichRow_;
};
#endif