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 namespace Gecode {
00043
00044 namespace Set {
00045
00046 forceinline
00047 SingletonView::SingletonView(void) {}
00048
00049 forceinline
00050 SingletonView::SingletonView(Gecode::Int::IntView& i0)
00051 : DerivedViewBase<Gecode::Int::IntView>(i0) {}
00052
00053 forceinline PropCond
00054 SingletonView::pc_settoint(PropCond pc) {
00055 switch(pc) {
00056 case PC_SET_VAL:
00057 case PC_SET_CGLB:
00058 case PC_SET_CARD:
00059 return Gecode::Int::PC_INT_VAL;
00060 default:
00061 return Gecode::Int::PC_INT_DOM;
00062 }
00063 }
00064
00065 forceinline ModEvent
00066 SingletonView::me_inttoset(ModEvent me) {
00067 switch(me) {
00068 case Gecode::Int::ME_INT_FAILED:
00069 return ME_SET_FAILED;
00070 case Gecode::Int::ME_INT_NONE:
00071 return ME_SET_NONE;
00072 case Gecode::Int::ME_INT_VAL:
00073 return ME_SET_VAL;
00074 case Gecode::Int::ME_INT_DOM:
00075 return ME_SET_LUB;
00076 default:
00077 return ME_SET_LUB;
00078 }
00079 }
00080
00081 forceinline ModEvent
00082 SingletonView::me_settoint(ModEvent me) {
00083 switch(me) {
00084 case ME_SET_FAILED:
00085 return Gecode::Int::ME_INT_FAILED;
00086 case ME_SET_NONE:
00087 return Gecode::Int::ME_INT_NONE;
00088 case ME_SET_VAL:
00089 return Gecode::Int::ME_INT_VAL;
00090 default:
00091 return Gecode::Int::ME_INT_DOM;
00092 }
00093 }
00094
00095 forceinline bool
00096 SingletonView::assigned(void) const { return view.assigned(); }
00097
00098 forceinline unsigned int
00099 SingletonView::glbSize(void) const {
00100 return view.assigned() ? 1U : 0U;
00101 }
00102
00103 forceinline unsigned int
00104 SingletonView::lubSize(void) const { return view.size(); }
00105
00106 forceinline unsigned int
00107 SingletonView::unknownSize(void) const {
00108 return lubSize() - glbSize();
00109 }
00110
00111 forceinline bool
00112 SingletonView::contains(int n) const { return view.assigned() ?
00113 (view.val()==n) : false; }
00114
00115 forceinline bool
00116 SingletonView::notContains(int n) const { return !view.in(n); }
00117
00118 forceinline unsigned int
00119 SingletonView::cardMin() const { return 1; }
00120
00121 forceinline unsigned int
00122 SingletonView::cardMax() const { return 1; }
00123
00124 forceinline int
00125 SingletonView::lubMin() const { return view.min(); }
00126
00127 forceinline int
00128 SingletonView::lubMax() const { return view.max(); }
00129
00130 forceinline int
00131 SingletonView::glbMin() const { return view.assigned() ?
00132 view.val() : BndSet::MIN_OF_EMPTY; }
00133
00134 forceinline int
00135 SingletonView::glbMax() const { return view.assigned() ?
00136 view.val() : BndSet::MAX_OF_EMPTY; }
00137
00138 forceinline ModEvent
00139 SingletonView::cardMin(Space&, unsigned int c) {
00140 return c<=1 ? ME_SET_NONE : ME_SET_FAILED;
00141 }
00142
00143 forceinline ModEvent
00144 SingletonView::cardMax(Space&, unsigned int c) {
00145 return c<1 ? ME_SET_FAILED : ME_SET_NONE;
00146 }
00147
00148 forceinline ModEvent
00149 SingletonView::include(Space& home,int c) {
00150 return me_inttoset(view.eq(home,c));
00151 }
00152
00153 forceinline ModEvent
00154 SingletonView::intersect(Space& home,int c) {
00155 return me_inttoset(view.eq(home,c));
00156 }
00157
00158 forceinline ModEvent
00159 SingletonView::intersect(Space& home,int i, int j) {
00160 ModEvent me1 = me_inttoset(view.gq(home,i));
00161 ModEvent me2 = me_inttoset(view.lq(home,j));
00162 if (me_failed(me1) || me_failed(me2))
00163 return ME_SET_FAILED;
00164 switch (me1) {
00165 case ME_SET_NONE:
00166 case ME_SET_LUB:
00167 return me2;
00168 case ME_SET_VAL:
00169 return ME_SET_VAL;
00170 default:
00171 GECODE_NEVER;
00172 return ME_SET_VAL;
00173 }
00174 }
00175
00176 forceinline ModEvent
00177 SingletonView::exclude(Space& home,int c) {
00178 return me_inttoset(view.nq(home,c));
00179 }
00180
00181 forceinline ModEvent
00182 SingletonView::include(Space& home, int j, int k) {
00183 return j==k ? me_inttoset(view.eq(home,j)) : ME_SET_FAILED ;
00184 }
00185
00186 forceinline ModEvent
00187 SingletonView::exclude(Space& home, int j, int k) {
00188 ModEvent me1 = me_inttoset(view.gr(home,j));
00189 ModEvent me2 = me_inttoset(view.le(home,k));
00190 if (me_failed(me1) || me_failed(me2))
00191 return ME_SET_FAILED;
00192 switch (me1) {
00193 case ME_SET_NONE:
00194 case ME_SET_LUB:
00195 return me2;
00196 case ME_SET_VAL:
00197 return ME_SET_VAL;
00198 default:
00199 GECODE_NEVER;
00200 return ME_SET_VAL;
00201 }
00202 }
00203
00204 template<class I> ModEvent
00205 SingletonView::excludeI(Space& home, I& iter) {
00206 return me_inttoset(view.minus_r(home,iter));
00207 }
00208
00209 template<class I> ModEvent
00210 SingletonView::includeI(Space& home, I& iter) {
00211 Iter::Ranges::IsRangeIter<I>();
00212 if (!iter())
00213 return ME_SET_NONE;
00214
00215 if (iter.min()!=iter.max())
00216 return ME_SET_FAILED;
00217
00218 int val = iter.min();
00219 ++iter;
00220 if ( iter() )
00221 return ME_SET_FAILED;
00222
00223 return me_inttoset(view.eq(home, val));
00224 }
00225
00226 template<class I> ModEvent
00227 SingletonView::intersectI(Space& home, I& iter) {
00228 return me_inttoset(view.inter_r(home,iter));
00229 }
00230
00231 forceinline void
00232 SingletonView::subscribe(Space& home, Propagator& p, PropCond pc,
00233 bool process) {
00234 view.subscribe(home,p,pc_settoint(pc),process);
00235 }
00236 forceinline void
00237 SingletonView::cancel(Space& home, Propagator& p, PropCond pc) {
00238 view.cancel(home,p,pc_settoint(pc));
00239 }
00240
00241 forceinline void
00242 SingletonView::subscribe(Space& home, Advisor& a) {
00243 view.subscribe(home,a);
00244 }
00245 forceinline void
00246 SingletonView::cancel(Space& home, Advisor& a) {
00247 view.cancel(home,a);
00248 }
00249
00250
00251 forceinline void
00252 SingletonView::schedule(Space& home, Propagator& p, ModEvent me) {
00253 return Gecode::Int::IntView::schedule(home,p,me_settoint(me));
00254 }
00255 forceinline ModEvent
00256 SingletonView::me(const ModEventDelta& med) {
00257 return me_inttoset(Int::IntView::me(med));
00258 }
00259 forceinline ModEventDelta
00260 SingletonView::med(ModEvent me) {
00261 return SetView::med(me_settoint(me));
00262 }
00263
00264 forceinline void
00265 SingletonView::update(Space& home, bool share, SingletonView& y) {
00266 view.update(home,share,y.view);
00267 }
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278 forceinline ModEvent
00279 SingletonView::modevent(const Delta& d) {
00280 return me_inttoset(Int::IntView::modevent(d));
00281 }
00282
00283 forceinline int
00284 SingletonView::glbMin(const Delta& d) const { return view.min(d); }
00285
00286 forceinline int
00287 SingletonView::glbMax(const Delta& d) const { return view.max(d); }
00288
00289 forceinline bool
00290 SingletonView::glbAny(const Delta& d) const { return view.any(d); }
00291
00292 forceinline int
00293 SingletonView::lubMin(const Delta& d) const { return view.min(d); }
00294
00295 forceinline int
00296 SingletonView::lubMax(const Delta& d) const { return view.max(d); }
00297
00298 forceinline bool
00299 SingletonView::lubAny(const Delta& d) const { return view.any(d); }
00300
00301
00302
00303
00304
00305
00310 template<>
00311 class LubRanges<SingletonView> : public Gecode::Int::IntVarImpFwd {
00312 public:
00314
00315
00316 LubRanges(void);
00318 LubRanges(const SingletonView& x);
00320 void init(const SingletonView& x);
00322 };
00323
00324 forceinline
00325 LubRanges<SingletonView>::LubRanges(void) {}
00326
00327 forceinline
00328 LubRanges<SingletonView>::LubRanges(const SingletonView& s) :
00329 Gecode::Int::IntVarImpFwd(s.base().var()) {}
00330
00331 forceinline void
00332 LubRanges<SingletonView>::init(const SingletonView& s) {
00333 Gecode::Int::IntVarImpFwd::init(s.base().var());
00334 }
00335
00340 template<>
00341 class GlbRanges<SingletonView> {
00342 private:
00343 int val;
00344 bool flag;
00345 public:
00347
00348
00349 GlbRanges(void);
00351 GlbRanges(const SingletonView& x);
00353 void init(const SingletonView& x);
00354
00356
00357
00358 bool operator ()(void) const;
00360 void operator ++(void);
00362
00364
00365
00366 int min(void) const;
00368 int max(void) const;
00370 unsigned int width(void) const;
00372 };
00373
00374 forceinline
00375 GlbRanges<SingletonView>::GlbRanges(void) {}
00376
00377 forceinline void
00378 GlbRanges<SingletonView>::init(const SingletonView& s) {
00379 if (s.base().assigned()) {
00380 val = s.base().val();
00381 flag = true;
00382 } else {
00383 val = 0;
00384 flag = false;
00385 }
00386 }
00387
00388 forceinline
00389 GlbRanges<SingletonView>::GlbRanges(const SingletonView& s) {
00390 init(s);
00391 }
00392
00393 forceinline bool
00394 GlbRanges<SingletonView>::operator ()(void) const { return flag; }
00395
00396 forceinline void
00397 GlbRanges<SingletonView>::operator ++(void) { flag=false; }
00398
00399 forceinline int
00400 GlbRanges<SingletonView>::min(void) const { return val; }
00401 forceinline int
00402 GlbRanges<SingletonView>::max(void) const { return val; }
00403 forceinline unsigned int
00404 GlbRanges<SingletonView>::width(void) const { return 1; }
00405
00406 }
00407
00408
00409
00410
00411
00412 forceinline bool
00413 same(const Set::SingletonView& x, const Set::SingletonView& y) {
00414 return same(x.base(),y.base());
00415 }
00416 forceinline bool
00417 before(const Set::SingletonView& x, const Set::SingletonView& y) {
00418 return before(x.base(),y.base());
00419 }
00420
00421
00422 }
00423
00424
00425