Go to the documentation of this file.
12 #ifndef COUENNE_EXPRPOW_HPP
13 #define COUENNE_EXPRPOW_HPP
41 exprOp (al, n), issignpower_ (signpower) {}
45 exprOp (arg0, arg1), issignpower_ (signpower) {}
57 {
return issignpower_ ?
"signpower" :
"^";}
134 CouNumber exponent,
bool signpower =
false) {
138 lexponent = exponent,
148 if ((rndexp % 2) || signpower)
149 retval = (- pow (- lbase, lexponent));
150 else retval = pow (- lbase, lexponent);
160 if ((fabs (lexponent - intk) <
COUENNE_EPS) && (intk % 2 || signpower))
166 retval = (pow (lbase, lexponent));
status of lower/upper bound of a variable, to be checked/modified in bound tightening
CouNumber(* unary_function)(CouNumber)
unary function, used in all exprUnary
virtual bool isCuttable(CouenneProblem *problem, int index) const
can this expression be further linearized or are we on its concave ("bad") side
virtual CouNumber gradientNorm(const double *x)
return l-2 norm of gradient at given point
int nargs_
number of arguments (cardinality of arglist)
expr_type
code returned by the method expression::code()
virtual expression * differentiate(int index)
differentiation
general n-ary operator-type expression: requires argument list.
expression * clone(Domain *d=NULL) const
cloning method
virtual bool isInteger()
is this expression integer?
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 std::string printOp() const
print operator
virtual expression * getFixVar()
return an index to the variable's argument that is better fixed in a branching rule for solving a non...
virtual void getBounds(expression *&, expression *&)
Get lower and upper bound of an expression (if any)
Power of an expression (binary operator), with constant.
pos
position where the operator should be printed when printing the expression
expression ** clonearglist(Domain *d=NULL) const
clone argument list (for use with clone method)
Cut Generator for linear convexifications.
void addPowEnvelope(const CouenneCutGenerator *, OsiCuts &, int, int, CouNumber, CouNumber, CouNumber, CouNumber, CouNumber, int, bool=false)
add upper/lower envelope to power in convex/concave areas
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
exprPow(expression **al, int n=2, bool signpower=false)
Constructor.
general include file for different compilers
virtual expression * simplify()
simplification
OsiObject for auxiliary variables $w=f(x)$.
virtual exprAux * standardize(CouenneProblem *p, bool addAux=true)
reduce expression in standard form, creating additional aux variables (and constraints)
double CouNumber
main number type in Couenne
auxSign
"sign" of the constraint defining an auxiliary.
virtual bool impliedBound(int, CouNumber *, CouNumber *, t_chg_bounds *, enum auxSign=expression::AUX_EQ)
implied bound processing
virtual int Linearity()
get a measure of "how linear" the expression is
virtual enum pos printPos() const
print operator positioning
CouNumber powNewton(CouNumber, CouNumber, unary_function, unary_function, unary_function)
find proper tangent point to add deepest tangent cut
CouNumber safe_pow(CouNumber base, CouNumber exponent, bool signpower=false)
compute power and check for integer-and-odd inverse exponent
Class for MINLP problems with symbolic information.
expression ** arglist_
argument list is an array of pointers to other expressions
virtual enum expr_type code()
code for comparison
virtual CouNumber operator()()
function for the evaluation of the expression
virtual void closestFeasible(expression *varind, expression *vardep, CouNumber &left, CouNumber &right) const
compute $y^{lv}$ and $y^{uv}$ for Violation Transfer algorithm
exprPow(expression *arg0, expression *arg1, bool signpower=false)
Constructor with only two arguments.
Define a dynamic point+bounds, with a way to save and restore previous points+bounds through a LIFO s...
virtual bool isSignpower() const
return whether this expression corresponds to a signed integer power