Power of an expression (binary operator) with even exponent, $
f(x)^k$ with $k\in \mathbb Z$ constant even. More...

#include <CouenneExprEvenPow.hpp>

Inheritance diagram for Couenne::exprEvenPow:

Collaboration diagram for Couenne::exprEvenPow:

Public Member Functions
	exprEvenPow (expression **al, int n=2)
	Constructor.

	exprEvenPow (expression arg0, expression arg1)
	Constructor with only two arguments.

expression *	clone (Domain *d=NULL) const
	cloning method

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)

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

expression *	getFixVar ()
	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.

expression *	clone (Domain *d=NULL) const
	cloning method

virtual enum pos	printPos () const
	print operator positioning

virtual std::string	printOp () const
	print operator

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 expression *	differentiate (int index)
	differentiation

virtual expression *	simplify ()
	simplification

virtual int	Linearity ()
	get a measure of "how linear" the expression is

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 &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)

virtual 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 expression *	getFixVar ()
	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

virtual 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 void	closestFeasible (expression varind, expression vardep, CouNumber &left, CouNumber &right) const
	compute $y^{lv}$ and $y^{uv}$ for Violation Transfer algorithm

virtual bool	isCuttable (CouenneProblem *problem, int index) const
	can this expression be further linearized or are we on its concave ("bad") side

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 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 expression *	simplify ()
	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 exprAux *	standardize (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 expression *	clone (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 expression *	Argument () 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 expression *	Image () 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 expression *	Original () 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 expression *	differentiate (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 expression *	simplify ()
	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 exprAux *	standardize (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 expression *	Copy () 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) with even exponent, $
f(x)^k$ with $k\in \mathbb Z$ constant even.

Definition at line 26 of file CouenneExprEvenPow.hpp.

Constructor & Destructor Documentation

◆ exprEvenPow() [1/2]

Couenne::exprEvenPow::exprEvenPow	(	expression **	al,
		int	n = `2`
	)

inline

Constructor.

Definition at line 31 of file CouenneExprEvenPow.hpp.

◆ exprEvenPow() [2/2]

Couenne::exprEvenPow::exprEvenPow	(	expression *	arg0,
		expression *	arg1
	)

inline

Constructor with only two arguments.

Definition at line 35 of file CouenneExprEvenPow.hpp.

Member Function Documentation

◆ clone()

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

inlinevirtual

cloning method

Reimplemented from Couenne::expression.

Definition at line 39 of file CouenneExprEvenPow.hpp.

◆ operator()()

CouNumber Couenne::exprEvenPow::operator() ( )

inlinevirtual

function for the evaluation of the expression

compute power

Reimplemented from Couenne::exprPow.

Definition at line 90 of file CouenneExprEvenPow.hpp.

◆ getBounds() [1/2]

void Couenne::exprEvenPow::getBounds	(	expression *&	,
		expression *&
	)

virtual

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

Reimplemented from Couenne::exprPow.

◆ getBounds() [2/2]

void Couenne::exprEvenPow::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::exprEvenPow::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::exprEvenPow::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::exprEvenPow::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 CouenneExprEvenPow.hpp.

◆ code()

virtual enum expr_type Couenne::exprEvenPow::code ( )

inlinevirtual

code for comparison

Reimplemented from Couenne::exprPow.

Definition at line 68 of file CouenneExprEvenPow.hpp.

◆ impliedBound()

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

virtual

implied bound processing

Reimplemented from Couenne::exprPow.

◆ selectBranch()

virtual CouNumber Couenne::exprEvenPow::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::exprEvenPow::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:

/builddir/build/BUILD/Couenne-0.5.8/src/expression/operators/CouenneExprEvenPow.hpp

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ exprEvenPow() [1/2]

◆ exprEvenPow() [2/2]

Member Function Documentation

◆ clone()

◆ operator()()

◆ getBounds() [1/2]

◆ getBounds() [2/2]

◆ standardize()

◆ generateCuts()

◆ getFixVar()

◆ code()

◆ impliedBound()

◆ selectBranch()

◆ isCuttable()