00001
00002
00003
00004
00005
00006
00007
00008
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_);
00093
00094 if (newdim==0) {
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_) {
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_) {
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
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234