CouenneExprOp.hpp

Go to the documentation of this file.

/* $Id: CouenneExprOp.hpp 490 2011-01-14 16:07:12Z pbelotti $
 *
 * Name:    exprOp.hpp
 * Author:  Pietro Belotti
 * Purpose: definition of the n-ary expression class
 *
 * (C) Carnegie-Mellon University, 2006-08.
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef COUENNE_EXPROP_HPP
#define COUENNE_EXPROP_HPP

#include <iostream>

#include "CouenneExpression.hpp"
#include "CouenneTypes.hpp"

namespace Couenne {

#define MAX_ARG_LINE 10

class CouenneProblem;
class Domain;


class exprOp: public expression {

 protected:

  expression **arglist_; 
  int          nargs_;   

 public:

  virtual inline enum nodeType Type () const
    {return N_ARY;}

  exprOp (expression **arglist, int nargs):  //< non-leaf expression, with argument list 
    arglist_ (arglist),
    nargs_   (nargs)
    {}

  exprOp (expression *arg0, expression *arg1):  //< two arguments 
    arglist_ (new expression * [2]),
    nargs_   (2)
    {arglist_ [0] = arg0; arglist_ [1] = arg1;}

  virtual ~exprOp ();

  exprOp (const exprOp &e, Domain *d = NULL):
    arglist_ (new expression * [e.nArgs ()]),
    nargs_   (e.nArgs ()) {}

  inline expression **ArgList () const 
  {return arglist_;}

  virtual inline void ArgList (expression **al) 
  {arglist_ = al;}

  inline int nArgs () const 
  {return nargs_;}

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

  virtual enum pos printPos () const
  {return INSIDE;}

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

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

  virtual expression *simplify ();

  expression **clonearglist (Domain *d = NULL) const {
    if (nargs_) {
      expression **al = new expression * [nargs_];
      for (register int i=0; i<nargs_; i++)
        al [i] = arglist_ [i] -> clone (d);
      return al;
    } else return NULL;
  }

  int shrink_arglist (CouNumber, CouNumber);

  virtual inline int Linearity ()
  {return NONLINEAR;}

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

  virtual inline enum expr_type code ()
  {return COU_EXPROP;}

  virtual bool isInteger ();

  virtual int compare (exprOp &);

  virtual int rank ();

  virtual void fillDepSet (std::set <DepNode *, compNode> *dep, DepGraph *g) {
    for (int i=nargs_; i--;)
      arglist_ [i] -> fillDepSet (dep, g);
  }

  virtual void replace (exprVar *, exprVar *);

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

}

#endif