CouenneExprSignPow.hpp

Go to the documentation of this file.

/* $Id: CouenneExprSignPow.hpp 698 2011-06-20 13:36:43Z pbelotti $
 *
 * Name:    CouenneExprSignPow.hpp
 * Author:  Pietro Belotti
 * Purpose: Defines signed powers, i.e., functions of the form x|x|^k with k in R
 *
 * (C) Pietro Belotti 2011
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef COUENNE_EXPRSIGNPOW_HPP
#define COUENNE_EXPRSIGNPOW_HPP

#include <math.h>

#include "CouenneExprPow.hpp"

namespace Couenne {

  class funtriplet;


  class exprSignPow: public exprSignPow {

  public:

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

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

    expression *clone (Domain *d = NULL) const
    {return new exprSignPow (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);

    virtual enum expr_type code () 
    {return COU_EXPRSIGNPOW;}

    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 exprSignPow::operator () () {
    //  return (currValue_ = safe_pow (base, exponent));
    return (safe_pow ((**arglist_) (), (*(arglist_ [1])) ()));
  }
}

#endif