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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/