OsiCut.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 OsiCut_H
#define OsiCut_H
 
#include "OsiCollections.hpp"
#include "OsiSolverInterface.hpp"

 
/*
  COIN_NOTEST_DUPLICATE is rooted in CoinUtils. Check there before you
  meddle here.
*/
#ifdef COIN_FAST_CODE
#ifndef COIN_NOTEST_DUPLICATE
#define COIN_NOTEST_DUPLICATE
#endif
#endif
 
#ifndef COIN_NOTEST_DUPLICATE
#define COIN_DEFAULT_VALUE_FOR_DUPLICATE true
#else
#define COIN_DEFAULT_VALUE_FOR_DUPLICATE false
#endif
 
class OsiCut {
 
public:
  //-------------------------------------------------------------------

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


  inline void setGloballyValid(bool trueFalse)
  {
    globallyValid_ = trueFalse ? 1 : 0;
  }
  inline void setGloballyValid()
  {
    globallyValid_ = 1;
  }
  inline void setNotGloballyValid()
  {
    globallyValid_ = 0;
  }

  inline bool globallyValid() const
  {
    return globallyValid_ != 0;
  }

  inline void setGloballyValidAsInteger(int trueFalse)
  {
    globallyValid_ = trueFalse;
  }

  inline int globallyValidAsInteger() 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_;
  int 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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/