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 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
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
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
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
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
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
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
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
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
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
00367