gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/test/int/distinct.cc

@@ -0,0 +1,248 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *     Mikael Lagerkvist, 2006
+ *
+ *  Last modified:
+ *     $Date: 2008-02-27 13:01:20 +0100 (Wed, 27 Feb 2008) $ by $Author: tack $
+ *     $Revision: 6324 $
+ *
+ *  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 distinct constraints
+   namespace Distinct {
+   
+     /**
+      * \defgroup TaskTestIntDistinct Distinct constraints
+      * \ingroup TaskTestInt
+      */
+     //@{
+     /// Simple test for distinct constraint
+     template <bool useCount>
+     class Distinct : public Test {
+     private:
+       Gecode::IntSet d;
+     public:
+       /// Create and register test
+       Distinct(const Gecode::IntSet& d0, Gecode::IntConLevel icl)
+         : Test(std::string(useCount ? "Count::Distinct" : "Distinct")+
+                "::Sparse::"+str(icl),6,d0,false,icl), d(d0) {}
+       /// Create and register test
+       Distinct(int min, int max, Gecode::IntConLevel icl)
+         : Test(std::string(useCount ? "Count::Distinct" : "Distinct")+
+                "::Dense::"+str(icl),6,min,max,false,icl), d(min,max) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         for (int i=0; i<x.size(); i++)
+           for (int j=i+1; j<x.size(); j++)
+             if (x[i]==x[j])
+               return false;
+         return true;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         if (!useCount) {
+           Gecode::distinct(home, x, icl);
+         } else {
+           Gecode::IntSetRanges dr(d);
+           int i = 0;
+           Gecode::IntArgs ia(Gecode::Iter::Ranges::size(dr));
+           for (Gecode::IntSetValues dr2(d); dr2(); ++dr2)
+             ia[i++] = dr2.val();
+           Gecode::count(home, x, Gecode::IntSet(0,1), ia, icl);
+         }
+       }
+     };
+     
+     /// Simple test for distinct constraint with offsets
+     class Offset : public Test {
+     public:
+       /// Create and register test
+       Offset(const Gecode::IntSet& d, Gecode::IntConLevel icl)
+         : Test("Distinct::Offset::Sparse::"+str(icl),6,d,false,icl) {}
+       /// Create and register test
+       Offset(int min, int max, Gecode::IntConLevel icl)
+         : Test("Distinct::Offset::Dense::"+str(icl),6,min,max,false,icl) {}
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         for (int i=0; i<x.size(); i++)
+           for (int j=i+1; j<x.size(); j++)
+             if (x[i]+i==x[j]+j)
+               return false;
+         return true;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         Gecode::IntArgs c(x.size());
+         for (int i=0; i<x.size(); i++)
+           c[i]=i;
+         Gecode::distinct(home, c, x, icl);
+       }
+     };
+   
+     /// Randomized test for distinct constraint
+     class Random : public Test {
+     public:
+       /// Create and register test
+       Random(int n, int min, int max, Gecode::IntConLevel icl)
+         : Test("Distinct::Random::"+str(icl),n,min,max,false,icl) {
+         testsearch = false;
+       }
+       /// Create and register initial assignment
+       virtual Assignment* assignment(void) const {
+         return new RandomAssignment(arity,dom,100);
+       }
+       /// Check whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         for (int i=0; i<x.size(); i++)
+           for (int j=i+1; j<x.size(); j++)
+             if (x[i]==x[j])
+               return false;
+         return true;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         Gecode::distinct(home, x, icl);
+       }
+     };
+     
+     /// Testing pathological cases
+     class Pathological : public Base {
+     protected:
+       /// Number of variables
+       int n;
+       /// Consistency level
+       Gecode::IntConLevel icl;
+       /// Test space
+       class TestSpace : public Gecode::Space {
+       public:
+         /// Constructor
+         TestSpace(void) {}
+         /// Constructor for cloning \a s
+         TestSpace(bool share, TestSpace& s) 
+           : Gecode::Space(share,s) {}
+         /// Copy space during cloning
+         virtual Gecode::Space* copy(bool share) {
+           return new TestSpace(share,*this);
+         }
+       };
+     public:
+       /// Create and register test
+       Pathological(int n0, Gecode::IntConLevel icl0)
+         : Base("Int::Distinct::Pathological::"+
+                Test::str(n0)+"::"+Test::str(icl0)), n(n0), icl(icl0) {}
+       /// Perform test
+       virtual bool run(void) {
+         using namespace Gecode;
+         {
+           TestSpace* s = new TestSpace;
+           IntVarArgs x(n);
+           for (int i=0; i<n; i++)
+             x[i].init(s,0,i);
+           distinct(s,x,icl);
+           if (s->status() == SS_FAILED) {
+             delete s; return false;
+           }
+           for (int i=0; i<n; i++)
+             if (!x[i].assigned() || (x[i].val() != i)) {
+               delete s; return false;
+             }
+           delete s;
+         }
+         {
+           TestSpace* s = new TestSpace;
+           IntVarArgs x(2*n);
+           for (int i=0; i<n; i++) {
+             int v[] = {0,i};
+             IntSet d(v,2);
+             x[i].init(s,d);
+           }
+           for (int i=n; i<2*n; i++)
+             x[i].init(s,n-1,i);
+           distinct(s,x,icl);
+           if (s->status() == SS_FAILED) {
+             delete s; return false;
+           }
+           for (int i=0; i<n; i++)
+             if (!x[i].assigned() || (x[i].val() != i)) {
+               delete s; return false;
+             }
+           delete s;
+         }
+         return true;
+       }
+     };
+
+     const int v[7] = {-1001,-1000,-10,0,10,1000,1001};
+     Gecode::IntSet d(v,7);
+   
+     Distinct<false> dom_d(-3,3,Gecode::ICL_DOM);
+     Distinct<false> bnd_d(-3,3,Gecode::ICL_BND);
+     Distinct<false> val_d(-3,3,Gecode::ICL_VAL);
+     Distinct<false> dom_s(d,Gecode::ICL_DOM);
+     Distinct<false> bnd_s(d,Gecode::ICL_BND);
+     Distinct<false> val_s(d,Gecode::ICL_VAL);
+
+     Distinct<true> count_dom_d(-3,3,Gecode::ICL_DOM);
+     Distinct<true> count_bnd_d(-3,3,Gecode::ICL_BND);
+     Distinct<true> count_val_d(-3,3,Gecode::ICL_VAL);
+     Distinct<true> count_dom_s(d,Gecode::ICL_DOM);
+     Distinct<true> count_bnd_s(d,Gecode::ICL_BND);
+     Distinct<true> count_val_s(d,Gecode::ICL_VAL);
+   
+     Offset dom_od(-3,3,Gecode::ICL_DOM);
+     Offset bnd_od(-3,3,Gecode::ICL_BND);
+     Offset val_od(-3,3,Gecode::ICL_VAL);
+     Offset dom_os(d,Gecode::ICL_DOM);
+     Offset bnd_os(d,Gecode::ICL_BND);
+     Offset val_os(d,Gecode::ICL_VAL);
+   
+     Random dom_r(20,-50,50,Gecode::ICL_DOM);
+     Random bnd_r(50,-500,500,Gecode::ICL_BND);
+     Random val_r(50,-500,500,Gecode::ICL_VAL);
+
+     Pathological p_16_v(16,Gecode::ICL_VAL);
+     Pathological p_16_b(16,Gecode::ICL_BND);
+     Pathological p_16_d(16,Gecode::ICL_DOM);
+
+     Pathological p_32_v(32,Gecode::ICL_VAL);
+     Pathological p_32_b(32,Gecode::ICL_BND);
+     Pathological p_32_d(32,Gecode::ICL_DOM);
+     //@}
+   
+   }
+}}
+
+// STATISTICS: test-int

