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