Couenne 0.5.8
Loading...
Searching...
No Matches
Public Types | List of all members
Couenne::exprQuad Class Reference

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

#include <CouenneExprQuad.hpp>

+ Inheritance diagram for Couenne::exprQuad:
+ Collaboration diagram for Couenne::exprQuad:

Public Types

typedef std::vector< std::pair< exprVar *, CouNumber > > sparseQcol
 matrix
 
typedef std::vector< std::pair< exprVar *, sparseQcol > > sparseQ
 
- Public Types inherited from Couenne::exprGroup
typedef std::vector< std::pair< exprVar *, CouNumber > > lincoeff
 
- Public Types inherited from Couenne::expression
enum  auxSign { AUX_UNDEF =-2 , AUX_LEQ =-1 , AUX_EQ , AUX_GEQ }
 "sign" of the constraint defining an auxiliary. More...
 

Protected Attributes

Q matrix storage

Sparse implementation: given expression of the form $\sum_{i \in N,
j \in N} q_{ij} x_i x_j$, qindexI_ and qindexJ_ contain respectively entries $i$ and $j$ for which $q_{ij}$ is nonzero in $q_{ij} x_i x_j$:

sparseQ matrix_
 
- Protected Attributes inherited from Couenne::exprGroup
lincoeff lcoeff_
 coefficients and indices of the linear term
 
CouNumber c0_
 constant term
 
- Protected Attributes inherited from Couenne::exprOp
expression ** arglist_
 argument list is an array of pointers to other expressions
 
int nargs_
 number of arguments (cardinality of arglist)
 

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.
 
sparseQgetQ () const
 
int getnQTerms ()
 
virtual expressionclone (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 expressiondifferentiate (int index)
 Compute derivative of this expression with respect to variable whose index is passed as argument.
 
virtual expressionsimplify ()
 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 $\alpha$-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
 

Additional Inherited Members

- Public Member Functions inherited from Couenne::exprGroup
 exprGroup (CouNumber, lincoeff &, expression **=NULL, int=0)
 Constructor.
 
 exprGroup (const exprGroup &src, Domain *d=NULL)
 Copy constructor.
 
virtual ~exprGroup ()
 Destructor – needed to clear bounds.
 
virtual expressionclone (Domain *d=NULL) const
 Cloning method.
 
CouNumber getc0 ()
 return constant term
 
lincoefflcoeff () const
 return linear term coefficients
 
virtual void print (std::ostream &=std::cout, bool=false) const
 Print expression to iostream.
 
virtual CouNumber operator() ()
 function for the evaluation of the expression
 
virtual CouNumber gradientNorm (const double *x)
 return l-2 norm of gradient at given point
 
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 expressiondifferentiate (int index)
 differentiation
 
virtual expressionsimplify ()
 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 &, CouNumber &)
 Get lower and upper bound of an expression (if any)
 
virtual void generateCuts (expression *, OsiCuts &, const CouenneCutGenerator *, t_chg_bounds *=NULL, int=-1, CouNumber=-COUENNE_INFINITY, CouNumber=COUENNE_INFINITY)
 special version for linear constraints
 
virtual int compare (exprGroup &)
 only compare with people of the same kind
 
virtual enum expr_type code ()
 code for comparisons
 
virtual bool isInteger ()
 is this expression integer?
 
virtual int rank ()
 used in rank-based branching variable choice
 
virtual void fillDepSet (std::set< DepNode *, compNode > *, DepGraph *)
 update dependence set with index of this variable
 
virtual void replace (exprVar *x, exprVar *w)
 replace variable x with new (aux) w
 
virtual void realign (const CouenneProblem *p)
 redirect variables to proper variable vector
 
- Public Member Functions inherited from Couenne::exprSum
 exprSum (expression **=NULL, int=0)
 Constructors, destructor.
 
 exprSum (expression *, expression *)
 Constructor with two elements.
 
virtual ~exprSum ()
 Empty destructor.
 
virtual expressionclone (Domain *d=NULL) const
 Cloning method.
 
std::string printOp () const
 Print operator.
 
virtual CouNumber operator() ()
 Function for the evaluation of the expression.
 
virtual expressiondifferentiate (int index)
 Differentiation.
 
virtual expressionsimplify ()
 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 &, CouNumber &)
 Get lower and upper bound of an expression (if any)
 
virtual exprAuxstandardize (CouenneProblem *p, bool addAux=true)
 Reduce expression in standard form, creating additional aux variables (and constraints)
 
virtual void generateCuts (expression *, OsiCuts &, const CouenneCutGenerator *, t_chg_bounds *=NULL, int=-1, CouNumber=-COUENNE_INFINITY, CouNumber=COUENNE_INFINITY)
 Special version for linear constraints.
 
virtual enum expr_type code ()
 Code for comparison.
 
virtual bool impliedBound (int, CouNumber *, CouNumber *, t_chg_bounds *, enum auxSign=expression::AUX_EQ)
 Implied bound.
 
exprAuxcreateQuadratic (CouenneProblem *)
 Checks for quadratic terms in the expression and returns an exprQuad if there are enough to create something that can be convexified.
 
- Public Member Functions inherited from Couenne::exprOp
virtual enum nodeType Type () const
 Node type.
 
 exprOp (expression **arglist, int nargs)
 Constructor.
 
 exprOp (expression *arg0, expression *arg1)
 Constructor with two arguments (for convenience)
 
virtual ~exprOp ()
 Destructor.
 
 exprOp (const exprOp &e, Domain *d=NULL)
 Copy constructor: only allocate space for argument list, which will be copied with clonearglist()
 
expression ** ArgList () const
 return argument list
 
virtual void ArgList (expression **al)
 set arglist (used in deleting nodes without deleting children)
 
int nArgs () const
 return number of arguments
 
virtual void print (std::ostream &out=std::cout, bool=false) const
 I/O.
 
virtual enum pos printPos () const
 print position (PRE, INSIDE, POST)
 
virtual std::string printOp () const
 print operator
 
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 expressionsimplify ()
 simplification
 
expression ** clonearglist (Domain *d=NULL) const
 clone argument list (for use with clone method)
 
int shrink_arglist (CouNumber, CouNumber)
 compress argument list
 
virtual int Linearity ()
 get a measure of "how linear" the expression is (see CouenneTypes.h)
 
virtual exprAuxstandardize (CouenneProblem *, bool addAux=true)
 generate auxiliary variable
 
virtual enum expr_type code ()
 return code to classify type of expression
 
virtual bool isInteger ()
 is this expression integer?
 
virtual int compare (exprOp &)
 compare with other generic exprOp
 
virtual int rank ()
 used in rank-based branching variable choice
 
virtual void fillDepSet (std::set< DepNode *, compNode > *dep, DepGraph *g)
 fill in dependence structure update dependence set with index of this variable
 
virtual void replace (exprVar *, exprVar *)
 replace variable with other
 
virtual void realign (const CouenneProblem *p)
 empty function to redirect variables to proper variable vector
 
- Public Member Functions inherited from Couenne::expression
 expression ()
 Constructor.
 
 expression (const expression &e, Domain *d=NULL)
 Copy constructor.
 
virtual ~expression ()
 Destructor.
 
virtual expressionclone (Domain *d=NULL) const
 Cloning method.
 
virtual int Index () const
 Return index of variable (only valid for exprVar and exprAux)
 
virtual int nArgs () const
 return number of arguments (when applicable, that is, with N-ary functions)
 
virtual expression ** ArgList () const
 return arglist (when applicable, that is, with N-ary functions)
 
virtual void ArgList (expression **al)
 set arglist (used in deleting nodes without deleting children)
 
virtual expressionArgument () const
 return argument (when applicable, i.e., with univariate functions)
 
virtual expression ** ArgPtr ()
 return pointer to argument (when applicable, i.e., with univariate functions)
 
virtual enum nodeType Type () const
 node type
 
virtual expressionImage () const
 return pointer to corresponding expression (for auxiliary variables only)
 
virtual void Image (expression *image)
 set expression associated with this auxiliary variable (for compatibility with exprAux)
 
virtual CouNumber Value () const
 value (empty)
 
virtual const expressionOriginal () const
 If this is an exprClone of a exprClone of an expr???, point to the original expr??? instead of an exprClone – improve computing efficiency.
 
virtual void print (std::ostream &s=std::cout, bool=false) const
 print expression to iostream
 
virtual CouNumber operator() ()=0
 null function for evaluating the expression
 
