CouenneExprPow.hpp

Go to the documentation of this file.

/* $Id: CouenneExprPow.hpp 1182 2015-08-17 12:39:40Z stefan $
 *
 * Name:    CouenneExprPow.hpp
 * Author:  Pietro Belotti
 * Purpose: definition of powers, specifically with fractional
 *          exponent (odd/even/signed: see appropriate files)
 *
 * (C) Carnegie-Mellon University, 2006-11.
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef COUENNE_EXPRPOW_HPP
#define COUENNE_EXPRPOW_HPP

#include <math.h>
#include <stdio.h>

#include "CouenneExprOp.hpp"
#include "CouenneExprMul.hpp"
#include "CouenneExprClone.hpp"
#include "CouenneExprConst.hpp"

namespace Couenne {

class funtriplet;



class exprPow: public exprOp {

 private:

  bool issignpower_;

 public:

  exprPow (expression **al, int n = 2, bool signpower = false): 
    exprOp (al, n), issignpower_ (signpower) {} //< non-leaf expression, with argument list

  exprPow (expression *arg0, expression *arg1, bool signpower = false):
    exprOp (arg0, arg1), issignpower_ (signpower) {}

  expression *clone (Domain *d = NULL) const
  {return new exprPow (clonearglist (d), nargs_, issignpower_);}

  virtual enum pos printPos () const
  {return issignpower_ ? PRE : INSIDE ;}

  virtual std::string printOp () const
  {return issignpower_ ? "signpower" : "^";}

  virtual CouNumber operator () ();

  virtual CouNumber gradientNorm (const double *x);

  virtual expression *differentiate (int index); 

  virtual expression *simplify ();

  virtual int Linearity ();

  virtual bool isInteger ();

  virtual void getBounds (expression *&, expression *&);

  virtual void getBounds (CouNumber &lb, CouNumber &ub);

  virtual exprAux *standardize (CouenneProblem *p, bool addAux = true);

  virtual void generateCuts (expression *w, //const OsiSolverInterface &si, 
                             OsiCuts &cs, const CouenneCutGenerator *cg, 
                             t_chg_bounds * = NULL, int = -1, 
                             CouNumber = -COUENNE_INFINITY, 
                             CouNumber =  COUENNE_INFINITY);

  virtual expression *getFixVar () 
  {return arglist_ [0];}

  virtual enum expr_type code () 
  {return (issignpower_ ? COU_EXPRSIGNPOW : COU_EXPRPOW);}

  virtual bool impliedBound (int, CouNumber *, CouNumber *, t_chg_bounds *, enum auxSign = expression::AUX_EQ);

  virtual CouNumber selectBranch (const CouenneObject *obj, 
                                  const OsiBranchingInformation *info,
                                  expression * &var, 
                                  double * &brpts, 
                                  double * &brDist, // distance of current LP
                                                    // point to new convexifications
                                  int &way);

  virtual void closestFeasible (expression *varind,
                                expression *vardep, 
                                CouNumber &left,
                                CouNumber &right) const;

  virtual bool isCuttable (CouenneProblem *problem, int index) const;

  virtual bool isSignpower () const { return issignpower_; } 
};



inline CouNumber safe_pow (CouNumber base, 
                           CouNumber exponent, bool signpower = false) {

  double 
    lbase     = base,
    lexponent = exponent,
    retval    = 0.;

  if (lbase < 0.) {

    register int rndexp = COUENNE_round (lexponent);

    if (((fabs (lexponent - rndexp) < COUENNE_EPS) ||
         ((fabs (lexponent) > COUENNE_EPS) && 
          (fabs (1. / lexponent - (rndexp = COUENNE_round (1. / lexponent))) < COUENNE_EPS)))) {
      if ((rndexp % 2) || signpower)
        retval = (- pow (- lbase, lexponent)); // x^k, x negative, k odd  or signed power
      else retval = pow (- lbase, lexponent);  // x^k, x negative, k even or signed power
    }
    else retval =  0.; // this is incorrect but avoids nan's
  }
  else if (fabs (lbase) >= COUENNE_INFINITY) {

    if (lbase <= -COUENNE_INFINITY) {

      register int intk = COUENNE_round (lexponent);

      if ((fabs (lexponent - intk) < COUENNE_EPS) && (intk % 2 || signpower))
        retval = (lexponent < 0.) ? 0. : -COUENNE_INFINITY;
    }
    else retval = (lexponent < 0.) ? 0. : COUENNE_INFINITY;
  }
  else
    retval = (pow (lbase, lexponent));

  return (CouNumber) (retval);
}


inline CouNumber exprPow::operator () () {
  //  return (currValue_ = safe_pow (base, exponent));
  return safe_pow ((**arglist_) (), (*(arglist_ [1])) (), issignpower_);
}


void addPowEnvelope (const CouenneCutGenerator *, OsiCuts &, int, int,
                     CouNumber, CouNumber, CouNumber, CouNumber, CouNumber, int, bool = false);

CouNumber powNewton (CouNumber, CouNumber, unary_function, unary_function, unary_function);

CouNumber powNewton (CouNumber, CouNumber, funtriplet *);

}

#endif