11 #ifndef COUENNE_EXPRINV_H
12 #define COUENNE_EXPRINV_H
25 {
return (-
inv (x*x));}
30 {
return (2 *
inv (x*x*x));}
51 virtual void print (std::ostream &out = std::cout,
bool =
false)
const;
87 const OsiBranchingInformation *info,
100 return 1./((*vardep)());
Cut Generator for linear convexifications.
expression * differentiate(int index)
differentiation
OsiObject for auxiliary variables $w=f(x)$.
unary_function F()
the operator's function
status of lower/upper bound of a variable, to be checked/modified in bound tightening ...
exprInv(expression *al)
Constructors, destructor.
CouNumber oppInvSqr(register CouNumber x)
derivative of inv (x)
CouNumber inv_dblprime(register CouNumber x)
inv_dblprime, second derivative of inv (x)
expression * argument_
single argument taken by this expression
virtual enum expr_type code()
code for comparisons
expression class for unary functions (sin, log, etc.)
virtual int Linearity()
get a measure of "how linear" the expression is (see CouenneTypes.h)
CouNumber inv(register CouNumber arg)
the operator itself
virtual CouNumber inverse(expression *vardep) const
return inverse of y=f(x)=1/x, i.e., x=1/y
auxSign
"sign" of the constraint defining an auxiliary.
CouNumber(* unary_function)(CouNumber)
unary function, used in all exprUnary
Class for MINLP problems with symbolic information.
bool impliedBound(int, CouNumber *, CouNumber *, t_chg_bounds *, enum auxSign=expression::AUX_EQ)
implied bound processing
void getBounds(expression *&, expression *&)
Get lower and upper bound of an expression (if any)
double CouNumber
main number type in Couenne
expression * clone(Domain *d=NULL) const
cloning method
CouNumber gradientNorm(const double *x)
return l-2 norm of gradient at given point
expr_type
code returned by the method expression::code()
virtual bool isBijective() const
return true if bijective
virtual void print(std::ostream &out=std::cout, bool=false) const
output "1/argument"
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 nodeType Type() const
node type
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 ...
Define a dynamic point+bounds, with a way to save and restore previous points+bounds through a LIFO s...
virtual bool isCuttable(CouenneProblem *problem, int index) const
can this expression be further linearized or are we on its concave ("bad") side