BonQuadCut.hpp

Go to the documentation of this file.

// (C) Copyright International Business Machines Corporation 2007
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors :
// Pierre Bonami, International Business Machines Corporation
//
// Date : 10/06/2007
 
#ifndef BonQuadCut_H
#define BonQuadCut_H
 
#include "CoinPackedMatrix.hpp"
#include "OsiRowCut.hpp"
#include "OsiCuts.hpp"
#include "BonTypes.hpp"
#include <list>
 
 
namespace Bonmin {
 
  enum MatrixStorageType {
   Upper ,
   Lower ,
   Full };
 
class QuadCut : public OsiRowCut {
 public:

  QuadCut();

  QuadCut(const QuadCut & other);

  QuadCut& operator=(const QuadCut & rhs);

  virtual OsiRowCut * clone() const;

  ~QuadCut(); 

  void print() const; 

  CoinPackedMatrix& Q(){
   return Q_;
  }

  const CoinPackedMatrix& Q() const{
   return Q_;
  }

  MatrixStorageType& type(){
    return type_;}
 
  const MatrixStorageType& type() const{
    return type_;}

  double & c(){return c_;}

  const double & c() const {return c_;}

  double violated(const double * solution) const;
 
 private:
   double c_;
   CoinPackedMatrix Q_;
   MatrixStorageType type_;


    void operator+=(double value);

    void operator-=(double value);

    void operator*=(double value);

    void operator/=(double value);
 
};

class Cuts : public OsiCuts {
 public:
  typedef vector<QuadCut *> QuadCutPtrStorage;
  Cuts();

  Cuts(const Cuts& other);

  Cuts& operator=(const Cuts & rhs);

 ~Cuts();

 inline void insert(const QuadCut& c);

  inline void insert(QuadCut* &c);

  inline void insert(const Cuts &cs);

  inline int sizeQuadCuts() const;

 inline int sizeCuts() const;

 void printCuts() const;
 

 inline QuadCut * quadCutPtr(int i);

 inline const QuadCut * quadCutPtr(int i) const;

 inline QuadCut& quadCut(int i);
 

 inline const QuadCut& quadCut(int i) const;

 inline void eraseQuadCut(int i);
 
 private:
   QuadCutPtrStorage quadCuts_;
};
 
void
Cuts::insert(const QuadCut &c){
  quadCuts_.push_back(new QuadCut(c));
}
 
void
Cuts::insert(QuadCut * &c){
  quadCuts_.push_back(c);
  c = NULL;
}
 
void 
Cuts::insert(const Cuts & cs){
  OsiCuts::insert(cs);
  for(unsigned int i = 0 ; i < cs.quadCuts_.size() ; i++){
    quadCuts_.push_back(new QuadCut(*cs.quadCuts_[i]));
  }
}
 
int 
Cuts::sizeQuadCuts() const {
  return static_cast<int>(quadCuts_.size());
}
 
int
Cuts::sizeCuts() const {
  return static_cast<int>(quadCuts_.size()) + OsiCuts::sizeCuts();
}
 
QuadCut *
Cuts::quadCutPtr(int i) {
  return quadCuts_[i];
}
 
const QuadCut *
Cuts::quadCutPtr(int i) const {
  return quadCuts_[i];
}
 
QuadCut &
Cuts::quadCut(int i) {
  return *quadCuts_[i];
}
 
const QuadCut &
Cuts::quadCut(int i) const {
  return *quadCuts_[i];
}
 
void
Cuts::eraseQuadCut(int i){
  delete quadCuts_[i];
  quadCuts_.erase(quadCuts_.begin() + i);
}
typedef std::list<QuadCut*> list_QuadCut; 
 
}// Ends Bonmin namespace
#endif