domain.hpp

Go to the documentation of this file.
00001 /* $Id: domain.hpp 217 2009-07-08 17:02:07Z pbelotti $
00002  *
00003  * Name:    domain.hpp
00004  * Author:  Pietro Belotti
00005  * Purpose: class for point and bounding box
00006  *
00007  * (C) Carnegie-Mellon University, 2008-09.
00008  * This file is licensed under the Common Public License (CPL)
00009  */
00010 
00011 #ifndef COUENNE_DOMAIN_HPP
00012 #define COUENNE_DOMAIN_HPP
00013 
00014 #include <stdlib.h>
00015 #include <stack>
00016 
00017 #include "CouenneTypes.hpp"
00018 
00020 
00021 class DomainPoint {
00022 
00023 protected:
00024 
00025   int dimension_; 
00026 
00027   CouNumber *x_;  
00028   CouNumber *lb_; 
00029   CouNumber *ub_; 
00030 
00031   bool copied_;   
00032 
00033 
00034   bool isNlp_;    
00035 
00036 public:
00037 
00039   DomainPoint (int dim = 0, 
00040                CouNumber *x   = NULL, 
00041                CouNumber *lb  = NULL, 
00042                CouNumber *ub  = NULL,
00043                bool copy = true);
00044 
00046   DomainPoint (int dim = 0, 
00047                const CouNumber *x   = NULL, 
00048                const CouNumber *lb  = NULL, 
00049                const CouNumber *ub  = NULL);
00050 
00052   ~DomainPoint () {
00053     if (copied_) {
00054       if (x_)  free (x_);
00055       if (lb_) free (lb_);
00056       if (ub_) free (ub_);
00057     }
00058   }
00059 
00061   DomainPoint (const DomainPoint &src);
00062 
00064   void resize (int newdim);
00065 
00067   int size () const {return dimension_;}
00068 
00070   inline int Dimension () {return dimension_;}
00071 
00072   inline CouNumber &x  (register int index) {return x_  [index];} 
00073   inline CouNumber &lb (register int index) {return lb_ [index];} 
00074   inline CouNumber &ub (register int index) {return ub_ [index];} 
00075 
00076   inline CouNumber *x  () {return x_ ;} 
00077   inline CouNumber *lb () {return lb_;} 
00078   inline CouNumber *ub () {return ub_;} 
00079 
00081   DomainPoint &operator= (const DomainPoint &src);
00082 
00084   bool &isNlp () 
00085   {return isNlp_;}
00086 };
00087 
00088 
00091 
00092 class Domain {
00093 
00094 protected:
00095 
00096   DomainPoint *point_;                  
00097   std::stack <DomainPoint *> domStack_; 
00098 
00099 public:
00100 
00102   Domain (): point_ (NULL) {}
00103 
00105   Domain (const Domain &src) {
00106     point_ = new DomainPoint (*(src.point_));
00107     // TODO -- not important, discard previous points when copying problem
00108     /*for (std::stack <DomainPoint *>::iterator i = src.domStack_.begin ();
00109          i != src.domStack_.end (); ++i)
00110          domStack_.push (new DomainPoint (**i));*/
00111   } 
00112 
00114   ~Domain ();
00115 
00117   void push (int dim, 
00118              CouNumber *x, 
00119              CouNumber *lb, 
00120              CouNumber *ub, 
00121              bool copy = true);
00122 
00124   void push (int dim, 
00125              const CouNumber *x, 
00126              const CouNumber *lb, 
00127              const CouNumber *ub);
00128 
00130   void push (const DomainPoint &dp, bool copy = true);
00131 
00133   void pop ();
00134 
00135   inline DomainPoint *current ()   {return point_;}                          
00136 
00137   inline CouNumber &x  (register int index) {return point_ -> x  (index);}   
00138   inline CouNumber &lb (register int index) {return point_ -> lb (index);}   
00139   inline CouNumber &ub (register int index) {return point_ -> ub (index);}   
00140 
00141   inline CouNumber *x  () {return point_ -> x  ();}   
00142   inline CouNumber *lb () {return point_ -> lb ();}   
00143   inline CouNumber *ub () {return point_ -> ub ();}   
00144 };
00145 
00146 #endif

Generated on Sun Mar 6 03:03:41 2011 for Couenne by  doxygen 1.4.7