Generated on Mon May 10 06:46:41 2010 for Gecode by doxygen 1.6.3

minus.hpp

Go to the documentation of this file.
00001 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
00002 /*
00003  *  Main authors:
00004  *     Christian Schulte <schulte@gecode.org>
00005  *
00006  *  Copyright:
00007  *     Christian Schulte, 2003
00008  *
00009  *  Last modified:
00010  *     $Date: 2009-11-04 17:06:58 +0100 (Wed, 04 Nov 2009) $ by $Author: tack $
00011  *     $Revision: 10046 $
00012  *
00013  *  This file is part of Gecode, the generic constraint
00014  *  development environment:
00015  *     http://www.gecode.org
00016  *
00017  *  Permission is hereby granted, free of charge, to any person obtaining
00018  *  a copy of this software and associated documentation files (the
00019  *  "Software"), to deal in the Software without restriction, including
00020  *  without limitation the rights to use, copy, modify, merge, publish,
00021  *  distribute, sublicense, and/or sell copies of the Software, and to
00022  *  permit persons to whom the Software is furnished to do so, subject to
00023  *  the following conditions:
00024  *
00025  *  The above copyright notice and this permission notice shall be
00026  *  included in all copies or substantial portions of the Software.
00027  *
00028  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
00029  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
00030  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
00031  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
00032  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
00033  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
00034  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00035  *
00036  */
00037 
00038 namespace Gecode {
00039 
00040   namespace Int {
00041 
00042     /*
00043      * Constructors and initialization
00044      *
00045      */
00046     forceinline
00047     MinusView::MinusView(void) {}
00048     forceinline
00049     MinusView::MinusView(const IntView& x)
00050       : DerivedViewBase<IntView>(x) {}
00051     forceinline void
00052     MinusView::init(const IntView& x) {
00053       view = x;
00054     }
00055 
00056 
00057     /*
00058      * Value access
00059      *
00060      */
00061     forceinline int
00062     MinusView::min(void) const {
00063       return -view.max();
00064     }
00065     forceinline int
00066     MinusView::max(void) const {
00067       return -view.min();
00068     }
00069     forceinline int
00070     MinusView::val(void) const {
00071       return -view.val();
00072     }
00073 
00074     forceinline unsigned int
00075     MinusView::width(void) const {
00076       return view.width();
00077     }
00078     forceinline unsigned int
00079     MinusView::size(void) const {
00080       return view.size();
00081     }
00082     forceinline unsigned int
00083     MinusView::regret_min(void) const {
00084       return view.regret_max();
00085     }
00086     forceinline unsigned int
00087     MinusView::regret_max(void) const {
00088       return view.regret_min();
00089     }
00090 
00091 
00092     /*
00093      * Domain tests
00094      *
00095      */
00096     forceinline bool
00097     MinusView::range(void) const {
00098       return view.range();
00099     }
00100     forceinline bool
00101     MinusView::assigned(void) const {
00102       return view.assigned();
00103     }
00104     forceinline bool
00105     MinusView::in(int n) const {
00106       return view.in(-n);
00107     }
00108     forceinline bool
00109     MinusView::in(double n) const {
00110       return view.in(-n);
00111     }
00112 
00113 
00114     /*
00115      * Domain update by value
00116      *
00117      */
00118     forceinline ModEvent
00119     MinusView::lq(Space& home, int n) {
00120       return view.gq(home,-n);
00121     }
00122     forceinline ModEvent
00123     MinusView::lq(Space& home, double n) {
00124       return view.gq(home,-n);
00125     }
00126     forceinline ModEvent
00127     MinusView::le(Space& home, int n) {
00128       return view.gr(home,-n);
00129     }
00130     forceinline ModEvent
00131     MinusView::le(Space& home, double n) {
00132       return view.gr(home,-n);
00133     }
00134     forceinline ModEvent
00135     MinusView::gq(Space& home, int n) {
00136       return view.lq(home,-n);
00137     }
00138     forceinline ModEvent
00139     MinusView::gq(Space& home, double n) {
00140       return view.lq(home,-n);
00141     }
00142     forceinline ModEvent
00143     MinusView::gr(Space& home, int n) {
00144       return view.le(home,-n);
00145     }
00146     forceinline ModEvent
00147     MinusView::gr(Space& home, double n) {
00148       return view.le(home,-n);
00149     }
00150     forceinline ModEvent
00151     MinusView::nq(Space& home, int n) {
00152       return view.nq(home,-n);
00153     }
00154     forceinline ModEvent
00155     MinusView::nq(Space& home, double n) {
00156       return view.nq(home,-n);
00157     }
00158     forceinline ModEvent
00159     MinusView::eq(Space& home, int n) {
00160       return view.eq(home,-n);
00161     }
00162     forceinline ModEvent
00163     MinusView::eq(Space& home, double n) {
00164       return view.eq(home,-n);
00165     }
00166 
00167 
00168     /*
00169      * Iterator-based domain update
00170      *
00171      */
00172     template<class I>
00173     forceinline ModEvent
00174     MinusView::narrow_r(Space& home, I& i, bool) {
00175       Iter::Ranges::Minus<I> mi(i);
00176       return view.narrow_r(home,mi,false);
00177     }
00178     template<class I>
00179     forceinline ModEvent
00180     MinusView::inter_r(Space& home, I& i, bool) {
00181       Iter::Ranges::Minus<I> mi(i);
00182       return view.inter_r(home,mi,false);
00183     }
00184     template<class I>
00185     forceinline ModEvent
00186     MinusView::minus_r(Space& home, I& i, bool) {
00187       Iter::Ranges::Minus<I> mi(i);
00188       return view.minus_r(home,mi,false);
00189     }
00190     template<class I>
00191     forceinline ModEvent
00192     MinusView::narrow_v(Space& home, I& i, bool) {
00193       Iter::Values::Minus<I> mi(i);
00194       return view.narrow_v(home,mi,false);
00195     }
00196     template<class I>
00197     forceinline ModEvent
00198     MinusView::inter_v(Space& home, I& i, bool) {
00199       Iter::Values::Minus<I> mi(i);
00200       return view.inter_v(home,mi,false);
00201     }
00202     template<class I>
00203     forceinline ModEvent
00204     MinusView::minus_v(Space& home, I& i, bool) {
00205       Iter::Values::Minus<I> mi(i);
00206       return view.minus_v(home,mi,false);
00207     }
00208 
00209 
00210     /*
00211      * Propagator modification events
00212      *
00213      */
00214     forceinline void
00215     MinusView::schedule(Space& home, Propagator& p, ModEvent me) {
00216       return IntView::schedule(home,p,me);
00217     }
00218     forceinline ModEvent
00219     MinusView::me(const ModEventDelta& med) {
00220       return IntView::me(med);
00221     }
00222     forceinline ModEventDelta
00223     MinusView::med(ModEvent me) {
00224       return IntView::med(me);
00225     }
00226 
00227 
00228     /*
00229      * Dependencies
00230      *
00231      */
00232     forceinline void
00233     MinusView::subscribe(Space& home, Propagator& p, PropCond pc,
00234                          bool process) {
00235       view.subscribe(home,p,pc,process);
00236     }
00237     forceinline void
00238     MinusView::cancel(Space& home, Propagator& p, PropCond pc) {
00239       view.cancel(home,p,pc);
00240     }
00241     forceinline void
00242     MinusView::subscribe(Space& home, Advisor& a) {
00243       view.subscribe(home,a);
00244     }
00245     forceinline void
00246     MinusView::cancel(Space& home, Advisor& a) {
00247       view.cancel(home,a);
00248     }
00249 
00250 
00251     /*
00252      * Delta information for advisors
00253      *
00254      */
00255     forceinline ModEvent
00256     MinusView::modevent(const Delta& d) {
00257       return IntView::modevent(d);
00258     }
00259     forceinline int
00260     MinusView::min(const Delta& d) const {
00261       return -view.max(d);
00262     }
00263     forceinline int
00264     MinusView::max(const Delta& d) const {
00265       return -view.min(d);
00266     }
00267     forceinline bool
00268     MinusView::any(const Delta& d) const {
00269       return view.any(d);
00270     }
00271 
00272 
00273 
00274     /*
00275      * Cloning
00276      *
00277      */
00278 
00279     forceinline void
00280     MinusView::update(Space& home, bool share, MinusView& x) {
00281       view.update(home,share,x.view);
00282     }
00283 
00284 
00289     template<>
00290     class ViewRanges<MinusView> : public IntVarImpBwd {
00291     public:
00293 
00294 
00295       ViewRanges(void);
00297       ViewRanges(const MinusView& x);
00299       void init(const MinusView& x);
00301 
00303 
00304 
00305       int min(void) const;
00307       int max(void) const;
00309     };
00310 
00311     forceinline
00312     ViewRanges<MinusView>::ViewRanges(void) {}
00313 
00314     forceinline
00315     ViewRanges<MinusView>::ViewRanges(const MinusView& x)
00316       : IntVarImpBwd(x.base().var()) {}
00317 
00318     forceinline void
00319     ViewRanges<MinusView>::init(const MinusView& x) {
00320       IntVarImpBwd::init(x.base().var());
00321     }
00322 
00323     forceinline int
00324     ViewRanges<MinusView>::min(void) const {
00325       return -IntVarImpBwd::max();
00326     }
00327     forceinline int
00328     ViewRanges<MinusView>::max(void) const {
00329       return -IntVarImpBwd::min();
00330     }
00331 
00332     inline int
00333     MinusView::med(void) const {
00334       if (view.range())
00335         return (min()+max())/2 - ((min()+max())%2 < 0 ? 1 : 0);
00336 
00337       unsigned int i = view.size() / 2;
00338       if (size() % 2 == 0)
00339         i--;
00340       ViewRanges<MinusView> r(*this);
00341       while (i >= r.width()) {
00342         i -= r.width();
00343         ++r;
00344       }
00345       return r.min() + static_cast<int>(i);
00346     }
00347 
00348   }
00349 
00350 
00351   /*
00352    * View comparison
00353    *
00354    */
00355   forceinline bool
00356   same(const Int::MinusView& x, const Int::MinusView& y) {
00357     return same(x.base(),y.base());
00358   }
00359   forceinline bool
00360   before(const Int::MinusView& x, const Int::MinusView& y) {
00361     return before(x.base(),y.base());
00362   }
00363 
00364 }
00365 
00366 // STATISTICS: int-var
00367