# Couenne::exprQuad Class Reference

class exprQuad, with constant, linear and quadratic terms More...

`#include <CouenneExprQuad.hpp>`

Inheritance diagram for Couenne::exprQuad:

List of all members.

## Public Types
typedef std::vector< std::pair < exprVar *, CouNumber > > | sparseQcol
| matrix
typedef std::vector< std::pair < exprVar *, sparseQcol > > | sparseQ
## Protected Attributes
Q matrix storage
Sparse implementation: given expression of the form , qindexI_ and qindexJ_ contain respectively entries and for which is nonzero in :
sparseQ | matrix_
## Convexification data structures
These are filled by alphaConvexify, which implements the alpha-convexification method described in the LaGO paper by Nowak and Vigerske -- see also Adjiman and Floudas.
std::vector< std::pair < CouNumber, std::vector < std::pair< exprVar *, CouNumber > > > > | eigen_
| eigenvalues and eigenvectors
std::map< exprVar *, std::pair < CouNumber, CouNumber > > | bounds_
| current bounds (checked before re-computing eigenvalues/vectors)
int | nqterms_
| number of non-zeroes in Q
| exprQuad (CouNumber c0, std::vector< std::pair< exprVar *, CouNumber > > &lcoeff, std::vector< quadElem > &qcoeff, expression **al=NULL, int n=0)
| Constructor.
| exprQuad (const exprQuad &src, Domain *d=NULL)
| Copy constructor.
sparseQ & | getQ () const
| eigenvalues and eigenvectors
int | getnQTerms ()
| eigenvalues and eigenvectors
virtual expression * | clone (Domain *d=NULL) const
| cloning method
virtual void | print (std::ostream &=std::cout, bool=false) const
| Print expression to an iostream.
virtual CouNumber | operator() ()
| Function for the evaluation of the expression.
CouNumber | gradientNorm (const double *x)
| return l-2 norm of gradient at given point
virtual expression * | differentiate (int index)
| Compute derivative of this expression with respect to variable whose index is passed as argument.
virtual expression * | simplify ()
| Simplify expression.
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 &, CouNumber &)
| Get lower and upper bound of an expression (if any).
virtual void | generateCuts (expression *w, OsiCuts &cs, const CouenneCutGenerator *cg, t_chg_bounds *=NULL, int=-1, CouNumber=-COUENNE_INFINITY, CouNumber=COUENNE_INFINITY)
| Generate cuts for the quadratic expression, which are supporting hyperplanes of the concave upper envelope and the convex lower envelope.
virtual bool | alphaConvexify (const CouenneProblem *)
| Compute data for -convexification of a quadratic form (fills in dCoeff_ and dIndex_ for the convex underestimator).
void | quadCuts (expression *w, OsiCuts &cs, const CouenneCutGenerator *cg)
| method exprQuad::quadCuts
virtual int | compare (exprQuad &)
| Compare two exprQuad.
virtual enum expr_type | code ()
| Code for comparisons.
virtual int | rank ()
| Used in rank-based branching variable choice.
virtual bool | isInteger ()
| is this expression integer?
virtual int | DepList (std::set< int > &deplist, enum dig_type type=ORIG_ONLY)
| fill in the set with all indices of variables appearing in the expression
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 | fillDepSet (std::set< DepNode *, compNode > *dep, DepGraph *g)
| Fill dependence set of the expression associated with this auxiliary variable.
virtual void | replace (exprVar *x, exprVar *w)
| replace variable x with new (aux) w
virtual void | realign (const CouenneProblem *p)
| replace variable x with new (aux) w
virtual bool | impliedBound (int, CouNumber *, CouNumber *, t_chg_bounds *, enum auxSign=expression::AUX_EQ)
| implied bound processing
CouNumber | computeQBound (int sign)
| method to compute the bound based on sign: -1 for lower, +1 for upper
virtual void | closestFeasible (expression *varind, expression *vardep, CouNumber &left, CouNumber &right) const
| compute $y^{lv}$ and $y^{uv}$ for Violation Transfer algorithm
void | computeQuadFiniteBound (CouNumber &qMin, CouNumber &qMax, CouNumber *l, CouNumber *u, int &indInfLo, int &indInfUp)
| return lower and upper bound of quadratic expression
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 exprQuad, with constant, linear and quadratic terms

It represents an expression of the form , with an affine term, a quadratic term, and a nonlinear sum . Standardization checks possible quadratic or linear terms in the latter and includes them in the former parts.

