CouenneCutGenerator.hpp

Go to the documentation of this file.

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

#ifndef COUENNE_CUT_GENERATOR_HPP
#define COUENNE_CUT_GENERATOR_HPP

//#include "BonRegisteredOptions.hpp"

#include "BonOaDecBase.hpp"
#include "CglConfig.h"
#include "CglCutGenerator.hpp"
#include "OsiRowCut.hpp"
#include "BonAuxInfos.hpp"
#include "BonBabInfos.hpp"
#include "OsiSolverInterface.hpp"
#include "CouenneConfig.h"
#include "CouenneJournalist.hpp"
#include "CouenneTypes.hpp"

namespace Ipopt {
  template <class T> class SmartPtr;
  class OptionsList;
  class Journalist;
}

namespace Bonmin {
  class RegisteredOptions;
  class BabInfo;
  class OsiTMINLPInterface;
  class BabSetupBase;
}

struct ASL;

namespace Couenne {

class CouenneProblem;
class funtriplet;


class CouenneCutGenerator: public CglCutGenerator {

 protected:

  mutable bool firstcall_;

  mutable bool addviolated_;

  enum conv_type convtype_;

  int nSamples_;

  CouenneProblem *problem_;

  mutable int nrootcuts_;

  mutable int ntotalcuts_;

  mutable double septime_;

  mutable double objValue_;

  Bonmin::OsiTMINLPInterface *nlp_;

  Bonmin::Bab *BabPtr_;

  mutable bool infeasNode_;

  JnlstPtr jnlst_;

  mutable double rootTime_;

  bool check_lp_;

  bool enable_lp_implied_bounds_;

  mutable int lastPrintLine;

 public:

  CouenneCutGenerator  (Bonmin::OsiTMINLPInterface * = NULL,
                        Bonmin::BabSetupBase *base = NULL,
                        CouenneProblem * = NULL,
                        struct ASL * = NULL);

  CouenneCutGenerator  (const CouenneCutGenerator &);

  ~CouenneCutGenerator ();

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

  inline CouenneProblem *Problem () const
  {return problem_;}

  inline void setProblem (CouenneProblem *p)
  {problem_ = p;}

  int getnvars () const;

  inline bool isFirst () const 
  {return firstcall_;}

  inline bool addViolated () const
  {return addviolated_;}

  inline enum conv_type ConvType () const
  {return convtype_;}

  inline int nSamples () const
  {return nSamples_;}

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

  int createCut (OsiCuts &, // cutset to insert
                 CouNumber, // lb
                 CouNumber, // ub
                            // index, coeff  (index -1: "don't care") 
                 int,    CouNumber,    // of first  term
                 int=-1, CouNumber=0., // of second term 
                 int=-1, CouNumber=0., // of third  term
                 bool = false) const;  // is it a global cut? No, by default

  int createCut (OsiCuts &, // cutset to insert
                 CouNumber, // rhs
                 int,       // sign: -1: <=, 0: =, +1: >=
                            // index, coeff  (index -1: "don't care") 
                 int,    CouNumber,    // of first  term
                 int=-1, CouNumber=0., // of second term 
                 int=-1, CouNumber=0., // of third  term
                 bool = false) const;  // is it a global cut? No, by default

  void addEnvelope (OsiCuts &,
                    int,
                    unary_function, unary_function, 
                    int, int, 
                    CouNumber, CouNumber, CouNumber,
                    t_chg_bounds * = NULL,
                    bool = false) const;

  void addEnvelope (OsiCuts &,
                    int,
                    funtriplet *,
                    int, int, 
                    CouNumber, CouNumber, CouNumber,
                    t_chg_bounds * = NULL,
                    bool = false) const;

  int addSegment (OsiCuts &, int, int,
                  CouNumber, CouNumber, 
                  CouNumber, CouNumber, int) const;

  int addTangent (OsiCuts &, int, int, 
                  CouNumber, CouNumber, 
                  CouNumber, int) const; 

  void setBabPtr (Bonmin::Bab *p)
  {BabPtr_ = p;}

  void getStats (int &nrc, int &ntc, double &st) {
    nrc = nrootcuts_;
    ntc = ntotalcuts_;
    st  = septime_;
  }

  bool &infeasNode () const
  {return infeasNode_;}

  void genRowCuts (const OsiSolverInterface &, OsiCuts &cs, 
                   int, int *, t_chg_bounds * = NULL) const;

  void genColCuts (const OsiSolverInterface &, OsiCuts &, int, int *) const;

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

  void printLineInfo() const;

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

  void setJnlst (JnlstPtr jnlst__)
  { jnlst_ = jnlst__; }

  double &rootTime ()
  {return rootTime_;}

  bool check_lp () const
  {return check_lp_;}

  bool enableLpImpliedBounds () const
  {return enable_lp_implied_bounds_;}
};


void sparse2dense (int ncols, t_chg_bounds *chg_bds, int *&changed, int &nchanged);

}

#endif