OsiColCut.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 OsiColCut_H
#define OsiColCut_H
 
#include <string>
 
#include "CoinPackedVector.hpp"
 
#include "OsiCollections.hpp"
#include "OsiCut.hpp"
 
class OsiColCut : public OsiCut {
  friend void OsiColCutUnitTest(const OsiSolverInterface *baseSiP,
    const std::string &mpsDir);
 
public:
  //----------------------------------------------------------------
 
  inline void setLbs(
    int nElements,
    const int *colIndices,
    const double *lbElements);
 
  inline void setLbs(const CoinPackedVector &lbs);
 
  inline void setUbs(
    int nElements,
    const int *colIndices,
    const double *ubElements);
 
  inline void setUbs(const CoinPackedVector &ubs);
 
  //----------------------------------------------------------------
 
  inline const CoinPackedVector &lbs() const;
  inline const CoinPackedVector &ubs() const;
 
#if __GNUC__ != 2
  using OsiCut::operator==;
#endif
 
  inline virtual bool operator==(const OsiColCut &rhs) const;
 
#if __GNUC__ != 2
  using OsiCut::operator!=;
#endif
  inline virtual bool operator!=(const OsiColCut &rhs) const;
 
  //----------------------------------------------------------------
 
  inline virtual bool consistent() const;
 
  inline virtual bool consistent(const OsiSolverInterface &im) const;
 
  inline virtual bool infeasible(const OsiSolverInterface &im) const;
  virtual double violated(const double *solution) const;
 
  //----------------------------------------------------------------
 
  OsiColCut &operator=(const OsiColCut &rhs);
 
  OsiColCut(const OsiColCut &);
 
  OsiColCut();
 
  virtual OsiColCut *clone() const;
 
  virtual ~OsiColCut();
 
  virtual void print() const;
 
private:
  CoinPackedVector lbs_;
  CoinPackedVector ubs_;
};
 
//-------------------------------------------------------------------
// Set lower & upper bound vectors
//-------------------------------------------------------------------
void OsiColCut::setLbs(
  int size,
  const int *colIndices,
  const double *lbElements)
{
  lbs_.setVector(size, colIndices, lbElements);
}
//
void OsiColCut::setUbs(
  int size,
  const int *colIndices,
  const double *ubElements)
{
  ubs_.setVector(size, colIndices, ubElements);
}
//
void OsiColCut::setLbs(const CoinPackedVector &lbs)
{
  lbs_ = lbs;
}
//
void OsiColCut::setUbs(const CoinPackedVector &ubs)
{
  ubs_ = ubs;
}
 
//-------------------------------------------------------------------
// Get Column Lower Bounds and Column Upper Bounds
//-------------------------------------------------------------------
const CoinPackedVector &OsiColCut::lbs() const
{
  return lbs_;
}
//
const CoinPackedVector &OsiColCut::ubs() const
{
  return ubs_;
}
 
//----------------------------------------------------------------
// == operator
//-------------------------------------------------------------------
bool OsiColCut::operator==(
  const OsiColCut &rhs) const
{
  if (this->OsiCut::operator!=(rhs))
    return false;
  if (lbs() != rhs.lbs())
    return false;
  if (ubs() != rhs.ubs())
    return false;
  return true;
}
//
bool OsiColCut::operator!=(
  const OsiColCut &rhs) const
{
  return !((*this) == rhs);
}
 
//----------------------------------------------------------------
// consistent & infeasible
//-------------------------------------------------------------------
bool OsiColCut::consistent() const
{
  const CoinPackedVector &lb = lbs();
  const CoinPackedVector &ub = ubs();
  // Test for consistent cut.
  // Are packed vectors consistent?
  lb.duplicateIndex("consistent", "OsiColCut");
  ub.duplicateIndex("consistent", "OsiColCut");
  if (lb.getMinIndex() < 0)
    return false;
  if (ub.getMinIndex() < 0)
    return false;
  return true;
}
//
bool OsiColCut::consistent(const OsiSolverInterface &im) const
{
  const CoinPackedVector &lb = lbs();
  const CoinPackedVector &ub = ubs();
 
  // Test for consistent cut.
  if (lb.getMaxIndex() >= im.getNumCols())
    return false;
  if (ub.getMaxIndex() >= im.getNumCols())
    return false;
 
  return true;
}
 
#if 0
bool OsiColCut::feasible(const OsiSolverInterface &im) const
{
  const double * oldColLb = im.getColLower();
  const double * oldColUb = im.getColUpper();
  const CoinPackedVector & cutLbs = lbs();
  const CoinPackedVector & cutUbs = ubs();
  int i;
  
  for ( i=0; i<cutLbs.size(); i++ ) {
    int colIndx = cutLbs.indices()[i];
    double newLb;
    if ( cutLbs.elements()[i] > oldColLb[colIndx] )
      newLb = cutLbs.elements()[i];
    else
      newLb = oldColLb[colIndx];
 
    double newUb = oldColUb[colIndx];
    if ( cutUbs.indexExists(colIndx) )
      if ( cutUbs[colIndx] < newUb ) newUb = cutUbs[colIndx];
      if ( newLb > newUb ) 
        return false;
  }
  
  for ( i=0; i<cutUbs.size(); i++ ) {
    int colIndx = cutUbs.indices()[i];
    double newUb = cutUbs.elements()[i] < oldColUb[colIndx] ? cutUbs.elements()[i] : oldColUb[colIndx];
    double newLb = oldColLb[colIndx];
    if ( cutLbs.indexExists(colIndx) )
      if ( cutLbs[colIndx] > newLb ) newLb = cutLbs[colIndx];
      if ( newUb < newLb ) 
        return false;
  }
  
  return true;
}
#endif
 
bool OsiColCut::infeasible(const OsiSolverInterface &im) const
{
  const double *oldColLb = im.getColLower();
  const double *oldColUb = im.getColUpper();
  const CoinPackedVector &cutLbs = lbs();
  const CoinPackedVector &cutUbs = ubs();
  int i;
 
  for (i = 0; i < cutLbs.getNumElements(); i++) {
    int colIndx = cutLbs.getIndices()[i];
    double newLb = cutLbs.getElements()[i] > oldColLb[colIndx] ? cutLbs.getElements()[i] : oldColLb[colIndx];
 
    double newUb = oldColUb[colIndx];
    if (cutUbs.isExistingIndex(colIndx))
      if (cutUbs[colIndx] < newUb)
        newUb = cutUbs[colIndx];
    if (newLb > newUb)
      return true;
  }
 
  for (i = 0; i < cutUbs.getNumElements(); i++) {
    int colIndx = cutUbs.getIndices()[i];
    double newUb = cutUbs.getElements()[i] < oldColUb[colIndx] ? cutUbs.getElements()[i] : oldColUb[colIndx];
    double newLb = oldColLb[colIndx];
    if (cutLbs.isExistingIndex(colIndx))
      if (cutLbs[colIndx] > newLb)
        newLb = cutLbs[colIndx];
    if (newUb < newLb)
      return true;
  }
 
  return false;
}
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/