Generated on Mon Nov 30 23:53:33 2009 for Gecode by doxygen 1.6.1

lin-rel.hpp

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  *
00006  *  Copyright:
00007  *     Christian Schulte, 2005
00008  *
00009  *  Last modified:
00010  *     $Date: 2009-10-12 17:36:53 +0200 (Mon, 12 Oct 2009) $ by $Author: schulte $
00011  *     $Revision: 9878 $
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   /*
00041    * Operations for linear expressions
00042    *
00043    */
00044   template<class Var>
00045   forceinline
00046   LinRel<Var>::LinRel(void) {}
00047 
00048   template<class Var>
00049   forceinline
00050   LinRel<Var>::LinRel(const LinExpr<Var>& l, IntRelType irt0,
00051                       const LinExpr<Var>& r)
00052     : e(l-r), irt(irt0) {}
00053 
00054   template<class Var>
00055   forceinline
00056   LinRel<Var>::LinRel(const LinExpr<Var>& l, IntRelType irt0, int r)
00057     : e(l-r), irt(irt0) {}
00058 
00059   template<class Var>
00060   forceinline
00061   LinRel<Var>::LinRel(int l, IntRelType irt0, const LinExpr<Var>& r)
00062     : e(l-r), irt(irt0) {}
00063 
00064   template<class Var>
00065   forceinline IntRelType
00066   LinRel<Var>::neg(IntRelType irt) {
00067     switch (irt) {
00068     case IRT_EQ: return IRT_NQ;
00069     case IRT_NQ: return IRT_EQ;
00070     case IRT_LQ: return IRT_GR;
00071     case IRT_LE: return IRT_GQ;
00072     case IRT_GQ: return IRT_LE;
00073     case IRT_GR: return IRT_LQ;
00074     default: GECODE_NEVER;
00075     }
00076     return IRT_LQ;
00077   }
00078 
00079   template<class Var>
00080   inline void
00081   LinRel<Var>::post(Home home, bool t, IntConLevel icl) const {
00082     if (t) {
00083       e.post(home,irt,icl);
00084     } else {
00085       e.post(home,neg(irt),icl);
00086     }
00087   }
00088 
00089   template<class Var>
00090   forceinline void
00091   LinRel<Var>::post(Home home, const BoolVar& b, bool t,
00092                     IntConLevel icl) const {
00093     if (t) {
00094       e.post(home,irt,b,icl);
00095     } else {
00096       e.post(home,neg(irt),b,icl);
00097     }
00098   }
00099 
00100 
00101   /*
00102    * Construction of linear relations
00103    *
00104    */
00105   inline LinRel<IntVar>
00106   operator ==(int l, const IntVar& r) {
00107     return LinRel<IntVar>(l,IRT_EQ,r);
00108   }
00109   inline LinRel<IntVar>
00110   operator ==(int l, const LinExpr<IntVar>& r) {
00111     return LinRel<IntVar>(l,IRT_EQ,r);
00112   }
00113   inline LinRel<IntVar>
00114   operator ==(const IntVar& l, int r) {
00115     return LinRel<IntVar>(l,IRT_EQ,r);
00116   }
00117   inline LinRel<IntVar>
00118   operator ==(const LinExpr<IntVar>& l, int r) {
00119     return LinRel<IntVar>(l,IRT_EQ,r);
00120   }
00121   inline LinRel<IntVar>
00122   operator ==(const IntVar& l, const IntVar& r) {
00123     return LinRel<IntVar>(l,IRT_EQ,r);
00124   }
00125   inline LinRel<IntVar>
00126   operator ==(const IntVar& l, const LinExpr<IntVar>& r) {
00127     return LinRel<IntVar>(l,IRT_EQ,r);
00128   }
00129   inline LinRel<IntVar>
00130   operator ==(const LinExpr<IntVar>& l, const IntVar& r) {
00131     return LinRel<IntVar>(l,IRT_EQ,r);
00132   }
00133   inline LinRel<IntVar>
00134   operator ==(const LinExpr<IntVar>& l, const LinExpr<IntVar>& r) {
00135     return LinRel<IntVar>(l,IRT_EQ,r);
00136   }
00137 
00138   inline LinRel<IntVar>
00139   operator !=(int l, const IntVar& r) {
00140     return LinRel<IntVar>(l,IRT_NQ,r);
00141   }
00142   inline LinRel<IntVar>
00143   operator !=(int l, const LinExpr<IntVar>& r) {
00144     return LinRel<IntVar>(l,IRT_NQ,r);
00145   }
00146   inline LinRel<IntVar>
00147   operator !=(const IntVar& l, int r) {
00148     return LinRel<IntVar>(l,IRT_NQ,r);
00149   }
00150   inline LinRel<IntVar>
00151   operator !=(const LinExpr<IntVar>& l, int r) {
00152     return LinRel<IntVar>(l,IRT_NQ,r);
00153   }
00154   inline LinRel<IntVar>
00155   operator !=(const IntVar& l, const IntVar& r) {
00156     return LinRel<IntVar>(l,IRT_NQ,r);
00157   }
00158   inline LinRel<IntVar>
00159   operator !=(const IntVar& l, const LinExpr<IntVar>& r) {
00160     return LinRel<IntVar>(l,IRT_NQ,r);
00161   }
00162   inline LinRel<IntVar>
00163   operator !=(const LinExpr<IntVar>& l, const IntVar& r) {
00164     return LinRel<IntVar>(l,IRT_NQ,r);
00165   }
00166   inline LinRel<IntVar>
00167   operator !=(const LinExpr<IntVar>& l, const LinExpr<IntVar>& r) {
00168     return LinRel<IntVar>(l,IRT_NQ,r);
00169   }
00170 
00171   inline LinRel<IntVar>
00172   operator <(int l, const IntVar& r) {
00173     return LinRel<IntVar>(l,IRT_LE,r);
00174   }
00175   inline LinRel<IntVar>
00176   operator <(int l, const LinExpr<IntVar>& r) {
00177     return LinRel<IntVar>(l,IRT_LE,r);
00178   }
00179   inline LinRel<IntVar>
00180   operator <(const IntVar& l, int r) {
00181     return LinRel<IntVar>(l,IRT_LE,r);
00182   }
00183   inline LinRel<IntVar>
00184   operator <(const LinExpr<IntVar>& l, int r) {
00185     return LinRel<IntVar>(l,IRT_LE,r);
00186   }
00187   inline LinRel<IntVar>
00188   operator <(const IntVar& l, const IntVar& r) {
00189     return LinRel<IntVar>(l,IRT_LE,r);
00190   }
00191   inline LinRel<IntVar>
00192   operator <(const IntVar& l, const LinExpr<IntVar>& r) {
00193     return LinRel<IntVar>(l,IRT_LE,r);
00194   }
00195   inline LinRel<IntVar>
00196   operator <(const LinExpr<IntVar>& l, const IntVar& r) {
00197     return LinRel<IntVar>(l,IRT_LE,r);
00198   }
00199   inline LinRel<IntVar>
00200   operator <(const LinExpr<IntVar>& l, const LinExpr<IntVar>& r) {
00201     return LinRel<IntVar>(l,IRT_LE,r);
00202   }
00203 
00204   inline LinRel<IntVar>
00205   operator <=(int l, const IntVar& r) {
00206     return LinRel<IntVar>(l,IRT_LQ,r);
00207   }
00208   inline LinRel<IntVar>
00209   operator <=(int l, const LinExpr<IntVar>& r) {
00210     return LinRel<IntVar>(l,IRT_LQ,r);
00211   }
00212   inline LinRel<IntVar>
00213   operator <=(const IntVar& l, int r) {
00214     return LinRel<IntVar>(l,IRT_LQ,r);
00215   }
00216   inline LinRel<IntVar>
00217   operator <=(const LinExpr<IntVar>& l, int r) {
00218     return LinRel<IntVar>(l,IRT_LQ,r);
00219   }
00220   inline LinRel<IntVar>
00221   operator <=(const IntVar& l, const IntVar& r) {
00222     return LinRel<IntVar>(l,IRT_LQ,r);
00223   }
00224   inline LinRel<IntVar>
00225   operator <=(const IntVar& l, const LinExpr<IntVar>& r) {
00226     return LinRel<IntVar>(l,IRT_LQ,r);
00227   }
00228   inline LinRel<IntVar>
00229   operator <=(const LinExpr<IntVar>& l, const IntVar& r) {
00230     return LinRel<IntVar>(l,IRT_LQ,r);
00231   }
00232   inline LinRel<IntVar>
00233   operator <=(const LinExpr<IntVar>& l, const LinExpr<IntVar>& r) {
00234     return LinRel<IntVar>(l,IRT_LQ,r);
00235   }
00236 
00237   inline LinRel<IntVar>
00238   operator >(int l, const IntVar& r) {
00239     return LinRel<IntVar>(l,IRT_GR,r);
00240   }
00241   inline LinRel<IntVar>
00242   operator >(int l, const LinExpr<IntVar>& r) {
00243     return LinRel<IntVar>(l,IRT_GR,r);
00244   }
00245   inline LinRel<IntVar>
00246   operator >(const IntVar& l, int r) {
00247     return LinRel<IntVar>(l,IRT_GR,r);
00248   }
00249   inline LinRel<IntVar>
00250   operator >(const LinExpr<IntVar>& l, int r) {
00251     return LinRel<IntVar>(l,IRT_GR,r);
00252   }
00253   inline LinRel<IntVar>
00254   operator >(const IntVar& l, const IntVar& r) {
00255     return LinRel<IntVar>(l,IRT_GR,r);
00256   }
00257   inline LinRel<IntVar>
00258   operator >(const IntVar& l, const LinExpr<IntVar>& r) {
00259     return LinRel<IntVar>(l,IRT_GR,r);
00260   }
00261   inline LinRel<IntVar>
00262   operator >(const LinExpr<IntVar>& l, const IntVar& r) {
00263     return LinRel<IntVar>(l,IRT_GR,r);
00264   }
00265   inline LinRel<IntVar>
00266   operator >(const LinExpr<IntVar>& l, const LinExpr<IntVar>& r) {
00267     return LinRel<IntVar>(l,IRT_GR,r);
00268   }
00269 
00270   inline LinRel<IntVar>
00271   operator >=(int l, const IntVar& r) {
00272     return LinRel<IntVar>(l,IRT_GQ,r);
00273   }
00274   inline LinRel<IntVar>
00275   operator >=(int l, const LinExpr<IntVar>& r) {
00276     return LinRel<IntVar>(l,IRT_GQ,r);
00277   }
00278   inline LinRel<IntVar>
00279   operator >=(const IntVar& l, int r) {
00280     return LinRel<IntVar>(l,IRT_GQ,r);
00281   }
00282   inline LinRel<IntVar>
00283   operator >=(const LinExpr<IntVar>& l, int r) {
00284     return LinRel<IntVar>(l,IRT_GQ,r);
00285   }
00286   inline LinRel<IntVar>
00287   operator >=(const IntVar& l, const IntVar& r) {
00288     return LinRel<IntVar>(l,IRT_GQ,r);
00289   }
00290   inline LinRel<IntVar>
00291   operator >=(const IntVar& l, const LinExpr<IntVar>& r) {
00292     return LinRel<IntVar>(l,IRT_GQ,r);
00293   }
00294   inline LinRel<IntVar>
00295   operator >=(const LinExpr<IntVar>& l, const IntVar& r) {
00296     return LinRel<IntVar>(l,IRT_GQ,r);
00297   }
00298   inline LinRel<IntVar>
00299   operator >=(const LinExpr<IntVar>& l, const LinExpr<IntVar>& r) {
00300     return LinRel<IntVar>(l,IRT_GQ,r);
00301   }
00302 
00303 
00304 
00305   inline LinRel<BoolVar>
00306   operator ==(int l, const BoolVar& r) {
00307     return LinRel<BoolVar>(l,IRT_EQ,r);
00308   }
00309   inline LinRel<BoolVar>
00310   operator ==(int l, const LinExpr<BoolVar>& r) {
00311     return LinRel<BoolVar>(l,IRT_EQ,r);
00312   }
00313   inline LinRel<BoolVar>
00314   operator ==(const BoolVar& l, int r) {
00315     return LinRel<BoolVar>(l,IRT_EQ,r);
00316   }
00317   inline LinRel<BoolVar>
00318   operator ==(const LinExpr<BoolVar>& l, int r) {
00319     return LinRel<BoolVar>(l,IRT_EQ,r);
00320   }
00321   inline LinRel<BoolVar>
00322   operator ==(const BoolVar& l, const BoolVar& r) {
00323     return LinRel<BoolVar>(l,IRT_EQ,r);
00324   }
00325   inline LinRel<BoolVar>
00326   operator ==(const BoolVar& l, const LinExpr<BoolVar>& r) {
00327     return LinRel<BoolVar>(l,IRT_EQ,r);
00328   }
00329   inline LinRel<BoolVar>
00330   operator ==(const LinExpr<BoolVar>& l, const BoolVar& r) {
00331     return LinRel<BoolVar>(l,IRT_EQ,r);
00332   }
00333   inline LinRel<BoolVar>
00334   operator ==(const LinExpr<BoolVar>& l, const LinExpr<BoolVar>& r) {
00335     return LinRel<BoolVar>(l,IRT_EQ,r);
00336   }
00337 
00338   inline LinRel<BoolVar>
00339   operator !=(int l, const BoolVar& r) {
00340     return LinRel<BoolVar>(l,IRT_NQ,r);
00341   }
00342   inline LinRel<BoolVar>
00343   operator !=(int l, const LinExpr<BoolVar>& r) {
00344     return LinRel<BoolVar>(l,IRT_NQ,r);
00345   }
00346   inline LinRel<BoolVar>
00347   operator !=(const BoolVar& l, int r) {
00348     return LinRel<BoolVar>(l,IRT_NQ,r);
00349   }
00350   inline LinRel<BoolVar>
00351   operator !=(const LinExpr<BoolVar>& l, int r) {
00352     return LinRel<BoolVar>(l,IRT_NQ,r);
00353   }
00354   inline LinRel<BoolVar>
00355   operator !=(const BoolVar& l, const BoolVar& r) {
00356     return LinRel<BoolVar>(l,IRT_NQ,r);
00357   }
00358   inline LinRel<BoolVar>
00359   operator !=(const BoolVar& l, const LinExpr<BoolVar>& r) {
00360     return LinRel<BoolVar>(l,IRT_NQ,r);
00361   }
00362   inline LinRel<BoolVar>
00363   operator !=(const LinExpr<BoolVar>& l, const BoolVar& r) {
00364     return LinRel<BoolVar>(l,IRT_NQ,r);
00365   }
00366   inline LinRel<BoolVar>
00367   operator !=(const LinExpr<BoolVar>& l, const LinExpr<BoolVar>& r) {
00368     return LinRel<BoolVar>(l,IRT_NQ,r);
00369   }
00370 
00371   inline LinRel<BoolVar>
00372   operator <(int l, const BoolVar& r) {
00373     return LinRel<BoolVar>(l,IRT_LE,r);
00374   }
00375   inline LinRel<BoolVar>
00376   operator <(int l, const LinExpr<BoolVar>& r) {
00377     return LinRel<BoolVar>(l,IRT_LE,r);
00378   }
00379   inline LinRel<BoolVar>
00380   operator <(const BoolVar& l, int r) {
00381     return LinRel<BoolVar>(l,IRT_LE,r);
00382   }
00383   inline LinRel<BoolVar>
00384   operator <(const LinExpr<BoolVar>& l, int r) {
00385     return LinRel<BoolVar>(l,IRT_LE,r);
00386   }
00387   inline LinRel<BoolVar>
00388   operator <(const BoolVar& l, const BoolVar& r) {
00389     return LinRel<BoolVar>(l,IRT_LE,r);
00390   }
00391   inline LinRel<BoolVar>
00392   operator <(const BoolVar& l, const LinExpr<BoolVar>& r) {
00393     return LinRel<BoolVar>(l,IRT_LE,r);
00394   }
00395   inline LinRel<BoolVar>
00396   operator <(const LinExpr<BoolVar>& l, const BoolVar& r) {
00397     return LinRel<BoolVar>(l,IRT_LE,r);
00398   }
00399   inline LinRel<BoolVar>
00400   operator <(const LinExpr<BoolVar>& l, const LinExpr<BoolVar>& r) {
00401     return LinRel<BoolVar>(l,IRT_LE,r);
00402   }
00403 
00404   inline LinRel<BoolVar>
00405   operator <=(int l, const BoolVar& r) {
00406     return LinRel<BoolVar>(l,IRT_LQ,r);
00407   }
00408   inline LinRel<BoolVar>
00409   operator <=(int l, const LinExpr<BoolVar>& r) {
00410     return LinRel<BoolVar>(l,IRT_LQ,r);
00411   }
00412   inline LinRel<BoolVar>
00413   operator <=(const BoolVar& l, int r) {
00414     return LinRel<BoolVar>(l,IRT_LQ,r);
00415   }
00416   inline LinRel<BoolVar>
00417   operator <=(const LinExpr<BoolVar>& l, int r) {
00418     return LinRel<BoolVar>(l,IRT_LQ,r);
00419   }
00420   inline LinRel<BoolVar>
00421   operator <=(const BoolVar& l, const BoolVar& r) {
00422     return LinRel<BoolVar>(l,IRT_LQ,r);
00423   }
00424   inline LinRel<BoolVar>
00425   operator <=(const BoolVar& l, const LinExpr<BoolVar>& r) {
00426     return LinRel<BoolVar>(l,IRT_LQ,r);
00427   }
00428   inline LinRel<BoolVar>
00429   operator <=(const LinExpr<BoolVar>& l, const BoolVar& r) {
00430     return LinRel<BoolVar>(l,IRT_LQ,r);
00431   }
00432   inline LinRel<BoolVar>
00433   operator <=(const LinExpr<BoolVar>& l, const LinExpr<BoolVar>& r) {
00434     return LinRel<BoolVar>(l,IRT_LQ,r);
00435   }
00436 
00437   inline LinRel<BoolVar>
00438   operator >(int l, const BoolVar& r) {
00439     return LinRel<BoolVar>(l,IRT_GR,r);
00440   }
00441   inline LinRel<BoolVar>
00442   operator >(int l, const LinExpr<BoolVar>& r) {
00443     return LinRel<BoolVar>(l,IRT_GR,r);
00444   }
00445   inline LinRel<BoolVar>
00446   operator >(const BoolVar& l, int r) {
00447     return LinRel<BoolVar>(l,IRT_GR,r);
00448   }
00449   inline LinRel<BoolVar>
00450   operator >(const LinExpr<BoolVar>& l, int r) {
00451     return LinRel<BoolVar>(l,IRT_GR,r);
00452   }
00453   inline LinRel<BoolVar>
00454   operator >(const BoolVar& l, const BoolVar& r) {
00455     return LinRel<BoolVar>(l,IRT_GR,r);
00456   }
00457   inline LinRel<BoolVar>
00458   operator >(const BoolVar& l, const LinExpr<BoolVar>& r) {
00459     return LinRel<BoolVar>(l,IRT_GR,r);
00460   }
00461   inline LinRel<BoolVar>
00462   operator >(const LinExpr<BoolVar>& l, const BoolVar& r) {
00463     return LinRel<BoolVar>(l,IRT_GR,r);
00464   }
00465   inline LinRel<BoolVar>
00466   operator >(const LinExpr<BoolVar>& l, const LinExpr<BoolVar>& r) {
00467     return LinRel<BoolVar>(l,IRT_GR,r);
00468   }
00469 
00470   inline LinRel<BoolVar>
00471   operator >=(int l, const BoolVar& r) {
00472     return LinRel<BoolVar>(l,IRT_GQ,r);
00473   }
00474   inline LinRel<BoolVar>
00475   operator >=(int l, const LinExpr<BoolVar>& r) {
00476     return LinRel<BoolVar>(l,IRT_GQ,r);
00477   }
00478   inline LinRel<BoolVar>
00479   operator >=(const BoolVar& l, int r) {
00480     return LinRel<BoolVar>(l,IRT_GQ,r);
00481   }
00482   inline LinRel<BoolVar>
00483   operator >=(const LinExpr<BoolVar>& l, int r) {
00484     return LinRel<BoolVar>(l,IRT_GQ,r);
00485   }
00486   inline LinRel<BoolVar>
00487   operator >=(const BoolVar& l, const BoolVar& r) {
00488     return LinRel<BoolVar>(l,IRT_GQ,r);
00489   }
00490   inline LinRel<BoolVar>
00491   operator >=(const BoolVar& l, const LinExpr<BoolVar>& r) {
00492     return LinRel<BoolVar>(l,IRT_GQ,r);
00493   }
00494   inline LinRel<BoolVar>
00495   operator >=(const LinExpr<BoolVar>& l, const BoolVar& r) {
00496     return LinRel<BoolVar>(l,IRT_GQ,r);
00497   }
00498   inline LinRel<BoolVar>
00499   operator >=(const LinExpr<BoolVar>& l, const LinExpr<BoolVar>& r) {
00500     return LinRel<BoolVar>(l,IRT_GQ,r);
00501   }
00502 
00503 
00504   /*
00505    * Posting
00506    *
00507    */
00508 
00509   template<class Var>
00510   forceinline void
00511   post(Home home, const LinRel<Var>& r, IntConLevel icl) {
00512     if (home.failed()) return;
00513     r.post(home,true,icl);
00514   }
00515   forceinline void
00516   post(Home home, bool r, IntConLevel) {
00517     if (home.failed()) return;
00518     if (!r)
00519       home.fail();
00520   }
00521 
00522 }
00523 
00524 // STATISTICS: minimodel-any