CouenneSolverInterface.hpp

Go to the documentation of this file.

/* $Id: CouenneSolverInterface.hpp 833 2012-02-11 14:09:50Z pbelotti $
 *
 * Name:    CouenneSolverInterface.hpp
 * Authors: Pietro Belotti, Carnegie Mellon University
 * Purpose: OsiSolverInterface with a pointer to a CouenneCutGenerator object
 *
 * (C) Carnegie-Mellon University, 2007-09.
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef COUENNESOLVERINTERFACE_HPP
#define COUENNESOLVERINTERFACE_HPP

class OsiSolverInterface;

namespace Couenne {

class CouenneCutGenerator;

 
template <class T> class CouenneSolverInterface: public T {

public:

  CouenneSolverInterface (CouenneCutGenerator *cg = NULL);

  CouenneSolverInterface (const CouenneSolverInterface &src);

  ~CouenneSolverInterface ();

  virtual OsiSolverInterface * clone (bool copyData = true) const
  {return new CouenneSolverInterface (*this);}

  virtual bool isProvenPrimalInfeasible () const;

  virtual bool isProvenOptimal () const;

  CouenneCutGenerator *CutGen ()
  {return cutgen_;}

  void setCutGenPtr (CouenneCutGenerator *cg) {
    cutgen_ = cg;
    //if (cutgen_ && !(cutgen_ -> enableLpImpliedBounds ()))
    //specialOptions_ = specialOptions_ | 262144; 
  }

  virtual void initialSolve (); 

  virtual void resolve ();

  virtual void resolve_nobt ()
  {T::resolve ();}

  virtual void markHotStart();

  virtual void solveFromHotStart();

  virtual void unmarkHotStart();

  virtual int tightenBounds (int lightweight);

  //bool &doingResolve () 
  //{return doingResolve_;}

  bool isProvenDualInfeasible () const;
  //{return knowDualInfeasible_;}

  virtual double getObjValue() const;

  // /// returns LP optimum at root node
  // double rootLB () const
  // {return rootLB_;}

protected:

  virtual int tightenBoundsCLP (int lightweight);

  virtual int tightenBoundsCLP_Light (int lightweight);

  CouenneCutGenerator *cutgen_;

  bool knowInfeasible_;

  bool knowOptimal_;

  bool knowDualInfeasible_;

  // /// First (root) LP not solved yet -- use this flag to obtain root
  // /// lower bound and print an alternative gap
  // bool beforeFirstRootLP_;

  // /// First (root) LP bound -- used to get an alternative gap
  // double rootLB_;
};

}

// These source files are #included due to the template classes
// defined in there

#include "CouenneSolverInterface.cpp"
#include "CouenneLPtightenBounds.cpp"
#include "CouenneLPtightenBoundsCLP-light.cpp"
#include "CouenneLPtightenBoundsCLP.cpp"

#endif