dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/test/int/basic.cpp

@@ -0,0 +1,82 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  Last modified:
+ *     $Date: 2010-04-08 20:35:31 +1000 (Thu, 08 Apr 2010) $ by $Author: schulte $
+ *     $Revision: 10684 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "test/int.hh"
+
+namespace Test { namespace Int {
+
+   /// %Tests for basic setup
+   namespace Basic {
+
+     /**
+      * \defgroup TaskTestIntBasic Basic setup
+      * \ingroup TaskTestInt
+      */
+     //@{
+
+     /// %Test whether testing infrastructure for integer variables works
+     class Basic : public Test {
+     public:
+       /// Initialize test
+       Basic(int n)
+         : Test("Basic",3,-n,n,true) {}
+       /// Initialize test
+       Basic(Gecode::IntArgs& i)
+         : Test("Basic",3,Gecode::IntSet(i),true) {}
+       /// Check whether \a x is a solution
+       virtual bool solution(const Assignment&) const {
+         return true;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space&, Gecode::IntVarArray&) {
+       }
+       /// Post reified constraint on \a x
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray&,
+                         Gecode::BoolVar b) {
+         Gecode::rel(home, b, Gecode::IRT_EQ, 1);
+       }
+     };
+
+     Gecode::IntArgs i(4, 1,2,3,4);
+     Basic b1(3);
+     Basic b2(i);
+     //@}
+
+   }
+}}
+
+// STATISTICS: test-int

data/ext/libgecode3/vendor/gecode-3.7.3/test/int/bin-packing.cpp

