Generated on Thu Jul 6 07:06:47 2006 for Gecode by doxygen 1.4.7

minus.icc

Go to the documentation of this file.
00001 /*
00002  *  Main authors:
00003  *     Christian Schulte <schulte@gecode.org>
00004  *
00005  *  Copyright:
00006  *     Christian Schulte, 2003
00007  *
00008  *  Last modified:
00009  *     $Date: 2006-05-23 17:20:37 +0200 (Tue, 23 May 2006) $ by $Author: schulte $
00010  *     $Revision: 3236 $
00011  *
00012  *  This file is part of Gecode, the generic constraint
00013  *  development environment:
00014  *     http://www.gecode.org
00015  *
00016  *  See the file "LICENSE" for information on usage and
00017  *  redistribution of this file, and for a
00018  *     DISCLAIMER OF ALL WARRANTIES.
00019  *
00020  */
00021 
00022 namespace Gecode { 
00023 
00024   namespace Int {
00025 
00026     /*
00027      * Constructors and initialization
00028      *
00029      */
00030     forceinline
00031     MinusView::MinusView(void) {}
00032     forceinline
00033     MinusView::MinusView(const IntView& x)
00034       : DerivedViewBase<IntView>(x) {}
00035     forceinline void
00036     MinusView::init(const IntView& x) {
00037       view = x;
00038     }
00039 
00040 
00041 
00042     /*
00043      * Value access
00044      *
00045      */
00046     forceinline int
00047     MinusView::min(void) const { 
00048       return -view.max(); 
00049     }
00050     forceinline int
00051     MinusView::max(void) const { 
00052       return -view.min(); 
00053     }
00054     forceinline int
00055     MinusView::med(void) const { 
00056       return -view.med(); 
00057     }
00058     forceinline int
00059     MinusView::val(void) const { 
00060       return -view.val(); 
00061     }
00062 
00063     forceinline unsigned int
00064     MinusView::width(void) const { 
00065       return view.width(); 
00066     }
00067     forceinline unsigned int
00068     MinusView::size(void) const { 
00069       return view.size(); 
00070     }
00071     forceinline unsigned int
00072     MinusView::regret_min(void) const { 
00073       return view.regret_max(); 
00074     }
00075     forceinline unsigned int
00076     MinusView::regret_max(void) const { 
00077       return view.regret_min(); 
00078     }
00079 
00080 
00081     /*
00082      * Domain tests
00083      *
00084      */
00085     forceinline bool
00086     MinusView::range(void) const { 
00087       return view.range(); 
00088     }
00089     forceinline bool
00090     MinusView::assigned(void) const { 
00091       return view.assigned(); 
00092     }
00093     forceinline bool
00094     MinusView::in(int n) const { 
00095       return view.in(-n); 
00096     }
00097     forceinline bool
00098     MinusView::in(double n) const { 
00099       return view.in(-n); 
00100     }
00101 
00102 
00103     /*
00104      * Domain update by value
00105      *
00106      */
00107     forceinline ModEvent
00108     MinusView::lq(Space* home, int n) { 
00109       return view.gq(home,-n); 
00110     }
00111     forceinline ModEvent
00112     MinusView::lq(Space* home, double n) { 
00113       return view.gq(home,-n); 
00114     }
00115     forceinline ModEvent
00116     MinusView::le(Space* home, int n) { 
00117       return view.gr(home,-n); 
00118     }
00119     forceinline ModEvent
00120     MinusView::le(Space* home, double n) { 
00121       return view.gr(home,-n); 
00122     }
00123     forceinline ModEvent
00124     MinusView::gq(Space* home, int n) { 
00125       return view.lq(home,-n); 
00126     }
00127     forceinline ModEvent
00128     MinusView::gq(Space* home, double n) { 
00129       return view.lq(home,-n); 
00130     }
00131     forceinline ModEvent
00132     MinusView::gr(Space* home, int n) { 
00133       return view.le(home,-n); 
00134     }
00135     forceinline ModEvent
00136     MinusView::gr(Space* home, double n) { 
00137       return view.le(home,-n); 
00138     }
00139     forceinline ModEvent
00140     MinusView::nq(Space* home, int n) { 
00141       return view.nq(home,-n); 
00142     }
00143     forceinline ModEvent
00144     MinusView::nq(Space* home, double n) { 
00145       return view.nq(home,-n); 
00146     }
00147     forceinline ModEvent
00148     MinusView::eq(Space* home, int n) { 
00149       return view.eq(home,-n); 
00150     }
00151     forceinline ModEvent
00152     MinusView::eq(Space* home, double n) { 
00153       return view.eq(home,-n); 
00154     }
00155 
00156 
00157 
00158     /*
00159      * Domain update by range iterator
00160      *
00161      */
00162     template <class I>
00163     ModEvent
00164     MinusView::narrow(Space* home, I& i) {
00165       Iter::Ranges::Minus<I> mi(i); return view.narrow(home,mi);
00166     }
00167     template <class I>
00168     ModEvent
00169     MinusView::inter(Space* home, I& i) {
00170       Iter::Ranges::Minus<I> mi(i); return view.inter(home,mi);
00171     }
00172     template <class I>
00173     ModEvent
00174     MinusView::minus(Space* home, I& i) {
00175       Iter::Ranges::Minus<I> mi(i); return view.minus(home,mi);
00176     }
00177 
00178 
00179     /*
00180      * Propagator modification events
00181      *
00182      */
00183     forceinline ModEvent
00184     MinusView::pme(const Propagator* p) {
00185       return IntView::pme(p);
00186     }
00187     forceinline PropModEvent
00188     MinusView::pme(ModEvent me) {
00189       return IntView::pme(me);
00190     }
00191 
00192 
00193     /*
00194      * Dependencies
00195      *
00196      */
00197     forceinline void
00198     MinusView::subscribe(Space* home, Propagator* p, PropCond pc) {
00199       view.subscribe(home,p,pc);
00200     }
00201     forceinline void
00202     MinusView::cancel(Space* home, Propagator* p, PropCond pc) {
00203       view.cancel(home,p,pc);
00204     }
00205 
00206 
00207     /*
00208      * Cloning
00209      *
00210      */
00211 
00212     forceinline void
00213     MinusView::update(Space* home, bool share, MinusView& x) {
00214       view.update(home,share,x.view);
00215     }
00216 
00217 
00222     template <>
00223     class ViewRanges<MinusView> : public IntVarImpBwd {
00224     public:
00226 
00227 
00228       ViewRanges(void);
00230       ViewRanges(const MinusView& x);
00232       void init(const MinusView& x);
00234 
00236 
00237 
00238       int min(void) const;
00240       int max(void) const;
00242     };
00243 
00244     forceinline
00245     ViewRanges<MinusView>::ViewRanges(void) {}
00246 
00247     forceinline
00248     ViewRanges<MinusView>::ViewRanges(const MinusView& x)
00249       : IntVarImpBwd(x.base().variable()) {}
00250 
00251     forceinline void
00252     ViewRanges<MinusView>::init(const MinusView& x) {
00253       IntVarImpBwd::init(x.base().variable());
00254     }
00255 
00256     forceinline int
00257     ViewRanges<MinusView>::min(void) const {
00258       return -IntVarImpBwd::max();
00259     }
00260     forceinline int
00261     ViewRanges<MinusView>::max(void) const {
00262       return -IntVarImpBwd::min();
00263     }
00264 
00265   }
00266 
00267 
00268   /*
00269    * View comparison
00270    *
00271    */
00272   forceinline bool
00273   same(const Int::MinusView& x, const Int::MinusView& y) {
00274     return same(x.base(),y.base());
00275   }
00276   forceinline bool
00277   before(const Int::MinusView& x, const Int::MinusView& y) {
00278     return before(x.base(),y.base());
00279   }
00280 
00281 }
00282 
00283 // STATISTICS: int-var
00284