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 namespace Gecode {
00039
00040 namespace Int {
00041
00042
00043
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
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
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
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
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
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
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
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
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
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
00432