@@ -0,0 +1,237 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2010
+ *
+ *  Last modified:
+ *     $Date: 2010-10-07 08:20:35 +1100 (Thu, 07 Oct 2010) $ by $Author: schulte $
+ *     $Revision: 11468 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "test/int.hh"
+
+#include <gecode/minimodel.hh>
+#include <climits>
+
+namespace Test { namespace Int {
+  
+  /// %Tests for bin-packing constraint
+  namespace BinPacking {
+
+    /**
+     * \defgroup TaskTestIntBinPacking Bin-packing constraints
+     * \ingroup TaskTestInt
+     */
+    //@{
+    /// Generate load and bin assignments
+    class LoadBinAssignment : public Assignment {
+    protected:
+      /// Number of bins
+      int n_bins;
+      /// Number of items
+      int n_items;
+      /// Domain for load variables
+      Gecode::IntSet d_load;
+      /// Domain for bin variables
+      Gecode::IntSet d_bin;
+      /// Load to generate (unless -1)
+      int load;
+      /// Iterator for each variable
+      Gecode::IntSetValues* dsv; 
+    public:
+      /// Initialize assignments for load and bin variables
+      LoadBinAssignment(int m, const Gecode::IntSet& d_m,
+                        int n, const Gecode::IntSet& d_n,
+                        int l)
+        : Assignment(m+n,d_m),
+          n_bins(m), n_items(n), d_load(d_m), d_bin(d_n), load(l),
+          dsv(new Gecode::IntSetValues[static_cast<unsigned int>(m+n)]) {
+        for (int i=n_bins; i--; )
+          dsv[i].init(d_load);
+        for (int i=n_items; i--; )
+          dsv[n_bins+i].init(d_bin);
+      }
+      /// Test whether all assignments have been iterated
+      virtual bool operator()(void) const {
+        return dsv[0]();
+      }
+      /// Move to next assignment
+      virtual void operator++(void) {
+        // Try to generate next bin assignment
+        {
+          int i = n_items-1;
+          while (i >= 0) {
+            ++dsv[n_bins+i];
+            if (dsv[n_bins+i]())
+              return;
+            dsv[n_bins+(i--)].init(d_bin);
+          }
+        }
+        // Try to generate next load assignment
+        {
+        retry:
+          int i = n_bins-1;
+          while (true) {
+            ++dsv[i];
+            if (dsv[i]() || (i == 0)) {
+              if (dsv[i]() && (load >= 0)) {
+                int l = 0;
+                for (int k=0;k<n_bins; k++)
+                  l += dsv[k].val();
+                if (load != l)
+                  goto retry;
+              }
+              return;
+            }
+            dsv[i--].init(d_load);
+          }
+        }
+      }
+      /// Return value for variable \a i
+      virtual int operator[](int i) const {
+        assert((i>=0) && (i<n_bins+n_items));
+        return dsv[i].val();
+      }
+      /// Destructor
+      virtual ~LoadBinAssignment(void) {
+        delete [] dsv;
+      }
+    };
+
+    /// %Test with different bin loads and items
+    class BPT : public Test {
+    protected:
+      /// Number of bins
+      int m;
+      /// Item sizes
+      Gecode::IntArgs s;
+      /// Whether to generate only valid loads
+      bool valid;
+      /// Total item sizes
+      int t;
+      /// Array of sufficient size for computing item loads
+      mutable int il[4];
+      /// Compute total size
+      static int total(const Gecode::IntArgs& s) {
+        int t = 0;
+        for (int i=s.size(); i--; )
+          t += s[i];
+        return t;
+      }
+    public:
+      /// Create and register test for \a m bins and item sizes \a s
+      BPT(int m0, const Gecode::IntArgs& s0, bool v=true) 
+        : Test("BinPacking::"+str(m0)+"::"+str(s0)+"::"+(v ? "+" : "-"),
+               m0+s0.size(), 0, 100), 
+          m(m0), s(s0), valid(v), t(total(s)) {
+        testsearch = false;
+      }
+      /// Create assignment
+      virtual Assignment* assignment(void) const {
+        // Compute plausible bin sizes
+        int a = t / m;
+        return new LoadBinAssignment(m,Gecode::IntSet(a-1,a+2),
+                                     s.size(),Gecode::IntSet(0,m-1),
+                                     valid ? t : -1);
+      }
+      /// %Test whether \a x is solution
+      virtual bool solution(const Assignment& x) const {
+        // Loads are from 0 to m-1, after that are items
+        // Check whether loads sum up to total size
+        int l=0;
+        for (int j=m; j--; )
+          l += x[j];
+        if (l != t)
+          return false;
+        // Compute whether items add up
+        for (int j=m; j--; )
+          il[j] = 0;
+        for (int i=s.size(); i--; )
+          il[x[m+i]] += s[i];
+        for (int j=m; j--; )
+          if (il[j] != x[j])
+            return false;
+        return true;
+      }
+      /// Post constraint on \a x
+      virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+        using namespace Gecode;
+        IntVarArgs l(m);
+        IntVarArgs b(s.size());
+        for (int j=m; j--; )
+          l[j]=x[j];
+        for (int i=s.size(); i--; )
+          b[i]=x[m+i];
+        binpacking(home, l, b, s);
+      }
+    };
+    
+    /// Help class to create and register tests
+    class Create {
+    public:
+      /// Perform creation and registration
+      Create(void) {
+        using namespace Gecode;
+
+        IntArgs s1(3, 2,1,1);
+        IntArgs s2(4, 1,2,3,4);
+        IntArgs s3(4, 4,3,2,1);
+        IntArgs s4(4, 1,2,4,8);
+        IntArgs s5(4, 1,1,1,1);
+        IntArgs s6(4, 1,1,2,2);
+        IntArgs s7(4, 1,3,3,4);
+        IntArgs s8(6, 1,2,4,8,16,32);
+
+        for (int m=1; m<4; m++) {
+          (void) new BPT(m, s1);
+          (void) new BPT(m, s2);
+          (void) new BPT(m, s3);
+          (void) new BPT(m, s4);
+          (void) new BPT(m, s5);
+          (void) new BPT(m, s6);
+          (void) new BPT(m, s7);
+          (void) new BPT(m, s8);
+          (void) new BPT(m, s1, false);
+        }
+
+      }
+    };
+    
+    Create c;
+    
+    //@}
+    
+  }
+
+}}
+
+
+// STATISTICS: test-int
+

data/ext/libgecode3/vendor/gecode-3.7.3/test/int/bool.cpp

