arithmetic.cpp
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: 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