virtual CouNumber gradientNorm (const double *x)
 return l-2 norm of gradient at given point
 
virtual expressiondifferentiate (int)
 differentiation
 
virtual int dependsOn (int *ind, int n, enum dig_type type=STOP_AT_AUX)
 dependence on variable set: return cardinality of subset of the set of indices in first argument which occur in expression.
 
int dependsOn (int singleton, enum dig_type type=STOP_AT_AUX)
 version with one index only
 
virtual int DepList (std::set< int > &deplist, enum dig_type type=ORIG_ONLY)
 fill std::set with indices of variables on which this expression depends.
 
virtual expressionsimplify ()
 simplify expression (useful for derivatives)
 
virtual int Linearity ()
 get a measure of "how linear" the expression is (see CouenneTypes.h)
 
virtual bool isDefinedInteger ()
 is this expression defined as an integer?
 
virtual bool isInteger ()
 is this expression integer?
 
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) – real values.
 
virtual exprAuxstandardize (CouenneProblem *p, bool addAux=true)
 Create standard form of this expression, by:
 
virtual void generateCuts (expression *w, OsiCuts &cs, const CouenneCutGenerator *cg, t_chg_bounds *chg=NULL, int wind=-1, CouNumber lb=-COUENNE_INFINITY, CouNumber ub=COUENNE_INFINITY)
 generate convexification cut for constraint w = this
 
virtual enum expr_type code ()
 return integer for comparing expressions (used to recognize common expression)
 
virtual enum convexity convexity () const
 either CONVEX, CONCAVE, AFFINE, or NONCONVEX
 
virtual int compare (expression &)
 compare expressions
 
virtual int compare (exprCopy &)
 compare copies of expressions
 
virtual int rank ()
 used in rank-based branching variable choice: original variables have rank 1; auxiliary w=f(x) has rank r(w) = r(x)+1; finally, auxiliary w=f(x1,x2...,xk) has rank r(w) = 1+max{r(xi):i=1..k}.
 
virtual bool impliedBound (int, CouNumber *, CouNumber *, t_chg_bounds *, enum auxSign=expression::AUX_EQ)
 does a backward implied bound processing on every expression, including exprSums although already done by Clp (useful when repeated within Couenne).
 
virtual int Multiplicity ()
 multiplicity of a variable
 
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 replace (exprVar *, exprVar *)
 replace expression with another
 
virtual void fillDepSet (std::set< DepNode *, compNode > *, DepGraph *)
 update dependence set with index of variables on which this expression depends
 
virtual void linkDomain (Domain *d)
 empty function to update domain pointer
 
virtual void realign (const CouenneProblem *p)
 empty function to redirect variables to proper variable vector
 
virtual bool isBijective () const
 indicating if function is monotonically increasing
 
virtual CouNumber inverse (expression *vardep) const
 compute the inverse function
 
virtual void closestFeasible (expression *varind, expression *vardep, CouNumber &left, CouNumber &right) const
 closest feasible points in function in both directions
 
virtual bool isCuttable (CouenneProblem *problem, int index) const
 can this expression be further linearized or are we on its concave ("bad") side
 
virtual bool isaCopy () const
 return true if this is a copy of something (i.e. an exprCopy)
 
virtual expressionCopy () const
 return copy of this expression (only makes sense in exprCopy)
 
- Static Public Member Functions inherited from Couenne::exprGroup
static expressiongenExprGroup (CouNumber, lincoeff &, expression **=NULL, int=0)
 Generalized (static) constructor: check parameters and return a constant, a single variable, or a real exprGroup.
 
- Protected Member Functions inherited from Couenne::exprSum
int impliedBoundSum (CouNumber wl, CouNumber wu, std::vector< CouNumber > &xl, std::vector< CouNumber > &xu, std::vector< std::pair< int, CouNumber > > &nl, std::vector< std::pair< int, CouNumber > > &nu)
 inferring bounds on factors of a product
 

Detailed Description

class exprQuad, with constant, linear and quadratic terms

It represents an expression of the form $a_0 + \sum_{i\in I} b_i
x_i + x^T Q x + \sum_{i \in J} h_i (x)$, with $a_0 + \sum_{i\in
I} b_i x_i$ an affine term, $x^T Q x$ a quadratic term, and a nonlinear sum $\sum_{i \in J} h_i (x)$. Standardization checks possible quadratic or linear terms in the latter and includes them in the former parts.

