# Couenne::exprBinProd Class Reference

class for with all binary More...

`#include <CouenneExprBinProd.hpp>`

List of all members.

## Public Member Functions
| exprBinProd (expression **, int)
| Constructor.
| exprBinProd (expression *, expression *)
| Constructor with two arguments.
CouNumber | gradientNorm (const double *x)
| return l-2 norm of gradient at given point
expression * | differentiate (int index)
| differentiation
expression * | simplify ()
| simplification
virtual int | Linearity ()
| get a measure of "how linear" the expression is:
virtual void | getBounds (expression *&, expression *&)
| Get lower and upper bound of an expression (if any).
virtual void | getBounds (CouNumber &lb, CouNumber &ub)
| Get value of lower and upper bound of an expression (if any).
virtual exprAux * | standardize (CouenneProblem *p, bool addAux=true)
| reduce expression in standard form, creating additional aux variables (and constraints)
void | generateCuts (expression *w, OsiCuts &cs, const CouenneCutGenerator *cg, t_chg_bounds *=NULL, int=-1, CouNumber=-COUENNE_INFINITY, CouNumber=COUENNE_INFINITY)
| generate equality between *this and *w
virtual enum expr_type | code ()
| code for comparison
bool | impliedBound (int, CouNumber *, CouNumber *, t_chg_bounds *, enum Couenne::expression::auxSign=Couenne::expression::AUX_EQ)
| implied bound processing
virtual CouNumber | selectBranch (const CouenneObject *obj, const OsiBranchingInformation *info, expression *&var, double *&brpts, double *&brDist, int &way)
| set up branching object by evaluating many branching points for each expression's arguments
virtual void | closestFeasible (expression *varind, expression *vardep, CouNumber &left, CouNumber &right) const
| compute and for Violation Transfer algorithm
## Protected Member Functions
CouNumber | balancedMul (const OsiBranchingInformation *info, int index, int wind)
| balanced strategy for branching point selection in products
virtual bool | isCuttable (CouenneProblem *problem, int index) const
| can this expression be further linearized or are we on its concave ("bad") side

## Detailed Description

class for with all binary

Definition at line 21 of file CouenneExprBinProd.hpp.

## Constructor & Destructor Documentation

Couenne::exprBinProd::exprBinProd | ( | expression ** | ,
|  | int |  |
| ) |  |  |

Constructor.

Couenne::exprBinProd::exprBinProd | ( | expression * | ,
|  | expression * |  |
| ) |  |  |

Constructor with two arguments.

## Member Function Documentation

CouNumber Couenne::exprBinProd::gradientNorm | ( | const double * | x | ) |

return l-2 norm of gradient at given point

expression* Couenne::exprBinProd::differentiate | ( | int | index | ) |

differentiation

expression* Couenne::exprBinProd::simplify | ( |  | ) |

simplification

virtual int Couenne::exprBinProd::Linearity | ( |  | ) | `[virtual]`

get a measure of "how linear" the expression is:

virtual void Couenne::exprBinProd::getBounds | ( | expression *& | ,
|  | expression *& |  |
| ) |  |  | `[virtual]`

Get lower and upper bound of an expression (if any).

virtual void Couenne::exprBinProd::getBounds | ( | CouNumber & | lb,
|  | CouNumber & | ub |
| ) |  |  | `[virtual]`

Get value of lower and upper bound of an expression (if any).

virtual exprAux* Couenne::exprBinProd::standardize | ( | CouenneProblem * | p,
|  | bool | addAux = `true` |
| ) |  |  | `[virtual]`

reduce expression in standard form, creating additional aux variables (and constraints)

void Couenne::exprBinProd::generateCuts | ( | expression * | w,
|  | OsiCuts & | cs,
|  | const CouenneCutGenerator * | cg,
|  | t_chg_bounds * | = `NULL`,
|  | int | = `-1`,
|  | CouNumber | = `-COUENNE_INFINITY`,
|  | CouNumber | = `COUENNE_INFINITY` |
| ) |  |  |

generate equality between *this and *w

virtual enum expr_type Couenne::exprBinProd::code | ( |  | ) | `[inline, virtual]`

code for comparison

Definition at line 61 of file CouenneExprBinProd.hpp.

References Couenne::COU_EXPRMUL.

bool Couenne::exprBinProd::impliedBound | ( | int | ,
|  | CouNumber * | ,
|  | CouNumber * | ,
|  | t_chg_bounds * | ,
|  | enum Couenne::expression::auxSign | = `Couenne::expression::AUX_EQ` |
| ) |  |  |

implied bound processing

virtual CouNumber Couenne::exprBinProd::selectBranch | ( | const CouenneObject * | obj,
|  | const OsiBranchingInformation * | info,
|  | expression *& | var,
|  | double *& | brpts,
|  | double *& | brDist,
|  | int & | way |
| ) |  |  | `[virtual]`

set up branching object by evaluating many branching points for each expression's arguments

virtual void Couenne::exprBinProd::closestFeasible | ( | expression * | varind,
|  | expression * | vardep,
|  | CouNumber & | left,
|  | CouNumber & | right |
| ) |  |  | const`[virtual]`

compute and for Violation Transfer algorithm

CouNumber Couenne::exprBinProd::balancedMul | ( | const OsiBranchingInformation * | info,
|  | int | index,
|  | int | wind |
| ) |  |  | `[protected]`

balanced strategy for branching point selection in products

virtual bool Couenne::exprBinProd::isCuttable | ( | CouenneProblem * | problem,
|  | int | index |
| ) |  |  | const`[inline, protected, virtual]`

can this expression be further linearized or are we on its concave ("bad") side

Definition at line 89 of file CouenneExprBinProd.hpp.

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

- CouenneExprBinProd.hpp

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines