linear.hh
Go to the documentation of this file.
00001 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */ 00002 /* 00003 * Main authors: 00004 * Christian Schulte <schulte@gecode.org> 00005 * Guido Tack <tack@gecode.org> 00006 * Tias Guns <tias.guns@cs.kuleuven.be> 00007 * 00008 * Copyright: 00009 * Christian Schulte, 2002 00010 * Guido Tack, 2004 00011 * Tias Guns, 2009 00012 * 00013 * Last modified: 00014 * $Date: 2009-12-04 13:57:33 +0100 (Fri, 04 Dec 2009) $ by $Author: schulte $ 00015 * $Revision: 10188 $ 00016 * 00017 * This file is part of Gecode, the generic constraint 00018 * development environment: 00019 * http://www.gecode.org 00020 * 00021 * Permission is hereby granted, free of charge, to any person obtaining 00022 * a copy of this software and associated documentation files (the 00023 * "Software"), to deal in the Software without restriction, including 00024 * without limitation the rights to use, copy, modify, merge, publish, 00025 * distribute, sublicense, and/or sell copies of the Software, and to 00026 * permit persons to whom the Software is furnished to do so, subject to 00027 * the following conditions: 00028 * 00029 * The above copyright notice and this permission notice shall be 00030 * included in all copies or substantial portions of the Software. 00031 * 00032 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 00033 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 00034 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 00035 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 00036 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 00037 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 00038 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 00039 * 00040 */ 00041 00042 #ifndef __GECODE_INT_LINEAR_HH__ 00043 #define __GECODE_INT_LINEAR_HH__ 00044 00045 #include <gecode/int.hh> 00046 00052 namespace Gecode { namespace Int { namespace Linear { 00053 00054 /* 00055 * Binary propagators 00056 * 00057 */ 00058 00068 template<class Val, class A, class B, PropCond pc> 00069 class LinBin : public Propagator { 00070 protected: 00072 A x0; 00074 B x1; 00076 Val c; 00078 LinBin(Space& home, bool share, LinBin& p); 00080 LinBin(Space& home, bool share, Propagator& p, A x0, B x1, Val c); 00082 LinBin(Home home, A x0, B x1, Val c); 00083 public: 00085 virtual PropCost cost(const Space& home, const ModEventDelta& med) const; 00087 virtual size_t dispose(Space& home); 00088 }; 00089 00099 template<class Val, class A, class B, PropCond pc, class Ctrl> 00100 class ReLinBin : public Propagator { 00101 protected: 00103 A x0; 00105 B x1; 00107 Val c; 00109 Ctrl b; 00111 ReLinBin(Space& home, bool share, ReLinBin& p); 00113 ReLinBin(Home home, A x0, B x1, Val c, Ctrl b); 00114 public: 00116 virtual PropCost cost(const Space& home, const ModEventDelta& med) const; 00118 virtual size_t dispose(Space& home); 00119 }; 00120 00133 template<class Val, class A, class B> 00134 class EqBin : public LinBin<Val,A,B,PC_INT_BND> { 00135 protected: 00136 using LinBin<Val,A,B,PC_INT_BND>::x0; 00137 using LinBin<Val,A,B,PC_INT_BND>::x1; 00138 using LinBin<Val,A,B,PC_INT_BND>::c; 00139 00141 EqBin(Space& home, bool share, EqBin& p); 00143 EqBin(Home home, A x0, B x1, Val c); 00144 public: 00146 EqBin(Space& home, bool share, Propagator& p, A x0, B x1, Val c); 00148 virtual Actor* copy(Space& home, bool share); 00150 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00152 static ExecStatus post(Home home, A x0, B x1, Val c); 00153 }; 00154 00167 template<class Val, class A, class B, class Ctrl> 00168 class ReEqBin : public ReLinBin<Val,A,B,PC_INT_BND,Ctrl> { 00169 protected: 00170 using ReLinBin<Val,A,B,PC_INT_BND,Ctrl>::x0; 00171 using ReLinBin<Val,A,B,PC_INT_BND,Ctrl>::x1; 00172 using ReLinBin<Val,A,B,PC_INT_BND,Ctrl>::c; 00173 using ReLinBin<Val,A,B,PC_INT_BND,Ctrl>::b; 00174 00176 ReEqBin(Space& home, bool share, ReEqBin& p); 00178 ReEqBin(Home home,A,B,Val,Ctrl); 00179 public: 00181 virtual Actor* copy(Space& home, bool share); 00183 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00185 static ExecStatus post(Home home, A x0, B x1, Val c, Ctrl b); 00186 }; 00187 00200 template<class Val, class A, class B> 00201 class NqBin : public LinBin<Val,A,B,PC_INT_VAL> { 00202 protected: 00203 using LinBin<Val,A,B,PC_INT_VAL>::x0; 00204 using LinBin<Val,A,B,PC_INT_VAL>::x1; 00205 using LinBin<Val,A,B,PC_INT_VAL>::c; 00206 00208 NqBin(Space& home, bool share, NqBin& p); 00210 NqBin(Home home, A x0, B x1, Val c); 00211 public: 00213 NqBin(Space& home, bool share, Propagator& p, A x0, B x1, Val c); 00215 virtual Actor* copy(Space& home, bool share); 00217 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00219 virtual PropCost cost(const Space& home, const ModEventDelta& med) const; 00221 static ExecStatus post(Home home, A x0, B x1, Val c); 00222 }; 00223 00236 template<class Val, class A, class B> 00237 class LqBin : public LinBin<Val,A,B,PC_INT_BND> { 00238 protected: 00239 using LinBin<Val,A,B,PC_INT_BND>::x0; 00240 using LinBin<Val,A,B,PC_INT_BND>::x1; 00241 using LinBin<Val,A,B,PC_INT_BND>::c; 00242 00244 LqBin(Space& home, bool share, LqBin& p); 00246 LqBin(Home home, A x0, B x1, Val c); 00247 public: 00249 LqBin(Space& home, bool share, Propagator& p, A x0, B x1, Val c); 00251 virtual Actor* copy(Space& home, bool share); 00253 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00255 static ExecStatus post(Home home, A x0, B x1, Val c); 00256 }; 00257 00270 template<class Val, class A, class B> 00271 class GqBin : public LinBin<Val,A,B,PC_INT_BND> { 00272 protected: 00273 using LinBin<Val,A,B,PC_INT_BND>::x0; 00274 using LinBin<Val,A,B,PC_INT_BND>::x1; 00275 using LinBin<Val,A,B,PC_INT_BND>::c; 00276 00278 GqBin(Space& home, bool share, GqBin& p); 00280 GqBin(Home home, A x0, B x1, Val c); 00281 public: 00283 GqBin(Space& home, bool share, Propagator& p, A x0, B x1, Val c); 00285 virtual Actor* copy(Space& home, bool share); 00287 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00289 static ExecStatus post(Home home, A x0, B x1, Val c); 00290 }; 00291 00304 template<class Val, class A, class B> 00305 class ReLqBin : public ReLinBin<Val,A,B,PC_INT_BND,BoolView> { 00306 protected: 00307 using ReLinBin<Val,A,B,PC_INT_BND,BoolView>::x0; 00308 using ReLinBin<Val,A,B,PC_INT_BND,BoolView>::x1; 00309 using ReLinBin<Val,A,B,PC_INT_BND,BoolView>::c; 00310 using ReLinBin<Val,A,B,PC_INT_BND,BoolView>::b; 00311 00313 ReLqBin(Space& home, bool share, ReLqBin& p); 00315 ReLqBin(Home home, A x0, B x1, Val c, BoolView b); 00316 public: 00318 virtual Actor* copy(Space& home, bool share); 00320 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00322 static ExecStatus post(Home home, A x0, B x1, Val c, BoolView b); 00323 }; 00324 00325 }}} 00326 00327 #include <gecode/int/linear/int-bin.hpp> 00328 00329 namespace Gecode { namespace Int { namespace Linear { 00330 00331 /* 00332 * Ternary propagators 00333 * 00334 */ 00335 00345 template<class Val, class A, class B, class C, PropCond pc> 00346 class LinTer : public Propagator { 00347 protected: 00349 A x0; 00351 B x1; 00353 C x2; 00355 Val c; 00357 LinTer(Space& home, bool share, LinTer& p); 00359 LinTer(Home home, A x0, B x1, C x2, Val c); 00361 LinTer(Space& home, bool share, Propagator& p, A x0, B x1, C x2, Val c); 00362 public: 00364 virtual PropCost cost(const Space& home, const ModEventDelta& med) const; 00366 virtual size_t dispose(Space& home); 00367 }; 00368 00381 template<class Val, class A, class B, class C> 00382 class EqTer : public LinTer<Val,A,B,C,PC_INT_BND> { 00383 protected: 00384 using LinTer<Val,A,B,C,PC_INT_BND>::x0; 00385 using LinTer<Val,A,B,C,PC_INT_BND>::x1; 00386 using LinTer<Val,A,B,C,PC_INT_BND>::x2; 00387 using LinTer<Val,A,B,C,PC_INT_BND>::c; 00388 00390 EqTer(Space& home, bool share, EqTer& p); 00392 EqTer(Home home, A x0, B x1, C x2, Val c); 00393 public: 00395 EqTer(Space& home, bool share, Propagator& p, A x0, B x1, C x2, Val c); 00397 virtual Actor* copy(Space& home, bool share); 00399 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00401 static ExecStatus post(Home home, A x0, B x1, C x2, Val c); 00402 }; 00403 00416 template<class Val, class A, class B, class C> 00417 class NqTer : public LinTer<Val,A,B,C,PC_INT_VAL> { 00418 protected: 00419 using LinTer<Val,A,B,C,PC_INT_VAL>::x0; 00420 using LinTer<Val,A,B,C,PC_INT_VAL>::x1; 00421 using LinTer<Val,A,B,C,PC_INT_VAL>::x2; 00422 using LinTer<Val,A,B,C,PC_INT_VAL>::c; 00423 00425 NqTer(Space& home, bool share, NqTer& p); 00427 NqTer(Home home, A x0, B x1, C x2, Val c); 00428 public: 00430 NqTer(Space& home, bool share, Propagator& p, A x0, B x1, C x2, Val c); 00432 virtual Actor* copy(Space& home, bool share); 00434 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00436 static ExecStatus post(Home home, A x0, B x1, C x2, Val c); 00437 }; 00438 00451 template<class Val, class A, class B, class C> 00452 class LqTer : public LinTer<Val,A,B,C,PC_INT_BND> { 00453 protected: 00454 using LinTer<Val,A,B,C,PC_INT_BND>::x0; 00455 using LinTer<Val,A,B,C,PC_INT_BND>::x1; 00456 using LinTer<Val,A,B,C,PC_INT_BND>::x2; 00457 using LinTer<Val,A,B,C,PC_INT_BND>::c; 00458 00460 LqTer(Space& home, bool share, LqTer& p); 00462 LqTer(Home home, A x0, B x1, C x2, Val c); 00463 public: 00465 LqTer(Space& home, bool share, Propagator& p, A x0, B x1, C x2, Val c); 00467 virtual Actor* copy(Space& home, bool share); 00469 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00471 static ExecStatus post(Home home, A x0, B x1, C x2, Val c); 00472 }; 00473 00474 }}} 00475 00476 #include <gecode/int/linear/int-ter.hpp> 00477 00478 namespace Gecode { namespace Int { namespace Linear { 00479 00480 /* 00481 * n-ary propagators 00482 * 00483 */ 00484 00494 template<class Val, class P, class N, PropCond pc> 00495 class Lin : public Propagator { 00496 protected: 00498 ViewArray<P> x; 00500 ViewArray<N> y; 00502 Val c; 00503 00505 Lin(Space& home, bool share, Lin<Val,P,N,pc>& p); 00507 Lin(Home home, ViewArray<P>& x, ViewArray<N>& y, Val c); 00508 public: 00510 virtual PropCost cost(const Space& home, const ModEventDelta& med) const; 00512 virtual size_t dispose(Space& home); 00513 }; 00514 00524 template<class Val, class P, class N, PropCond pc, class Ctrl> 00525 class ReLin : public Lin<Val,P,N,pc> { 00526 protected: 00528 Ctrl b; 00530 ReLin(Space& home, bool share, ReLin& p); 00532 ReLin(Home home, ViewArray<P>& x, ViewArray<N>& y, Val c, Ctrl b); 00533 public: 00535 virtual size_t dispose(Space& home); 00536 }; 00537 00543 template<class Val, class View> 00544 void bounds_p(ModEventDelta med, ViewArray<View>& x, 00545 Val& c, Val& sl, Val& su); 00546 00552 template<class Val, class View> 00553 void bounds_n(ModEventDelta med, ViewArray<View>& y, 00554 Val& c, Val& sl, Val& su); 00555 00568 template<class Val, class P, class N> 00569 class Eq : public Lin<Val,P,N,PC_INT_BND> { 00570 protected: 00571 using Lin<Val,P,N,PC_INT_BND>::x; 00572 using Lin<Val,P,N,PC_INT_BND>::y; 00573 using Lin<Val,P,N,PC_INT_BND>::c; 00574 00576 Eq(Space& home, bool share, Eq& p); 00577 public: 00579 Eq(Home home, ViewArray<P>& x, ViewArray<N>& y, Val c); 00581 virtual Actor* copy(Space& home, bool share); 00583 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00585 static ExecStatus 00586 post(Home home, ViewArray<P>& x, ViewArray<N>& y, Val c); 00587 }; 00588 00599 template<class Val, class View> 00600 class DomEq 00601 : public Lin<Val,View,View,PC_INT_DOM> { 00602 protected: 00603 using Lin<Val,View,View,PC_INT_DOM>::x; 00604 using Lin<Val,View,View,PC_INT_DOM>::y; 00605 using Lin<Val,View,View,PC_INT_DOM>::c; 00606 00608 DomEq(Space& home, bool share, DomEq& p); 00609 public: 00611 DomEq(Home home, ViewArray<View>& x, ViewArray<View>& y, Val c); 00613 virtual Actor* copy(Space& home, bool share); 00620 virtual PropCost cost(const Space& home, const ModEventDelta& med) const; 00622 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00624 static ExecStatus 00625 post(Home home, ViewArray<View>& x, ViewArray<View>& y, Val c); 00626 }; 00627 00640 template<class Val, class P, class N, class Ctrl> 00641 class ReEq : public ReLin<Val,P,N,PC_INT_BND,Ctrl> { 00642 protected: 00643 using ReLin<Val,P,N,PC_INT_BND,Ctrl>::x; 00644 using ReLin<Val,P,N,PC_INT_BND,Ctrl>::y; 00645 using ReLin<Val,P,N,PC_INT_BND,Ctrl>::c; 00646 using ReLin<Val,P,N,PC_INT_BND,Ctrl>::b; 00647 00649 ReEq(Space& home, bool share, ReEq& p); 00650 public: 00652 ReEq(Home home, ViewArray<P>& x, ViewArray<N>& y, Val c, Ctrl b); 00654 virtual Actor* copy(Space& home, bool share); 00656 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00658 static ExecStatus 00659 post(Home home, ViewArray<P>& x, ViewArray<N>& y, Val c, Ctrl b); 00660 }; 00661 00674 template<class Val, class P, class N> 00675 class Nq : public Lin<Val,P,N,PC_INT_VAL> { 00676 protected: 00677 using Lin<Val,P,N,PC_INT_VAL>::x; 00678 using Lin<Val,P,N,PC_INT_VAL>::y; 00679 using Lin<Val,P,N,PC_INT_VAL>::c; 00680 00682 Nq(Space& home, bool share, Nq& p); 00683 public: 00685 Nq(Home home, ViewArray<P>& x, ViewArray<N>& y, Val c); 00687 virtual Actor* copy(Space& home, bool share); 00689 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00691 static ExecStatus 00692 post(Home home, ViewArray<P>& x, ViewArray<N>& y, Val c); 00693 }; 00694 00707 template<class Val, class P, class N> 00708 class Lq : public Lin<Val,P,N,PC_INT_BND> { 00709 protected: 00710 using Lin<Val,P,N,PC_INT_BND>::x; 00711 using Lin<Val,P,N,PC_INT_BND>::y; 00712 using Lin<Val,P,N,PC_INT_BND>::c; 00713 00715 Lq(Space& home, bool share, Lq& p); 00716 public: 00718 Lq(Home home, ViewArray<P>& x, ViewArray<N>& y, Val c); 00720 virtual Actor* copy(Space& home, bool share); 00722 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00724 static ExecStatus 00725 post(Home home, ViewArray<P>& x, ViewArray<N>& y, Val c); 00726 }; 00727 00740 template<class Val, class P, class N> 00741 class ReLq : public ReLin<Val,P,N,PC_INT_BND,BoolView> { 00742 protected: 00743 using ReLin<Val,P,N,PC_INT_BND,BoolView>::x; 00744 using ReLin<Val,P,N,PC_INT_BND,BoolView>::y; 00745 using ReLin<Val,P,N,PC_INT_BND,BoolView>::c; 00746 using ReLin<Val,P,N,PC_INT_BND,BoolView>::b; 00747 00749 ReLq(Space& home, bool share, ReLq& p); 00750 public: 00752 ReLq(Home home, ViewArray<P>& x, ViewArray<N>& y, Val c, BoolView b); 00754 virtual Actor* copy(Space& home, bool share); 00756 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00758 static ExecStatus 00759 post(Home home, ViewArray<P>& x, ViewArray<N>& y, Val c, BoolView b); 00760 }; 00761 00762 }}} 00763 00764 #include <gecode/int/linear/int-nary.hpp> 00765 #include <gecode/int/linear/int-dom.hpp> 00766 00767 namespace Gecode { namespace Int { namespace Linear { 00768 00769 /* 00770 * Boolean linear propagators 00771 * 00772 */ 00773 00778 template<class VX> 00779 class LinBoolInt : public Propagator { 00780 protected: 00782 Council<Advisor> co; 00784 ViewArray<VX> x; 00786 int n_as; 00788 int n_hs; 00790 int c; 00792 void normalize(void); 00794 LinBoolInt(Space& home, bool share, LinBoolInt& p); 00796 LinBoolInt(Home home, ViewArray<VX>& x, int n_s, int c); 00797 public: 00799 virtual PropCost cost(const Space& home, const ModEventDelta& med) const; 00801 virtual size_t dispose(Space& home); 00802 }; 00803 00810 template<class VX> 00811 class EqBoolInt : public LinBoolInt<VX> { 00812 protected: 00813 using LinBoolInt<VX>::co; 00814 using LinBoolInt<VX>::x; 00815 using LinBoolInt<VX>::n_as; 00816 using LinBoolInt<VX>::n_hs; 00817 using LinBoolInt<VX>::c; 00819 EqBoolInt(Space& home, bool share, EqBoolInt& p); 00821 EqBoolInt(Home home, ViewArray<VX>& x, int c); 00822 public: 00824 virtual Actor* copy(Space& home, bool share); 00826 virtual ExecStatus advise(Space& home, Advisor& a, const Delta& d); 00828 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00830 static ExecStatus post(Home home, ViewArray<VX>& x, int c); 00831 }; 00832 00839 template<class VX> 00840 class GqBoolInt : public LinBoolInt<VX> { 00841 protected: 00842 using LinBoolInt<VX>::co; 00843 using LinBoolInt<VX>::x; 00844 using LinBoolInt<VX>::n_as; 00845 using LinBoolInt<VX>::n_hs; 00846 using LinBoolInt<VX>::c; 00848 GqBoolInt(Space& home, bool share, GqBoolInt& p); 00850 GqBoolInt(Home home, ViewArray<VX>& x, int c); 00851 public: 00853 virtual Actor* copy(Space& home, bool share); 00855 virtual ExecStatus advise(Space& home, Advisor& a, const Delta& d); 00857 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00859 static ExecStatus post(Home home, ViewArray<VX>& x, int c); 00860 }; 00861 00868 template<class VX> 00869 class NqBoolInt : public BinaryPropagator<VX,PC_INT_VAL> { 00870 protected: 00871 using BinaryPropagator<VX,PC_INT_VAL>::x0; 00872 using BinaryPropagator<VX,PC_INT_VAL>::x1; 00874 ViewArray<VX> x; 00876 int c; 00878 bool resubscribe(Space& home, VX& y); 00880 NqBoolInt(Home home, ViewArray<VX>& b, int c); 00882 NqBoolInt(Space& home, bool share, NqBoolInt<VX>& p); 00883 public: 00885 virtual Actor* copy(Space& home, bool share); 00887 virtual PropCost cost(const Space& home, const ModEventDelta& med) const; 00889 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00891 static ExecStatus post(Home home, ViewArray<VX>& b, int c); 00893 virtual size_t dispose(Space& home); 00894 }; 00895 00896 00901 template<class VX, class VB> 00902 class ReLinBoolInt : public Propagator { 00903 protected: 00905 Council<Advisor> co; 00907 ViewArray<VX> x; 00909 int n_s; 00911 int c; 00913 VB b; 00915 void normalize(void); 00917 ReLinBoolInt(Space& home, bool share, ReLinBoolInt& p); 00919 ReLinBoolInt(Home home, ViewArray<VX>& x, int c, VB b); 00920 public: 00922 virtual PropCost cost(const Space& home, const ModEventDelta& med) const; 00924 virtual size_t dispose(Space& home); 00925 }; 00926 00927 00931 template<class BV> 00932 class BoolNegTraits {}; 00933 00940 template<class VX, class VB> 00941 class ReGqBoolInt : public ReLinBoolInt<VX,VB> { 00942 protected: 00943 using ReLinBoolInt<VX,VB>::co; 00944 using ReLinBoolInt<VX,VB>::x; 00945 using ReLinBoolInt<VX,VB>::c; 00946 using ReLinBoolInt<VX,VB>::b; 00947 using ReLinBoolInt<VX,VB>::n_s; 00948 using ReLinBoolInt<VX,VB>::normalize; 00950 ReGqBoolInt(Space& home, bool share, ReGqBoolInt& p); 00952 ReGqBoolInt(Home home, ViewArray<VX>& x, int c, VB b); 00953 public: 00955 virtual Actor* copy(Space& home, bool share); 00957 virtual ExecStatus advise(Space& home, Advisor& a, const Delta& d); 00959 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00961 static ExecStatus post(Home home, ViewArray<VX>& x, int c, VB b); 00962 }; 00963 00970 template<class VX, class VB> 00971 class ReEqBoolInt : public ReLinBoolInt<VX,VB> { 00972 protected: 00973 using ReLinBoolInt<VX,VB>::co; 00974 using ReLinBoolInt<VX,VB>::x; 00975 using ReLinBoolInt<VX,VB>::c; 00976 using ReLinBoolInt<VX,VB>::b; 00977 using ReLinBoolInt<VX,VB>::n_s; 00978 using ReLinBoolInt<VX,VB>::normalize; 00980 ReEqBoolInt(Space& home, bool share, ReEqBoolInt& p); 00982 ReEqBoolInt(Home home, ViewArray<VX>& x, int c, VB b); 00983 public: 00985 virtual Actor* copy(Space& home, bool share); 00987 virtual ExecStatus advise(Space& home, Advisor& a, const Delta& d); 00989 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 00991 static ExecStatus post(Home home, ViewArray<VX>& x, int c, VB b); 00992 }; 00993 00994 }}} 00995 00996 #include <gecode/int/linear/bool-int.hpp> 00997 00998 namespace Gecode { namespace Int { namespace Linear { 00999 01004 template<class XV, class YV> 01005 class LinBoolView : public Propagator { 01006 protected: 01008 ViewArray<XV> x; 01010 YV y; 01012 int c; 01014 LinBoolView(Space& home, bool share, LinBoolView& p); 01016 LinBoolView(Home home, ViewArray<XV>& x, YV y, int c); 01017 public: 01019 virtual PropCost cost(const Space& home, const ModEventDelta& med) const; 01021 virtual size_t dispose(Space& home); 01022 }; 01023 01024 01031 template<class XV, class YV> 01032 class EqBoolView : public LinBoolView<XV,YV> { 01033 protected: 01034 using LinBoolView<XV,YV>::x; 01035 using LinBoolView<XV,YV>::y; 01036 using LinBoolView<XV,YV>::c; 01037 01039 EqBoolView(Space& home, bool share, EqBoolView& p); 01041 EqBoolView(Home home, ViewArray<XV>& x, YV y, int c); 01042 public: 01044 virtual Actor* copy(Space& home, bool share); 01046 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 01048 static ExecStatus post(Home home, ViewArray<XV>& x, YV y, int c); 01049 }; 01050 01057 template<class XV, class YV> 01058 class NqBoolView : public LinBoolView<XV,YV> { 01059 protected: 01060 using LinBoolView<XV,YV>::x; 01061 using LinBoolView<XV,YV>::y; 01062 using LinBoolView<XV,YV>::c; 01063 01065 NqBoolView(Space& home, bool share, NqBoolView& p); 01067 NqBoolView(Home home, ViewArray<XV>& x, YV y, int c); 01068 public: 01070 virtual Actor* copy(Space& home, bool share); 01072 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 01074 static ExecStatus post(Home home, ViewArray<XV>& x, YV y, int c); 01075 }; 01076 01083 template<class XV, class YV> 01084 class GqBoolView : public LinBoolView<XV,YV> { 01085 protected: 01086 using LinBoolView<XV,YV>::x; 01087 using LinBoolView<XV,YV>::y; 01088 using LinBoolView<XV,YV>::c; 01089 01091 GqBoolView(Space& home, bool share, GqBoolView& p); 01093 GqBoolView(Home home, ViewArray<XV>& x, YV y, int c); 01094 public: 01096 virtual Actor* copy(Space& home, bool share); 01098 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 01100 static ExecStatus post(Home home, ViewArray<XV>& x, YV y, int c); 01101 }; 01102 01103 }}} 01104 01105 #include <gecode/int/linear/bool-view.hpp> 01106 01107 namespace Gecode { namespace Int { namespace Linear { 01108 01110 class ScaleBool { 01111 public: 01113 int a; 01115 BoolView x; 01116 }; 01117 01119 class ScaleBoolArray { 01120 private: 01122 ScaleBool* _fst; 01124 ScaleBool* _lst; 01125 public: 01127 ScaleBoolArray(void); 01129 ScaleBoolArray(Space& home, int n); 01131 void subscribe(Space& home, Propagator& p); 01133 void cancel(Space& home, Propagator& p); 01135 void update(Space& home, bool share, ScaleBoolArray& sba); 01137 ScaleBool* fst(void) const; 01139 ScaleBool* lst(void) const; 01141 void fst(ScaleBool* f); 01143 void lst(ScaleBool* l); 01145 bool empty(void) const; 01147 int size(void) const; 01148 private: 01150 class ScaleDec { 01151 public: 01152 bool 01153 operator ()(const ScaleBool& x, const ScaleBool& y); 01154 }; 01155 public: 01157 void sort(void); 01158 }; 01159 01160 01162 class EmptyScaleBoolArray { 01163 public: 01165 EmptyScaleBoolArray(void); 01167 EmptyScaleBoolArray(Space& home, int n); 01169 void subscribe(Space& home, Propagator& p); 01171 void cancel(Space& home, Propagator& p); 01173 void update(Space& home, bool share, EmptyScaleBoolArray& esba); 01175 ScaleBool* fst(void) const; 01177 ScaleBool* lst(void) const; 01179 void fst(ScaleBool* f); 01181 void lst(ScaleBool* l); 01183 bool empty(void) const; 01185 int size(void) const; 01187 void sort(void); 01188 }; 01189 01190 01195 template<class SBAP, class SBAN, class VX, PropCond pcx> 01196 class LinBoolScale : public Propagator { 01197 protected: 01199 SBAP p; 01201 SBAN n; 01203 VX x; 01205 int c; 01206 public: 01208 LinBoolScale(Home home, SBAP& p, SBAN& n, VX x, int c); 01210 LinBoolScale(Space& home, bool share, Propagator& pr, 01211 SBAP& p, SBAN& n, VX x, int c); 01213 virtual PropCost cost(const Space& home, const ModEventDelta& med) const; 01215 virtual size_t dispose(Space& home); 01216 }; 01217 01224 template<class SBAP, class SBAN, class VX> 01225 class EqBoolScale : public LinBoolScale<SBAP,SBAN,VX,PC_INT_BND> { 01226 protected: 01227 using LinBoolScale<SBAP,SBAN,VX,PC_INT_BND>::p; 01228 using LinBoolScale<SBAP,SBAN,VX,PC_INT_BND>::n; 01229 using LinBoolScale<SBAP,SBAN,VX,PC_INT_BND>::x; 01230 using LinBoolScale<SBAP,SBAN,VX,PC_INT_BND>::c; 01231 public: 01233 EqBoolScale(Home home, SBAP& p, SBAN& n, VX x, int c); 01235 EqBoolScale(Space& home, bool share, Propagator& pr, 01236 SBAP& p, SBAN& n, VX x, int c); 01238 virtual Actor* copy(Space& home, bool share); 01240 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 01242 static ExecStatus post(Home home, SBAP& p, SBAN& n, VX x, int c); 01243 }; 01244 01251 template<class SBAP, class SBAN, class VX> 01252 class LqBoolScale : public LinBoolScale<SBAP,SBAN,VX,PC_INT_BND> { 01253 protected: 01254 using LinBoolScale<SBAP,SBAN,VX,PC_INT_BND>::p; 01255 using LinBoolScale<SBAP,SBAN,VX,PC_INT_BND>::n; 01256 using LinBoolScale<SBAP,SBAN,VX,PC_INT_BND>::x; 01257 using LinBoolScale<SBAP,SBAN,VX,PC_INT_BND>::c; 01258 public: 01260 LqBoolScale(Home home, SBAP& p, SBAN& n, VX x, int c); 01262 LqBoolScale(Space& home, bool share, Propagator& pr, 01263 SBAP& p, SBAN& n, VX x, int c); 01265 virtual Actor* copy(Space& home, bool share); 01267 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 01269 static ExecStatus post(Home home, SBAP& p, SBAN& n, VX x, int c); 01270 }; 01271 01278 template<class SBAP, class SBAN, class VX> 01279 class NqBoolScale : public LinBoolScale<SBAP,SBAN,VX,PC_INT_VAL> { 01280 protected: 01281 using LinBoolScale<SBAP,SBAN,VX,PC_INT_VAL>::p; 01282 using LinBoolScale<SBAP,SBAN,VX,PC_INT_VAL>::n; 01283 using LinBoolScale<SBAP,SBAN,VX,PC_INT_VAL>::x; 01284 using LinBoolScale<SBAP,SBAN,VX,PC_INT_VAL>::c; 01285 public: 01287 NqBoolScale(Home home, SBAP& p, SBAN& n, VX x, int c); 01289 NqBoolScale(Space& home, bool share, Propagator& pr, 01290 SBAP& p, SBAN& n, VX x, int c); 01292 virtual Actor* copy(Space& home, bool share); 01294 virtual ExecStatus propagate(Space& home, const ModEventDelta& med); 01296 static ExecStatus post(Home home, SBAP& p, SBAN& n, VX x, int c); 01297 }; 01298 01299 }}} 01300 01301 #include <gecode/int/linear/bool-scale.hpp> 01302 01303 namespace Gecode { namespace Int { namespace Linear { 01304 01309 template<class View> 01310 class Term { 01311 public: 01313 int a; 01315 View x; 01316 }; 01317 01332 template<class View> 01333 void estimate(Term<View>* t, int n, int c, 01334 int& l, int& u); 01335 01357 template<class View> 01358 bool normalize(Term<View>* t, int &n, 01359 Term<View>* &t_p, int &n_p, 01360 Term<View>* &t_n, int &n_n); 01361 01362 01390 GECODE_INT_EXPORT void 01391 post(Home home, Term<IntView>* t, int n, IntRelType r, int c, 01392 IntConLevel=ICL_DEF); 01393 01423 GECODE_INT_EXPORT void 01424 post(Home home, Term<IntView>* t, int n, IntRelType r, int c, BoolView b, 01425 IntConLevel=ICL_DEF); 01426 01454 GECODE_INT_EXPORT void 01455 post(Home home, Term<BoolView>* t, int n, IntRelType r, int c, 01456 IntConLevel=ICL_DEF); 01457 01486 GECODE_INT_EXPORT void 01487 post(Home home, Term<BoolView>* t, int n, IntRelType r, int c, BoolView b, 01488 IntConLevel=ICL_DEF); 01489 01518 GECODE_INT_EXPORT void 01519 post(Home home, Term<BoolView>* t, int n, IntRelType r, IntView y, int c=0, 01520 IntConLevel=ICL_DEF); 01521 01550 GECODE_INT_EXPORT void 01551 post(Home home, Term<BoolView>* t, int n, IntRelType r, IntView y, 01552 BoolView b, IntConLevel=ICL_DEF); 01553 01554 }}} 01555 01556 #include <gecode/int/linear/post.hpp> 01557 01558 #endif 01559 01560 // STATISTICS: int-prop