CouenneExprEvenPow.hpp

Go to the documentation of this file.

/* $Id: CouenneExprEvenPow.hpp 698 2011-06-20 13:36:43Z pbelotti $
 *
 * Name:    CouenneExprEvenPow.hpp
 * Author:  Pietro Belotti
 * Purpose: definition of powers with even exponent
 *
 * (C) Pietro Belotti 2011
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef COUENNE_EXPREVENPOW_HPP
#define COUENNE_EXPREVENPOW_HPP

#include <math.h>

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

namespace Couenne {


  class exprEvenPow: public exprPow {

  public:

    exprEvenPow (expression **al, int n = 2): 
      exprPow (al, n) {} //< non-leaf expression, with argument list

    exprEvenPow (expression *arg0, expression *arg1):
      exprPow (arg0, arg1) {}

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

    CouNumber operator () ();

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

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

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

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

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

    virtual enum expr_type code () 
    {return COU_EXPREVENPOW;}

    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 bool isCuttable (CouenneProblem *problem, int index) const;
  };

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

#endif