Couenne  0.5.8
CouenneExprCos.hpp
Go to the documentation of this file.
1 /* $Id: CouenneExprCos.hpp 615 2011-06-08 20:36:24Z pbelotti $
2  *
3  * Name: exprCos.hpp
4  * Author: Pietro Belotti
5  * Purpose: definition of cosine
6  *
7  * (C) Carnegie-Mellon University, 2006-10.
8  * This file is licensed under the Eclipse Public License (EPL)
9  */
10 
11 #ifndef COUENNE_EXPRCOS_HPP
12 #define COUENNE_EXPRCOS_HPP
13 
14 #include "CouenneExprSin.hpp"
15 
16 namespace Couenne {
17 
19 
20 class exprCos: public exprUnary {
21 
22  public:
23 
26  exprUnary (al) {}
27 
29  expression *clone (Domain *d = NULL) const
30  {return new exprCos (argument_ -> clone (d));}
31 
33  inline unary_function F ()
34  {return cos;}
35 
37  std::string printOp () const
38  {return "cos";}
39 
41  inline CouNumber gradientNorm (const double *x) {
42  return (argument_ -> Index () < 0) ?
43  0. : fabs (sin (x [argument_ -> Index ()]));
44  }
45 
47  expression *differentiate (int index);
48 
51 
53  void getBounds (CouNumber &lb, CouNumber &ub);
54 
56  void generateCuts (expression *w, //const OsiSolverInterface &si,
57  OsiCuts &cs, const CouenneCutGenerator *cg,
58  t_chg_bounds * = NULL, int = -1,
61 
63  virtual enum expr_type code ()
64  {return COU_EXPRCOS;}
65 
67  bool impliedBound (int index, CouNumber *l, CouNumber *u, t_chg_bounds *chg, enum auxSign = expression::AUX_EQ) {
68 
69  bool impl = trigImpliedBound (COU_COSINE, index, argument_ -> Index (), l, u, chg);
70 
71  if (impl && argument_ -> isInteger ()) {
72 
73  int ind = argument_ -> Index ();
74  assert (ind >= 0);
75  l [ind] = ceil (l [ind] - COUENNE_EPS);
76  u [ind] = floor (u [ind] + COUENNE_EPS);
77  }
78 
79  return impl;
80  }
81 
84  virtual CouNumber selectBranch (const CouenneObject *obj,
85  const OsiBranchingInformation *info,
86  expression * &var,
87  double * &brpts,
88  double * &brDist, // distance of current LP
89  // point to new convexifications
90  int &way)
91  {return trigSelBranch (obj, info, var, brpts, brDist, way, COU_COSINE);}
92 
94  virtual void closestFeasible (expression *varind, expression *vardep,
95  CouNumber& left, CouNumber& right) const;
96 
99  virtual bool isCuttable (CouenneProblem *problem, int index) const
100  {return false;}
101 
103  //virtual enum convexity convexity () const;
104 };
105 
106 
109 
110 }
111 
112 #endif
#define COUENNE_EPS
#define COUENNE_INFINITY
Cut Generator for linear convexifications.
OsiObject for auxiliary variables $w=f(x)$.
Class for MINLP problems with symbolic information.
Define a dynamic point+bounds, with a way to save and restore previous points+bounds through a LIFO s...
class cosine,
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 expr_type code()
code for comparisons
bool impliedBound(int index, CouNumber *l, CouNumber *u, t_chg_bounds *chg, 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.
void getBounds(expression *&, expression *&)
Get lower and upper bound of an expression (if any)
unary_function F()
the operator itself (e.g. sin, log...)
expression * differentiate(int index)
obtain derivative of expression
virtual void closestFeasible(expression *varind, expression *vardep, CouNumber &left, CouNumber &right) const
closest feasible points in function in both directions
exprCos(expression *al)
constructor, destructor
expression * clone(Domain *d=NULL) const
cloning method
virtual bool isCuttable(CouenneProblem *problem, int index) const
can this expression be further linearized or are we on its concave ("bad") side
std::string printOp() const
print operator
void getBounds(CouNumber &lb, CouNumber &ub)
Get value of lower and upper bound of an expression.
CouNumber gradientNorm(const double *x)
return l-2 norm of gradient at given point
expression class for unary functions (sin, log, etc.)
virtual bool isInteger()
is this expression integer?
expression * argument_
single argument taken by this expression
Expression base class.
virtual int Index() const
Return index of variable (only valid for exprVar and exprAux)
auxSign
"sign" of the constraint defining an auxiliary.
status of lower/upper bound of a variable, to be checked/modified in bound tightening
general include file for different compilers
double CouNumber
main number type in Couenne
CouNumber trigNewton(CouNumber, CouNumber, CouNumber)
common convexification method used by both cos and sin
CouNumber(* unary_function)(CouNumber)
unary function, used in all exprUnary
CouExpr & cos(CouExpr &e)
bool trigImpliedBound(enum cou_trig, int, int, CouNumber *, CouNumber *, t_chg_bounds *)
generalized implied bound procedure for sine/cosine
expr_type
code returned by the method expression::code()
CouNumber trigSelBranch(const CouenneObject *obj, const OsiBranchingInformation *info, expression *&var, double *&brpts, double *&brDist, int &way, enum cou_trig type)
generalized procedure for both sine and cosine
CouExpr & sin(CouExpr &e)
int Index