# Couenne::CouenneSolverInterface< T > Class Template Reference

Solver interface class with a pointer to a Couenne cut generator. More...

`#include <CouenneSolverInterface.hpp>`

List of all members.

## Public Member Functions
| CouenneSolverInterface (CouenneCutGenerator *cg=NULL)
| Constructor.
| CouenneSolverInterface (const CouenneSolverInterface &src)
| Copy constructor.
| ~CouenneSolverInterface ()
| Destructor.
virtual OsiSolverInterface * | clone (bool copyData=true) const
| Clone.
virtual bool | isProvenPrimalInfeasible () const
| we need to overwrite this since we might have internal knowledge
virtual bool | isProvenOptimal () const
| we need to overwrite this since we might have internal knowledge
CouenneCutGenerator * | CutGen ()
| Return cut generator pointer.
void | setCutGenPtr (CouenneCutGenerator *cg)
| Set cut generator pointer after setup, to avoid changes in the pointer due to cut generator cloning (it happens twice in the algorithm).
virtual void | initialSolve ()
| Solve initial LP relaxation.
virtual void | resolve ()
| Resolve an LP relaxation after problem modification.
virtual void | resolve_nobt ()
| Resolve an LP without applying bound tightening beforehand.
virtual int | tightenBounds (int lightweight)
| Tighten bounds on all variables (including continuous).
bool | isProvenDualInfeasible () const
| set doingResolve_
virtual double | getObjValue () const
| Get the objective function value.
Methods for strong branching.
virtual void | markHotStart ()
| Create a hot start snapshot of the optimization process.
virtual void | solveFromHotStart ()
| Optimize starting from the hot start snapshot.
virtual void | unmarkHotStart ()
| Delete the hot start snapshot.
## Protected Member Functions
virtual int | tightenBoundsCLP (int lightweight)
| Copy of the Clp version --- not light version.
virtual int | tightenBoundsCLP_Light (int lightweight)
| Copy of the Clp version --- light version.
## Protected Attributes
CouenneCutGenerator * | cutgen_
| The pointer to the Couenne cut generator.
bool | knowInfeasible_
| Flag indicating that infeasibility was detected during solveFromHotStart.
bool | knowOptimal_
| Flag indicating that optimality was detected during solveFromHotStart.
bool | knowDualInfeasible_
| Flag indicating this problem's continuous relaxation is unbounded.

## Detailed Description

### template<class T>
class Couenne::CouenneSolverInterface< T >

Solver interface class with a pointer to a Couenne cut generator.

Its main purposes are:

1) to apply bound tightening before re-solving 2) to replace OsiSolverInterface::isInteger () with problem_ -> [expression] -> isInteger () 3) to use NLP solution at branching

Definition at line 27 of file CouenneSolverInterface.hpp.

## Constructor & Destructor Documentation

template<class T >

Couenne::CouenneSolverInterface< T >::CouenneSolverInterface | ( | CouenneCutGenerator * | cg = `NULL` | ) |

Constructor.

Referenced by Couenne::CouenneSolverInterface< T >::clone().

template<class T >

Couenne::CouenneSolverInterface< T >::CouenneSolverInterface | ( | const CouenneSolverInterface< T > & | src | ) |

Copy constructor.

template<class T >

Couenne::CouenneSolverInterface< T >::~CouenneSolverInterface | ( |  | ) |

Destructor.

## Member Function Documentation

template<class T >

virtual OsiSolverInterface* Couenne::CouenneSolverInterface< T >::clone | ( | bool | copyData = `true` | ) | const`[inline, virtual]`

Clone.

Definition at line 41 of file CouenneSolverInterface.hpp.

References Couenne::CouenneSolverInterface< T >::CouenneSolverInterface().

template<class T >

virtual bool Couenne::CouenneSolverInterface< T >::isProvenPrimalInfeasible | ( |  | ) | const`[virtual]`

we need to overwrite this since we might have internal knowledge

template<class T >

virtual bool Couenne::CouenneSolverInterface< T >::isProvenOptimal | ( |  | ) | const`[virtual]`

we need to overwrite this since we might have internal knowledge

template<class T >

