arithmetic.cpp

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: 2010-04-08 12:35:31 +0200 (Thu, 08 Apr 2010) $ by $Author: schulte $
00011  *     $Revision: 10684 $
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 #include "test/int.hh"
00039 
00040 #include <cmath>
00041 #include <algorithm>
00042 
00043 namespace Test { namespace Int {
00044 
00046    namespace Arithmetic {
00047 
00053 
00054      class MultXYZ : public Test {
00055      public:
00057        MultXYZ(const std::string& s, const Gecode::IntSet& d,
00058                Gecode::IntConLevel icl)
00059          : Test("Arithmetic::Mult::XYZ::"+str(icl)+"::"+s,3,d,false,icl) {}
00061        virtual bool solution(const Assignment& x) const {
00062          double d0 = static_cast<double>(x[0]);
00063          double d1 = static_cast<double>(x[1]);
00064          double d2 = static_cast<double>(x[2]);
00065          return d0*d1 == d2;
00066        }
00068        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00069          Gecode::mult(home, x[0], x[1], x[2], icl);
00070        }
00071      };
00072 
00074      class MultXXY : public Test {
00075      public:
00077        MultXXY(const std::string& s, const Gecode::IntSet& d,
00078                Gecode::IntConLevel icl)
00079          : Test("Arithmetic::Mult::XXY::"+str(icl)+"::"+s,2,d,false,icl) {}
00081        virtual bool solution(const Assignment& x) const {
00082          double d0 = static_cast<double>(x[0]);
00083          double d1 = static_cast<double>(x[0]);
00084          double d2 = static_cast<double>(x[1]);
00085          return d0*d1 == d2;
00086        }
00088        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00089          Gecode::mult(home, x[0], x[0], x[1], icl);
00090        }
00091      };
00092 
00094      class MultXYX : public Test {
00095      public:
00097        MultXYX(const std::string& s, const Gecode::IntSet& d,
00098                Gecode::IntConLevel icl)
00099          : Test("Arithmetic::Mult::XYX::"+str(icl)+"::"+s,2,d,false,icl) {}
00101        virtual bool solution(const Assignment& x) const {
00102          double d0 = static_cast<double>(x[0]);
00103          double d1 = static_cast<double>(x[1]);
00104          double d2 = static_cast<double>(x[0]);
00105          return d0*d1 == d2;
00106        }
00108        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00109          Gecode::mult(home, x[0], x[1], x[0], icl);
00110        }
00111      };
00112 
00114      class MultXYY : public Test {
00115      public:
00117        MultXYY(const std::string& s, const Gecode::IntSet& d,
00118                Gecode::IntConLevel icl)
00119          : Test("Arithmetic::Mult::XYY::"+str(icl)+"::"+s,2,d,false,icl) {}
00121        virtual bool solution(const Assignment& x) const {
00122          double d0 = static_cast<double>(x[0]);
00123          double d1 = static_cast<double>(x[1]);
00124          double d2 = static_cast<double>(x[1]);
00125          return d0*d1 == d2;
00126        }
00128        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00129          Gecode::mult(home, x[0], x[1], x[1], icl);
00130        }
00131      };
00132 
00134      class MultXXX : public Test {
00135      public:
00137        MultXXX(const std::string& s, const Gecode::IntSet& d,
00138                Gecode::IntConLevel icl)
00139          : Test("Arithmetic::Mult::XXX::"+str(icl)+"::"+s,1,d,false,icl) {}
00141        virtual bool solution(const Assignment& x) const {
00142          double d0 = static_cast<double>(x[0]);
00143          double d1 = static_cast<double>(x[0]);
00144          double d2 = static_cast<double>(x[0]);
00145          return d0*d1 == d2;
00146        }
00148        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00149          Gecode::mult(home, x[0], x[0], x[0], icl);
00150        }
00151      };
00152 
00154      class SqrXY : public Test {
00155      public:
00157        SqrXY(const std::string& s, const Gecode::IntSet& d,
00158              Gecode::IntConLevel icl)
00159          : Test("Arithmetic::Sqr::XY::"+str(icl)+"::"+s,2,d,false,icl) {}
00161        virtual bool solution(const Assignment& x) const {
00162          double d0 = static_cast<double>(x[0]);
00163          double d1 = static_cast<double>(x[1]);
00164          return d0*d0 == d1;
00165        }
00167        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00168          Gecode::sqr(home, x[0], x[1], icl);
00169        }
00170      };
00171 
00173      class SqrXX : public Test {
00174      public:
00176        SqrXX(const std::string& s, const Gecode::IntSet& d,
00177              Gecode::IntConLevel icl)
00178          : Test("Arithmetic::Sqr::XX::"+str(icl)+"::"+s,1,d,false,icl) {}
00180        virtual bool solution(const Assignment& x) const {
00181          double d0 = static_cast<double>(x[0]);
00182          return d0*d0 == d0;
00183        }
00185        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00186          Gecode::sqr(home, x[0], x[0], icl);
00187        }
00188      };
00189 
00191      class SqrtXY : public Test {
00192      public:
00194        SqrtXY(const std::string& s, const Gecode::IntSet& d,
00195               Gecode::IntConLevel icl)
00196          : Test("Arithmetic::Sqrt::XY::"+str(icl)+"::"+s,2,d,false,icl) {}
00198        virtual bool solution(const Assignment& x) const {
00199          double d0 = static_cast<double>(x[0]);
00200          double d1 = static_cast<double>(x[1]);
00201          return (d0 >= 0) && (d0 >= d1*d1) && (d0 < (d1+1)*(d1+1));
00202        }
00204        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00205          Gecode::sqrt(home, x[0], x[1], icl);
00206        }
00207      };
00208 
00210      class SqrtXX : public Test {
00211      public:
00213        SqrtXX(const std::string& s, const Gecode::IntSet& d,
00214               Gecode::IntConLevel icl)
00215          : Test("Arithmetic::Sqrt::XX::"+str(icl)+"::"+s,1,d,false,icl) {}
00217        virtual bool solution(const Assignment& x) const {
00218          double d0 = static_cast<double>(x[0]);
00219          return (d0 >= 0) && (d0 >= d0*d0) && (d0 < (d0+1)*(d0+1));
00220        }
00222        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00223          Gecode::sqrt(home, x[0], x[0], icl);
00224        }
00225      };
00226 
00228      class DivMod : public Test {
00229      private:
00230        static int abs(int a) { return a<0 ? -a:a; }
00231        static int sgn(int a) { return a<0 ? -1:1; }
00232      public:
00234        DivMod(const std::string& s, const Gecode::IntSet& d)
00235          : Test("Arithmetic::DivMod::"+s,4,d,false,icl) {}
00237        virtual bool solution(const Assignment& x) const {
00238          return x[0] == x[1]*x[2]+x[3] &&
00239                 abs(x[3]) < abs(x[1]) &&
00240                 (x[3] == 0 || sgn(x[3]) == sgn(x[0]));
00241        }
00243        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00244          Gecode::divmod(home, x[0], x[1], x[2], x[3], icl);
00245        }
00246      };
00247 
00249      class Div : public Test {
00250      public:
00252        Div(const std::string& s, const Gecode::IntSet& d)
00253          : Test("Arithmetic::Div::"+s,3,d,false,icl) {}
00255        virtual bool solution(const Assignment& x) const {
00256          if (x[1] == 0)
00257            return false;
00258          int divsign = (x[0] / x[1] < 0) ? -1 : 1;
00259          int divresult =
00260            divsign *
00261            static_cast<int>(floor(static_cast<double>(std::abs(x[0]))/
00262                                   static_cast<double>(std::abs(x[1]))));
00263          return x[2] == divresult;
00264        }
00266        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00267          Gecode::div(home, x[0], x[1], x[2], icl);
00268        }
00269      };
00270 
00272      class Mod : public Test {
00273      public:
00275        Mod(const std::string& s, const Gecode::IntSet& d)
00276          : Test("Arithmetic::Mod::"+s,3,d,false,icl) {}
00278        virtual bool solution(const Assignment& x) const {
00279          if (x[1] == 0)
00280            return false;
00281          int divsign = (x[0] / x[1] < 0) ? -1 : 1;
00282          int divresult =
00283            divsign *
00284            static_cast<int>(floor(static_cast<double>(std::abs(x[0]))/
00285                                   static_cast<double>(std::abs(x[1]))));
00286          return x[0] == x[1]*divresult+x[2];
00287        }
00289        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00290          Gecode::mod(home, x[0], x[1], x[2], icl);
00291        }
00292      };
00293 
00295      class AbsXY : public Test {
00296      public:
00298        AbsXY(const std::string& s, const Gecode::IntSet& d,
00299              Gecode::IntConLevel icl)
00300          : Test("Arithmetic::Abs::XY::"+str(icl)+"::"+s,2,d,false,icl) {}
00302        virtual bool solution(const Assignment& x) const {
00303          double d0 = static_cast<double>(x[0]);
00304          double d1 = static_cast<double>(x[1]);
00305          return (d0<0 ? -d0 : d0) == d1;
00306        }
00308        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00309          Gecode::abs(home, x[0], x[1], icl);
00310        }
00311      };
00312 
00314      class AbsXX : public Test {
00315      public:
00317        AbsXX(const std::string& s, const Gecode::IntSet& d,
00318              Gecode::IntConLevel icl)
00319          : Test("Arithmetic::Abs::XX::"+str(icl)+"::"+s,1,d,false,icl) {}
00321        virtual bool solution(const Assignment& x) const {
00322          double d0 = static_cast<double>(x[0]);
00323          double d1 = static_cast<double>(x[0]);
00324          return (d0<0 ? -d0 : d0) == d1;
00325        }
00327        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00328          Gecode::abs(home, x[0], x[0], icl);
00329        }
00330      };
00331 
00333      class MinXYZ : public Test {
00334      public:
00336        MinXYZ(const std::string& s, const Gecode::IntSet& d,
00337               Gecode::IntConLevel icl)
00338          : Test("Arithmetic::Min::Bin::XYZ::"+str(icl)+"::"+s,3,d,false,icl) {}
00340        virtual bool solution(const Assignment& x) const {
00341          return std::min(x[0],x[1]) == x[2];
00342        }
00344        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00345          Gecode::min(home, x[0], x[1], x[2], icl);
00346        }
00347      };
00348 
00350      class MinXXY : public Test {
00351      public:
00353        MinXXY(const std::string& s, const Gecode::IntSet& d,
00354               Gecode::IntConLevel icl)
00355          : Test("Arithmetic::Min::Bin::XYX::"+str(icl)+"::"+s,2,d) {}
00357        virtual bool solution(const Assignment& x) const {
00358          return std::min(x[0],x[0]) == x[1];
00359        }
00361        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00362          Gecode::min(home, x[0], x[0], x[1], icl);
00363        }
00364      };
00365 
00367      class MinXYX : public Test {
00368      public:
00370        MinXYX(const std::string& s, const Gecode::IntSet& d,
00371               Gecode::IntConLevel icl)
00372          : Test("Arithmetic::Min::Bin::XYX::"+str(icl)+"::"+s,2,d) {}
00374        virtual bool solution(const Assignment& x) const {
00375          return std::min(x[0],x[1]) == x[0];
00376        }
00378        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00379          Gecode::min(home, x[0], x[1], x[0], icl);
00380        }
00381      };
00382 
00384      class MinXYY : public Test {
00385      public:
00387        MinXYY(const std::string& s, const Gecode::IntSet& d,
00388               Gecode::IntConLevel icl)
00389          : Test("Arithmetic::Min::Bin::XYY::"+str(icl)+"::"+s,2,d) {}
00391        virtual bool solution(const Assignment& x) const {
00392          return std::min(x[0],x[1]) == x[1];
00393        }
00395        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00396          Gecode::min(home, x[0], x[1], x[1], icl);
00397        }
00398      };
00399 
00401      class MinXXX : public Test {
00402      public:
00404        MinXXX(const std::string& s, const Gecode::IntSet& d,
00405               Gecode::IntConLevel icl)
00406          : Test("Arithmetic::Min::Bin::XXX::"+str(icl)+"::"+s,1,d) {}
00408        virtual bool solution(const Assignment& x) const {
00409          return std::min(x[0],x[0]) == x[0];
00410        }
00412        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00413          Gecode::min(home, x[0], x[0], x[0], icl);
00414        }
00415      };
00416 
00418      class MaxXYZ : public Test {
00419      public:
00421        MaxXYZ(const std::string& s, const Gecode::IntSet& d,
00422               Gecode::IntConLevel icl)
00423          : Test("Arithmetic::Max::Bin::XYZ::"+str(icl)+"::"+s,3,d) {
00424          contest = CTL_BOUNDS_Z;
00425        }
00427        virtual bool solution(const Assignment& x) const {
00428          return std::max(x[0],x[1]) == x[2];
00429        }
00431        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00432          Gecode::max(home, x[0], x[1], x[2], icl);
00433        }
00434      };
00435 
00437      class MaxXXY : public Test {
00438      public:
00440        MaxXXY(const std::string& s, const Gecode::IntSet& d,
00441               Gecode::IntConLevel icl)
00442          : Test("Arithmetic::Max::Bin::XXY::"+str(icl)+"::"+s,2,d) {}
00444        virtual bool solution(const Assignment& x) const {
00445          return std::max(x[0],x[0]) == x[1];
00446        }
00448        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00449          Gecode::max(home, x[0], x[0], x[1], icl);
00450        }
00451      };
00452 
00454      class MaxXYX : public Test {
00455      public:
00457        MaxXYX(const std::string& s, const Gecode::IntSet& d,
00458               Gecode::IntConLevel icl)
00459          : Test("Arithmetic::Max::Bin::XYX::"+str(icl)+"::"+s,2,d) {}
00461        virtual bool solution(const Assignment& x) const {
00462          return std::max(x[0],x[1]) == x[0];
00463        }
00465        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00466          Gecode::max(home, x[0], x[1], x[0], icl);
00467        }
00468      };
00469 
00471      class MaxXYY : public Test {
00472      public:
00474        MaxXYY(const std::string& s, const Gecode::IntSet& d,
00475               Gecode::IntConLevel icl)
00476          : Test("Arithmetic::Max::Bin::XYY::"+str(icl)+"::"+s,2,d) {}
00478        virtual bool solution(const Assignment& x) const {
00479          return std::max(x[0],x[1]) == x[1];
00480        }
00482        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00483          Gecode::max(home, x[0], x[1], x[1], icl);
00484        }
00485      };
00486 
00488      class MaxXXX : public Test {
00489      public:
00491        MaxXXX(const std::string& s, const Gecode::IntSet& d,
00492               Gecode::IntConLevel icl)
00493          : Test("Arithmetic::Max::Bin::XXX::"+str(icl)+"::"+s,1,d) {}
00495        virtual bool solution(const Assignment& x) const {
00496          return std::max(x[0],x[0]) == x[0];
00497        }
00499        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00500          Gecode::max(home, x[0], x[0], x[0], icl);
00501        }
00502      };
00503 
00505      class MinNary : public Test {
00506      public:
00508        MinNary(Gecode::IntConLevel icl)
00509          : Test("Arithmetic::Min::Nary::"+str(icl),4,-4,4,false,icl) {}
00511        virtual bool solution(const Assignment& x) const {
00512          return std::min(std::min(x[0],x[1]), x[2]) == x[3];
00513        }
00515        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00516          Gecode::IntVarArgs m(3);
00517          m[0]=x[0]; m[1]=x[1]; m[2]=x[2];
00518          Gecode::min(home, m, x[3], icl);
00519        }
00520      };
00521 
00523      class MinNaryShared : public Test {
00524      public:
00526        MinNaryShared(Gecode::IntConLevel icl)
00527          : Test("Arithmetic::Min::Nary::Shared::"+str(icl),3,-4,4,false,icl) {}
00529        virtual bool solution(const Assignment& x) const {
00530          return std::min(std::min(x[0],x[1]), x[2]) == x[1];
00531        }
00533        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00534          Gecode::IntVarArgs m(3);
00535          m[0]=x[0]; m[1]=x[1]; m[2]=x[2];
00536          Gecode::min(home, m, x[1], icl);
00537        }
00538      };
00539 
00541      class MaxNary : public Test {
00542      public:
00544        MaxNary(Gecode::IntConLevel icl)
00545          : Test("Arithmetic::Max::Nary::"+str(icl),4,-4,4,false,icl) {}
00547        virtual bool solution(const Assignment& x) const {
00548          return std::max(std::max(x[0],x[1]), x[2]) == x[3];
00549        }
00551        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00552          Gecode::IntVarArgs m(3);
00553          m[0]=x[0]; m[1]=x[1]; m[2]=x[2];
00554          Gecode::max(home, m, x[3], icl);
00555        }
00556      };
00557 
00559      class MaxNaryShared : public Test {
00560      public:
00562        MaxNaryShared(Gecode::IntConLevel icl)
00563          : Test("Arithmetic::Max::Nary::Shared::"+str(icl),3,-4,4,false,icl) {}
00565        virtual bool solution(const Assignment& x) const {
00566          return std::max(std::max(x[0],x[1]), x[2]) == x[1];
00567        }
00569        virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
00570          Gecode::IntVarArgs m(3);
00571          m[0]=x[0]; m[1]=x[1]; m[2]=x[2];
00572          Gecode::max(home, m, x[1], icl);
00573        }
00574      };
00575 
00576 
00577 
00578      const int va[7] = {
00579        Gecode::Int::Limits::min, Gecode::Int::Limits::min+1,
00580        -1,0,1,
00581        Gecode::Int::Limits::max-1, Gecode::Int::Limits::max
00582      };
00583      const int vb[9] = {
00584        static_cast<int>(-sqrt(static_cast<double>
00585                               (-Gecode::Int::Limits::min))),
00586        -4,-2,-1,0,1,2,4,
00587        static_cast<int>(sqrt(static_cast<double>
00588                              (Gecode::Int::Limits::max)))
00589      };
00590 
00591      Gecode::IntSet a(va,7);
00592      Gecode::IntSet b(vb,9);
00593      Gecode::IntSet c(-8,8);
00594 
00595      MultXYZ mult_xyz_b_a("A",a,Gecode::ICL_BND);
00596      MultXYZ mult_xyz_b_b("B",b,Gecode::ICL_BND);
00597      MultXYZ mult_xyz_b_c("C",c,Gecode::ICL_BND);
00598 
00599      MultXXY mult_xxy_b_a("A",a,Gecode::ICL_BND);
00600      MultXXY mult_xxy_b_b("B",b,Gecode::ICL_BND);
00601      MultXXY mult_xxy_b_c("C",c,Gecode::ICL_BND);
00602 
00603      MultXYX mult_xyx_b_a("A",a,Gecode::ICL_BND);
00604      MultXYX mult_xyx_b_b("B",b,Gecode::ICL_BND);
00605      MultXYX mult_xyx_b_c("C",c,Gecode::ICL_BND);
00606 
00607      MultXYY mult_xyy_b_a("A",a,Gecode::ICL_BND);
00608      MultXYY mult_xyy_b_b("B",b,Gecode::ICL_BND);
00609      MultXYY mult_xyy_b_c("C",c,Gecode::ICL_BND);
00610 
00611      MultXXX mult_xxx_b_a("A",a,Gecode::ICL_BND);
00612      MultXXX mult_xxx_b_b("B",b,Gecode::ICL_BND);
00613      MultXXX mult_xxx_b_c("C",c,Gecode::ICL_BND);
00614 
00615      MultXYZ mult_xyz_d_a("A",a,Gecode::ICL_DOM);
00616      MultXYZ mult_xyz_d_b("B",b,Gecode::ICL_DOM);
00617      MultXYZ mult_xyz_d_c("C",c,Gecode::ICL_DOM);
00618 
00619      MultXXY mult_xxy_d_a("A",a,Gecode::ICL_DOM);
00620      MultXXY mult_xxy_d_b("B",b,Gecode::ICL_DOM);
00621      MultXXY mult_xxy_d_c("C",c,Gecode::ICL_DOM);
00622 
00623      MultXYX mult_xyx_d_a("A",a,Gecode::ICL_DOM);
00624      MultXYX mult_xyx_d_b("B",b,Gecode::ICL_DOM);
00625      MultXYX mult_xyx_d_c("C",c,Gecode::ICL_DOM);
00626 
00627      MultXYY mult_xyy_d_a("A",a,Gecode::ICL_DOM);
00628      MultXYY mult_xyy_d_b("B",b,Gecode::ICL_DOM);
00629      MultXYY mult_xyy_d_c("C",c,Gecode::ICL_DOM);
00630 
00631      MultXXX mult_xxx_d_a("A",a,Gecode::ICL_DOM);
00632      MultXXX mult_xxx_d_b("B",b,Gecode::ICL_DOM);
00633      MultXXX mult_xxx_d_c("C",c,Gecode::ICL_DOM);
00634 
00635      SqrXY sqr_xy_b_a("A",a,Gecode::ICL_BND);
00636      SqrXY sqr_xy_b_b("B",b,Gecode::ICL_BND);
00637      SqrXY sqr_xy_b_c("C",c,Gecode::ICL_BND);
00638      SqrXY sqr_xy_d_a("A",a,Gecode::ICL_DOM);
00639      SqrXY sqr_xy_d_b("B",b,Gecode::ICL_DOM);
00640      SqrXY sqr_xy_d_c("C",c,Gecode::ICL_DOM);
00641 
00642      SqrXX sqr_xx_b_a("A",a,Gecode::ICL_BND);
00643      SqrXX sqr_xx_b_b("B",b,Gecode::ICL_BND);
00644      SqrXX sqr_xx_b_c("C",c,Gecode::ICL_BND);
00645      SqrXX sqr_xx_d_a("A",a,Gecode::ICL_DOM);
00646      SqrXX sqr_xx_d_b("B",b,Gecode::ICL_DOM);
00647      SqrXX sqr_xx_d_c("C",c,Gecode::ICL_DOM);
00648 
00649      SqrtXY sqrt_xy_b_a("A",a,Gecode::ICL_BND);
00650      SqrtXY sqrt_xy_b_b("B",b,Gecode::ICL_BND);
00651      SqrtXY sqrt_xy_b_c("C",c,Gecode::ICL_BND);
00652      SqrtXY sqrt_xy_d_a("A",a,Gecode::ICL_DOM);
00653      SqrtXY sqrt_xy_d_b("B",b,Gecode::ICL_DOM);
00654      SqrtXY sqrt_xy_d_c("C",c,Gecode::ICL_DOM);
00655 
00656      SqrtXX sqrt_xx_b_a("A",a,Gecode::ICL_BND);
00657      SqrtXX sqrt_xx_b_b("B",b,Gecode::ICL_BND);
00658      SqrtXX sqrt_xx_b_c("C",c,Gecode::ICL_BND);
00659      SqrtXX sqrt_xx_d_a("A",a,Gecode::ICL_DOM);
00660      SqrtXX sqrt_xx_d_b("B",b,Gecode::ICL_DOM);
00661      SqrtXX sqrt_xx_d_c("C",c,Gecode::ICL_DOM);
00662 
00663      DivMod divmod_a_bnd("A",a);
00664      DivMod divmod_b_bnd("B",b);
00665      DivMod divmod_c_bnd("C",c);
00666 
00667      Div div_a_bnd("A",a);
00668      Div div_b_bnd("B",b);
00669      Div div_c_bnd("C",c);
00670 
00671      Mod mod_a_bnd("A",a);
00672      Mod mod_b_bnd("B",b);
00673      Mod mod_c_bnd("C",c);
00674 
00675      AbsXY abs_xy_b_a("A",a,Gecode::ICL_BND);
00676      AbsXY abs_xy_b_b("B",b,Gecode::ICL_BND);
00677      AbsXY abs_xy_b_c("C",c,Gecode::ICL_BND);
00678      AbsXY abs_xy_d_a("A",a,Gecode::ICL_DOM);
00679      AbsXY abs_xy_d_b("B",b,Gecode::ICL_DOM);
00680      AbsXY abs_xy_d_c("C",c,Gecode::ICL_DOM);
00681 
00682      AbsXX abs_xx_b_a("A",a,Gecode::ICL_BND);
00683      AbsXX abs_xx_b_b("B",b,Gecode::ICL_BND);
00684      AbsXX abs_xx_b_c("C",c,Gecode::ICL_BND);
00685      AbsXX abs_xx_d_a("A",a,Gecode::ICL_DOM);
00686      AbsXX abs_xx_d_b("B",b,Gecode::ICL_DOM);
00687      AbsXX abs_xx_d_c("C",c,Gecode::ICL_DOM);
00688 
00689      MinXYZ min_xyz_b_a("A",a,Gecode::ICL_BND);
00690      MinXYZ min_xyz_b_b("B",b,Gecode::ICL_BND);
00691      MinXYZ min_xyz_b_c("C",c,Gecode::ICL_BND);
00692      MinXYZ min_xyz_d_a("A",a,Gecode::ICL_DOM);
00693      MinXYZ min_xyz_d_b("B",b,Gecode::ICL_DOM);
00694      MinXYZ min_xyz_d_c("C",c,Gecode::ICL_DOM);
00695 
00696      MinXXY min_xxy_b_a("A",a,Gecode::ICL_BND);
00697      MinXXY min_xxy_b_b("B",b,Gecode::ICL_BND);
00698      MinXXY min_xxy_b_c("C",c,Gecode::ICL_BND);
00699      MinXXY min_xxy_d_a("A",a,Gecode::ICL_DOM);
00700      MinXXY min_xxy_d_b("B",b,Gecode::ICL_DOM);
00701      MinXXY min_xxy_d_c("C",c,Gecode::ICL_DOM);
00702 
00703      MinXYX min_xyx_b_a("A",a,Gecode::ICL_BND);
00704      MinXYX min_xyx_b_b("B",b,Gecode::ICL_BND);
00705      MinXYX min_xyx_b_c("C",c,Gecode::ICL_BND);
00706      MinXYX min_xyx_d_a("A",a,Gecode::ICL_DOM);
00707      MinXYX min_xyx_d_b("B",b,Gecode::ICL_DOM);
00708      MinXYX min_xyx_d_c("C",c,Gecode::ICL_DOM);
00709 
00710      MinXYY min_xyy_b_a("A",a,Gecode::ICL_BND);
00711      MinXYY min_xyy_b_b("B",b,Gecode::ICL_BND);
00712      MinXYY min_xyy_b_c("C",c,Gecode::ICL_BND);
00713      MinXYY min_xyy_d_a("A",a,Gecode::ICL_DOM);
00714      MinXYY min_xyy_d_b("B",b,Gecode::ICL_DOM);
00715      MinXYY min_xyy_d_c("C",c,Gecode::ICL_DOM);
00716 
00717      MinXXX min_xxx_b_a("A",a,Gecode::ICL_BND);
00718      MinXXX min_xxx_b_b("B",b,Gecode::ICL_BND);
00719      MinXXX min_xxx_b_c("C",c,Gecode::ICL_BND);
00720      MinXXX min_xxx_d_a("A",a,Gecode::ICL_DOM);
00721      MinXXX min_xxx_d_b("B",b,Gecode::ICL_DOM);
00722      MinXXX min_xxx_d_c("C",c,Gecode::ICL_DOM);
00723 
00724      MaxXYZ max_xyz_b_a("A",a,Gecode::ICL_BND);
00725      MaxXYZ max_xyz_b_b("B",b,Gecode::ICL_BND);
00726      MaxXYZ max_xyz_b_c("C",c,Gecode::ICL_BND);
00727      MaxXYZ max_xyz_d_a("A",a,Gecode::ICL_DOM);
00728      MaxXYZ max_xyz_d_b("B",b,Gecode::ICL_DOM);
00729      MaxXYZ max_xyz_d_c("C",c,Gecode::ICL_DOM);
00730 
00731      MaxXXY max_xxy_b_a("A",a,Gecode::ICL_BND);
00732      MaxXXY max_xxy_b_b("B",b,Gecode::ICL_BND);
00733      MaxXXY max_xxy_b_c("C",c,Gecode::ICL_BND);
00734      MaxXXY max_xxy_d_a("A",a,Gecode::ICL_DOM);
00735      MaxXXY max_xxy_d_b("B",b,Gecode::ICL_DOM);
00736      MaxXXY max_xxy_d_c("C",c,Gecode::ICL_DOM);
00737 
00738      MaxXYX max_xyx_b_a("A",a,Gecode::ICL_BND);
00739      MaxXYX max_xyx_b_b("B",b,Gecode::ICL_BND);
00740      MaxXYX max_xyx_b_c("C",c,Gecode::ICL_BND);
00741      MaxXYX max_xyx_d_a("A",a,Gecode::ICL_DOM);
00742      MaxXYX max_xyx_d_b("B",b,Gecode::ICL_DOM);
00743      MaxXYX max_xyx_d_c("C",c,Gecode::ICL_DOM);
00744 
00745      MaxXYY max_xyy_b_a("A",a,Gecode::ICL_BND);
00746      MaxXYY max_xyy_b_b("B",b,Gecode::ICL_BND);
00747      MaxXYY max_xyy_b_c("C",c,Gecode::ICL_BND);
00748      MaxXYY max_xyy_d_a("A",a,Gecode::ICL_DOM);
00749      MaxXYY max_xyy_d_b("B",b,Gecode::ICL_DOM);
00750      MaxXYY max_xyy_d_c("C",c,Gecode::ICL_DOM);
00751 
00752      MaxXXX max_xxx_b_a("A",a,Gecode::ICL_BND);
00753      MaxXXX max_xxx_b_b("B",b,Gecode::ICL_BND);
00754      MaxXXX max_xxx_b_c("C",c,Gecode::ICL_BND);
00755      MaxXXX max_xxx_d_a("A",a,Gecode::ICL_DOM);
00756      MaxXXX max_xxx_d_b("B",b,Gecode::ICL_DOM);
00757      MaxXXX max_xxx_d_c("C",c,Gecode::ICL_DOM);
00758 
00759      MinNary       min_nary_b(Gecode::ICL_BND);
00760      MinNary       min_nary_d(Gecode::ICL_DOM);
00761      MinNaryShared min_s_nary_b(Gecode::ICL_BND);
00762      MinNaryShared min_s_nary_d(Gecode::ICL_DOM);
00763      MaxNary       max_nary_b(Gecode::ICL_BND);
00764      MaxNary       max_nary_d(Gecode::ICL_DOM);
00765      MaxNaryShared max_s_nary_b(Gecode::ICL_BND);
00766      MaxNaryShared max_s_nary_d(Gecode::ICL_DOM);
00768 
00769    }
00770 }}
00771 
00772 // STATISTICS: test-int