@@ -0,0 +1,500 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  Last modified:
+ *     $Date: 2011-10-06 23:38:44 +1100 (Thu, 06 Oct 2011) $ by $Author: schulte $
+ *     $Revision: 12421 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "test/int.hh"
+
+#include <gecode/minimodel.hh>
+
+namespace Test { namespace Int {
+
+   /// %Tests for Boolean constraints
+   namespace Bool {
+
+     inline int
+     check(int x0, Gecode::BoolOpType op, int x1) {
+       switch (op) {
+       case Gecode::BOT_AND: return x0 & x1;
+       case Gecode::BOT_OR:  return x0 | x1;
+       case Gecode::BOT_IMP: return !x0 | x1;
+       case Gecode::BOT_EQV: return x0 == x1;
+       case Gecode::BOT_XOR: return x0 != x1;
+       default: GECODE_NEVER;
+       }
+       GECODE_NEVER;
+       return 0;
+     }
+
+     /**
+      * \defgroup TaskTestIntBool Boolean constraints
+      * \ingroup TaskTestInt
+      */
+     //@{
+     /// %Test for binary Boolean operation
+     class BinXYZ : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+     public:
+       /// Construct and register test
+       BinXYZ(Gecode::BoolOpType op0)
+         : Test("Bool::Bin::XYZ::"+str(op0),3,0,1), op(op0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return check(x[0],op,x[1]) == x[2];
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         rel(home,
+             channel(home,x[0]), op, channel(home,x[1]),
+             channel(home,x[2]));
+       }
+     };
+
+     /// %Test for binary Boolean operation with shared variables
+     class BinXXY : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+     public:
+       /// Construct and register test
+       BinXXY(Gecode::BoolOpType op0)
+         : Test("Bool::Bin::XXY::"+str(op0),2,0,1), op(op0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return check(x[0],op,x[0]) == x[1];
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVar b = channel(home,x[0]);
+         rel(home, b, op, b, channel(home,x[1]));
+       }
+     };
+
+     /// %Test for binary Boolean operation with shared variables
+     class BinXYX : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+     public:
+       /// Construct and register test
+       BinXYX(Gecode::BoolOpType op0)
+         : Test("Bool::Bin::XYX::"+str(op0),2,0,1), op(op0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return check(x[0],op,x[1]) == x[0];
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVar b = channel(home,x[0]);
+         rel(home, b, op, channel(home,x[1]), b);
+       }
+     };
+
+     /// %Test for binary Boolean operation with shared variables
+     class BinXYY : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+     public:
+       /// Construct and register test
+       BinXYY(Gecode::BoolOpType op0)
+         : Test("Bool::Bin::XYY::"+str(op0),2,0,1), op(op0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return check(x[0],op,x[1]) == x[1];
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVar b = channel(home,x[1]);
+         rel(home, channel(home,x[0]), op, b, b);
+       }
+     };
+
+     /// %Test for binary Boolean operation with shared variables
+     class BinXXX : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+     public:
+       /// Construct and register test
+       BinXXX(Gecode::BoolOpType op0)
+         : Test("Bool::Bin::XXX::"+str(op0),1,0,1), op(op0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return check(x[0],op,x[0]) == x[0];
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVar b = channel(home,x[0]);
+         rel(home, b, op, b, b);
+       }
+     };
+
+     /// %Test for binary Boolean operation with constant
+     class BinConstXY : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+       /// Integer constant
+       int c;
+     public:
+       /// Construct and register test
+       BinConstXY(Gecode::BoolOpType op0, int c0)
+         : Test("Bool::Bin::XY::"+str(op0)+"::"+str(c0),2,0,1),
+           op(op0), c(c0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return check(x[0],op,x[1]) == c;
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         rel(home, channel(home,x[0]), op, channel(home,x[1]), c);
+       }
+     };
+
+     /// %Test for binary Boolean operation with shared variables and constant
+     class BinConstXX : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+       /// Integer constant
+       int c;
+     public:
+       /// Construct and register test
+       BinConstXX(Gecode::BoolOpType op0, int c0)
+         : Test("Bool::Bin::XX::"+str(op0)+"::"+str(c0),1,0,1),
+           op(op0), c(c0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return check(x[0],op,x[0]) == c;
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVar b = channel(home,x[0]);
+         rel(home, b, op, b, c);
+       }
+     };
+
+     /// %Test for Nary Boolean operation
+     class Nary : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+     public:
+       /// Construct and register test
+       Nary(Gecode::BoolOpType op0, int n)
+         : Test("Bool::Nary::"+str(op0)+"::"+str(n),n+1,0,1), op(op0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         int n = x.size()-1;
+         int b = check(x[n-2],op,x[n-1]);
+         for (int i=0; i<n-2; i++)
+           b = check(x[i],op,b);
+         return b == x[n];
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVarArgs b(x.size()-1);
+         for (int i=x.size()-1; i--; )
+           b[i]=channel(home,x[i]);
+         rel(home, op, b, channel(home,x[x.size()-1]));
+       }
+     };
+
+     /// %Test for Nary Boolean operation
+     class NaryShared : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+     public:
+       /// Construct and register test
+       NaryShared(Gecode::BoolOpType op0, int n)
+         : Test("Bool::Nary::Shared::"+str(op0)+"::"+str(n),n,0,1),
+           op(op0) {
+         if ((op == Gecode::BOT_EQV) || (op == Gecode::BOT_XOR))
+           testfix = false;
+       }
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         int n = x.size();
+         int b = check(x[n-2],op,x[n-1]);
+         for (int i=0; i<n-2; i++)
+           b = check(x[i],op,b);
+         return b == x[n-1];
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVarArgs b(x.size());
+         for (int i=x.size(); i--; )
+           b[i]=channel(home,x[i]);
+         rel(home, op, b, b[x.size()-1]);
+       }
+     };
+
+     /// %Test for Nary Boolean operation with constant
+     class NaryConst : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+       /// Integer constant
+       int c;
+     public:
+       /// Construct and register test
+       NaryConst(Gecode::BoolOpType op0, int n, int c0)
+         : Test("Bool::Nary::"+str(op0)+"::"+str(n)+"::"+str(c0),n,0,1),
+           op(op0), c(c0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         int n = x.size();
+         int b = check(x[n-2],op,x[n-1]);
+         for (int i=0; i<n-2; i++)
+           b = check(x[i],op,b);
+         return b == c;
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVarArgs b(x.size());
+         for (int i=x.size(); i--; )
+           b[i]=channel(home,x[i]);
+         rel(home, op, b, c);
+       }
+     };
+
+
+     /// %Test for Clause Boolean operation
+     class ClauseXYZ : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+     public:
+       /// Construct and register test
+       ClauseXYZ(Gecode::BoolOpType op0, int n)
+         : Test("Bool::Clause::XYZ::"+str(op0)+"::"+str(n),n+1,0,1), op(op0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         int n = (x.size()-1) / 2;
+         int b;
+         if (n == 1) {
+           b = check(x[0],op,!x[1]);
+         } else {
+           b = check(x[0],op,!x[n]);
+           for (int i=1; i<n; i++)
+             b = check(b,op,check(x[i],op,!x[n+i]));
+         }
+         return b == x[x.size()-1];
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         int n = (x.size()-1) / 2;
+         BoolVarArgs a(n), b(n);
+         for (int i=n; i--; ) {
+           a[i]=channel(home,x[i]);
+           b[i]=channel(home,x[i+n]);
+         }
+         clause(home, op, a, b, channel(home,x[x.size()-1]));
+       }
+     };
+
+     /// %Test for Clause Boolean operation
+     class ClauseXXYYX : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+     public:
+       /// Construct and register test
+       ClauseXXYYX(Gecode::BoolOpType op0, int n)
+         : Test("Bool::Clause::XXYYX::"+str(op0)+"::"+str(n),n,0,1),
+           op(op0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         int n = x.size() / 2;
+         int b;
+         if (n == 1) {
+           b = check(x[0],op,!x[1]);
+         } else {
+           b = check(x[0],op,!x[n]);
+           for (int i=1; i<n; i++)
+             b = check(b,op,check(x[i],op,!x[n+i]));
+         }
+         return b == x[0];
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         int n = x.size() / 2;
+         BoolVarArgs a(2*n), b(2*n);
+         for (int i=n; i--; ) {
+           a[i]=a[i+n]=channel(home,x[i]);
+           b[i]=b[i+n]=channel(home,x[i+n]);
+         }
+         clause(home, op, a, b, a[0]);
+       }
+     };
+
+     /// %Test for Clause Boolean operation
+     class ClauseXXY : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+     public:
+       /// Construct and register test
+       ClauseXXY(Gecode::BoolOpType op0, int n)
+         : Test("Bool::Clause::XXY::"+str(op0)+"::"+str(n),n,0,1),
+           op(op0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return (x[0] == 1) == (op == Gecode::BOT_OR);
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         int n = x.size() / 2;
+         BoolVarArgs a(2*n), b(2*n);
+         for (int i=n; i--; ) {
+           a[i]=b[i+n]=channel(home,x[i]);
+           b[i]=a[i+n]=channel(home,x[i+n]);
+         }
+         clause(home, op, a, b, a[0]);
+       }
+     };
+
+     /// %Test for Clause Boolean operation with constant
+     class ClauseConst : public Test {
+     protected:
+       /// Boolean operation type for test
+       Gecode::BoolOpType op;
+       /// Integer constant
+       int c;
+     public:
+       /// Construct and register test
+       ClauseConst(Gecode::BoolOpType op0, int n, int c0)
+         : Test("Bool::Clause::"+str(op0)+"::"+str(n)+"::"+str(c0),n,0,1),
+           op(op0), c(c0) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         int n = x.size() / 2;
+         int b;
+         if (n == 1) {
+           b = check(x[0],op,!x[1]);
+         } else {
+           b = check(x[0],op,!x[n]);
+           for (int i=1; i<n; i++)
+             b = check(b,op,check(x[i],op,!x[n+i]));
+         }
+         return b == c;
+       }
+       /// Post constraint
+       virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         int n = x.size() / 2;
+         BoolVarArgs a(n), b(n);
+         for (int i=n; i--; ) {
+           a[i]=channel(home,x[i]);
+           b[i]=channel(home,x[i+n]);
+         }
+         clause(home, op, a, b, c);
+       }
+     };
+
+     /// Help class to create and register tests
+     class Create {
+     public:
+       /// Perform creation and registration
+       Create(void) {
+         using namespace Gecode;
+         for (BoolOpTypes bots; bots(); ++bots) {
+           (void) new BinXYZ(bots.bot());
+           (void) new BinXXY(bots.bot());
+           (void) new BinXYX(bots.bot());
+           (void) new BinXYY(bots.bot());
+           (void) new BinXXX(bots.bot());
+           (void) new BinConstXY(bots.bot(),0);
+           (void) new BinConstXY(bots.bot(),1);
+           (void) new BinConstXX(bots.bot(),0);
+           (void) new BinConstXX(bots.bot(),1);
+           (void) new Nary(bots.bot(),2);
+           (void) new Nary(bots.bot(),6);
+           (void) new Nary(bots.bot(),10);
+           (void) new NaryShared(bots.bot(),2);
+           (void) new NaryShared(bots.bot(),6);
+           (void) new NaryShared(bots.bot(),10);
+           (void) new NaryConst(bots.bot(),2,0);
+           (void) new NaryConst(bots.bot(),6,0);
+           (void) new NaryConst(bots.bot(),10,0);
+           (void) new NaryConst(bots.bot(),2,1);
+           (void) new NaryConst(bots.bot(),6,1);
+           (void) new NaryConst(bots.bot(),10,1);
+           if ((bots.bot() == BOT_AND) || (bots.bot() == BOT_OR)) {
+             (void) new ClauseXYZ(bots.bot(),2);
+             (void) new ClauseXYZ(bots.bot(),6);
+             (void) new ClauseXYZ(bots.bot(),10);
+             (void) new ClauseXXYYX(bots.bot(),2);
+             (void) new ClauseXXYYX(bots.bot(),6);
+             (void) new ClauseXXYYX(bots.bot(),10);
+             (void) new ClauseXXY(bots.bot(),2);
+             (void) new ClauseXXY(bots.bot(),6);
+             (void) new ClauseXXY(bots.bot(),10);
+             (void) new ClauseConst(bots.bot(),2,0);
+             (void) new ClauseConst(bots.bot(),6,0);
+             (void) new ClauseConst(bots.bot(),10,0);
+             (void) new ClauseConst(bots.bot(),2,1);
+             (void) new ClauseConst(bots.bot(),6,1);
+             (void) new ClauseConst(bots.bot(),10,1);
+           }
+         }
+       }
+     };
+
+     Create c;
+     //@}
+
+   }
+}}
+
+// STATISTICS: test-int
+