CouenneExprMul.hpp

Go to the documentation of this file.

/* $Id: CouenneExprMul.hpp 811 2012-02-01 19:21:41Z pbelotti $
 *
 * Name:    exprMul.hpp
 * Author:  Pietro Belotti
 * Purpose: definition of multiplications
 *
 * (C) Carnegie-Mellon University, 2006-10.
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef COUENNE_EXPRMUL_H
#define COUENNE_EXPRMUL_H

#include <vector>

#include "CouenneExprOp.hpp"

namespace Couenne {

class CouenneCutGenerator;


class exprMul: public exprOp {

 public:

  exprMul (expression **, int);

  exprMul (expression *, expression *);

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

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

  inline CouNumber operator () ();

  virtual CouNumber gradientNorm (const double *x);

  expression *differentiate (int index); 

  expression *simplify ();

  virtual int Linearity ();

  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 enum expr_type code () 
  {return COU_EXPRMUL;}

  virtual bool impliedBound (int, CouNumber *, CouNumber *, t_chg_bounds *, 
                             enum Couenne::expression::auxSign = Couenne::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;
protected:

  int impliedBoundMul (CouNumber wl, 
                       CouNumber wu, 
                       std::vector <CouNumber> &xl,
                       std::vector <CouNumber> &xu,
                       std::vector <std::pair <int, CouNumber> > &nl,
                       std::vector <std::pair <int, CouNumber> > &nu);

  CouNumber balancedMul (const OsiBranchingInformation *info, int index, int wind);

  virtual bool isCuttable (CouenneProblem *problem, int index) const
  {return false;} // concave on both sides, as for products
};


inline CouNumber exprMul:: operator () () {

  CouNumber ret = 1.;
  expression **al = arglist_;

  for (int n = nargs_; n--;)
    ret *= (**al++) ();

  return ret;
}


void unifiedProdCuts (const CouenneCutGenerator *, OsiCuts &, 
                      int, CouNumber, CouNumber, CouNumber,
                      int, CouNumber, CouNumber, CouNumber,
                      int, CouNumber, CouNumber, CouNumber,
                      t_chg_bounds *, enum expression::auxSign);


void upperEnvHull (const CouenneCutGenerator *cg, OsiCuts &cs, 
                   int xi, CouNumber x0, CouNumber xl, CouNumber xu,
                   int yi, CouNumber y0, CouNumber yl, CouNumber yu,
                   int wi, CouNumber w0, CouNumber wl, CouNumber wu);


double *computeMulBrDist (const OsiBranchingInformation *info,
                          int xi, int yi, int wi, int brind, double *brpt, int nPts = 1);

}

#endif