data/ext/gecode-2.2.0/test/int/dom.cc

@@ -0,0 +1,123 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  Last modified:
+ *     $Date: 2008-02-18 08:02:14 +0100 (Mon, 18 Feb 2008) $ by $Author: schulte $
+ *     $Revision: 6199 $
+ *
+ *  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 domain constraints
+   namespace Dom {
+   
+     /**
+      * \defgroup TaskTestIntDom Domain constraints
+      * \ingroup TaskTestInt
+      */
+     //@{
+     /// Test for domain constraint (range)
+     class DomRange : public Test {
+     public:
+       /// Create and register test
+       DomRange(int n) : Test("Dom::Range::"+str(n),n,-4,4,n == 1) {}
+       /// Test whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         for (int i=x.size(); i--; )
+           if ((x[i] < -2) || (x[i] > 2))
+             return false;
+         return true;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         if (x.size() == 1)
+           Gecode::dom(home, x[0], -2, 2);
+         else
+           Gecode::dom(home, x, -2, 2);
+       }
+       /// Post reified constraint on \a x for \a b
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x, 
+                         Gecode::BoolVar b) {
+         assert(x.size() == 1);
+         Gecode::dom(home, x[0], -2, 2, b);
+       }
+     };
+   
+   
+     const int r[4][2] = {
+       {-4,-3},{-1,-1},{1,1},{3,5}
+     };
+     Gecode::IntSet d(r,4);
+   
+     /// Test for domain constraint (full integer set)
+     class DomDom : public Test {
+     public:
+       /// Create and register test
+       DomDom(int n) : Test("Dom::Dom::"+str(n),n,-6,6,n == 1) {}
+       /// Test whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         for (int i=x.size(); i--; )
+           if (!(((x[i] >= -4) && (x[i] <= -3)) ||
+                 ((x[i] >= -1) && (x[i] <= -1)) ||
+                 ((x[i] >=  1) && (x[i] <=  1)) ||
+                 ((x[i] >=  3) && (x[i] <=  5))))
+             return false;
+         return true;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         if (x.size() == 1)
+           Gecode::dom(home, x[0], d);
+         else
+           Gecode::dom(home, x, d);
+       }
+       /// Post reified constraint on \a x for \a b
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x,
+                         Gecode::BoolVar b) {
+         assert(x.size() == 1);
+         Gecode::dom(home, x[0], d, b);
+       }
+     };
+   
+     DomRange dr1(1);
+     DomRange dr3(3);
+     DomDom dd1(1);
+     DomDom dd3(3);
+     //@}
+   
+   }
+}}
+
+// STATISTICS: test-int
+

