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 Common 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