gecode » set » view
offset.hpp

00001 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
00002 /*
00003  *  Main authors:
00004  *     Guido Tack <tack@gecode.org>
00005  *
00006  *  Contributing authors:
00007  *     Christian Schulte <schulte@gecode.org>
00008  *
00009  *  Copyright:
00010  *     Guido Tack, 2004, 2006
00011  *     Christian Schulte, 2004
00012  *
00013  *  Last modified:
00014  *     $Date: 2009-09-08 21:10:29 +0200 (Tue, 08 Sep 2009) $ by $Author: schulte $
00015  *     $Revision: 9692 $
00016  *
00017  *  This file is part of Gecode, the generic constraint
00018  *  development environment:
00019  *     http://www.gecode.org
00020  *
00021  *  Permission is hereby granted, free of charge, to any person obtaining
00022  *  a copy of this software and associated documentation files (the
00023  *  "Software"), to deal in the Software without restriction, including
00024  *  without limitation the rights to use, copy, modify, merge, publish,
00025  *  distribute, sublicense, and/or sell copies of the Software, and to
00026  *  permit persons to whom the Software is furnished to do so, subject to
00027  *  the following conditions:
00028  *
00029  *  The above copyright notice and this permission notice shall be
00030  *  included in all copies or substantial portions of the Software.
00031  *
00032  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
00033  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
00034  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
00035  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
00036  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
00037  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
00038  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
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      * Delta information for advisors
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    * Testing
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 // STATISTICS: set-var