# Couenne::CouenneChooseStrong Class Reference

`#include <CouenneChooseStrong.hpp>`

List of all members.

## Public Member Functions
| CouenneChooseStrong (Bonmin::BabSetupBase &b, CouenneProblem *problem, JnlstPtr jnlst)
| Constructor from solver (so we can set up arrays etc).
| CouenneChooseStrong (const CouenneChooseStrong &)
| Copy constructor.
CouenneChooseStrong & | operator= (const CouenneChooseStrong &rhs)
| Assignment operator.
virtual OsiChooseVariable * | clone () const
| Clone.
virtual | ~CouenneChooseStrong ()
| Destructor.
virtual int | setupList (OsiBranchingInformation *info, bool initialize)
| Sets up strong list and clears all if initialize is true.
int | gutsOfSetupList (OsiBranchingInformation *info, bool initialize)
virtual int | doStrongBranching (OsiSolverInterface *OsiSolver, OsiBranchingInformation *info, int numberToDo, int returnCriterion)
| This is a utility function which does strong branching on a list of objects and stores the results in OsiHotInfo.objects.
virtual bool | feasibleSolution (const OsiBranchingInformation *info, const double *solution, int numberObjects, const OsiObject **objects)
| Returns true if solution looks feasible against given objects.
virtual int | chooseVariable (OsiSolverInterface *solver, OsiBranchingInformation *info, bool fixVariables)
| choose object to branch based on earlier setup
## Static Public Member Functions
static void | registerOptions (Ipopt::SmartPtr< Bonmin::RegisteredOptions > roptions)
| Add list of options to be read from file.
## Protected Member Functions
int | simulateBranch (OsiObject *Object, OsiBranchingInformation *info, OsiBranchingObject *branch, OsiSolverInterface *solver, Bonmin::HotInfo *result, int direction)
| does one side of the branching
## Protected Attributes
CouenneProblem * | problem_
| Pointer to the associated MINLP problem.
bool | pseudoUpdateLP_
| should we update the pseudocost multiplier with the distance between the LP point and the solution of the resulting branches' LPs? If so, this only happens in strong branching
bool | estimateProduct_
| Normally, a convex combination of the min/max lower bounds' estimates is taken to select a branching variable, as in the original definition of strong branching.
JnlstPtr | jnlst_
| pointer to journalist for detailed information
double | branchtime_
| total time spent in strong branching
## Private Member Functions
| CouenneChooseStrong ()
| Default Constructor, forbidden for some reason.
void | printObjViol (OsiBranchingInformation *info)
int | goodCandidate (OsiSolverInterface *solver, OsiBranchingInformation *info, OsiObject **object, const int iObject, const double prec)
bool | saveBestCand (OsiObject **object, const int iObject, const double value, const double upEstimate, const double downEstimate, double &bestVal1, double &bestVal2, int &bestIndex, int &bestWay)
| Save best candidate.

## Detailed Description

Definition at line 23 of file CouenneChooseStrong.hpp.

## Constructor & Destructor Documentation

Couenne::CouenneChooseStrong::CouenneChooseStrong | ( | Bonmin::BabSetupBase & | b,
|  | CouenneProblem * | problem,
|  | JnlstPtr | jnlst |
| ) |  |  |

Constructor from solver (so we can set up arrays etc).

Couenne::CouenneChooseStrong::CouenneChooseStrong | ( | const CouenneChooseStrong & |  | ) |

Copy constructor.

virtual Couenne::CouenneChooseStrong::~CouenneChooseStrong | ( |  | ) | `[virtual]`

Destructor.

Couenne::CouenneChooseStrong::CouenneChooseStrong | ( |  | ) | `[private]`

Default Constructor, forbidden for some reason.

## Member Function Documentation

CouenneChooseStrong& Couenne::CouenneChooseStrong::operator= | ( | const CouenneChooseStrong & | rhs | ) |

Assignment operator.

virtual OsiChooseVariable* Couenne::CouenneChooseStrong::clone | ( |  | ) | const`[virtual]`

Clone.

virtual int Couenne::CouenneChooseStrong::setupList | ( | OsiBranchingInformation * | info,
|  | bool | initialize |
| ) |  |  | `[virtual]`