If $h_i(x)$ is a product of two nonlinear, nonquadratic functions $h'(x)h''(x)$, two auxiliary variables $w'=f'(x)$ and $w''=h''(x)$ are created and the product $w'w''$ is included in the quadratic part of the exprQuad. If $h(x)$ nonquadratic, nonlinear function, an auxiliary variable $w=h(x)$ is created and included in the linear part.

Definition at line 44 of file CouenneExprQuad.hpp.

Member Typedef Documentation

◆ sparseQcol

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

matrix

Definition at line 49 of file CouenneExprQuad.hpp.

◆ sparseQ

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

Definition at line 50 of file CouenneExprQuad.hpp.

Constructor & Destructor Documentation

◆ exprQuad() [1/2]

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

Constructor.

◆ exprQuad() [2/2]

Couenne::exprQuad::exprQuad ( const exprQuad src,
Domain d = NULL 
)

Copy constructor.

Member Function Documentation

◆ getQ()

sparseQ & Couenne::exprQuad::getQ ( ) const
inline

Definition at line 94 of file CouenneExprQuad.hpp.

◆ getnQTerms()

int Couenne::exprQuad::getnQTerms ( )
inline

Definition at line 97 of file CouenneExprQuad.hpp.

◆ clone()

virtual expression * Couenne::exprQuad::clone ( Domain d = NULL) const
inlinevirtual

cloning method

Reimplemented from Couenne::exprGroup.

Definition at line 101 of file CouenneExprQuad.hpp.

◆ print()

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

Print expression to an iostream.

Reimplemented from Couenne::exprGroup.

◆ operator()()

CouNumber Couenne::exprQuad::operator() ( )
inlinevirtual

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.

◆ gradientNorm()

CouNumber Couenne::exprQuad::gradientNorm ( const double *  x)
virtual

return l-2 norm of gradient at given point

Reimplemented from Couenne::exprGroup.

◆ differentiate()

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.

◆ simplify()

virtual expression * Couenne::exprQuad::simplify ( )
virtual

Simplify expression.

Reimplemented from Couenne::exprGroup.

◆ Linearity()

virtual int Couenne::exprQuad::Linearity ( )
inlinevirtual

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

Reimplemented from Couenne::exprGroup.

Definition at line 121 of file CouenneExprQuad.hpp.

◆ getBounds() [1/2]

virtual void Couenne::exprQuad::getBounds ( expression *&  ,
expression *&   
)
virtual

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

Reimplemented from Couenne::exprGroup.

◆ getBounds() [2/2]

virtual void Couenne::exprQuad::getBounds ( CouNumber ,
CouNumber  
)
virtual

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

Reimplemented from Couenne::exprGroup.

◆ generateCuts()

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.

◆ alphaConvexify()

virtual bool Couenne::exprQuad::alphaConvexify ( const CouenneProblem )
virtual

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

◆ quadCuts()

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 :

\[
\eta = a_0 + a^T x + x^T Q x
\]

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

The under-estimator of $ x^T Q x$ is given by

\[ x^T Q x +
\sum \lambda_{\min,i} (x_i - l_i ) (u_i - x_i ) \]

and its over-estimator is given by

\[ x^T Q x + \sum \lambda_{\max, i} (x_i - l_i ) (u_i - x_i )
\]

(where $ \lambda_{\min, i} = \frac{\lambda_{\min}}{w_i^2}
$, $ \lambda_{\max, i} = \frac{\lambda_{\max}}{w_i^2} $, and $w_i = u_i - l_i$), where $\lambda_{\max}$ ( $\lambda_{\max}$) is the minimum (maximum) eigenvalue of the matrix $A={\rm Diag}({\bf u} - {\bf l}) Q {\rm Diag}({\bf u} -
{\bf l})$, obtained by pre- and post-multiplying $ Q $ by the diagonal matrix whose $i$-th element is $u_i - l_i$.

Let $ \tilde a_0(\lambda)$, $ \tilde a(\lambda) $ and $ \tilde Q (\lambda) $ be

\[ \tilde a_0(\lambda) = a_0 - \sum_{i = 1}^n \lambda_i l_i u_i \]

\[ \tilde a(\lambda) = a + \left[ \begin{array}{c} \lambda_1
(u_1 + l_1) \\ \vdots \\ \lambda_n (u_n + l_n) \end{array}
\right], \]

\[ \tilde Q(\lambda) = Q - \left( \begin{array}{ccc}
{\lambda_1} & & 0 \\ & \ddots & \\ 0 & & \lambda_n \end{array}
\right). \]

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

\[ \eta \geq \tilde a_0(\lambda_{\min}) + \tilde
a(\lambda_{\min})^T x + x^T \tilde Q(\lambda_{\min}) x \]

\[ \eta \leq \tilde a_0(\lambda_{\max}) + \tilde
a(\lambda_{\max})^T x + x^T \tilde Q(\lambda_{\max}) x \]

The cut is computed as follow. Let $ (x^*, \eta^*) $ be the solution at hand. The two outer-approximation cuts are:

\[ \eta \geq \tilde a_0(\lambda_{\min}) + \tilde
a(\lambda_{\min})^T x + {x^*}^T \tilde Q(\lambda_{\min}) (2x -
x^*) \]

and

\[ \eta \leq \tilde a_0(\lambda_{\max}) + \tilde
a(\lambda_{\max})^T x + {x^*}^T \tilde Q(\lambda_{\max}) (2x -
x^*); \]

grouping coefficients, we get:

\[ {x^*}^T \tilde Q(\lambda_{\min}) x^* - \tilde
a_0(\lambda_{\min}) \geq (\tilde a(\lambda_{\min}) + 2
\tilde Q(\lambda_{\min} ) x^*)^T x - \eta \]

and

\[ {x^*}^T \tilde Q(\lambda_{\max}) x^* - \tilde
a_0(\lambda_{\max}) \leq (\tilde a(\lambda_{\max}) + 2
\tilde Q (\lambda_{\max}) x^* )^T x - \eta \]

◆ compare()

virtual int Couenne::exprQuad::compare ( exprQuad )
virtual

Compare two exprQuad.

◆ code()

virtual enum expr_type Couenne::exprQuad::code ( )
inlinevirtual

Code for comparisons.

Reimplemented from Couenne::exprGroup.

Definition at line 231 of file CouenneExprQuad.hpp.

◆ rank()

virtual int Couenne::exprQuad::rank ( )
virtual

Used in rank-based branching variable choice.

Reimplemented from Couenne::exprGroup.

◆ isInteger()

virtual bool Couenne::exprQuad::isInteger ( )
virtual

is this expression integer?

Reimplemented from Couenne::exprGroup.

◆ DepList()

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.

◆ selectBranch()

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.

Reimplemented from Couenne::expression.

◆ fillDepSet()

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.

◆ replace()

virtual void Couenne::exprQuad::replace ( exprVar x,
exprVar w 
)
virtual

replace variable x with new (aux) w

Reimplemented from Couenne::exprGroup.

◆ realign()

virtual void Couenne::exprQuad::realign ( const CouenneProblem p)
virtual

replace variable x with new (aux) w

Reimplemented from Couenne::exprGroup.

◆ impliedBound()

virtual bool Couenne::exprQuad::impliedBound ( int  ,
CouNumber ,
CouNumber ,
t_chg_bounds ,
enum  auxSign = expression::AUX_EQ 
)
virtual

implied bound processing

Reimplemented from Couenne::exprSum.

◆ computeQBound()

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

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

◆ closestFeasible()

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

Reimplemented from Couenne::expression.

◆ computeQuadFiniteBound()

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

◆ isCuttable()

virtual bool Couenne::exprQuad::isCuttable ( CouenneProblem problem,
int  index 
) const
inlineprotectedvirtual

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

◆ matrix_

sparseQ Couenne::exprQuad::matrix_
mutableprotected

Definition at line 61 of file CouenneExprQuad.hpp.

◆ eigen_

std::vector<std::pair <CouNumber, std::vector <std::pair <exprVar *, CouNumber> > > > Couenne::exprQuad::eigen_
mutableprotected

eigenvalues and eigenvectors

Definition at line 73 of file CouenneExprQuad.hpp.

◆ bounds_

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.

◆ nqterms_

int Couenne::exprQuad::nqterms_
protected

number of non-zeroes in Q

Definition at line 79 of file CouenneExprQuad.hpp.


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