CouenneExprGroup.hpp

Go to the documentation of this file.

/* $Id: CouenneExprGroup.hpp 615 2011-06-08 20:36:24Z pbelotti $
 *
 * Name:    exprGroup.hpp
 * Author:  Pietro Belotti
 * Purpose: definition of mixed sum expressions (constant+linear+nonlinear)
 *
 * (C) Carnegie-Mellon University, 2006-09.
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef COUENNE_EXPRGROUP_H
#define COUENNE_EXPRGROUP_H

#include <vector>

#include "CouenneExprSum.hpp"
#include "CouenneExprVar.hpp"

namespace Couenne {

class Domain;


class exprGroup: public exprSum {

public:

  typedef std::vector <std::pair <exprVar *, CouNumber> > lincoeff;

protected:

  mutable lincoeff lcoeff_;  
  CouNumber        c0_;      

public:

  static expression *genExprGroup (CouNumber,
                                   lincoeff &, 
                                   expression ** = NULL, 
                                   int = 0);

  exprGroup  (CouNumber,
              lincoeff &, 
              expression ** = NULL, 
              int = 0);

  exprGroup (const exprGroup &src, Domain *d = NULL);

  virtual ~exprGroup ();

  virtual expression *clone (Domain *d = NULL) const
  {return new exprGroup (*this, d);}

  // Get constant, indices, and coefficients vectors, and number of linear terms
  CouNumber  getc0 () {return c0_;}           
  lincoeff &lcoeff () const {return lcoeff_;} 

  virtual void print (std::ostream &   = std::cout, 
                      bool             = false) const;

  virtual CouNumber operator () ();

  virtual CouNumber gradientNorm (const double *x);

  virtual int DepList (std::set <int> &deplist, 
                       enum dig_type type = ORIG_ONLY);

  virtual expression *differentiate (int index); 

  virtual expression *simplify ();

  virtual int Linearity ();

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

  virtual void getBounds (CouNumber &, CouNumber &);

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

  virtual int compare (exprGroup &);

  virtual enum expr_type code () {return COU_EXPRGROUP;}

  virtual bool isInteger ();

  virtual int rank ();

  virtual void fillDepSet (std::set <DepNode *, compNode> *, DepGraph *);

  virtual void replace (exprVar *x, exprVar *w);

  virtual void realign (const CouenneProblem *p);
};



inline CouNumber exprGroup::operator () () {

  CouNumber ret = c0_ + exprSum::operator () (); // add constant and nonlinear part

  // add linear part
  for (lincoeff::iterator el = lcoeff_.begin (); el != lcoeff_.end (); ++el)
    ret += el -> second * (*(el -> first)) ();

  return (CouNumber) ret;
}

}

#endif