If is a product of two nonlinear, nonquadratic functions , two auxiliary variables and are created and the product is included in the quadratic part of the exprQuad. If nonquadratic, nonlinear function, an auxiliary variable is created and included in the linear part.

Definition at line 44 of file CouenneExprQuad.hpp.

## Member Typedef Documentation

typedef std::vector<std::pair <exprVar *, CouNumber> > Couenne::exprQuad::sparseQcol

matrix

Definition at line 49 of file CouenneExprQuad.hpp.

typedef std::vector<std::pair <exprVar *, sparseQcol> > Couenne::exprQuad::sparseQ

Definition at line 50 of file CouenneExprQuad.hpp.

## Constructor & Destructor Documentation

Couenne::exprQuad::exprQuad | ( | CouNumber | c0,
|  | std::vector< std::pair< exprVar *, CouNumber > > & | lcoeff,
|  | std::vector< quadElem > & | qcoeff,
|  | expression ** | al = `NULL`,
|  | int | n = `0` |
| ) |  |  |

Constructor.

Referenced by clone().

Couenne::exprQuad::exprQuad | ( | const exprQuad & | src,
|  | Domain * | d = `NULL` |
| ) |  |  |

Copy constructor.

## Member Function Documentation

sparseQ& Couenne::exprQuad::getQ | ( |  | ) | const`[inline]`

eigenvalues and eigenvectors

Definition at line 94 of file CouenneExprQuad.hpp.

References matrix_.

int Couenne::exprQuad::getnQTerms | ( |  | ) | `[inline]`

eigenvalues and eigenvectors

Definition at line 97 of file CouenneExprQuad.hpp.

References nqterms_.

virtual expression* Couenne::exprQuad::clone | ( | Domain * | d = `NULL` | ) | const`[inline, virtual]`

cloning method

Reimplemented from Couenne::exprGroup.

Definition at line 101 of file CouenneExprQuad.hpp.

References exprQuad().

virtual void Couenne::exprQuad::print | ( | std::ostream & | = `std::cout`,
|  | bool | = `false` |
| ) |  |  | const`[virtual]`

Print expression to an iostream.

Reimplemented from Couenne::exprGroup.

CouNumber Couenne::exprQuad::operator() | ( |  | ) | `[inline, virtual]`

Function for the evaluation of the expression.

Compute sum of linear and nonlinear terms.

Reimplemented from Couenne::exprGroup.

Definition at line 293 of file CouenneExprQuad.hpp.

References Couenne::expression::Index(), and matrix_.

CouNumber Couenne::exprQuad::gradientNorm | ( | const double * | x | ) | `[virtual]`

return l-2 norm of gradient at given point

Reimplemented from Couenne::exprGroup.

virtual expression* Couenne::exprQuad::differentiate | ( | int | index | ) | `[virtual]`

Compute derivative of this expression with respect to variable whose index is passed as argument.

Reimplemented from Couenne::exprGroup.

virtual expression* Couenne::exprQuad::simplify | ( |  | ) | `[virtual]`

Simplify expression.

Reimplemented from Couenne::exprGroup.

virtual int Couenne::exprQuad::Linearity | ( |  | ) | `[inline, virtual]`

Get a measure of "how linear" the expression is.

Reimplemented from Couenne::exprGroup.

Definition at line 121 of file CouenneExprQuad.hpp.

References Couenne::exprGroup::c0_, Couenne::CONSTANT, COUENNE_EPS, Couenne::exprGroup::lcoeff_, Couenne::LINEAR, matrix_, Couenne::QUADRATIC, and Couenne::ZERO.

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

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

Reimplemented from Couenne::exprGroup.

virtual void Couenne::exprQuad::getBounds | ( | CouNumber & | ,
|  | CouNumber & |  |
| ) |  |  | `[virtual]`

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

Reimplemented from Couenne::exprGroup.

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

Generate cuts for the quadratic expression, which are supporting hyperplanes of the concave upper envelope and the convex lower envelope.

Reimplemented from Couenne::exprGroup.

virtual bool Couenne::exprQuad::alphaConvexify | ( | const CouenneProblem * |  | ) | `[virtual]`

Compute data for -convexification of a quadratic form (fills in dCoeff_ and dIndex_ for the convex underestimator).

void Couenne::exprQuad::quadCuts | ( | expression * | w,
|  | OsiCuts & | cs,
|  | const CouenneCutGenerator * | cg |
| ) |  |  |

method exprQuad::quadCuts

