gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/test/set/projection.cc

@@ -0,0 +1,436 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2005
+ *
+ *  Last modified:
+ *     $Date: 2007-09-13 17:50:04 +0200 (Thu, 13 Sep 2007) $ by $Author: tack $
+ *     $Revision: 5028 $
+ *
+ *  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/set.hh"
+#include "gecode/set/projectors.hh"
+#include "gecode/minimodel.hh"
+
+using namespace Gecode;
+
+namespace Test { namespace Set {
+
+  /// Tests for projection constraints
+  namespace Projection {
+
+    /**
+      * \defgroup TaskTestSetProj Projection constraints
+      * \ingroup TaskTestSet
+      */
+    //@{
+
+    static IntSet ds_22(-2,2);
+    static IntSet ds_33(-3,3);
+
+    /// Test for binary disequality constraint
+    class RelBinNEq : public SetTest {
+    public:
+      /// Create and register test
+      RelBinNEq(const char* t)
+        : SetTest(t,2,ds_33) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr0(x.lub, x[0]);
+        CountableSetRanges xr1(x.lub, x[1]);
+        return !Iter::Ranges::equal(xr0, xr1);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        Gecode::Projector p(0, Gecode::SetExpr(1), Gecode::SetExpr(1));
+        Gecode::Projector q(1, Gecode::SetExpr(0), Gecode::SetExpr(0));
+        Gecode::ProjectorSet ps(2);
+        ps.add(p); ps.add(q);
+        Gecode::projector(home, x[0], x[1], ps, true);
+      }
+    };
+    RelBinNEq _relneq("Proj::Rel::BinNEq");
+
+    /// Test for binary equality constraint
+    class RelBinEq : public SetTest {
+    public:
+      /// Create and register test
+      RelBinEq(const char* t)
+        : SetTest(t,2,ds_33,true) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr0(x.lub, x[0]);
+        CountableSetRanges xr1(x.lub, x[1]);
+        return Iter::Ranges::equal(xr0, xr1);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        Gecode::SetExpr xe(0);
+        Gecode::SetExpr ye(1);
+        Gecode::Projector p(0, ye, ye);
+        Gecode::Projector q(1, xe, xe);
+        Gecode::ProjectorSet ps(2);
+        ps.add(p);
+        ps.add(q);
+        Gecode::projector(home, x[0], x[1], ps);
+      }
+      /// Post reified constraint on \a x for \a b
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&,
+                        BoolVar b) {
+        Gecode::Projector p(0, Gecode::SetExpr(1), Gecode::SetExpr(1));
+        Gecode::Projector q(1, Gecode::SetExpr(0), Gecode::SetExpr(0));
+        Gecode::ProjectorSet ps(2);
+        ps.add(p); ps.add(q);
+        Gecode::projector(home, x[0], x[1], b, ps);
+      }
+    };
+    RelBinEq _releq("Proj::Rel::BinEq");
+
+    /// Test for binary subset constraint
+    class RelBinSub : public SetTest {
+    public:
+      /// Create and register test
+      RelBinSub(const char* t)
+        : SetTest(t,2,ds_33,true) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr0(x.lub, x[0]);
+        CountableSetRanges xr1(x.lub, x[1]);
+        return Iter::Ranges::subset(xr0, xr1);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        Gecode::Projector p(0, Gecode::SetExpr(), Gecode::SetExpr(1));
+        Gecode::Projector q(1, Gecode::SetExpr(0), -Gecode::SetExpr());
+        Gecode::ProjectorSet ps(2);
+        ps.add(p); ps.add(q);
+        Gecode::projector(home, x[0], x[1], ps);
+      }
+      /// Post reified constraint on \a x for \a b
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&,  
+                        BoolVar b) {
+        Gecode::Projector p(0, Gecode::SetExpr(), Gecode::SetExpr(1));
+        Gecode::Projector q(1, Gecode::SetExpr(0), -Gecode::SetExpr());
+        Gecode::ProjectorSet ps(2);
+        ps.add(p); ps.add(q);
+        Gecode::projector(home, x[0], x[1], b, ps);
+      }
+    };
+    RelBinSub _relsub("Proj::Rel::BinSub");
+
+    /// Test for binary disjointness constraint
+    class RelBinDisj : public SetTest {
+    public:
+      /// Create and register test
+      RelBinDisj(const char* t)
+        : SetTest(t,2,ds_33,true) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr0(x.lub, x[0]);
+        CountableSetRanges xr1(x.lub, x[1]);
+        return Iter::Ranges::disjoint(xr0, xr1);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        Gecode::Projector p(0, Gecode::SetExpr(), -Gecode::SetExpr(1));
+        Gecode::Projector q(1, Gecode::SetExpr(), -Gecode::SetExpr(0));
+        Gecode::ProjectorSet ps(2);
+        ps.add(p); ps.add(q);
+        Gecode::projector(home, x[0], x[1], ps);
+      }
+      /// Post reified constraint on \a x for \a b
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&,
+                        BoolVar b) {
+        Gecode::Projector p(0, Gecode::SetExpr(), -Gecode::SetExpr(1));
+        Gecode::Projector q(1, Gecode::SetExpr(), -Gecode::SetExpr(0));
+        Gecode::ProjectorSet ps(2);
+        ps.add(p); ps.add(q);
+        Gecode::projector(home, x[0], x[1], b, ps);
+      }
+    };
+    RelBinDisj _reldisj("Proj::Rel::BinDisj");
+
+    /// Test for binary complement constraint
+    class RelBinCompl : public SetTest {
+    public:
+      /// Create and register test
+      RelBinCompl(const char* t)
+      : SetTest(t,2,ds_33,true) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr0(x.lub, x[0]);
+        CountableSetRanges xr1(x.lub, x[1]);
+        Gecode::Set::RangesCompl<CountableSetRanges> xr1c(xr1);
+        return Iter::Ranges::equal(xr0, xr1c);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        Gecode::Projector p(0, -Gecode::SetExpr(1), -Gecode::SetExpr(1));
+        Gecode::Projector q(1, -Gecode::SetExpr(0), -Gecode::SetExpr(0));
+        Gecode::ProjectorSet ps(2);
+        ps.add(p); ps.add(q);
+        Gecode::projector(home, x[0], x[1], ps);
+      }
+      /// Post reified constraint on \a x for \a b
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&,
+                        BoolVar b) {
+        Gecode::Projector p(0, -Gecode::SetExpr(1), -Gecode::SetExpr(1));
+        Gecode::Projector q(1, -Gecode::SetExpr(0), -Gecode::SetExpr(0));
+        Gecode::ProjectorSet ps(2);
+        ps.add(p); ps.add(q);
+        Gecode::projector(home, x[0], x[1], b, ps);
+      }
+    };
+    RelBinCompl _relcompl("Proj::Rel::BinCompl");
+
+    /// Test for ternary union constraint
+    class RelUnionEq : public SetTest {
+    public:
+      /// Create and register test
+      RelUnionEq(const char* t)
+        : SetTest(t,3,ds_22,true) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr0(x.lub, x[0]);
+        CountableSetRanges xr1(x.lub, x[1]);
+        CountableSetRanges xr2(x.lub, x[2]);
+        Iter::Ranges::Union<CountableSetRanges, CountableSetRanges> 
+          u(xr0,xr1);
+        return Iter::Ranges::equal(xr2, u);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        Gecode::Projector p0(0,
+                             Gecode::SetExpr(2) - Gecode::SetExpr(1),
+                             Gecode::SetExpr(2)
+                             );
+        Gecode::Projector p1(1,
+                             Gecode::SetExpr(2) - Gecode::SetExpr(0),
+                             Gecode::SetExpr(2)
+                             );
+        Gecode::Projector p2(2,
+                             Gecode::SetExpr(0) || Gecode::SetExpr(1),
+                             Gecode::SetExpr(0) || Gecode::SetExpr(1)
+                             );
+        Gecode::ProjectorSet ps(3);
+        ps.add(p0); ps.add(p1); ps.add(p2);
+        Gecode::projector(home, x[0], x[1], x[2], ps);
+
+        IntVar x0c(home, 0, 10);
+        IntVar x1c(home, 0, 10);
+        IntVar x2c(home, 0, 10);
+        Gecode::cardinality(home, x[0], x0c);
+        Gecode::cardinality(home, x[1], x1c);
+        Gecode::cardinality(home, x[2], x2c);
+
+        Gecode::Projector p3(2,
+                             Gecode::SetExpr(0) && Gecode::SetExpr(1),
+                             Gecode::SetExpr(0) && Gecode::SetExpr(1)
+                             );
+        IntVar x0ix1c(home, 0, 20);
+        Gecode::projector(home, x[0], x[1], x[2], x0ix1c, p3);
+        /// Post constraint on \a x
+        Gecode::post(home, x2c == x0c + x1c - x0ix1c);
+
+        Gecode::Projector p4(2,
+                             Gecode::SetExpr(0) - Gecode::SetExpr(1),
+                             Gecode::SetExpr(0) - Gecode::SetExpr(1)
+                             );
+        IntVar x0mx1c(home, 0, 20);
+        Gecode::projector(home, x[0], x[1], x[2], x0mx1c, p4);
+        /// Post constraint on \a x
+        Gecode::post(home, x1c == x2c - x0mx1c);
+
+        Gecode::Projector p5(2,
+                             Gecode::SetExpr(1) - Gecode::SetExpr(0),
+                             Gecode::SetExpr(1) - Gecode::SetExpr(0)
+                             );
+        IntVar x1mx0c(home, 0, 20);
+        Gecode::projector(home, x[0], x[1], x[2], x1mx0c, p5);
+        /// Post constraint on \a x
+        Gecode::post(home, x0c == x2c - x1mx0c);
+      }
+      /// Post reified constraint on \a x for \a b
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&,
+                        BoolVar b) {
+        Gecode::Projector p0(0,
+                             Gecode::SetExpr(2) - Gecode::SetExpr(1),
+                             Gecode::SetExpr(2)
+                             );
+        Gecode::Projector p1(1,
+                             Gecode::SetExpr(2) - Gecode::SetExpr(0),
+                             Gecode::SetExpr(2)
+                             );
+        Gecode::Projector p2(2,
+                             Gecode::SetExpr(0) || Gecode::SetExpr(1),
+                             Gecode::SetExpr(0) || Gecode::SetExpr(1)
+                             );
+        Gecode::ProjectorSet ps(3);
+        ps.add(p0); ps.add(p1); ps.add(p2);
+        Gecode::projector(home, x[0], x[1], x[2], b, ps);
+      }
+    };
+    RelUnionEq _relunioneq("Proj::RelOp::UnionEq");
+
+    /// Test for ternary union constraint, posted using a formula
+    class RelUnionEqFormula : public SetTest {
+    public:
+      /// Create and register test
+      RelUnionEqFormula(const char* t)
+        : SetTest(t,3,ds_22,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr0(x.lub, x[0]);
+        CountableSetRanges xr1(x.lub, x[1]);
+        CountableSetRanges xr2(x.lub, x[2]);
+        Iter::Ranges::Union<CountableSetRanges, CountableSetRanges> 
+          u(xr0,xr1);
+        return Iter::Ranges::equal(xr2, u);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        Formula f = (Formula(0) | Formula(1)) == Formula(2);
+        Gecode::ProjectorSet ps = f.projectors();
+        Gecode::projector(home, x[0], x[1], x[2], ps);
+      }
+    };
+    RelUnionEqFormula _relunioneqfor("Proj::Formula::RelOp::UnionEq");
+
+    /// Test for ternary intersection constraint with cardinality propagation
+    class RelInterEqCard : public SetTest {
+    public:
+      /// Create and register test
+      RelInterEqCard(const char* t)
+        : SetTest(t,3,ds_22,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr0(x.lub, x[0]);
+        CountableSetRanges xr1(x.lub, x[1]);
+        CountableSetRanges xr2(x.lub, x[2]);
+        Iter::Ranges::Inter<CountableSetRanges, CountableSetRanges> 
+          u(xr0,xr1);
+        return Iter::Ranges::equal(xr2, u);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        Gecode::Projector p0(0,
+                             Gecode::SetExpr(2),
+                             Gecode::SetExpr(2) || -Gecode::SetExpr(1)
+                             );
+        Gecode::Projector p1(1,
+                             Gecode::SetExpr(2),
+                             Gecode::SetExpr(2) || -Gecode::SetExpr(0)
+                             );
+        Gecode::Projector p2(2,
+                             Gecode::SetExpr(0) && Gecode::SetExpr(1),
+                             Gecode::SetExpr(0) && Gecode::SetExpr(1)
+                             );
+        Gecode::ProjectorSet ps(3);
+        ps.add(p0); ps.add(p1); ps.add(p2);
+        Gecode::projector(home, x[0], x[1], x[2], ps);
+
+        IntVar x0c(home, 0, 10);
+        IntVar x1c(home, 0, 10);
+        IntVar x2c(home, 0, 10);
+        Gecode::cardinality(home, x[0], x0c);
+        Gecode::cardinality(home, x[1], x1c);
+        Gecode::cardinality(home, x[2], x2c);
+
+        Gecode::Projector p3(2,
+                             Gecode::SetExpr(0) || Gecode::SetExpr(1),
+                             Gecode::SetExpr(0) || Gecode::SetExpr(1)
+                             );
+        IntVar x0ux1c(home, 0, 20);
+        Gecode::projector(home, x[0], x[1], x[2], x0ux1c, p3);
+        /// Post constraint on \a x
+        Gecode::post(home, x2c == x0c + x1c - x0ux1c);
+
+        Gecode::Projector p4(2,
+                             Gecode::SetExpr(0) - Gecode::SetExpr(1),
+                             Gecode::SetExpr(0) - Gecode::SetExpr(1)
+                             );
+        IntVar x0mx1c(home, 0, 20);
+        Gecode::projector(home, x[0], x[1], x[2], x0mx1c, p4);
+        /// Post constraint on \a x
+        Gecode::post(home, x2c == x0c - x0mx1c);
+
+        Gecode::Projector p5(2,
+                             Gecode::SetExpr(1) - Gecode::SetExpr(0),
+                             Gecode::SetExpr(1) - Gecode::SetExpr(0)
+                             );
+        IntVar x1mx0c(home, 0, 20);
+        Gecode::projector(home, x[0], x[1], x[2], x1mx0c, p5);
+        /// Post constraint on \a x
+        Gecode::post(home, x2c == x1c - x1mx0c);
+
+      }
+    };
+    RelInterEqCard _relintereqcard("Proj::RelOp::InterEqCard");
+
+    /// Test for negated ternary union constraint
+    class NegRelUnionEq : public SetTest {
+    public:
+      /// Create and register test
+      NegRelUnionEq(const char* t)
+        : SetTest(t,3,ds_22) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr0(x.lub, x[0]);
+        CountableSetRanges xr1(x.lub, x[1]);
+        CountableSetRanges xr2(x.lub, x[2]);
+        Iter::Ranges::Union<CountableSetRanges, CountableSetRanges> 
+          u(xr0,xr1);
+        return !Iter::Ranges::equal(xr2, u);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        Gecode::Projector p0(0,
+                             Gecode::SetExpr(2) - Gecode::SetExpr(1),
+                             Gecode::SetExpr(2)
+                             );
+        Gecode::Projector p1(1,
+                             Gecode::SetExpr(2) - Gecode::SetExpr(0),
+                             Gecode::SetExpr(2)
+                             );
+        Gecode::Projector p2(2,
+                             Gecode::SetExpr(0) || Gecode::SetExpr(1),
+                             Gecode::SetExpr(0) || Gecode::SetExpr(1)
+                             );
+        Gecode::ProjectorSet ps(3);
+        ps.add(p0); ps.add(p1); ps.add(p2);
+        Gecode::projector(home, x[0], x[1], x[2], ps, true);
+      }
+    };
+
+    NegRelUnionEq _negrelunioneq("Proj::RelOp::NegUnionEq");
+
+}}}
+
+// STATISTICS: test-set

