CouenneProblemElem.hpp

Go to the documentation of this file.

/* $Id: CouenneProblemElem.hpp 910 2012-10-27 13:14:44Z pbelotti $
 *
 * Name:    CouenneProblemElem.hpp
 * Author:  Pietro Belotti
 * Purpose: define the classes used by class CouenneProblem
 *
 * (C) Carnegie-Mellon University, 2006-08. 
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef COUENNE_PROBLEM_ELEM_HPP
#define COUENNE_PROBLEM_ELEM_HPP

#include <iostream>

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

namespace Couenne {

class CouenneConstraint {

 protected:

  expression *body_; 
  expression *lb_;   
  expression *ub_;   

 public:

  CouenneConstraint  (expression *body = NULL, 
                      expression *lb   = NULL, 
                      expression *ub   = NULL):
    body_     (body), 
    lb_       (lb), 
    ub_       (ub) {

    if (!lb_) 
      if (!ub_) {
        lb_ = new exprConst (0.);
        ub_ = new exprConst (0.);
      } 
      else         lb_ = new exprConst (- COUENNE_INFINITY);
    else if (!ub_) ub_ = new exprConst   (COUENNE_INFINITY);
  }

  virtual ~CouenneConstraint () {
    delete body_; 
    delete lb_; 
    delete ub_;
  }

  CouenneConstraint  (const CouenneConstraint &c, Domain *d = NULL):
    body_  (c.Body () -> clone (d)),
    lb_    (c.Lb   () -> clone (d)),
    ub_    (c.Ub   () -> clone (d)) {}

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

  // Get constraint's elements
  virtual inline expression *Lb   () const {return lb_;}   
  virtual inline expression *Ub   () const {return ub_;}   
  virtual inline expression *Body () const {return body_;} 

  virtual inline expression *Body (expression *newBody) 
  {body_ = newBody; return body_;}

  virtual exprAux *standardize (CouenneProblem *);

  virtual void print (std::ostream & = std::cout);
};



class CouenneObjective {

 protected:

  expression *body_;

 public:

  CouenneObjective (expression *body):
    body_ (body) {}

  ~CouenneObjective () 
  {delete body_;}

  CouenneObjective  (const CouenneObjective &o, Domain *d = NULL):
    body_  (o.body_ -> clone (d)) {}

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

  inline expression *Body () const
  {return body_;}

  expression *Body (expression *newBody) 
  {body_ = newBody; return body_;}

  inline exprAux *standardize (CouenneProblem *p) 
  {return body_ -> standardize (p);}

  void print (std::ostream &out = std::cout) {
    out << "min ";
    body_ -> print (out);
    out << std::endl;
  }
};

}

#endif