CouenneExprCos.hpp

Go to the documentation of this file.

/* $Id: CouenneExprCos.hpp 615 2011-06-08 20:36:24Z pbelotti $
 *
 * Name:    exprCos.hpp
 * Author:  Pietro Belotti
 * Purpose: definition of cosine 
 *
 * (C) Carnegie-Mellon University, 2006-10.
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef COUENNE_EXPRCOS_HPP
#define COUENNE_EXPRCOS_HPP

#include "CouenneExprSin.hpp"

namespace Couenne {


class exprCos: public exprUnary {

 public:

  exprCos (expression *al):
    exprUnary (al) {}

  expression *clone (Domain *d = NULL) const
  {return new exprCos (argument_ -> clone (d));}

  inline unary_function F () 
  {return cos;}

  std::string printOp () const
  {return "cos";}

  inline CouNumber gradientNorm (const double *x) {
    return (argument_ -> Index () < 0) ? 
      0. : fabs (sin (x [argument_ -> Index ()]));
  }

  expression *differentiate (int index); 

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

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

  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_EXPRCOS;}

  bool impliedBound (int index, CouNumber *l, CouNumber *u, t_chg_bounds *chg, enum auxSign = expression::AUX_EQ) {

    bool impl = trigImpliedBound (COU_COSINE, index, argument_ -> Index (), l, u, chg);

    if (impl && argument_ -> isInteger ()) {

      int ind = argument_ -> Index ();
      assert (ind >= 0);
      l [ind] = ceil  (l [ind] - COUENNE_EPS);
      u [ind] = floor (u [ind] + COUENNE_EPS);
    }

    return impl;
  }

  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)
  {return trigSelBranch (obj, info, var, brpts, brDist, way, COU_COSINE);}

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

  virtual bool isCuttable (CouenneProblem *problem, int index) const
  {return false;}

  //virtual enum convexity convexity () const;
};


CouNumber trigNewton (CouNumber, CouNumber, CouNumber);

}

#endif