/home/coin/SVN-release/OS-2.1.1/Couenne/src/expression/operators/exprPow.hpp

Go to the documentation of this file.
00001 /* $Id: exprPow.hpp 217 2009-07-08 17:02:07Z pbelotti $
00002  *
00003  * Name:    exprPow.hpp
00004  * Author:  Pietro Belotti
00005  * Purpose: definition of powers
00006  *
00007  * (C) Carnegie-Mellon University, 2006. 
00008  * This file is licensed under the Common Public License (CPL)
00009  */
00010 
00011 #ifndef COUENNE_EXPRPOW_HPP
00012 #define COUENNE_EXPRPOW_HPP
00013 
00014 #include <math.h>
00015 
00016 #include "exprOp.hpp"
00017 #include "exprMul.hpp"
00018 #include "exprClone.hpp"
00019 #include "exprConst.hpp"
00020 
00021 class funtriplet;
00022 
00023 
00025 
00026 class exprPow: public exprOp {
00027 
00028  public:
00029 
00031   exprPow (expression **al, int n = 2): 
00032     exprOp (al, n) {} //< non-leaf expression, with argument list
00033 
00035   exprPow (expression *arg0, expression *arg1):
00036     exprOp (arg0, arg1) {}
00037 
00039   expression *clone (Domain *d = NULL) const
00040     {return new exprPow (clonearglist (d), nargs_);}
00041 
00043   std::string printOp () const
00044     {return "^";}
00045 
00047   CouNumber operator () ();
00048 
00050   CouNumber gradientNorm (const double *x);
00051 
00053   expression *differentiate (int index); 
00054 
00056   expression *simplify ();
00057 
00059   int Linearity ();
00060 
00062   bool isInteger ();
00063 
00065   void getBounds (expression *&, expression *&);
00066 
00068   void getBounds (CouNumber &lb, CouNumber &ub);
00069 
00072   exprAux *standardize (CouenneProblem *p, bool addAux = true);
00073 
00075   void generateCuts (expression *w, //const OsiSolverInterface &si, 
00076                      OsiCuts &cs, const CouenneCutGenerator *cg, 
00077                      t_chg_bounds * = NULL, int = -1, 
00078                      CouNumber = -COUENNE_INFINITY, 
00079                      CouNumber =  COUENNE_INFINITY);
00080 
00083   expression *getFixVar () 
00084     {return arglist_ [0];}
00085 
00087   virtual enum expr_type code () 
00088     {return COU_EXPRPOW;}
00089 
00091   bool impliedBound (int, CouNumber *, CouNumber *, t_chg_bounds *);
00092 
00095   virtual CouNumber selectBranch (const CouenneObject *obj, 
00096                                   const OsiBranchingInformation *info,
00097                                   expression * &var, 
00098                                   double * &brpts, 
00099                                   double * &brDist, // distance of current LP
00100                                                     // point to new convexifications
00101                                   int &way);
00102 
00104   virtual void closestFeasible (expression *varind,
00105                                 expression *vardep, 
00106                                 CouNumber &left,
00107                                 CouNumber &right) const;
00108 
00111   virtual bool isCuttable (CouenneProblem *problem, int index) const;
00112 };
00113 
00114 
00116 
00117 inline CouNumber safe_pow (CouNumber base, 
00118                            CouNumber exponent) {
00119 
00120   long double 
00121     lbase     = base,
00122     lexponent = exponent,
00123     retval    = 0.;
00124 
00125   if (lbase < 0.) {
00126 
00127     register int rndexp;
00128 
00129     if (((fabs (lexponent - (rndexp = COUENNE_round (lexponent))) < COUENNE_EPS) ||
00130          ((fabs (lexponent) > COUENNE_EPS) && 
00131           (fabs (1. / lexponent - (rndexp = COUENNE_round (1. / lexponent))) < COUENNE_EPS)))) {
00132       if (rndexp % 2)
00133         retval = (- pow (- lbase, lexponent)); // x^k, x negative, k odd
00134       else retval = pow (-lbase, lexponent);   // x^k, x negative, k even
00135     }
00136     else retval =  0.; // this is incorrect but avoids nan's
00137   }
00138   else if (fabs (lbase) >= COUENNE_INFINITY) {
00139 
00140     if (lbase <= -COUENNE_INFINITY) {
00141 
00142       register int intk = COUENNE_round (lexponent);
00143 
00144       if ((fabs (lexponent - intk) < COUENNE_EPS) && (intk % 2))
00145         retval = (lexponent < 0.) ? 0. : -COUENNE_INFINITY;
00146     }
00147     else retval = (lexponent < 0.) ? 0. : COUENNE_INFINITY;
00148   }
00149 
00150   retval = (pow (lbase, lexponent));
00151 
00152   return (CouNumber) (retval);
00153 }
00154 
00155 
00157 inline CouNumber exprPow::operator () () {
00158   //  return (currValue_ = safe_pow (base, exponent));
00159   return (safe_pow ((**arglist_) (), (*(arglist_ [1])) ()));
00160 }
00161 
00162 
00164 void addPowEnvelope (const CouenneCutGenerator *, OsiCuts &, int, int,
00165                      CouNumber, CouNumber, CouNumber, CouNumber, CouNumber, int);
00166 
00167 
00169 CouNumber powNewton (CouNumber, CouNumber, unary_function, unary_function, unary_function);
00170 
00172 CouNumber powNewton (CouNumber, CouNumber, funtriplet *);
00173 
00174 #endif

Generated on Mon May 3 03:05:20 2010 by  doxygen 1.4.7