data/ext/gecode-2.2.0/test/set/rel-op-const.cc

@@ -0,0 +1,368 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2005
+ *
+ *  Last modified:
+ *     $Date: 2008-02-21 07:45:06 +0100 (Thu, 21 Feb 2008) $ by $Author: schulte $
+ *     $Revision: 6261 $
+ *
+ *  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/set.hh"
+
+using namespace Gecode;
+
+namespace Test { namespace Set {
+
+  /// Tests for relation/operation constraints with constants
+  namespace RelOpConst {
+
+    /**
+      * \defgroup TaskTestSetRelOpConst Relation/operation constraints with constants
+      * \ingroup TaskTestSet
+      */
+    //@{
+
+    static IntSet ds_33(-3,3);
+    static IntSet ds_22(-2,2);
+    static IntSet ds_12(-1,2);
+    
+    static IntSet iss[] = {IntSet(-1,1), IntSet(-4,-4), IntSet(0,2)};
+    
+    /// Test for set relation constraint with constants
+    class RelSIS : public SetTest {
+    private:
+      IntSet is;
+      Gecode::SetOpType sot;
+      Gecode::SetRelType srt;
+      bool inverse;
+
+      template <class I, class J>
+      bool
+      sol(I& i, J& j) const {
+        switch (srt) {
+        case SRT_EQ: return Iter::Ranges::equal(i,j);
+        case SRT_NQ: return !Iter::Ranges::equal(i,j);
+        case SRT_SUB: return Iter::Ranges::subset(i,j);
+        case SRT_SUP: return Iter::Ranges::subset(j,i);
+        case SRT_DISJ:
+          {
+            Gecode::Iter::Ranges::Inter<I,J> inter(i,j);
+            return !inter();
+          }
+        case SRT_CMPL:
+          {
+            Gecode::Set::RangesCompl<J> jc(j);
+            return Iter::Ranges::equal(i,jc);
+          }
+        }
+        GECODE_NEVER;
+        return false;
+      }
+
+    public:
+      /// Create and register test
+      RelSIS(Gecode::SetOpType sot0, Gecode::SetRelType srt0,
+             int intSet, bool inverse0)
+       : SetTest("RelOp::ConstSIS::"+str(sot0)+"::"+str(srt0)+"::"+
+                 str(intSet)+(inverse0 ? "i" :""),2,ds_22,false)
+       , is(iss[intSet]), sot(sot0), srt(srt0), inverse(inverse0) {}
+      /// Test whether \a x is solution
+      bool solution(const SetAssignment& x) const {
+        IntSetRanges isr(is);
+        CountableSetRanges xr0(x.lub, x[0]);
+        CountableSetRanges xr1(x.lub, x[1]);
+        switch (sot) {
+        case SOT_UNION:
+          {
+            Iter::Ranges::Union<IntSetRanges, CountableSetRanges> 
+              u(isr, xr0);
+            return sol(u,xr1);
+          }
+          break;
+        case SOT_DUNION:
+          {
+            Iter::Ranges::Inter<IntSetRanges, CountableSetRanges> 
+              inter(isr, xr0);
+            if (inter())
+              return false;
+            Iter::Ranges::Union<IntSetRanges, CountableSetRanges> 
+              u(isr,xr0);
+            return sol(u,xr1);
+          }
+          break;
+        case SOT_INTER:
+          {
+            Iter::Ranges::Inter<IntSetRanges, CountableSetRanges> 
+              u(isr,xr0);
+            return sol(u,xr1);
+          }
+          break;
+        case SOT_MINUS:
+          {
+            if (!inverse) {
+              Iter::Ranges::Diff<IntSetRanges, CountableSetRanges> 
+                u(isr,xr0);
+              return sol(u,xr1);
+            } else {
+              Iter::Ranges::Diff<CountableSetRanges, IntSetRanges> 
+                u(xr0,isr);
+              return sol(u,xr1);
+              
+            }
+          }
+          break;
+        }
+        GECODE_NEVER;
+        return false;
+      }
+      /// Post constraint on \a x
+      void post(Space* home, SetVarArray& x, IntVarArray&) {
+        if (!inverse)
+          Gecode::rel(home, is, sot, x[0], srt, x[1]);
+        else
+          Gecode::rel(home, x[0], sot, is, srt, x[1]);
+      }
+    };
+
+    /// Test for set relation constraint with constants
+    class RelSSI : public SetTest {
+    private:
+      IntSet is;
+      Gecode::SetOpType sot;
+      Gecode::SetRelType srt;
+
+      template <class I, class J>
+      bool
+      sol(I& i, J& j) const {
+        switch (srt) {
+        case SRT_EQ: return Iter::Ranges::equal(i,j);
+        case SRT_NQ: return !Iter::Ranges::equal(i,j);
+        case SRT_SUB: return Iter::Ranges::subset(i,j);
+        case SRT_SUP: return Iter::Ranges::subset(j,i);
+        case SRT_DISJ:
+          {
+            Gecode::Iter::Ranges::Inter<I,J> inter(i,j);
+            return !inter();
+          }
+        case SRT_CMPL:
+          {
+            Gecode::Set::RangesCompl<J> jc(j);
+            return Iter::Ranges::equal(i,jc);
+          }
+        }
+        GECODE_NEVER;
+        return false;
+      }
+
+    public:
+      /// Create and register test
+      RelSSI(Gecode::SetOpType sot0, Gecode::SetRelType srt0,
+             int intSet)
+       : SetTest("RelOp::ConstSSI::"+str(sot0)+"::"+str(srt0)+"::"+
+                 str(intSet),2,ds_22,false)
+       , is(iss[intSet]), sot(sot0), srt(srt0) {}
+      /// Test whether \a x is solution
+      bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr0(x.lub, x[0]);
+        CountableSetRanges xr1(x.lub, x[1]);
+        IntSetRanges isr(is);
+        switch (sot) {
+        case SOT_UNION:
+          {
+            Iter::Ranges::Union<CountableSetRanges, CountableSetRanges> 
+              u(xr0, xr1);
+            return sol(u,isr);
+          }
+          break;
+        case SOT_DUNION:
+          {
+            Iter::Ranges::Inter<CountableSetRanges, CountableSetRanges> 
+              inter(xr0, xr1);
+            if (inter())
+              return false;
+            Iter::Ranges::Union<CountableSetRanges, CountableSetRanges> 
+              u(xr0, xr1);
+            return sol(u,isr);
+          }
+          break;
+        case SOT_INTER:
+          {
+            Iter::Ranges::Inter<CountableSetRanges, CountableSetRanges> 
+              u(xr0,xr1);
+            return sol(u,isr);
+          }
+          break;
+        case SOT_MINUS:
+          {
+            Iter::Ranges::Diff<CountableSetRanges, CountableSetRanges> 
+              u(xr0,xr1);
+            return sol(u,isr);
+          }
+          break;
+        }
+        GECODE_NEVER;
+        return false;
+      }
+      /// Post constraint on \a x
+      void post(Space* home, SetVarArray& x, IntVarArray&) {
+        Gecode::rel(home, x[0], sot, x[1], srt, is);
+      }
+    };
+
+    /// Test for set relation constraint with constants
+    class RelISI : public SetTest {
+    private:
+      IntSet is0;
+      IntSet is1;
+      Gecode::SetOpType sot;
+      Gecode::SetRelType srt;
+      bool inverse;
+
+      template <class I, class J>
+      bool
+      sol(I& i, J& j) const {
+        switch (srt) {
+        case SRT_EQ: return Iter::Ranges::equal(i,j);
+        case SRT_NQ: return !Iter::Ranges::equal(i,j);
+        case SRT_SUB: return Iter::Ranges::subset(i,j);
+        case SRT_SUP: return Iter::Ranges::subset(j,i);
+        case SRT_DISJ:
+          {
+            Gecode::Iter::Ranges::Inter<I,J> inter(i,j);
+            return !inter();
+          }
+        case SRT_CMPL:
+          {
+            Gecode::Set::RangesCompl<J> jc(j);
+            return Iter::Ranges::equal(i,jc);
+          }
+        }
+        GECODE_NEVER;
+        return false;
+      }
+
+    public:
+      /// Create and register test
+      RelISI(Gecode::SetOpType sot0, Gecode::SetRelType srt0,
+             int intSet0, int intSet1, bool inverse0)
+       : SetTest("RelOp::ConstISI::"+str(sot0)+"::"+str(srt0)+"::"+
+                 str(intSet0)+"::"+str(intSet1)+
+                 (inverse0 ? "i" : ""),1,ds_33,false)
+       , is0(iss[intSet0]), is1(iss[intSet1]), sot(sot0), srt(srt0)
+       , inverse(inverse0) {}
+      /// Test whether \a x is solution
+      bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr0(x.lub, x[0]);
+        IntSetRanges isr0(is0);
+        IntSetRanges isr1(is1);
+        switch (sot) {
+        case SOT_UNION:
+          {
+            Iter::Ranges::Union<IntSetRanges, CountableSetRanges> 
+              u(isr0, xr0);
+            return sol(u,isr1);
+          }
+          break;
+        case SOT_DUNION:
+          {
+            Iter::Ranges::Inter<IntSetRanges, CountableSetRanges> 
+              inter(isr0, xr0);
+            if (inter())
+              return false;
+            Iter::Ranges::Union<IntSetRanges, CountableSetRanges> 
+              u(isr0, xr0);
+            return sol(u,isr1);
+          }
+          break;
+        case SOT_INTER:
+          {
+            Iter::Ranges::Inter<IntSetRanges, CountableSetRanges> 
+              u(isr0,xr0);
+            return sol(u,isr1);
+          }
+          break;
+        case SOT_MINUS:
+          {
+            if (!inverse) {
+              Iter::Ranges::Diff<IntSetRanges, CountableSetRanges> 
+                u(isr0,xr0);
+              return sol(u,isr1);
+            } else {
+              Iter::Ranges::Diff<CountableSetRanges, IntSetRanges> 
+                u(xr0,isr0);
+              return sol(u,isr1);              
+            }
+          }
+          break;
+        }
+        GECODE_NEVER;
+        return false;
+      }
+      /// Post constraint on \a x
+      void post(Space* home, SetVarArray& x, IntVarArray&) {
+        if (!inverse)
+          Gecode::rel(home, is0, sot, x[0], srt, is1);
+        else
+          Gecode::rel(home, x[0], sot, is0, srt, is1);
+      }
+    };
+
+    /// Help class to create and register tests
+    class Create {
+    public:
+      /// Perform creation and registration
+      Create(void) {
+        using namespace Gecode;
+        for (SetRelTypes srts; srts(); ++srts) {
+          for (SetOpTypes sots; sots(); ++sots) {
+            for (int i=0; i<=2; i++) {
+              (void) new RelSIS(sots.sot(),srts.srt(),i,false);
+              (void) new RelSIS(sots.sot(),srts.srt(),i,true);
+              (void) new RelSSI(sots.sot(),srts.srt(),i);
+              (void) new RelISI(sots.sot(),srts.srt(),i,0,false);
+              (void) new RelISI(sots.sot(),srts.srt(),i,1,false);
+              (void) new RelISI(sots.sot(),srts.srt(),i,2,false);
+              (void) new RelISI(sots.sot(),srts.srt(),i,0,true);
+              (void) new RelISI(sots.sot(),srts.srt(),i,1,true);
+              (void) new RelISI(sots.sot(),srts.srt(),i,2,true);
+            }
+          }
+        }      
+      }
+    };
+   
+    Create c;
+
+    //@}
+
+}}}
+
+// STATISTICS: test-set