data/ext/gecode-2.2.0/test/int/element.cc

@@ -0,0 +1,333 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 09:36:57 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7295 $
+ *
+ *  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 element constraints
+   namespace Element {
+   
+     /**
+      * \defgroup TaskTestIntElement Element constraints
+      * \ingroup TaskTestInt
+      */
+     //@{
+     /// Test for element with integer array and integer variables
+     class IntIntVar : public Test {
+     protected:
+       /// Array of integers
+       Gecode::IntArgs c;
+     public:
+       /// Create and register test
+       IntIntVar(const std::string& s, const Gecode::IntArgs& c0)
+         : Test("Element::Int::Int::Var::"+s,2,-4,8), c(c0) {}
+       /// Test whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return (x[0]>= 0) && (x[0]<c.size()) && c[x[0]]==x[1];
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         Gecode::element(home, c, x[0], x[1]);
+       }
+     };
+   
+     /// Test for element with integer array and integer variables
+     class IntIntInt : public Test {
+     protected:
+       /// Array of integers
+       Gecode::IntArgs c;
+       /// Integer result
+       int r;
+     public:
+       /// Create and register test
+       IntIntInt(const std::string& s, const Gecode::IntArgs& c0, int r0)
+         : Test("Element::Int::Int::Int::"+s+"::"+str(r0),1,-4,8), 
+           c(c0), r(r0) {}
+       /// Test whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return (x[0]>= 0) && (x[0]<c.size()) && c[x[0]]==r;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         Gecode::element(home, c, x[0], r);
+       }
+     };
+   
+     /// Test for element with integer array and single shared integer variable
+     class IntIntShared : public Test {
+     protected:
+       /// Array of integers
+       Gecode::IntArgs c;
+     public:
+       /// Create and register test
+       IntIntShared(const std::string& s, const Gecode::IntArgs& c0,
+                    int minDomain=-4)
+         : Test("Element::Int::Int::Shared::"+s,1,minDomain,8), c(c0) {}
+       /// Test whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return (x[0]>= 0) && (x[0]<c.size()) && c[x[0]]==x[0];
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         Gecode::element(home, c, x[0], x[0]);
+       }
+     };
+   
+     /// Test for element with integer array and integer and Boolean variable
+     class IntBoolVar : public Test {
+     protected:
+       /// Array of integers
+       Gecode::IntArgs c;
+     public:
+       /// Create and register test
+       IntBoolVar(const std::string& s, const Gecode::IntArgs& c0)
+         : Test("Element::Int::Bool::Var::"+s,2,-4,8), c(c0) {}
+       /// Test whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return (x[0]>= 0) && (x[0]<c.size()) && c[x[0]]==x[1];
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         Gecode::element(home, c, x[0], Gecode::channel(home,x[1]));
+       }
+     };
+   
+     /// Test for element with integer array and integer and Boolean variable
+     class IntBoolInt : public Test {
+     protected:
+       /// Array of integers
+       Gecode::IntArgs c;
+       /// Integer result
+       int r;
+     public:
+       /// Create and register test
+       IntBoolInt(const std::string& s, const Gecode::IntArgs& c0, int r0)
+         : Test("Element::Int::Bool::Int::"+s+"::"+str(r0),1,-4,8), 
+           c(c0), r(r0) {}
+       /// Test whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return (x[0]>= 0) && (x[0]<c.size()) && c[x[0]]==r;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         Gecode::element(home, c, x[0], r);
+       }
+     };
+   
+     /// Test for element with variable array and integer variables
+     class VarIntVar : public Test {
+     public:
+       /// Create and register test
+       VarIntVar(Gecode::IntConLevel icl)
+         : Test("Element::Var::Int::Var::"+str(icl),6,-1,3,false,icl) {}
+       /// Test whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return (x[0]>= 0) && (x[0]<x.size()-2) && x[2+x[0]]==x[1];
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         Gecode::IntVarArgs c(x.size()-2);
+         for (int i=0; i<x.size()-2; i++)
+           c[i]=x[2+i];
+         Gecode::element(home, c, x[0], x[1], icl);
+       }
+     };
+   
+     /// Test for element with variable array and integer variables
+     class VarIntInt : public Test {
+     protected:
+       /// Integer result
+       int r;
+     public:
+       /// Create and register test
+       VarIntInt(Gecode::IntConLevel icl, int r0)
+         : Test("Element::Var::Int::Int::"+str(icl)+"::"+str(r0),
+                5,-1,3,false,icl), r(r0) {
+         testdomcon = false;
+       }
+       /// Test whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return (x[0]>= 0) && (x[0]<x.size()-1) && x[1+x[0]]==r;
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         Gecode::IntVarArgs c(x.size()-1);
+         for (int i=0; i<x.size()-1; i++)
+           c[i]=x[1+i];
+         Gecode::element(home, c, x[0], r, icl);
+       }
+     };
+   
+     /// Test for element with variable array and shared integer variable
+     class VarIntShared : public Test {
+     public:
+       /// Create and register test
+       VarIntShared(Gecode::IntConLevel icl)
+         : Test("Element::Var::Int::Shared::"+str(icl),5,-1,3,false,icl) {}
+       /// Test whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         return (x[0]>= 0) && (x[0]<x.size()-1) && x[1+x[0]]==x[0];
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         Gecode::IntVarArgs c(x.size()-1);
+         for (int i=0; i<x.size()-1; i++)
+           c[i]=x[1+i];
+         Gecode::element(home, c, x[0], x[0], icl);
+       }
+     };
+   
+     /// Test for element with Boolean variable array and integer variable
+     class VarBoolVar : public Test {
+     public:
+       /// Create and register test
+       VarBoolVar(void) : Test("Element::Var::Bool::Var",6,-1,3,false) {}
+       /// Test whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         for (int i=0; i<x.size()-2; i++)
+           if ((x[2+i] < 0) || (x[2+i]>1))
+             return false;
+         return ((x[0]>= 0) && (x[0]<x.size()-2) && x[2+x[0]]==x[1] 
+                 && (x[1]>=0) && (x[1]<=1));
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVarArgs c(x.size()-2);
+         for (int i=0; i<x.size()-2; i++)
+           c[i]=channel(home,x[2+i]);
+         element(home, c, x[0], channel(home,x[1]));
+       }
+     };
+   
+     /// Test for element with Boolean variable array and integer variable
+     class VarBoolInt : public Test {
+     protected:
+       /// Integer result
+       int r;
+     public:
+       /// Create and register test
+       VarBoolInt(int r0) 
+         : Test("Element::Var::Bool::Int::"+str(r0),5,-1,3,false), r(r0) {}
+       /// Test whether \a x is solution
+       virtual bool solution(const Assignment& x) const {
+         for (int i=0; i<x.size()-1; i++)
+           if ((x[1+i] < 0) || (x[1+i]>1))
+             return false;
+         return ((x[0]>= 0) && (x[0]<x.size()-1) && x[1+x[0]]==r);
+       }
+       /// Post constraint on \a x
+       virtual void post(Gecode::Space* home, Gecode::IntVarArray& x) {
+         using namespace Gecode;
+         BoolVarArgs c(x.size()-1);
+         for (int i=0; i<x.size()-1; i++)
+           c[i]=channel(home,x[1+i]);
+         element(home, c, x[0], r);
+       }
+     };
+   
+     /// Help class to create and register tests
+     class Create {
+     public:
+       /// Perform creation and registration
+       Create(void) {
+         using namespace Gecode;
+         IntArgs ic1(5, -1,1,-3,3,-4);
+         IntArgs ic2(8, -1,1,-1,1,-1,1,0,0);
+         IntArgs ic3(1, -1);
+         IntArgs ic4(7, 0,-1,2,-2,4,-3,6);
+         IntArgs ic5(6, 0,0,1,2,3,4);
+         
+         IntArgs bc1(5, 0,1,1,0,1);
+         IntArgs bc2(8, 1,1,0,1,0,1,0,0);
+         IntArgs bc3(1, 1);
+   
+         (void) new IntIntVar("A",ic1);
+         (void) new IntIntVar("B",ic2);
+         (void) new IntIntVar("C",ic3);
+         (void) new IntIntVar("D",ic4);
+
+         for (int i=-4; i<=4; i++) {
+           (void) new IntIntInt("A",ic1,i);
+           (void) new IntIntInt("B",ic2,i);
+           (void) new IntIntInt("C",ic3,i);
+           (void) new IntIntInt("D",ic4,i);
+         }
+         
+         (void) new IntIntShared("A",ic1);
+         (void) new IntIntShared("B",ic2);
+         (void) new IntIntShared("C",ic3);
+         (void) new IntIntShared("D",ic4);
+         (void) new IntIntShared("E",ic5,1);
+         
+         (void) new IntBoolVar("A",bc1);
+         (void) new IntBoolVar("B",bc2);
+         (void) new IntBoolVar("C",bc3);
+         
+         for (int i=0; i<=1; i++) {
+           (void) new IntBoolInt("A",bc1,i);
+           (void) new IntBoolInt("B",bc2,i);
+           (void) new IntBoolInt("C",bc3,i);
+         }
+
+         (void) new VarIntVar(ICL_BND);
+         (void) new VarIntVar(ICL_DOM);
+
+         for (int i=-4; i<=4; i++) {
+           (void) new VarIntInt(ICL_BND,i);
+           (void) new VarIntInt(ICL_DOM,i);
+         }
+         
+         (void) new VarIntShared(ICL_BND);
+         (void) new VarIntShared(ICL_DOM);
+     
+         (void) new VarBoolVar();
+         (void) new VarBoolInt(0);
+         (void) new VarBoolInt(1);
+       }
+     };
+   
+     Create c;
+     //@}
+   
+   }
+}}
+
+// STATISTICS: test-int