CouenneExprCopy.hpp

Go to the documentation of this file.

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

#ifndef COUENNE_EXPRCOPY_HPP
#define COUENNE_EXPRCOPY_HPP

#include <iostream>

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

namespace Couenne {

class CouenneObject;

// expression copy (points to VALUE of another expression) 

class exprCopy: public expression {

 protected:

  expression *copy_;

  CouNumber value_;

 public:

  inline enum nodeType Type () const
    {return copy_ -> Type ();}

  //exprCopy () {}

  exprCopy (expression *copy):
    //copy_  (getOriginal (copy)),// -> Original ()),
    copy_  (copy),// -> Original ()),
    value_ (0.) {}

  exprCopy (const exprCopy &e, Domain *d = NULL);

  virtual ~exprCopy () {
    if (copy_)
      delete copy_;
  }

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

  inline const expression *Original () const
  {return copy_ -> Original ();}

  inline bool isaCopy () const
  {return true;}

  inline expression *Copy () const
  {return (copy_ -> isaCopy ()) ? copy_ -> Copy () : copy_;}

  inline expression *Image () const
  {return copy_ -> Image ();}

  inline int Index () const
  {return copy_ -> Index ();}

  inline int nArgs () const
  {return copy_ -> nArgs ();}

  inline expression **ArgList () const
  {return copy_ -> ArgList ();}

  inline void ArgList (expression **al)
  {copy_ -> ArgList (al);}

  inline expression *Argument () const
  {return copy_ -> Argument ();}

  inline expression **ArgPtr ()
  {return copy_ -> ArgPtr ();}

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

  virtual inline CouNumber Value () const 
  {return value_;}

  virtual inline CouNumber operator () () 
  {return (value_ = (*copy_) ());}
    //    {return (*copy_) ();}
    //    {return (copy_ -> Value ());}

  inline CouNumber gradientNorm (const double *x)
  {return copy_ -> gradientNorm (x);}

  inline expression *differentiate (int index) 
  {return copy_ -> differentiate (index);}

  inline int DepList (std::set <int> &deplist, 
                      enum dig_type   type = ORIG_ONLY)
  {return copy_ -> DepList (deplist, type);}

  inline expression *simplify () 
  {return copy_ -> simplify ();}

  inline int Linearity ()
  {return copy_ -> Linearity ();}

  inline bool isInteger ()
  {return copy_ -> isInteger ();}

  virtual inline bool isDefinedInteger ()
  {return copy_ -> isDefinedInteger ();}

  inline void getBounds (expression *&lower, expression *&upper) 
  {copy_ -> getBounds (lower, upper);}

  inline void getBounds (CouNumber &lower, CouNumber &upper) 
  {copy_ -> getBounds (lower, upper);}
 

  inline exprAux *standardize (CouenneProblem *p, bool addAux = true)
  {return copy_ -> standardize (p, addAux);}

  inline void generateCuts (expression *w, //const OsiSolverInterface &si, 
                            OsiCuts &cs, const CouenneCutGenerator *cg, 
                            t_chg_bounds *chg = NULL, int wind= -1, 
                            CouNumber lb = -COUENNE_INFINITY, 
                            CouNumber ub =  COUENNE_INFINITY)

  {copy_ -> generateCuts (w, /*si,*/ cs, cg, chg, wind, lb, ub);}

  inline enum expr_type code () 
  {return copy_ -> code ();}

  inline enum convexity convexity () const
  {return copy_ -> convexity ();}

  int compare (expression &e) 
  {return copy_ -> compare (e);}

  inline int rank ()
  {return copy_ -> rank ();} 

  inline bool impliedBound (int wind, CouNumber *l, CouNumber *u, t_chg_bounds *chg)
  {return copy_ -> impliedBound (wind, l, u, chg);}

  inline int Multiplicity ()
  {return copy_ -> Multiplicity ();}

  inline 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 copy_ -> selectBranch (obj, info, var, brpts, brDist, way);}

  void replace (exprVar *, exprVar *);

  inline void fillDepSet (std::set <DepNode *, compNode> *dep, DepGraph *g)
  {copy_ -> fillDepSet (dep, g);}

  void realign (const CouenneProblem *p);
  //{copy_ -> realign (p);}

  bool isBijective() const 
  {return copy_ -> isBijective ();}

  CouNumber inverse (expression *vardep) const
  {return copy_ -> inverse (vardep);}

  void closestFeasible (expression *varind, expression *vardep,
                                CouNumber& left, CouNumber& right) const
  {copy_ -> closestFeasible (varind, vardep, left, right);}

  bool isCuttable (CouenneProblem *problem, int index) const
  {return copy_ -> isCuttable (problem, index);}
};

}

#endif