Couenne 0.5.8
Loading...
Searching...
No Matches
Public Member Functions | List of all members
Couenne::exprOddPow Class Reference

Power of an expression (binary operator), $ f(x)^k$ with $ k$ constant. More...

#include <CouenneExprOddPow.hpp>

+ Inheritance diagram for Couenne::exprOddPow:
+ Collaboration diagram for Couenne::exprOddPow:

Public Member Functions

 exprOddPow (expression **al, int n=2)
 Constructor.
 
 exprOddPow (expression *arg0, expression *arg1)
 Constructor with only two arguments.
 
expressionclone (Domain *d=NULL) const
 cloning method
 
std::string printOp () const
 print operator
 
CouNumber operator() ()
 function for the evaluation of the expression
 
void getBounds (expression *&, expression *&)
 Get lower and upper bound of an expression (if any)
 
void getBounds (CouNumber &lb, CouNumber &ub)
 Get value of lower and upper bound of an expression (if any)
 
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
 
expressiongetFixVar ()
 return an index to the variable's argument that is better fixed in a branching rule for solving a nonconvexity gap
 
virtual enum expr_type code ()
 code for comparison
 
bool impliedBound (int, CouNumber *, CouNumber *, t_chg_bounds *, enum auxSign=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 bool isCuttable (CouenneProblem *problem, int index) const
 can this expression be further linearized or are we on its concave ("bad") side
 
- Public Member Functions inherited from Couenne::exprPow
 exprPow (expression **al, int n=2, bool signpower=false)
 Constructor.
 
 exprPow (expression *arg0, expression *arg1, bool signpower=false)
 Constructor with only two arguments.
 
expressionclone (Domain *d=NULL) const
 cloning method
 
virtual enum pos printPos () const
 print operator positioning
 
virtual CouNumber gradientNorm (const double *x)
 return l-2 norm of gradient at given point
 
virtual expressiondifferentiate (int index)
 differentiation
 
virtual expressionsimplify ()
 simplification
 
virtual int Linearity ()
 get a measure of "how linear" the expression is
 
virtual bool isInteger ()
 is this expression integer?
 
virtual void closestFeasible (expression *varind, expression *vardep, CouNumber &left, CouNumber &right) const
 compute $y^{lv}$ and $y^{uv}$ for Violation Transfer algorithm
 
virtual bool isSignpower () const
 return whether this expression corresponds to a signed integer power
 
- 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 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
 
expression ** clonearglist (Domain *d=NULL) const
 clone argument list (for use with clone method)
 
int shrink_arglist (CouNumber, CouNumber)
 compress argument list
 
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 int Index () const
 Return index of variable (only valid for exprVar and exprAux)
 
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 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 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 bool isDefinedInteger ()
 is this expression defined as an integer?
 
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 Multiplicity ()
 multiplicity of a variable
 
virtual void linkDomain (Domain *d)
 empty function to update domain pointer
 
virtual bool isBijective () const
 indicating if function is monotonically increasing
 
virtual CouNumber inverse (expression *vardep) const
 compute the inverse function
 
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)
 

Additional Inherited Members

- 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 inherited from Couenne::exprOp
expression ** arglist_
 argument list is an array of pointers to other expressions
 
int nargs_
 number of arguments (cardinality of arglist)
 

Detailed Description

Power of an expression (binary operator), $ f(x)^k$ with $ k$ constant.

Definition at line 22 of file CouenneExprOddPow.hpp.

Constructor & Destructor Documentation

◆ exprOddPow() [1/2]

Couenne::exprOddPow::exprOddPow ( expression ** al,
int n = 2 )
inline

Constructor.

Definition at line 27 of file CouenneExprOddPow.hpp.

◆ exprOddPow() [2/2]

Couenne::exprOddPow::exprOddPow ( expression * arg0,
expression * arg1 )
inline

Constructor with only two arguments.

Definition at line 31 of file CouenneExprOddPow.hpp.

Member Function Documentation

◆ clone()

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

cloning method

Reimplemented from Couenne::expression.

Definition at line 35 of file CouenneExprOddPow.hpp.

◆ printOp()

std::string Couenne::exprOddPow::printOp ( ) const
inlinevirtual

print operator

Reimplemented from Couenne::exprPow.

Definition at line 39 of file CouenneExprOddPow.hpp.

◆ operator()()

CouNumber Couenne::exprOddPow::operator() ( )
inlinevirtual

function for the evaluation of the expression

compute power

Reimplemented from Couenne::exprPow.

Definition at line 90 of file CouenneExprOddPow.hpp.

◆ getBounds() [1/2]

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

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

Reimplemented from Couenne::exprPow.

◆ getBounds() [2/2]

void Couenne::exprOddPow::getBounds ( CouNumber & lb,
CouNumber & ub )
virtual

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

Reimplemented from Couenne::exprPow.

◆ standardize()

exprAux * Couenne::exprOddPow::standardize ( CouenneProblem * p,
bool addAux = true )
virtual

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

Reimplemented from Couenne::exprPow.

◆ generateCuts()

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

generate equality between *this and *w

Reimplemented from Couenne::exprPow.

◆ getFixVar()

expression * Couenne::exprOddPow::getFixVar ( )
inlinevirtual

return an index to the variable's argument that is better fixed in a branching rule for solving a nonconvexity gap

Reimplemented from Couenne::exprPow.

Definition at line 64 of file CouenneExprOddPow.hpp.

◆ code()

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

code for comparison

Reimplemented from Couenne::exprPow.

Definition at line 68 of file CouenneExprOddPow.hpp.

◆ impliedBound()

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

implied bound processing

Reimplemented from Couenne::exprPow.

◆ selectBranch()

virtual CouNumber Couenne::exprOddPow::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::exprPow.

◆ isCuttable()

virtual bool Couenne::exprOddPow::isCuttable ( CouenneProblem * problem,
int index ) const
virtual

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

Reimplemented from Couenne::exprPow.


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