Couenne::exprMultiLin Class Reference

another class for multiplications, $ \prod_{i=1}^n f_i(x) $ More...

#include <CouenneExprMultiLin.hpp>

List of all members.

Public Member Functions

 exprMultiLin (expression **, int)
 Constructor.
 exprMultiLin (expression *, expression *)
 Constructor with two arguments.
CouNumber gradientNorm (const double *x)
 return l-2 norm of gradient at given point
expressiondifferentiate (int index)
 differentiation
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 &lb, CouNumber &ub)
 Get value of 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)
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 $y^{lv}$ and $y^{uv}$ for Violation Transfer algorithm

Protected Member Functions

int impliedBoundMul (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
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

another class for multiplications, $ \prod_{i=1}^n f_i(x) $

Definition at line 21 of file CouenneExprMultiLin.hpp.


Constructor & Destructor Documentation

Couenne::exprMultiLin::exprMultiLin ( expression **  ,
int   
)

Constructor.

Couenne::exprMultiLin::exprMultiLin ( expression ,
expression  
)

Constructor with two arguments.


Member Function Documentation

CouNumber Couenne::exprMultiLin::gradientNorm ( const double *  x  ) 

return l-2 norm of gradient at given point

expression* Couenne::exprMultiLin::differentiate ( int  index  ) 

differentiation

expression* Couenne::exprMultiLin::simplify (  ) 

simplification

virtual int Couenne::exprMultiLin::Linearity (  )  [virtual]

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

virtual void Couenne::exprMultiLin::getBounds ( expression *&  ,
expression *&   
) [virtual]

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

virtual void Couenne::exprMultiLin::getBounds ( CouNumber lb,
CouNumber ub 
) [virtual]

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

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

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

void Couenne::exprMultiLin::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::exprMultiLin::code (  )  [inline, virtual]

code for comparison

Definition at line 61 of file CouenneExprMultiLin.hpp.

References Couenne::COU_EXPRMUL.

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

implied bound processing

virtual CouNumber Couenne::exprMultiLin::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::exprMultiLin::closestFeasible ( expression varind,
expression vardep,
CouNumber left,
CouNumber right 
) const [virtual]

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

int Couenne::exprMultiLin::impliedBoundMul ( 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 
) [protected]

inferring bounds on factors of a product

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

balanced strategy for branching point selection in products

virtual bool Couenne::exprMultiLin::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 97 of file CouenneExprMultiLin.hpp.


The documentation for this class was generated from the following file:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

Generated on 2 Aug 2012 for Couenne by  doxygen 1.6.1