/home/coin/SVN-release/OS-2.0.0/Couenne/src/expression/domain.cpp

Go to the documentation of this file.
00001 /* $Id: domain.cpp 141 2009-06-03 04:19:19Z pbelotti $ */
00002 /*
00003  * Name:    domain.cpp
00004  * Author:  Pietro Belotti
00005  * Purpose: implementation of methods of classes 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 #include "CoinHelperFunctions.hpp"
00012 #include "domain.hpp"
00013 #include "CouennePrecisions.hpp"
00014 
00015 #define EXTRA_STORAGE 1024
00016 
00018 DomainPoint::DomainPoint (int dim, 
00019                           CouNumber *x, 
00020                           CouNumber *lb, 
00021                           CouNumber *ub,
00022                           bool copy):
00023   dimension_ (dim),
00024   x_         (x),
00025   lb_        (lb),
00026   ub_        (ub),
00027   copied_    (copy) {
00028 
00029   if ((dimension_ > 0) && copied_) {
00030 
00031     x_  = (CouNumber *) malloc (dim * sizeof (CouNumber)); 
00032     lb_ = (CouNumber *) malloc (dim * sizeof (CouNumber)); 
00033     ub_ = (CouNumber *) malloc (dim * sizeof (CouNumber)); 
00034 
00035     if (x)  CoinCopyN (x,  dim, x_);  else CoinFillN (x_,  dim, 0.);
00036     if (lb) CoinCopyN (lb, dim, lb_); else CoinFillN (lb_, dim, -COUENNE_INFINITY);
00037     if (ub) CoinCopyN (ub, dim, ub_); else CoinFillN (ub_, dim,  COUENNE_INFINITY);
00038   }
00039 }
00040 
00041 
00043 DomainPoint::DomainPoint (int dim, 
00044                           const CouNumber *x, 
00045                           const CouNumber *lb, 
00046                           const CouNumber *ub):
00047   dimension_ (dim),
00048   x_         (NULL),
00049   lb_        (NULL),
00050   ub_        (NULL),
00051   copied_    (true) {
00052 
00053   if (dimension_ > 0) {
00054 
00055     x_  = (CouNumber *) malloc (dim * sizeof (CouNumber)); 
00056     lb_ = (CouNumber *) malloc (dim * sizeof (CouNumber)); 
00057     ub_ = (CouNumber *) malloc (dim * sizeof (CouNumber)); 
00058 
00059     if (x)  CoinCopyN (x,  dim, x_);  else CoinFillN (x_,  dim, 0.);
00060     if (lb) CoinCopyN (lb, dim, lb_); else CoinFillN (lb_, dim, -COUENNE_INFINITY);
00061     if (ub) CoinCopyN (ub, dim, ub_); else CoinFillN (ub_, dim,  COUENNE_INFINITY);
00062   }
00063 }
00064 
00065 
00067 DomainPoint::DomainPoint (const DomainPoint &src):
00068   dimension_ (src.dimension_),
00069   x_         (src.x_),
00070   lb_        (src.lb_),
00071   ub_        (src.ub_),
00072   copied_    (src.copied_) {
00073 
00074   if ((dimension_ > 0) && copied_) {
00075 
00076     x_  = (CouNumber *) malloc (dimension_ * sizeof (CouNumber));
00077     lb_ = (CouNumber *) malloc (dimension_ * sizeof (CouNumber));
00078     ub_ = (CouNumber *) malloc (dimension_ * sizeof (CouNumber));
00079 
00080     CoinCopyN (src.x_,  dimension_, x_);
00081     CoinCopyN (src.lb_, dimension_, lb_);
00082     CoinCopyN (src.ub_, dimension_, ub_);
00083   }
00084 }
00085 
00086 
00088 void DomainPoint::resize (int newdim) {
00089 
00090   if (newdim == dimension_) return;
00091 
00092   assert (copied_); // cannot resize domain point as it was not copied
00093 
00094   if (newdim==0) { // clear
00095 
00096     free (x_);  x_  = NULL;
00097     free (lb_); lb_ = NULL;
00098     free (ub_); ub_ = NULL;
00099 
00100     dimension_ = newdim;
00101 
00102   } else if (newdim < dimension_) { // resize exactly
00103 
00104     x_  = (CouNumber *) realloc (x_,  newdim * sizeof (CouNumber)); 
00105     lb_ = (CouNumber *) realloc (lb_, newdim * sizeof (CouNumber)); 
00106     ub_ = (CouNumber *) realloc (ub_, newdim * sizeof (CouNumber)); 
00107 
00108     dimension_ = newdim;
00109 
00110   } else if (newdim > dimension_) { // expand and leave some extra space
00111 
00112     newdim += EXTRA_STORAGE;
00113 
00114     x_  = (CouNumber *) realloc (x_,  newdim * sizeof (CouNumber)); 
00115     lb_ = (CouNumber *) realloc (lb_, newdim * sizeof (CouNumber)); 
00116     ub_ = (CouNumber *) realloc (ub_, newdim * sizeof (CouNumber)); 
00117 
00118     dimension_ = newdim;
00119   }
00120 }
00121 
00122 
00124 DomainPoint &DomainPoint::operator= (const DomainPoint &src) {
00125 
00126   copied_ = src.copied_;
00127 
00128   if (src.dimension_ != dimension_) {
00129     if (x_)  free (x_);  x_  = (CouNumber *) malloc (src.dimension_ * sizeof (CouNumber));
00130     if (lb_) free (lb_); lb_ = (CouNumber *) malloc (src.dimension_ * sizeof (CouNumber));
00131     if (ub_) free (ub_); ub_ = (CouNumber *) malloc (src.dimension_ * sizeof (CouNumber));
00132     dimension_ = src.dimension_;
00133   }
00134 
00135   CoinCopyN (src.x_,  dimension_, x_);
00136   CoinCopyN (src.lb_, dimension_, lb_);
00137   CoinCopyN (src.ub_, dimension_, ub_);
00138 
00139   return *this;
00140 }
00141 
00142 
00144 Domain::~Domain () {
00145 
00146   if (point_) 
00147     delete point_;
00148 
00149   while (!(domStack_.empty ())) {
00150     delete domStack_.top ();
00151     domStack_.pop ();
00152   }
00153 }
00154 
00155 
00157 void Domain::push (int dim, CouNumber *x, CouNumber *lb, CouNumber *ub, bool copy) {
00158 
00159   if (!x)  x  = point_ -> x  ();
00160   if (!lb) lb = point_ -> lb ();
00161   if (!ub) ub = point_ -> ub ();
00162 
00163   if (point_)
00164     domStack_.push (point_);
00165 
00166   point_ = new DomainPoint (dim, x, lb, ub, copy);
00167 }
00168 
00169 
00171 void Domain::push (int dim, 
00172                    const CouNumber *x, 
00173                    const CouNumber *lb, 
00174                    const CouNumber *ub) {
00175 
00176   if (point_) 
00177     domStack_.push (point_);
00178 
00179   point_ = new DomainPoint (dim, x, lb, ub);
00180 }
00181 
00182 
00184 void Domain::push (const DomainPoint &dp, bool copy) {
00185 
00186   if (point_)
00187     domStack_.push (point_);
00188   point_ = new DomainPoint (dp);
00189 }
00190 
00191 
00193 void Domain::pop () {
00194 
00195   delete point_;
00196   if (!(domStack_.empty ())) {
00197     point_ = domStack_.top ();
00198     domStack_.pop ();
00199   }
00200   else point_ = NULL;
00201 }
00202 
00203 /*int main (int argc, char **argv) {
00204 
00205 CouNumber 
00206 x1 [] = {1,2,3},
00207 l1 [] = {0,-1,-2},
00208 u1 [] = {2,5,8},
00209 
00210 x3 [] = {14,15,16,17,18,19},
00211 l3 [] = {-100,-100,-100,-100,-100,-100},
00212 u3 [] = {10,10,10,10,10,10},
00213 
00214 x2 [] = {5001,5002,5003,5006},
00215 l2 [] = {4000,3000,2000,1000},
00216 u2 [] = {5000,6000,8000,6000};
00217 
00218 Domain dom;
00219 
00220 for (int i=80; i--;) {
00221 dom.push (3,x1,l1,u1);printf("1: %g %g %g\n", dom.x(1),dom.x(2),dom.x(0));
00222 dom.push(5,x3,l3,u3);printf("2: %g %g %g %g %g\n",dom.x(1),dom.x(2),dom.x(3),dom.x(4),dom.x(0));
00223 dom.push (4,x2,l2,u2); printf ("3: %g %g %g %g\n", dom.x(1),dom.x(2),dom.x(3),dom.x(0));
00224 dom.push (3,x1,l1,u1); printf ("4: %g %g %g\n", dom.x(1),dom.x(2),dom.x(0));
00225 dom.push (4,x2,l2,u2); printf ("5: %g %g %g %g\n", dom.x(1),dom.x(2),dom.x(3),dom.x(0));
00226 dom.push(5,x3,l3,u3);printf("6: %g %g %g %g %g\n",dom.x(1),dom.x(2),dom.x(3),dom.x(4),dom.x(0));
00227 dom.pop ();
00228 dom.pop ();
00229 dom.pop ();
00230 dom.pop ();
00231 dom.pop ();
00232 dom.pop ();
00233 }
00234 }*/

Generated on Mon Aug 3 03:02:20 2009 by  doxygen 1.4.7