CouenneCutGenerator* Couenne::CouenneSolverInterface< T >::CutGen | ( |  | ) | `[inline]`

Return cut generator pointer.

Definition at line 51 of file CouenneSolverInterface.hpp.

References Couenne::CouenneSolverInterface< T >::cutgen_.

template<class T >

void Couenne::CouenneSolverInterface< T >::setCutGenPtr | ( | CouenneCutGenerator * | cg | ) | `[inline]`

Set cut generator pointer after setup, to avoid changes in the pointer due to cut generator cloning (it happens twice in the algorithm).

Definition at line 57 of file CouenneSolverInterface.hpp.

References Couenne::CouenneSolverInterface< T >::cutgen_.

template<class T >

virtual void Couenne::CouenneSolverInterface< T >::initialSolve | ( |  | ) | `[virtual]`

Solve initial LP relaxation.

template<class T >

virtual void Couenne::CouenneSolverInterface< T >::resolve | ( |  | ) | `[virtual]`

Resolve an LP relaxation after problem modification.

Referenced by Couenne::CouenneSolverInterface< T >::resolve_nobt().

template<class T >

virtual void Couenne::CouenneSolverInterface< T >::resolve_nobt | ( |  | ) | `[inline, virtual]`

Resolve an LP without applying bound tightening beforehand.

Definition at line 70 of file CouenneSolverInterface.hpp.

References Couenne::CouenneSolverInterface< T >::resolve().

template<class T >

virtual void Couenne::CouenneSolverInterface< T >::markHotStart | ( |  | ) | `[virtual]`

Create a hot start snapshot of the optimization process.

template<class T >

virtual void Couenne::CouenneSolverInterface< T >::solveFromHotStart | ( |  | ) | `[virtual]`

Optimize starting from the hot start snapshot.

template<class T >

virtual void Couenne::CouenneSolverInterface< T >::unmarkHotStart | ( |  | ) | `[virtual]`

Delete the hot start snapshot.

template<class T >

virtual int Couenne::CouenneSolverInterface< T >::tightenBounds | ( | int | lightweight | ) | `[virtual]`

Tighten bounds on all variables (including continuous).

template<class T >

bool Couenne::CouenneSolverInterface< T >::isProvenDualInfeasible | ( |  | ) | const

set doingResolve_

is this problem unbounded?

template<class T >

virtual double Couenne::CouenneSolverInterface< T >::getObjValue | ( |  | ) | const`[virtual]`

Get the objective function value.

Modified due to possible constant objectives passed to Couenne

template<class T >

virtual int Couenne::CouenneSolverInterface< T >::tightenBoundsCLP | ( | int | lightweight | ) | `[protected, virtual]`

Copy of the Clp version --- not light version.

template<class T >

virtual int Couenne::CouenneSolverInterface< T >::tightenBoundsCLP_Light | ( | int | lightweight | ) | `[protected, virtual]`

Copy of the Clp version --- light version.

## Member Data Documentation

template<class T >

CouenneCutGenerator* Couenne::CouenneSolverInterface< T >::cutgen_`[protected]`

The pointer to the Couenne cut generator.

Gives us a lot of information, for instance the nlp solver pointer, and the chance to do bound tightening before resolve ().

Definition at line 116 of file CouenneSolverInterface.hpp.

Referenced by Couenne::CouenneSolverInterface< T >::CutGen(), and Couenne::CouenneSolverInterface< T >::setCutGenPtr().

template<class T >

bool Couenne::CouenneSolverInterface< T >::knowInfeasible_`[protected]`

Flag indicating that infeasibility was detected during solveFromHotStart.

Definition at line 119 of file CouenneSolverInterface.hpp.

template<class T >

bool Couenne::CouenneSolverInterface< T >::knowOptimal_`[protected]`

Flag indicating that optimality was detected during solveFromHotStart.

Definition at line 122 of file CouenneSolverInterface.hpp.

template<class T >

bool Couenne::CouenneSolverInterface< T >::knowDualInfeasible_`[protected]`

Flag indicating this problem's continuous relaxation is unbounded.

Definition at line 125 of file CouenneSolverInterface.hpp.

The documentation for this class was generated from the following file:

- CouenneSolverInterface.hpp

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines