11 #ifndef COUENNE_EXPRMUL_H 12 #define COUENNE_EXPRMUL_H 20 class CouenneCutGenerator;
102 std::vector <CouNumber> &xl,
103 std::vector <CouNumber> &xu,
104 std::vector <std::pair <int, CouNumber> > &nl,
105 std::vector <std::pair <int, CouNumber> > &nu);
123 for (
int n =
nargs_; n--;)
148 int xi,
int yi,
int wi,
int brind,
double *brpt,
int nPts = 1);
CouNumber balancedMul(const OsiBranchingInformation *info, int index, int wind)
balanced strategy for branching point selection in products
CouNumber operator()()
Method to evaluate the expression.
expression ** arglist_
argument list is an array of pointers to other expressions
void upperEnvHull(const CouenneCutGenerator *cg, OsiCuts &cs, int xi, CouNumber x0, CouNumber xl, CouNumber xu, int yi, CouNumber y0, CouNumber yl, CouNumber yu, int wi, CouNumber w0, CouNumber wl, CouNumber wu)
better cuts than those from unifiedProdCuts
expression * differentiate(int index)
differentiation
expr_type
code returned by the method expression::code()
Cut Generator for linear convexifications.
void unifiedProdCuts(const CouenneCutGenerator *, OsiCuts &, int, CouNumber, CouNumber, CouNumber, int, CouNumber, CouNumber, CouNumber, int, CouNumber, CouNumber, CouNumber, t_chg_bounds *, enum expression::auxSign)
unified convexification of products and divisions
auxSign
"sign" of the constraint defining an auxiliary.
std::string printOp() const
Print operator.
int nargs_
number of arguments (cardinality of arglist)
int impliedBoundMul(CouNumber wl, CouNumber wu, std::vector< CouNumber > &xl, std::vector< CouNumber > &xu, std::vector< std::pair< int, CouNumber > > &nl, std::vector< std::pair< int, CouNumber > > &nu)
inferring bounds on factors of a product
general n-ary operator-type expression: requires argument list.
double CouNumber
main number type in Couenne
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 int Linearity()
get a measure of "how linear" the expression is:
virtual expression * clone(Domain *d=NULL) const
Cloning method.
virtual void closestFeasible(expression *varind, expression *vardep, CouNumber &left, CouNumber &right) const
compute and for Violation Transfer algorithm
Class for MINLP problems with symbolic information.
expression ** clonearglist(Domain *d=NULL) const
clone argument list (for use with clone method)
class for multiplications,
virtual CouNumber gradientNorm(const double *x)
return l-2 norm of gradient at given point
exprMul(expression **, int)
Constructor.
virtual void getBounds(expression *&, expression *&)
Get lower and upper bound of an expression (if any)
virtual bool impliedBound(int, CouNumber *, CouNumber *, t_chg_bounds *, enum Couenne::expression::auxSign=Couenne::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...
OsiObject for auxiliary variables $w=f(x)$.
double * computeMulBrDist(const OsiBranchingInformation *info, int xi, int yi, int wi, int brind, double *brpt, int nPts=1)
compute distance from future convexifications in set with x,y,w bounded.
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
status of lower/upper bound of a variable, to be checked/modified in bound tightening
general include file for different compilers
virtual enum expr_type code()
code for comparison
virtual exprAux * standardize(CouenneProblem *p, bool addAux=true)
reduce expression in standard form, creating additional aux variables (and constraints)
expression * simplify()
simplification