Sets up strong list and clears all if initialize is true.

Returns number of infeasibilities.

int Couenne::CouenneChooseStrong::gutsOfSetupList | ( | OsiBranchingInformation * | info,
|  | bool | initialize |
| ) |  |  |

virtual int Couenne::CouenneChooseStrong::doStrongBranching | ( | OsiSolverInterface * | OsiSolver,
|  | OsiBranchingInformation * | info,
|  | int | numberToDo,
|  | int | returnCriterion |
| ) |  |  | `[virtual]`

This is a utility function which does strong branching on a list of objects and stores the results in OsiHotInfo.objects.

On entry the object sequence is stored in the OsiHotInfo object and maybe more. It returns - -1 - one branch was infeasible both ways 0 - all inspected - nothing can be fixed 1 - all inspected - some can be fixed (returnCriterion==0) 2 - may be returning early - one can be fixed (last one done) (returnCriterion==1) 3 - returning because max time

virtual bool Couenne::CouenneChooseStrong::feasibleSolution | ( | const OsiBranchingInformation * | info,
|  | const double * | solution,
|  | int | numberObjects,
|  | const OsiObject ** | objects |
| ) |  |  | `[virtual]`

Returns true if solution looks feasible against given objects.

virtual int Couenne::CouenneChooseStrong::chooseVariable | ( | OsiSolverInterface * | solver,
|  | OsiBranchingInformation * | info,
|  | bool | fixVariables |
| ) |  |  | `[virtual]`

choose object to branch based on earlier setup

static void Couenne::CouenneChooseStrong::registerOptions | ( | Ipopt::SmartPtr< Bonmin::RegisteredOptions > | roptions | ) | `[static]`

Add list of options to be read from file.

void Couenne::CouenneChooseStrong::printObjViol | ( | OsiBranchingInformation * | info | ) | `[private]`

int Couenne::CouenneChooseStrong::goodCandidate | ( | OsiSolverInterface * | solver,
|  | OsiBranchingInformation * | info,
|  | OsiObject ** | object,
|  | const int | iObject,
|  | const double | prec |
| ) |  |  | `[private]`

bool Couenne::CouenneChooseStrong::saveBestCand | ( | OsiObject ** | object,
|  | const int | iObject,
|  | const double | value,
|  | const double | upEstimate,
|  | const double | downEstimate,
|  | double & | bestVal1,
|  | double & | bestVal2,
|  | int & | bestIndex,
|  | int & | bestWay |
| ) |  |  | `[private]`

Save best candidate.

int Couenne::CouenneChooseStrong::simulateBranch | ( | OsiObject * | Object,
|  | OsiBranchingInformation * | info,
|  | OsiBranchingObject * | branch,
|  | OsiSolverInterface * | solver,
|  | Bonmin::HotInfo * | result,
|  | int | direction |
| ) |  |  | `[protected]`

does one side of the branching

## Member Data Documentation

CouenneProblem* Couenne::CouenneChooseStrong::problem_`[protected]`

Pointer to the associated MINLP problem.

Definition at line 119 of file CouenneChooseStrong.hpp.

bool Couenne::CouenneChooseStrong::pseudoUpdateLP_`[protected]`

should we update the pseudocost multiplier with the distance between the LP point and the solution of the resulting branches' LPs? If so, this only happens in strong branching

Definition at line 124 of file CouenneChooseStrong.hpp.

bool Couenne::CouenneChooseStrong::estimateProduct_`[protected]`

Normally, a convex combination of the min/max lower bounds' estimates is taken to select a branching variable, as in the original definition of strong branching.

If this option is set to true, their product is taken instead:

(1e-6+min) * max

where the 1e-6 is used to ensure that even those with one subproblem with no improvement are compared.

Definition at line 135 of file CouenneChooseStrong.hpp.

JnlstPtr Couenne::CouenneChooseStrong::jnlst_`[protected]`

pointer to journalist for detailed information

Definition at line 138 of file CouenneChooseStrong.hpp.

double Couenne::CouenneChooseStrong::branchtime_`[protected]`

total time spent in strong branching

Definition at line 141 of file CouenneChooseStrong.hpp.

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

- CouenneChooseStrong.hpp

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines