CouenneDisjCuts.hpp

Go to the documentation of this file.

/* $Id: CouenneDisjCuts.hpp 945 2013-04-06 20:25:21Z stefan $
 *
 * Name:    CouenneDisjCuts.hpp
 * Author:  Pietro Belotti
 * Purpose: a generator of disjunctive cuts for MINLP problems
 *
 * (C) Carnegie-Mellon University, 2008. 
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef COUENNE_DISJUNCTIVE_CUTS_HPP
#define COUENNE_DISJUNCTIVE_CUTS_HPP

#include "BonRegisteredOptions.hpp"

#include "OsiSolverInterface.hpp"
#include "CglConfig.h"
#include "CglCutGenerator.hpp"
#include "BonOsiTMINLPInterface.hpp"
#include "BonBabSetupBase.hpp"
#include "BonBabInfos.hpp"
#include "OsiChooseVariable.hpp"
#include "CouenneTypes.hpp"
#include "CouenneJournalist.hpp"

namespace Couenne {

class CouenneCutGenerator;

enum {COUENNE_INFEASIBLE, COUENNE_TIGHTENED, COUENNE_FEASIBLE};


class CouenneDisjCuts: public CglCutGenerator {

 protected:

  CouenneCutGenerator *couenneCG_;

  mutable int nrootcuts_;

  mutable int ntotalcuts_;

  mutable double septime_;

  mutable double objValue_;

  Bonmin::OsiTMINLPInterface *minlp_;

  OsiChooseVariable *branchingMethod_;

  bool isBranchingStrong_;

  JnlstPtr jnlst_;

  mutable int numDisjunctions_;

  double initDisjPercentage_;

  int initDisjNumber_;

  int depthLevelling_;

  int depthStopSeparate_;

  bool activeRows_;

  bool activeCols_;

  bool addPreviousCut_;

  double cpuTime_;

 public:

  CouenneDisjCuts (Bonmin::OsiTMINLPInterface *minlp = NULL,
                   Bonmin::BabSetupBase *base = NULL,
                   CouenneCutGenerator *cg = NULL,
                   OsiChooseVariable *bcv = NULL,
                   bool is_strong = false,
                   JnlstPtr journalist = NULL,
                   const Ipopt::SmartPtr<Ipopt::OptionsList> options = NULL);

  CouenneDisjCuts (const CouenneDisjCuts &);

  ~CouenneDisjCuts ();

  CouenneDisjCuts *clone () const
  {return new CouenneDisjCuts (*this);}

  inline CouenneCutGenerator *couenneCG () const
  {return couenneCG_;}

  void generateCuts (const OsiSolverInterface &, 
                     OsiCuts &, 
                     const CglTreeInfo = CglTreeInfo ())
#if CGL_VERSION_MAJOR == 0 && CGL_VERSION_MINOR <= 57
  const
#endif
  ;

  static void registerOptions (Ipopt::SmartPtr <Bonmin::RegisteredOptions> roptions);

  inline ConstJnlstPtr Jnlst() const 
  {return ConstPtr (jnlst_);}

  int getDisjunctions (std::vector <std::pair <OsiCuts *, OsiCuts *> > &disjunctions, 
                       OsiSolverInterface &si, 
                       OsiCuts &cs, 
                       const CglTreeInfo &info) const;

  int separateWithDisjunction (OsiCuts *cuts,
                               OsiSolverInterface &si, 
                               OsiCuts &cs, 
                               const CglTreeInfo &info) const;

  int generateDisjCuts (std::vector <std::pair <OsiCuts *, OsiCuts *> > &disjs, 
                       OsiSolverInterface &si, 
                       OsiCuts &cs, 
                        const CglTreeInfo &info) const;

  int checkDisjSide (OsiSolverInterface &si, OsiCuts *cuts) const;

  int getBoxUnion (OsiSolverInterface &si, 
                   OsiCuts *left, OsiCuts *right, 
                   CoinPackedVector &lower, CoinPackedVector &upper) const;

protected:

  OsiCuts *getSingleDisjunction (OsiSolverInterface &si) const;

  void mergeBoxes (int dir,                        // direction (negative for "<", positive for ">")
                   CoinPackedVector &left,         // input
                   CoinPackedVector &right,        // input
                   CoinPackedVector merged) const; // output  

  void applyColCuts (OsiSolverInterface &si,
                     OsiCuts *cuts) const;

  void applyColCuts (OsiSolverInterface &si, 
                     OsiColCut *cut) const;

  // construct reduced, standard form matrix M from coefficient matrix of si
  void OsiSI2MatrVec (CoinPackedMatrix &M,
                      CoinPackedVector &r,
                      OsiSolverInterface &si) const;

  int OsiCuts2MatrVec (OsiSolverInterface *cglp,
                       OsiCuts *cuts,
                       int displRow,
                       int displRhs) const;
};


inline void CoinInvN (register const double *orig, 
                      register int n, 
                      register double *inverted) {

  while (n--) *inverted++ = - *orig++;
}


inline void CoinCopyDisp (register const int *src, 
                          register int num, 
                          register int *dst, 
                          register int displacement) {
  while (num--)
    *dst++ = *src++ + displacement;
}

}

#endif