rel.cpp

00001 /* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
00002 /*
00003  *  Main authors:
00004  *     Christian Schulte <schulte@gecode.org>
00005  *     Vincent Barichard <Vincent.Barichard@univ-angers.fr>
00006  *
00007  *  Copyright:
00008  *     Christian Schulte, 2002
00009  *     Vincent Barichard, 2012
00010  *
00011  *  Last modified:
00012  *     $Date: 2016-05-23 22:18:23 +0200 (Mon, 23 May 2016) $ by $Author: schulte $
00013  *     $Revision: 15073 $
00014  *
00015  *  This file is part of Gecode, the generic constraint
00016  *  development environment:
00017  *     http://www.gecode.org
00018  *
00019  *  Permission is hereby granted, free of charge, to any person obtaining
00020  *  a copy of this software and associated documentation files (the
00021  *  "Software"), to deal in the Software without restriction, including
00022  *  without limitation the rights to use, copy, modify, merge, publish,
00023  *  distribute, sublicense, and/or sell copies of the Software, and to
00024  *  permit persons to whom the Software is furnished to do so, subject to
00025  *  the following conditions:
00026  *
00027  *  The above copyright notice and this permission notice shall be
00028  *  included in all copies or substantial portions of the Software.
00029  *
00030  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
00031  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
00032  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
00033  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
00034  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
00035  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
00036  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00037  *
00038  */
00039 
00040 #include <gecode/float/rel.hh>
00041 
00042 #include <algorithm>
00043 
00044 namespace Gecode {
00045 
00046   void
00047   rel(Home home, FloatVar x0, FloatRelType frt, FloatVal n) {
00048     using namespace Float;
00049     Limits::check(n,"Float::rel");
00050     GECODE_POST;
00051     FloatView x(x0);
00052     switch (frt) {
00053     case FRT_EQ: GECODE_ME_FAIL(x.eq(home,n)); break;
00054     case FRT_NQ:
00055       GECODE_ES_FAIL((Rel::NqFloat<FloatView>::post(home,x,n)));
00056       break;
00057     case FRT_LQ: GECODE_ME_FAIL(x.lq(home,n)); break;
00058     case FRT_LE:
00059       GECODE_ME_FAIL(x.lq(home,n));
00060       GECODE_ES_FAIL((Rel::NqFloat<FloatView>::post(home,x,n)));
00061       break;
00062     case FRT_GQ: GECODE_ME_FAIL(x.gq(home,n)); break;
00063     case FRT_GR:
00064       GECODE_ME_FAIL(x.gq(home,n));
00065       GECODE_ES_FAIL((Rel::NqFloat<FloatView>::post(home,x,n)));
00066       break;
00067     default: throw UnknownRelation("Float::rel");
00068     }
00069   }
00070 
00071   void
00072   rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1) {
00073     using namespace Float;
00074     GECODE_POST;
00075     switch (frt) {
00076     case FRT_EQ:
00077       GECODE_ES_FAIL((Rel::Eq<FloatView,FloatView>::post(home,x0,x1)));
00078       break;
00079     case FRT_NQ:
00080       GECODE_ES_FAIL((Rel::Nq<FloatView,FloatView>::post(home,x0,x1)));
00081       break;
00082     case FRT_GQ:
00083       std::swap(x0,x1); // Fall through
00084     case FRT_LQ:
00085       GECODE_ES_FAIL((Rel::Lq<FloatView>::post(home,x0,x1))); break;
00086     case FRT_GR:
00087       std::swap(x0,x1); // Fall through
00088     case FRT_LE:
00089       GECODE_ES_FAIL((Rel::Le<FloatView>::post(home,x0,x1))); break;
00090     default:
00091       throw UnknownRelation("Float::rel");
00092     }
00093   }
00094 
00095   void
00096   rel(Home home, FloatVar x0, FloatRelType frt, FloatVar x1, Reify r) {
00097     using namespace Float;
00098     GECODE_POST;
00099     switch (frt) {
00100     case FRT_EQ:
00101       switch (r.mode()) {
00102       case RM_EQV:
00103         GECODE_ES_FAIL((Rel::ReEq<FloatView,Int::BoolView,RM_EQV>::
00104                              post(home,x0,x1,r.var())));
00105         break;
00106       case RM_IMP:
00107         GECODE_ES_FAIL((Rel::ReEq<FloatView,Int::BoolView,RM_IMP>::
00108                              post(home,x0,x1,r.var())));
00109         break;
00110       case RM_PMI:
00111         GECODE_ES_FAIL((Rel::ReEq<FloatView,Int::BoolView,RM_PMI>::
00112                              post(home,x0,x1,r.var())));
00113         break;
00114       default: throw Int::UnknownReifyMode("Float::rel");
00115       }
00116       break;
00117     case FRT_NQ:
00118     {
00119       Int::NegBoolView n(r.var());
00120       switch (r.mode()) {
00121       case RM_EQV:
00122         GECODE_ES_FAIL((Rel::ReEq<FloatView,Int::NegBoolView,RM_EQV>::
00123                              post(home,x0,x1,n)));
00124         break;
00125       case RM_IMP:
00126         GECODE_ES_FAIL((Rel::ReEq<FloatView,Int::NegBoolView,RM_PMI>::
00127                              post(home,x0,x1,n)));
00128         break;
00129       case RM_PMI:
00130         GECODE_ES_FAIL((Rel::ReEq<FloatView,Int::NegBoolView,RM_IMP>::
00131                              post(home,x0,x1,n)));
00132         break;
00133       default: throw Int::UnknownReifyMode("Float::rel");
00134       }
00135       break;
00136     }
00137     case FRT_GQ:
00138       std::swap(x0,x1); // Fall through
00139     case FRT_LQ:
00140       switch (r.mode()) {
00141       case RM_EQV:
00142         GECODE_ES_FAIL((Rel::ReLq<FloatView,Int::BoolView,RM_EQV>::
00143                              post(home,x0,x1,r.var())));
00144         break;
00145       case RM_IMP:
00146         GECODE_ES_FAIL((Rel::ReLq<FloatView,Int::BoolView,RM_IMP>::
00147                              post(home,x0,x1,r.var())));
00148         break;
00149       case RM_PMI:
00150         GECODE_ES_FAIL((Rel::ReLq<FloatView,Int::BoolView,RM_PMI>::
00151                              post(home,x0,x1,r.var())));
00152         break;
00153       default: throw Int::UnknownReifyMode("Float::rel");
00154       }
00155       break;
00156     case FRT_LE:
00157       std::swap(x0,x1); // Fall through
00158     case FRT_GR:
00159     {
00160       Int::NegBoolView n(r.var());
00161       switch (r.mode()) {
00162       case RM_EQV:
00163         GECODE_ES_FAIL((Rel::ReLq<FloatView,Int::NegBoolView,RM_EQV>::
00164                              post(home,x0,x1,n)));
00165         break;
00166       case RM_IMP:
00167         GECODE_ES_FAIL((Rel::ReLq<FloatView,Int::NegBoolView,RM_PMI>::
00168                              post(home,x0,x1,n)));
00169         break;
00170       case RM_PMI:
00171         GECODE_ES_FAIL((Rel::ReLq<FloatView,Int::NegBoolView,RM_IMP>::
00172                              post(home,x0,x1,n)));
00173         break;
00174       default: throw Int::UnknownReifyMode("Float::rel");
00175       }
00176       break;
00177     }
00178     default:
00179       throw Int::UnknownRelation("Float::rel");
00180     }
00181   }
00182 
00183   void
00184   rel(Home home, FloatVar x, FloatRelType frt, FloatVal n, Reify r) {
00185     using namespace Float;
00186     Limits::check(n,"Float::rel");
00187     GECODE_POST;
00188     switch (frt) {
00189     case FRT_EQ:
00190       switch (r.mode()) {
00191       case RM_EQV:
00192         GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::BoolView,RM_EQV>::
00193                              post(home,x,n,r.var())));
00194         break;
00195       case RM_IMP:
00196         GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::BoolView,RM_IMP>::
00197                              post(home,x,n,r.var())));
00198         break;
00199       case RM_PMI:
00200         GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::BoolView,RM_PMI>::
00201                              post(home,x,n,r.var())));
00202         break;
00203       default: throw Int::UnknownReifyMode("Float::rel");
00204       }
00205       break;
00206     case FRT_NQ:
00207     {
00208       Int::NegBoolView nb(r.var());
00209       switch (r.mode()) {
00210       case RM_EQV:
00211         GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::NegBoolView,RM_EQV>::
00212                              post(home,x,n,nb)));
00213         break;
00214       case RM_IMP:
00215         GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::NegBoolView,RM_PMI>::
00216                              post(home,x,n,nb)));
00217         break;
00218       case RM_PMI:
00219         GECODE_ES_FAIL((Rel::ReEqFloat<FloatView,Int::NegBoolView,RM_IMP>::
00220                              post(home,x,n,nb)));
00221         break;
00222       default: throw Int::UnknownReifyMode("Float::rel");
00223       }
00224       break;
00225     }
00226     case FRT_LQ:
00227       switch (r.mode()) {
00228       case RM_EQV:
00229         GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::BoolView,RM_EQV>::
00230                              post(home,x,n,r.var())));
00231         break;
00232       case RM_IMP:
00233         GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::BoolView,RM_IMP>::
00234                              post(home,x,n,r.var())));
00235         break;
00236       case RM_PMI:
00237         GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::BoolView,RM_PMI>::
00238                              post(home,x,n,r.var())));
00239         break;
00240       default: throw Int::UnknownReifyMode("Float::rel");
00241       }
00242       break;
00243     case FRT_LE:
00244       switch (r.mode()) {
00245       case RM_EQV:
00246         GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::BoolView,RM_EQV>::
00247                              post(home,x,n,r.var())));
00248         break;
00249       case RM_IMP:
00250         GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::BoolView,RM_IMP>::
00251                              post(home,x,n,r.var())));
00252         break;
00253       case RM_PMI:
00254         GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::BoolView,RM_PMI>::
00255                              post(home,x,n,r.var())));
00256         break;
00257       default: throw Int::UnknownReifyMode("Float::rel");
00258       }
00259       break;
00260     case FRT_GQ:
00261     {
00262       Int::NegBoolView nb(r.var());
00263       switch (r.mode()) {
00264       case RM_EQV:
00265         GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::NegBoolView,RM_EQV>::
00266                              post(home,x,n,nb)));
00267         break;
00268       case RM_IMP:
00269         GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::NegBoolView,RM_PMI>::
00270                              post(home,x,n,nb)));
00271         break;
00272       case RM_PMI:
00273         GECODE_ES_FAIL((Rel::ReLeFloat<FloatView,Int::NegBoolView,RM_IMP>::
00274                              post(home,x,n,nb)));
00275         break;
00276       default: throw Int::UnknownReifyMode("Float::rel");
00277       }
00278       break;
00279     }
00280     case FRT_GR:
00281     {
00282       Int::NegBoolView nb(r.var());
00283       switch (r.mode()) {
00284       case RM_EQV:
00285         GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::NegBoolView,RM_EQV>::
00286                              post(home,x,n,nb)));
00287         break;
00288       case RM_IMP:
00289         GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::NegBoolView,RM_PMI>::
00290                              post(home,x,n,nb)));
00291         break;
00292       case RM_PMI:
00293         GECODE_ES_FAIL((Rel::ReLqFloat<FloatView,Int::NegBoolView,RM_IMP>::
00294                              post(home,x,n,nb)));
00295         break;
00296       default: throw Int::UnknownReifyMode("Float::rel");
00297       }
00298       break;
00299     }
00300     default:
00301       throw Int::UnknownRelation("Float::rel");
00302     }
00303   }
00304 
00305   void
00306   rel(Home home, const FloatVarArgs& x, FloatRelType frt, FloatVal c) {
00307     using namespace Float;
00308     Limits::check(c,"Float::rel");
00309     GECODE_POST;
00310     switch (frt) {
00311     case FRT_EQ:
00312       for (int i=x.size(); i--; ) {
00313         FloatView xi(x[i]); GECODE_ME_FAIL(xi.eq(home,c));
00314       }
00315       break;
00316     case FRT_NQ:
00317       for (int i=x.size(); i--; ) {
00318         FloatView xi(x[i]); GECODE_ES_FAIL((Rel::NqFloat<FloatView>::post(home,xi,c)));
00319       }
00320       break;
00321     case FRT_LQ:
00322       for (int i=x.size(); i--; ) {
00323         FloatView xi(x[i]); GECODE_ME_FAIL(xi.lq(home,c));
00324       }
00325       break;
00326     case FRT_LE:
00327       for (int i=x.size(); i--; ) {
00328         FloatView xi(x[i]); GECODE_ME_FAIL(xi.lq(home,c));
00329         GECODE_ES_FAIL((Rel::NqFloat<FloatView>::post(home,xi,c)));
00330       }
00331       break;
00332     case FRT_GQ:
00333       for (int i=x.size(); i--; ) {
00334         FloatView xi(x[i]); GECODE_ME_FAIL(xi.gq(home,c));
00335       }
00336       break;
00337     case FRT_GR:
00338       for (int i=x.size(); i--; ) {
00339         FloatView xi(x[i]); GECODE_ME_FAIL(xi.gq(home,c));
00340         GECODE_ES_FAIL((Rel::NqFloat<FloatView>::post(home,xi,c)));
00341       }
00342       break;
00343     default:
00344       throw UnknownRelation("Float::rel");
00345     }
00346   }
00347 
00348   void
00349   rel(Home home, const FloatVarArgs& x, FloatRelType frt, FloatVar y) {
00350     using namespace Float;
00351     GECODE_POST;
00352     switch (frt) {
00353     case FRT_EQ:
00354       for (int i=x.size(); i--; ) {
00355         GECODE_ES_FAIL((Rel::Eq<FloatView,FloatView>::post(home,y,x[i])));
00356       }
00357       break;
00358     case FRT_NQ:
00359       for (int i=x.size(); i--; ) {
00360         GECODE_ES_FAIL((Rel::Nq<FloatView,FloatView>::post(home,y,x[i])));
00361       }
00362       break;
00363     case FRT_GQ:
00364       for (int i=x.size(); i--; ) {
00365         GECODE_ES_FAIL((Rel::Lq<FloatView>::post(home,y,x[i])));
00366       }
00367       break;
00368     case FRT_GR:
00369       for (int i=x.size(); i--; ) {
00370         GECODE_ES_FAIL((Rel::Le<FloatView>::post(home,y,x[i])));
00371       }
00372       break;
00373     case FRT_LQ:
00374       for (int i=x.size(); i--; ) {
00375         GECODE_ES_FAIL((Rel::Lq<FloatView>::post(home,x[i],y)));
00376       }
00377       break;
00378     case FRT_LE:
00379       for (int i=x.size(); i--; ) {
00380         GECODE_ES_FAIL((Rel::Le<FloatView>::post(home,x[i],y)));
00381       }
00382       break;
00383     default:
00384       throw UnknownRelation("Float::rel");
00385     }
00386   }
00387 }
00388 
00389 // STATISTICS: float-post