00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042 #include <sstream>
00043
00044 namespace Gecode {
00045
00046 namespace Set {
00047
00048 template<class View>
00049 forceinline
00050 OffsetSetView<View>::OffsetSetView(void) {}
00051
00052 template<class View>
00053 forceinline
00054 OffsetSetView<View>::OffsetSetView(View& s0, int k0)
00055 : DerivedViewBase<View>(s0), k(k0) {}
00056
00057 template<class View>
00058 forceinline bool
00059 OffsetSetView<View>::assigned(void) const { return view.assigned(); }
00060
00061 template<class View>
00062 forceinline unsigned int
00063 OffsetSetView<View>::glbSize(void) const {
00064 return view.glbSize();
00065 }
00066
00067 template<class View>
00068 forceinline unsigned int
00069 OffsetSetView<View>::lubSize(void) const {
00070 return view.lubSize();
00071 }
00072
00073 template<class View>
00074 forceinline unsigned int
00075 OffsetSetView<View>::unknownSize(void) const {
00076 return view.unknownSize();
00077 }
00078
00079 template<class View>
00080 forceinline int
00081 OffsetSetView<View>::offset(void) const {
00082 return k;
00083 }
00084
00085 template<class View>
00086 forceinline bool
00087 OffsetSetView<View>::contains(int n) const {
00088 return view.contains(n-k);
00089 }
00090
00091 template<class View>
00092 forceinline bool
00093 OffsetSetView<View>::notContains(int n) const {
00094 return view.notContains(n-k);
00095 }
00096
00097 template<class View>
00098 forceinline unsigned int
00099 OffsetSetView<View>::cardMin() const {
00100 return view.cardMin();
00101 }
00102
00103 template<class View>
00104 forceinline unsigned int
00105 OffsetSetView<View>::cardMax() const {
00106 return view.cardMax();
00107 }
00108
00109 template<class View>
00110 forceinline int
00111 OffsetSetView<View>::lubMin() const {
00112 if (view.cardMax() == 0)
00113 return view.lubMin();
00114 return view.lubMin() + k;
00115 }
00116
00117 template<class View>
00118 forceinline int
00119 OffsetSetView<View>::lubMax() const {
00120 if (view.cardMax() == 0)
00121 return view.lubMax();
00122 return view.lubMax() + k;
00123 }
00124
00125 template<class View>
00126 forceinline int
00127 OffsetSetView<View>::glbMin() const {
00128 if (view.cardMax() == 0)
00129 return view.glbMin();
00130 return view.glbMin() + k;
00131 }
00132
00133 template<class View>
00134 forceinline int
00135 OffsetSetView<View>::glbMax() const {
00136 if (view.cardMax() == 0)
00137 return view.glbMax();
00138 return view.glbMax() + k;
00139 }
00140
00141 template<class View>
00142 forceinline ModEvent
00143 OffsetSetView<View>::cardMin(Space& home, unsigned int c) {
00144 return view.cardMin(home, c);
00145 }
00146
00147 template<class View>
00148 forceinline ModEvent
00149 OffsetSetView<View>::cardMax(Space& home, unsigned int c) {
00150 return view.cardMax(home, c);
00151 }
00152
00153 template<class View>
00154 forceinline ModEvent
00155 OffsetSetView<View>::include(Space& home, int c) {
00156 return view.include(home, c-k);
00157 }
00158
00159 template<class View>
00160 forceinline ModEvent
00161 OffsetSetView<View>::exclude(Space& home, int c) {
00162 return view.exclude(home, c-k);
00163 }
00164
00165 template<class View>
00166 forceinline ModEvent
00167 OffsetSetView<View>::intersect(Space& home, int c) {
00168 return view.intersect(home, c-k);
00169 }
00170
00171 template<class View>
00172 forceinline ModEvent
00173 OffsetSetView<View>::intersect(Space& home, int i, int j) {
00174 return view.intersect(home, i-k, j-k);
00175 }
00176
00177 template<class View>
00178 forceinline ModEvent
00179 OffsetSetView<View>::include(Space& home, int i, int j) {
00180 return view.include(home, i-k, j-k);
00181 }
00182
00183 template<class View>
00184 forceinline ModEvent
00185 OffsetSetView<View>::exclude(Space& home, int i, int j) {
00186 return view.exclude(home, i-k, j-k);
00187 }
00188
00189 template<class View>
00190 template<class I> ModEvent
00191 OffsetSetView<View>::excludeI(Space& home,I& iter) {
00192 Iter::Ranges::Offset<I> off(iter, -k);
00193 return view.excludeI(home, off);
00194 }
00195
00196 template<class View>
00197 template<class I> ModEvent
00198 OffsetSetView<View>::includeI(Space& home,I& iter) {
00199 Iter::Ranges::Offset<I> off(iter, -k);
00200 return view.includeI(home, off);
00201 }
00202
00203 template<class View>
00204 template<class I> ModEvent
00205 OffsetSetView<View>::intersectI(Space& home,I& iter) {
00206 Iter::Ranges::Offset<I> off(iter, -k);
00207 return view.intersectI(home, off);
00208 }
00209
00210 template<class View>
00211 forceinline void
00212 OffsetSetView<View>::subscribe(Space& home, Propagator& p, PropCond pc,
00213 bool process) {
00214 view.subscribe(home,p, pc,process);
00215 }
00216
00217 template<class View>
00218 forceinline void
00219 OffsetSetView<View>::cancel(Space& home, Propagator& p, PropCond pc) {
00220 view.cancel(home,p, pc);
00221 }
00222
00223 template<class View>
00224 forceinline void
00225 OffsetSetView<View>::subscribe(Space& home, Advisor& a) {
00226 view.subscribe(home,a);
00227 }
00228
00229 template<class View>
00230 forceinline void
00231 OffsetSetView<View>::cancel(Space& home, Advisor& a) {
00232 view.cancel(home,a);
00233 }
00234
00235 template<class View>
00236 forceinline void
00237 OffsetSetView<View>::schedule(Space& home, Propagator& p, ModEvent me) {
00238 return View::schedule(home,p,me);
00239 }
00240 template<class View>
00241 forceinline ModEvent
00242 OffsetSetView<View>::me(const ModEventDelta& med) {
00243 return View::me(med);
00244 }
00245
00246 template<class View>
00247 forceinline ModEventDelta
00248 OffsetSetView<View>::med(ModEvent me) {
00249 return View::med(me);
00250 }
00251
00252 template<class View>
00253 forceinline void
00254 OffsetSetView<View>::update(Space& home, bool share, OffsetSetView& y) {
00255 k = y.k;
00256 view.update(home,share,y.view);
00257 }
00258
00259
00260
00261
00262
00263
00264
00265 template<class View>
00266 forceinline ModEvent
00267 OffsetSetView<View>::modevent(const Delta& d) {
00268 return View::modevent(d);
00269 }
00270
00271 template<class View>
00272 forceinline int
00273 OffsetSetView<View>::glbMin(const Delta& d) const {
00274 return view.glbMin(d)+k;
00275 }
00276
00277 template<class View>
00278 forceinline int
00279 OffsetSetView<View>::glbMax(const Delta& d) const {
00280 return view.glbMax(d)+k;
00281 }
00282
00283 template<class View>
00284 forceinline bool
00285 OffsetSetView<View>::glbAny(const Delta& d) const {
00286 return view.glbAny(d);
00287 }
00288
00289 template<class View>
00290 forceinline int
00291 OffsetSetView<View>::lubMin(const Delta& d) const {
00292 return view.lubMin(d)+k;
00293 }
00294
00295 template<class View>
00296 forceinline int
00297 OffsetSetView<View>::lubMax(const Delta& d) const {
00298 return view.lubMax(d)+k;
00299 }
00300
00301 template<class View>
00302 forceinline bool
00303 OffsetSetView<View>::lubAny(const Delta& d) const {
00304 return view.lubAny(d);
00305 }
00306
00311 template<class View>
00312 class LubRanges<OffsetSetView<View> > : public Iter::Ranges::Offset<LubRanges<View> > {
00313 private:
00314 LubRanges<View> ub;
00315 Iter::Ranges::Offset<LubRanges<View> > ubo;
00316 public:
00318
00319
00320 LubRanges(void) {}
00322 LubRanges(const OffsetSetView<View>& x);
00324 void init(const OffsetSetView<View>& x);
00325
00327
00328
00329 bool operator ()(void) const;
00331 void operator ++(void);
00333
00335
00336
00337 int min(void) const;
00339 int max(void) const;
00341 unsigned int width(void) const;
00343 };
00344
00345 template<class View>
00346 forceinline
00347 LubRanges<OffsetSetView<View> >::LubRanges(const OffsetSetView<View>& s)
00348 : ub(s.base()), ubo(ub, s.offset()) {}
00349
00350 template<class View>
00351 forceinline void
00352 LubRanges<OffsetSetView<View> >::init(const OffsetSetView<View>& s) {
00353 ub.init(s.base());
00354 ubo.init(ub, s.offset());
00355 }
00356
00357 template<class View>
00358 forceinline bool
00359 LubRanges<OffsetSetView<View> >::operator ()(void) const { return ubo(); }
00360
00361 template<class View>
00362 forceinline void
00363 LubRanges<OffsetSetView<View> >::operator ++(void) { return ++ubo; }
00364
00365 template<class View>
00366 forceinline int
00367 LubRanges<OffsetSetView<View> >::min(void) const { return ubo.min(); }
00368
00369 template<class View>
00370 forceinline int
00371 LubRanges<OffsetSetView<View> >::max(void) const { return ubo.max(); }
00372
00373 template<class View>
00374 forceinline unsigned int
00375 LubRanges<OffsetSetView<View> >::width(void) const { return ubo.width(); }
00376
00377
00382 template<class View>
00383 class GlbRanges<OffsetSetView<View> > {
00384 private:
00385 GlbRanges<View> lb;
00386 Iter::Ranges::Offset<GlbRanges<View> > lbo;
00387 public:
00389
00390
00391 GlbRanges(void) {}
00393 GlbRanges(const OffsetSetView<View> & x);
00395 void init(const OffsetSetView<View> & x);
00396
00398
00399
00400 bool operator ()(void) const;
00402 void operator ++(void);
00404
00406
00407
00408 int min(void) const;
00410 int max(void) const;
00412 unsigned int width(void) const;
00414 };
00415
00416 template<class View>
00417 forceinline
00418 GlbRanges<OffsetSetView<View> >::GlbRanges(const OffsetSetView<View> & s)
00419 : lb(s.base()), lbo(lb, s.offset()) {}
00420
00421 template<class View>
00422 forceinline void
00423 GlbRanges<OffsetSetView<View> >::init(const OffsetSetView<View> & s) {
00424 lb.init(s.base());
00425 lbo.init(lb, s.offset());
00426 }
00427
00428 template<class View>
00429 forceinline bool
00430 GlbRanges<OffsetSetView<View> >::operator ()(void) const { return lbo(); }
00431
00432 template<class View>
00433 forceinline void
00434 GlbRanges<OffsetSetView<View> >::operator ++(void) { return ++lbo; }
00435
00436 template<class View>
00437 forceinline int
00438 GlbRanges<OffsetSetView<View> >::min(void) const { return lbo.min(); }
00439
00440 template<class View>
00441 forceinline int
00442 GlbRanges<OffsetSetView<View> >::max(void) const { return lbo.max(); }
00443
00444 template<class View>
00445 forceinline unsigned int
00446 GlbRanges<OffsetSetView<View> >::width(void) const { return lbo.width(); }
00447
00448 template<class Char, class Traits, class View>
00449 std::basic_ostream<Char,Traits>&
00450 operator <<(std::basic_ostream<Char,Traits>& os,
00451 const OffsetSetView<View>& x) {
00452 std::basic_ostringstream<Char,Traits> s;
00453 s.copyfmt(os); s.width(0);
00454 s << "(" << x.base() << ")+"<<x.offset();
00455 return os << s.str();
00456 }
00457
00458 }
00459
00460
00461
00462
00463
00464
00465 template<class View>
00466 forceinline bool
00467 same(const Set::OffsetSetView<View>& x,
00468 const Set::OffsetSetView<View>& y) {
00469 return same(x.base(),y.base());
00470 }
00471 template<class View>
00472 forceinline bool
00473 before(const Set::OffsetSetView<View>& x,
00474 const Set::OffsetSetView<View>& y) {
00475 return before(x.base(),y.base());
00476 }
00477
00478 }
00479
00480