Based on the information (dIndex_, dCoeffLo_, dCoeffUp_) created/modified by alphaConvexify(), create convexification cuts for this expression. The original constraint is :

where is the auxiliary corresponding to this expression and are the auxiliaries corresponding to the other non-linear terms contained in the expression.

The under-estimator of is given by

and its over-estimator is given by

(where , , and ), where () is the minimum (maximum) eigenvalue of the matrix , obtained by pre- and post-multiplying by the diagonal matrix whose -th element is .

Let , and be

The convex relaxation of the initial constraint is then given by the two constraints

The cut is computed as follow. Let be the solution at hand. The two outer-approximation cuts are:

and

grouping coefficients, we get:

and

virtual int Couenne::exprQuad::compare | ( | exprQuad & |  | ) | `[virtual]`

Compare two exprQuad.

Reimplemented from Couenne::exprGroup.

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

Code for comparisons.

Reimplemented from Couenne::exprGroup.

Definition at line 231 of file CouenneExprQuad.hpp.

References Couenne::COU_EXPRQUAD.

virtual int Couenne::exprQuad::rank | ( |  | ) | `[virtual]`

Used in rank-based branching variable choice.

Reimplemented from Couenne::exprGroup.

virtual bool Couenne::exprQuad::isInteger | ( |  | ) | `[virtual]`

is this expression integer?

Reimplemented from Couenne::exprGroup.

virtual int Couenne::exprQuad::DepList | ( | std::set< int > & | deplist,
|  | enum dig_type | type = `ORIG_ONLY` |
| ) |  |  | `[virtual]`

fill in the set with all indices of variables appearing in the expression

Reimplemented from Couenne::exprGroup.

virtual CouNumber Couenne::exprQuad::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::exprQuad::fillDepSet | ( | std::set< DepNode *, compNode > * | dep,
|  | DepGraph * | g |
| ) |  |  | `[virtual]`

Fill dependence set of the expression associated with this auxiliary variable.

Reimplemented from Couenne::exprGroup.

virtual void Couenne::exprQuad::replace | ( | exprVar * | x,
|  | exprVar * | w |
| ) |  |  | `[virtual]`

replace variable x with new (aux) w

Reimplemented from Couenne::exprGroup.

virtual void Couenne::exprQuad::realign | ( | const CouenneProblem * | p | ) | `[virtual]`

replace variable x with new (aux) w

Reimplemented from Couenne::exprGroup.

virtual bool Couenne::exprQuad::impliedBound | ( | int | ,
|  | CouNumber * | ,
|  | CouNumber * | ,
|  | t_chg_bounds * | ,
|  | enum | auxSign = `expression::AUX_EQ` |
| ) |  |  | `[virtual]`

implied bound processing

Reimplemented from Couenne::exprSum.

CouNumber Couenne::exprQuad::computeQBound | ( | int | sign | ) |

method to compute the bound based on sign: -1 for lower, +1 for upper

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

compute $y^{lv}$ and $y^{uv}$ for Violation Transfer algorithm

void Couenne::exprQuad::computeQuadFiniteBound | ( | CouNumber & | qMin,
|  | CouNumber & | qMax,
|  | CouNumber * | l,
|  | CouNumber * | u,
|  | int & | indInfLo,
|  | int & | indInfUp |
| ) |  |  | `[protected]`

return lower and upper bound of quadratic expression

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

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

Reimplemented from Couenne::expression.

Definition at line 286 of file CouenneExprQuad.hpp.

## Member Data Documentation

sparseQ Couenne::exprQuad::matrix_`[mutable, protected]`

Definition at line 61 of file CouenneExprQuad.hpp.

Referenced by getQ(), Linearity(), and operator()().

std::vector<std::pair <CouNumber, std::vector <std::pair <exprVar *, CouNumber> > > > Couenne::exprQuad::eigen_`[mutable, protected]`

eigenvalues and eigenvectors

Definition at line 73 of file CouenneExprQuad.hpp.

std::map<exprVar *, std::pair <CouNumber, CouNumber> > Couenne::exprQuad::bounds_`[protected]`

current bounds (checked before re-computing eigenvalues/vectors)

Definition at line 76 of file CouenneExprQuad.hpp.

int Couenne::exprQuad::nqterms_`[protected]`

number of non-zeroes in Q

Definition at line 79 of file CouenneExprQuad.hpp.

Referenced by getnQTerms().

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

- CouenneExprQuad.hpp

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines