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 #include <gecode/int/div.hh>
00039
00040 namespace Gecode { namespace Int {
00041
00042
00043
00044
00045
00046 template<class Val, class UnsVal>
00047 forceinline
00048 ScaleView<Val,UnsVal>::ScaleView(void) {}
00049
00050 template<class Val, class UnsVal>
00051 forceinline
00052 ScaleView<Val,UnsVal>::ScaleView(int b, const IntView& y)
00053 : DerivedView<IntView>(y), a(b) {}
00054
00055
00056
00057
00058
00059
00060 template<class Val, class UnsVal>
00061 forceinline int
00062 ScaleView<Val,UnsVal>::scale(void) const {
00063 return a;
00064 }
00065 template<class Val, class UnsVal>
00066 forceinline Val
00067 ScaleView<Val,UnsVal>::min(void) const {
00068 return static_cast<Val>(x.min()) * a;
00069 }
00070
00071 template<class Val, class UnsVal>
00072 forceinline Val
00073 ScaleView<Val,UnsVal>::max(void) const {
00074 return static_cast<Val>(x.max()) * a;
00075 }
00076
00077 template<class Val, class UnsVal>
00078 forceinline Val
00079 ScaleView<Val,UnsVal>::med(void) const {
00080 return static_cast<Val>(x.med()) * a;
00081 }
00082
00083 template<class Val, class UnsVal>
00084 forceinline Val
00085 ScaleView<Val,UnsVal>::val(void) const {
00086 return static_cast<Val>(x.val()) * a;
00087 }
00088
00089 template<class Val, class UnsVal>
00090 forceinline UnsVal
00091 ScaleView<Val,UnsVal>::size(void) const {
00092 return static_cast<UnsVal>(x.size());
00093 }
00094
00095 template<class Val, class UnsVal>
00096 forceinline UnsVal
00097 ScaleView<Val,UnsVal>::width(void) const {
00098 return static_cast<UnsVal>(x.width()) * a;
00099 }
00100
00101 template<class Val, class UnsVal>
00102 forceinline UnsVal
00103 ScaleView<Val,UnsVal>::regret_min(void) const {
00104 return static_cast<UnsVal>(x.regret_min()) * a;
00105 }
00106
00107 template<class Val, class UnsVal>
00108 forceinline UnsVal
00109 ScaleView<Val,UnsVal>::regret_max(void) const {
00110 return static_cast<UnsVal>(x.regret_max()) * a;
00111 }
00112
00113
00114
00115
00116
00117
00118 template<class Val, class UnsVal>
00119 forceinline bool
00120 ScaleView<Val,UnsVal>::range(void) const {
00121 return x.range();
00122 }
00123 template<class Val, class UnsVal>
00124 forceinline bool
00125 ScaleView<Val,UnsVal>::in(Val n) const {
00126 return ((n % a) == 0) && x.in(n / a);
00127 }
00128
00129
00130
00131
00132
00133
00134
00135
00136 template<class Val, class UnsVal>
00137 forceinline ModEvent
00138 ScaleView<Val,UnsVal>::lq(Space& home, Val n) {
00139 return (n >= max()) ? ME_INT_NONE :
00140 x.lq(home,floor_div_xp(n,static_cast<Val>(a)));
00141 }
00142
00143 template<class Val, class UnsVal>
00144 forceinline ModEvent
00145 ScaleView<Val,UnsVal>::le(Space& home, Val n) {
00146 return (n > max()) ? ME_INT_NONE :
00147 x.le(home,floor_div_xp(n,static_cast<Val>(a)));
00148 }
00149
00150 template<class Val, class UnsVal>
00151 forceinline ModEvent
00152 ScaleView<Val,UnsVal>::gq(Space& home, Val n) {
00153 return (n <= min()) ? ME_INT_NONE :
00154 x.gq(home,ceil_div_xp(n,static_cast<Val>(a)));
00155 }
00156 template<class Val, class UnsVal>
00157 forceinline ModEvent
00158 ScaleView<Val,UnsVal>::gr(Space& home, Val n) {
00159 return (n < min()) ? ME_INT_NONE :
00160 x.gr(home,ceil_div_xp(n,static_cast<Val>(a)));
00161 }
00162
00163 template<class Val, class UnsVal>
00164 forceinline ModEvent
00165 ScaleView<Val,UnsVal>::nq(Space& home, Val n) {
00166 return ((n % a) == 0) ? x.nq(home,n/a) : ME_INT_NONE;
00167 }
00168
00169 template<class Val, class UnsVal>
00170 forceinline ModEvent
00171 ScaleView<Val,UnsVal>::eq(Space& home, Val n) {
00172 return ((n % a) == 0) ? x.eq(home,n/a) : ME_INT_FAILED;
00173 }
00174
00175
00176
00177
00178
00179
00180 template<class Val, class UnsVal>
00181 forceinline ModEventDelta
00182 ScaleView<Val,UnsVal>::med(ModEvent me) {
00183 return IntView::med(me);
00184 }
00185
00186
00187
00188
00189
00190
00191
00192 template<class Val, class UnsVal>
00193 forceinline Val
00194 ScaleView<Val,UnsVal>::min(const Delta& d) const {
00195 return static_cast<Val>(x.min(d)) * a;
00196 }
00197 template<class Val, class UnsVal>
00198 forceinline Val
00199 ScaleView<Val,UnsVal>::max(const Delta& d) const {
00200 return static_cast<Val>(x.max(d)) * a;
00201 }
00202 template<class Val, class UnsVal>
00203 forceinline bool
00204 ScaleView<Val,UnsVal>::any(const Delta& d) const {
00205 return x.any(d);
00206 }
00207
00208
00209
00210
00211
00212
00213
00214 template<class Val, class UnsVal>
00215 forceinline void
00216 ScaleView<Val,UnsVal>::update(Space& home, bool share,
00217 ScaleView<Val,UnsVal>& y) {
00218 DerivedView<IntView>::update(home,share,y);
00219 a=y.a;
00220 }
00221
00222
00223
00228 template<>
00229 class ViewRanges<IntScaleView>
00230 : public Iter::Ranges::ScaleUp<int,unsigned int,ViewRanges<IntView> > {
00231 public:
00233
00234
00235 ViewRanges(void);
00237 ViewRanges(const IntScaleView& x);
00239 void init(const IntScaleView& x);
00241 };
00242
00243 forceinline
00244 ViewRanges<IntScaleView>::ViewRanges(void) {}
00245 forceinline
00246 ViewRanges<IntScaleView>::ViewRanges(const IntScaleView& x) {
00247 ViewRanges<IntView> xi(x.base());
00248 Iter::Ranges::ScaleUp<int,unsigned int,ViewRanges<IntView> >::init
00249 (xi,x.scale());
00250 }
00251 forceinline void
00252 ViewRanges<IntScaleView>::init(const IntScaleView& x) {
00253 ViewRanges<IntView> xi(x.base());
00254 Iter::Ranges::ScaleUp<int,unsigned int,ViewRanges<IntView> >::init
00255 (xi,x.scale());
00256 }
00257
00258
00263 template<>
00264 class ViewRanges<LLongScaleView>
00265 : public Iter::Ranges::ScaleUp<long long int,unsigned long long int,
00266 ViewRanges<IntView> > {
00267 public:
00269
00270
00271 ViewRanges(void);
00273 ViewRanges(const LLongScaleView& x);
00275 void init(const LLongScaleView& x);
00277 };
00278
00279 forceinline
00280 ViewRanges<LLongScaleView>::ViewRanges(void) {}
00281 forceinline
00282 ViewRanges<LLongScaleView>::ViewRanges(const LLongScaleView& x) {
00283 ViewRanges<IntView> xi(x.base());
00284 Iter::Ranges::ScaleUp<long long int,unsigned long long int,
00285 ViewRanges<IntView> >::init(xi,x.scale());
00286 }
00287 forceinline void
00288 ViewRanges<LLongScaleView>::init(const LLongScaleView& x) {
00289 ViewRanges<IntView> xi(x.base());
00290 Iter::Ranges::ScaleUp<long long int,unsigned long long int,
00291 ViewRanges<IntView> >::init(xi,x.scale());
00292 }
00293
00294
00295
00296
00297
00298
00299 template<class Val, class UnsVal>
00300 forceinline bool
00301 same(const ScaleView<Val,UnsVal>& x, const ScaleView<Val,UnsVal>& y) {
00302 return same(x.base(),y.base()) && (x.scale() == y.scale());
00303 }
00304 template<class Val, class UnsVal>
00305 forceinline bool
00306 before(const ScaleView<Val,UnsVal>& x, const ScaleView<Val,UnsVal>& y) {
00307 return before(x.base(),y.base())
00308 || (same(x.base(),y.base()) && (x.scale() < y.scale()));
00309 }
00310
00311 }}
00312
00313
00314