gecode » int » view
scale.hpp

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, 2002
00008  *
00009  *  Last modified:
00010  *     $Date: 2009-09-08 21:10:29 +0200 (Tue, 08 Sep 2009) $ by $Author: schulte $
00011  *     $Revision: 9692 $
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      * Support functions for division
00044      *
00045      */
00046     template<class Val, class UnsVal>
00047     forceinline int
00048     ScaleView<Val,UnsVal>::floor_div(double x) const {
00049       return static_cast<int>(floor(x / a));
00050     }
00051 
00052     template<class Val, class UnsVal>
00053     forceinline int
00054     ScaleView<Val,UnsVal>::ceil_div(double x) const {
00055       return static_cast<int>(ceil(x / a));
00056     }
00057 
00058     template<class Val, class UnsVal>
00059     forceinline int
00060     ScaleView<Val,UnsVal>::exact_div(double x, bool& exact) const {
00061       double xa = x / a;
00062       if (ceil(xa) == xa) {
00063         exact = true;  return static_cast<int>(xa);
00064       } else {
00065         exact = false; return 0;
00066       }
00067     }
00068 
00069 #if GECODE_INT_RND_TWDS_ZERO
00070 
00071     template<class Val, class UnsVal>
00072     forceinline int
00073     ScaleView<Val,UnsVal>::floor_div(int x) const {
00074       return ((x >= 0) ? x : (x-a+1))/a;
00075     }
00076 
00077     template<class Val, class UnsVal>
00078     forceinline int
00079     ScaleView<Val,UnsVal>::ceil_div(int x) const {
00080       return ((x >= 0) ? (x+a-1) : x)/a;
00081     }
00082 
00083     template<class Val, class UnsVal>
00084     forceinline int
00085     ScaleView<Val,UnsVal>::exact_div(int x, bool& exact) const {
00086       int xa = x / a;
00087       if (a * xa == x) {
00088         exact = true;  return xa;
00089       } else {
00090         exact = false; return 0;
00091       }
00092     }
00093 
00094 #endif
00095 
00096 
00097     /*
00098      * Constructors and initialization
00099      *
00100      */
00101     template<class Val, class UnsVal>
00102     forceinline
00103     ScaleView<Val,UnsVal>::ScaleView(void) {}
00104 
00105     template<class Val, class UnsVal>
00106     forceinline
00107     ScaleView<Val,UnsVal>::ScaleView(int b, const IntView& x)
00108       : DerivedViewBase<IntView>(x), a(b) {}
00109 
00110     template<class Val, class UnsVal>
00111     forceinline void
00112     ScaleView<Val,UnsVal>::init(int b, const IntView& x) {
00113       view=x; a=b;
00114     }
00115 
00116     template<class Val, class UnsVal>
00117     forceinline int
00118     ScaleView<Val,UnsVal>::scale(void) const {
00119       return a;
00120     }
00121 
00122 
00123 
00124     /*
00125      * Value access
00126      *
00127      */
00128     template<class Val, class UnsVal>
00129     forceinline Val
00130     ScaleView<Val,UnsVal>::min(void) const {
00131       Val c = view.min(); c *= a; return c;
00132     }
00133 
00134     template<class Val, class UnsVal>
00135     forceinline Val
00136     ScaleView<Val,UnsVal>::max(void) const {
00137       Val c = view.max(); c *= a; return c;
00138     }
00139 
00140     template<class Val, class UnsVal>
00141     forceinline Val
00142     ScaleView<Val,UnsVal>::med(void) const {
00143       Val c = view.med(); c *= a; return c;
00144     }
00145 
00146     template<class Val, class UnsVal>
00147     forceinline Val
00148     ScaleView<Val,UnsVal>::val(void) const {
00149       Val c = view.val(); c *= a; return c;
00150     }
00151 
00152     template<class Val, class UnsVal>
00153     forceinline UnsVal
00154     ScaleView<Val,UnsVal>::size(void) const {
00155       return static_cast<UnsVal>(view.size());
00156     }
00157 
00158     template<class Val, class UnsVal>
00159     forceinline UnsVal
00160     ScaleView<Val,UnsVal>::width(void) const {
00161       UnsVal c = view.width(); c *= a; return c;
00162     }
00163 
00164     template<class Val, class UnsVal>
00165     forceinline UnsVal
00166     ScaleView<Val,UnsVal>::regret_min(void) const {
00167       UnsVal c = view.regret_min(); c *= a; return c;
00168     }
00169 
00170     template<class Val, class UnsVal>
00171     forceinline UnsVal
00172     ScaleView<Val,UnsVal>::regret_max(void) const {
00173       UnsVal c = view.regret_max(); c *= a; return c;
00174     }
00175 
00176 
00177     /*
00178      * Domain tests
00179      *
00180      */
00181     template<class Val, class UnsVal>
00182     forceinline bool
00183     ScaleView<Val,UnsVal>::range(void) const {
00184       return view.range();
00185     }
00186 
00187     template<class Val, class UnsVal>
00188     forceinline bool
00189     ScaleView<Val,UnsVal>::assigned(void) const {
00190       return view.assigned();
00191     }
00192 
00193     template<class Val, class UnsVal>
00194     forceinline bool
00195     ScaleView<Val,UnsVal>::in(Val n) const {
00196       bool exact;
00197       int nda = exact_div(n, exact);
00198       return exact && view.in(nda);
00199     }
00200 
00201 
00202 
00203 
00204     /*
00205      * Domain update by value
00206      *
00207      */
00208     template<class Val, class UnsVal>
00209     forceinline ModEvent
00210     ScaleView<Val,UnsVal>::lq(Space& home, Val n) {
00211       return (n >= max()) ? ME_INT_NONE : view.lq(home,floor_div(n));
00212     }
00213 
00214     template<class Val, class UnsVal>
00215     forceinline ModEvent
00216     ScaleView<Val,UnsVal>::le(Space& home, Val n) {
00217       return (n > max()) ? ME_INT_NONE : view.le(home,floor_div(n));
00218     }
00219 
00220     template<class Val, class UnsVal>
00221     forceinline ModEvent
00222     ScaleView<Val,UnsVal>::gq(Space& home, Val n) {
00223       return (n <= min()) ? ME_INT_NONE : view.gq(home,ceil_div(n));
00224     }
00225     template<class Val, class UnsVal>
00226     forceinline ModEvent
00227     ScaleView<Val,UnsVal>::gr(Space& home, Val n) {
00228       return (n < min()) ? ME_INT_NONE : view.gr(home,ceil_div(n));
00229     }
00230 
00231     template<class Val, class UnsVal>
00232     forceinline ModEvent
00233     ScaleView<Val,UnsVal>::nq(Space& home, Val n) {
00234       bool exact;
00235       int nda = exact_div(n,exact);
00236       return exact ? view.nq(home,nda) :  ME_INT_NONE;
00237     }
00238 
00239     template<class Val, class UnsVal>
00240     forceinline ModEvent
00241     ScaleView<Val,UnsVal>::eq(Space& home, Val n) {
00242       bool exact;
00243       int nda = exact_div(n,exact);
00244       return exact ? view.eq(home,nda) : ME_INT_FAILED;
00245     }
00246 
00247 
00248     /*
00249      * Propagator modification events
00250      *
00251      */
00252     template<class Val, class UnsVal>
00253     forceinline void
00254     ScaleView<Val,UnsVal>::schedule(Space& home, Propagator& p, ModEvent me) {
00255       return IntView::schedule(home,p,me);
00256     }
00257     template<class Val, class UnsVal>
00258     forceinline ModEvent
00259     ScaleView<Val,UnsVal>::me(const ModEventDelta& med) {
00260       return IntView::me(med);
00261     }
00262 
00263     template<class Val, class UnsVal>
00264     forceinline ModEventDelta
00265     ScaleView<Val,UnsVal>::med(ModEvent me) {
00266       return IntView::med(me);
00267     }
00268 
00269 
00270 
00271     /*
00272      * Dependencies
00273      *
00274      */
00275     template<class Val, class UnsVal>
00276     forceinline void
00277     ScaleView<Val,UnsVal>::subscribe(Space& home, Propagator& p, PropCond pc,
00278                                      bool process) {
00279       view.subscribe(home,p,pc,process);
00280     }
00281     template<class Val, class UnsVal>
00282     forceinline void
00283     ScaleView<Val,UnsVal>::cancel(Space& home, Propagator& p, PropCond pc) {
00284       view.cancel(home,p,pc);
00285     }
00286     template<class Val, class UnsVal>
00287     forceinline void
00288     ScaleView<Val,UnsVal>::subscribe(Space& home, Advisor& a) {
00289       view.subscribe(home,a);
00290     }
00291     template<class Val, class UnsVal>
00292     forceinline void
00293     ScaleView<Val,UnsVal>::cancel(Space& home, Advisor& a) {
00294       view.cancel(home,a);
00295     }
00296 
00297 
00298     /*
00299      * Delta information for advisors
00300      *
00301      */
00302     template<class Val, class UnsVal>
00303     forceinline ModEvent
00304     ScaleView<Val,UnsVal>::modevent(const Delta& d) {
00305       return IntView::modevent(d);
00306     }
00307     template<class Val, class UnsVal>
00308     forceinline Val
00309     ScaleView<Val,UnsVal>::min(const Delta& d) const {
00310       Val c = view.min(d); c *= a; return c;
00311     }
00312     template<class Val, class UnsVal>
00313     forceinline Val
00314     ScaleView<Val,UnsVal>::max(const Delta& d) const {
00315       Val c = view.max(d); c *= a; return c;
00316     }
00317     template<class Val, class UnsVal>
00318     forceinline bool
00319     ScaleView<Val,UnsVal>::any(const Delta& d) const {
00320       return view.any(d);
00321     }
00322 
00323 
00324 
00325     /*
00326      * Cloning
00327      *
00328      */
00329     template<class Val, class UnsVal>
00330     forceinline void
00331     ScaleView<Val,UnsVal>::update(Space& home, bool share,
00332                                   ScaleView<Val,UnsVal>& x) {
00333       a=x.a; view.update(home,share,x.view);
00334     }
00335 
00336 
00337 
00342     template<>
00343     class ViewRanges<IntScaleView>
00344       : public Iter::Ranges::ScaleUp<int,unsigned int,ViewRanges<IntView> > {
00345     public:
00347 
00348 
00349       ViewRanges(void);
00351       ViewRanges(const IntScaleView& x);
00353       void init(const IntScaleView& x);
00355     };
00356 
00357     forceinline
00358     ViewRanges<IntScaleView>::ViewRanges(void) {}
00359     forceinline
00360     ViewRanges<IntScaleView>::ViewRanges(const IntScaleView& x) {
00361       ViewRanges<IntView> xi(x.base());
00362       Iter::Ranges::ScaleUp<int,unsigned int,ViewRanges<IntView> >::init
00363         (xi,x.scale());
00364     }
00365     forceinline void
00366     ViewRanges<IntScaleView>::init(const IntScaleView& x) {
00367       ViewRanges<IntView> xi(x.base());
00368       Iter::Ranges::ScaleUp<int,unsigned int,ViewRanges<IntView> >::init
00369         (xi,x.scale());
00370     }
00371 
00372 
00377     template<>
00378     class ViewRanges<DoubleScaleView>
00379       : public Iter::Ranges::ScaleUp<double,double,ViewRanges<IntView> > {
00380     public:
00382 
00383 
00384       ViewRanges(void);
00386       ViewRanges(const DoubleScaleView& x);
00388       void init(const DoubleScaleView& x);
00390     };
00391 
00392     forceinline
00393     ViewRanges<DoubleScaleView>::ViewRanges(void) {}
00394     forceinline
00395     ViewRanges<DoubleScaleView>::ViewRanges(const DoubleScaleView& x) {
00396       ViewRanges<IntView> xi(x.base());
00397       Iter::Ranges::ScaleUp<double,double,ViewRanges<IntView> >::init
00398         (xi,x.scale());
00399     }
00400     forceinline void
00401     ViewRanges<DoubleScaleView>::init(const DoubleScaleView& x) {
00402       ViewRanges<IntView> xi(x.base());
00403       Iter::Ranges::ScaleUp<double,double,ViewRanges<IntView> >::init
00404         (xi,x.scale());
00405     }
00406 
00407   }
00408 
00409 
00410 
00411   /*
00412    * View comparison
00413    *
00414    */
00415   template<class Val, class UnsVal>
00416   forceinline bool
00417   same(const Int::ScaleView<Val,UnsVal>& x,
00418        const Int::ScaleView<Val,UnsVal>& y) {
00419     return same(x.base(),y.base()) && (x.scale() == y.scale());
00420   }
00421   template<class Val, class UnsVal>
00422   forceinline bool
00423   before(const Int::ScaleView<Val,UnsVal>& x,
00424          const Int::ScaleView<Val,UnsVal>& y) {
00425     return before(x.base(),y.base())
00426       || (same(x.base(),y.base()) && (x.scale() < y.scale()));
00427   }
00428 
00429 }
00430 
00431 // STATISTICS: int-var
00432