gecoder-with-gecode 0.9.0 → 0.9.1

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

@@ -0,0 +1,116 @@
+/* -*- 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-11-11 21:36:30 +0100 (Sun, 11 Nov 2007) $ by $Author: tack $
+ *     $Revision: 5260 $
+ *
+ *  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 distinctness constraints
+  namespace Distinct {
+
+    /**
+      * \defgroup TaskTestSetDistinct Distinctness constraints
+      * \ingroup TaskTestSet
+      */
+    //@{
+
+    static IntSet ds_33(-2,2);
+    static IntSet ds_44(-4,4);
+
+    /// Test for the atmostone propagator
+    class AtmostOne : public SetTest {
+    public:
+      /// Create and register test
+      AtmostOne(const char* t)
+        : SetTest(t,3,ds_33,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]);
+          Iter::Ranges::Inter<CountableSetRanges,CountableSetRanges> 
+            i(xr0,xr1);
+          if (Iter::Ranges::size(i)>1)
+            return false;
+        }
+        {
+          CountableSetRanges xr0(x.lub, x[0]);
+          CountableSetRanges xr2(x.lub, x[2]);
+          Iter::Ranges::Inter<CountableSetRanges,CountableSetRanges> 
+            i(xr0,xr2);
+          if (Iter::Ranges::size(i)>1)
+            return false;
+        }
+        {
+          CountableSetRanges xr1(x.lub, x[1]);
+          CountableSetRanges xr2(x.lub, x[2]);
+          Iter::Ranges::Inter<CountableSetRanges,CountableSetRanges> 
+            i(xr1,xr2);
+          if (Iter::Ranges::size(i)>1)
+            return false;
+        }
+        {
+          CountableSetRanges xr0(x.lub, x[0]);
+          CountableSetRanges xr1(x.lub, x[1]);
+          CountableSetRanges xr2(x.lub, x[2]);
+          if (Iter::Ranges::size(xr0)!=3 ||
+              Iter::Ranges::size(xr1)!=3 ||
+              Iter::Ranges::size(xr2)!=3)
+            return false;
+        }
+        return true;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        SetVar s1(home, IntSet::empty, -2, 2, 0,1);
+        Gecode::rel(home, x[0], SOT_INTER, x[1], SRT_EQ, s1);
+        SetVar s2(home, IntSet::empty, -2, 2, 0,1);
+        Gecode::rel(home, x[0], SOT_INTER, x[2], SRT_EQ, s2);
+        SetVar s3(home, IntSet::empty, -2, 2, 0,1);
+        Gecode::rel(home, x[1], SOT_INTER, x[2], SRT_EQ, s3);
+        Gecode::atmostOne(home, x, 3);
+      }
+    };
+    AtmostOne _atmostone("Distinct::AtmostOne");
+
+    //@}
+
+}}}
+
+// STATISTICS: test-set

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

@@ -0,0 +1,292 @@
+/* -*- 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 12:44:18 +0100 (Thu, 21 Feb 2008) $ by $Author: tack $
+ *     $Revision: 6269 $
+ *
+ *  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 domain constraints
+  namespace Dom {
+
+    /**
+      * \defgroup TaskTestSetDom Domain constraints
+      * \ingroup TaskTestSet
+      */
+    //@{
+
+    static const int d1r[4][2] = {
+      {-4,-3},{-1,-1},{1,1},{3,5}
+    };
+    static IntSet d1(d1r,4);
+
+    static const int d1cr[5][2] = {
+      {Gecode::Set::Limits::min,-5},
+      {-2,-2},{0,0},{2,2},
+      {6,Gecode::Set::Limits::max}
+    };
+    static IntSet d1c(d1cr,5);
+
+    static IntSet ds_33(-3,3);
+
+    static const int d2r[2][2] = {
+      {Gecode::Set::Limits::min,-4}, {4,Gecode::Set::Limits::max}
+    };
+    static IntSet ds_33c(d2r,2);
+    static IntSet ds_55(-5,5);
+
+    /// Test for equality with a range
+    class DomRange : public SetTest {
+    private:
+      Gecode::SetRelType srt;
+      IntSet is;
+    public:
+      /// Create and register test
+      DomRange(SetRelType srt0)
+        : SetTest("Dom::Range::"+str(srt0),1,ds_55,true), srt(srt0)
+        , is(srt == Gecode::SRT_CMPL ? ds_33c: ds_33) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr(x.lub, x[0]);
+        IntSetRanges dr(is);
+        switch (srt) {
+        case SRT_EQ: return Iter::Ranges::equal(xr, dr);
+        case SRT_NQ: return !Iter::Ranges::equal(xr, dr);
+        case SRT_SUB: return Iter::Ranges::subset(xr, dr);
+        case SRT_SUP: return Iter::Ranges::subset(dr, xr);
+        case SRT_DISJ:
+          {
+            Gecode::Iter::Ranges::Inter<CountableSetRanges,IntSetRanges>
+              inter(xr, dr);
+            return !inter();
+          }
+        case SRT_CMPL:
+          {
+            Gecode::Set::RangesCompl<IntSetRanges> drc(dr);
+            return Iter::Ranges::equal(xr,drc);
+          }
+        }
+        GECODE_NEVER;
+        return false;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        Gecode::dom(home, x[0], srt, is);
+      }
+      /// Post reified constraint on \a x for \a b
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&,BoolVar b) {
+        Gecode::dom(home, x[0], srt, is, b);
+      }
+    };
+    DomRange _domrange_eq(SRT_EQ);
+    DomRange _domrange_nq(SRT_NQ);
+    DomRange _domrange_sub(SRT_SUB);
+    DomRange _domrange_sup(SRT_SUP);
+    DomRange _domrange_disj(SRT_DISJ);
+    DomRange _domrange_cmpl(SRT_CMPL);
+
+    /// Test for equality with an integer range
+    class DomIntRange : public SetTest {
+    private:
+      Gecode::SetRelType srt;
+    public:
+      /// Create and register test
+      DomIntRange(Gecode::SetRelType srt0)
+        : SetTest("Dom::IntRange::"+str(srt0),1,ds_55,true), srt(srt0) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr(x.lub, x[0]);
+        IntSet is(-3,-1);
+        IntSetRanges dr(is);
+        switch (srt) {
+        case SRT_EQ: return Iter::Ranges::equal(xr, dr);
+        case SRT_NQ: return !Iter::Ranges::equal(xr, dr);
+        case SRT_SUB: return Iter::Ranges::subset(xr, dr);
+        case SRT_SUP: return Iter::Ranges::subset(dr, xr);
+        case SRT_DISJ:
+          {
+            Gecode::Iter::Ranges::Inter<CountableSetRanges,IntSetRanges>
+              inter(xr, dr);
+            return !inter();
+          }
+        case SRT_CMPL:
+          {
+            Gecode::Set::RangesCompl<IntSetRanges> drc(dr);
+            return Iter::Ranges::equal(xr,drc);
+          }
+        }
+        GECODE_NEVER;
+        return false;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        Gecode::dom(home, x[0], srt, -3, -1);
+      }
+      /// Post reified constraint on \a x for \a b
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&,BoolVar b) {
+        Gecode::dom(home, x[0], srt, -3, -1, b);
+      }
+    };
+    DomIntRange _domintrange_eq(SRT_EQ);
+    DomIntRange _domintrange_nq(SRT_NQ);
+    DomIntRange _domintrange_sub(SRT_SUB);
+    DomIntRange _domintrange_sup(SRT_SUP);
+    DomIntRange _domintrange_disj(SRT_DISJ);
+    DomIntRange _domintrange_cmpl(SRT_CMPL);
+
+    /// Test for equality with an integer
+    class DomInt : public SetTest {
+    private:
+      Gecode::SetRelType srt;
+    public:
+      /// Create and register test
+      DomInt(Gecode::SetRelType srt0)
+        : SetTest("Dom::Int::"+str(srt0),1,ds_55,true), srt(srt0) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr(x.lub, x[0]);
+        IntSet is(-3,-3);
+        IntSetRanges dr(is);
+        switch (srt) {
+        case SRT_EQ: return Iter::Ranges::equal(xr, dr);
+        case SRT_NQ: return !Iter::Ranges::equal(xr, dr);
+        case SRT_SUB: return Iter::Ranges::subset(xr, dr);
+        case SRT_SUP: return Iter::Ranges::subset(dr, xr);
+        case SRT_DISJ:
+          {
+            Gecode::Iter::Ranges::Inter<CountableSetRanges,IntSetRanges>
+              inter(xr, dr);
+            return !inter();
+          }
+        case SRT_CMPL:
+          {
+            Gecode::Set::RangesCompl<IntSetRanges> drc(dr);
+            return Iter::Ranges::equal(xr,drc);
+          }
+        }
+        GECODE_NEVER;
+        return false;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        Gecode::dom(home, x[0], srt, -3);
+      }
+      /// Post reified constraint on \a x for \a b
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&,BoolVar b) {
+        Gecode::dom(home, x[0], srt, -3, b);
+      }
+    };
+    DomInt _domint_eq(SRT_EQ);
+    DomInt _domint_nq(SRT_NQ);
+    DomInt _domint_sub(SRT_SUB);
+    DomInt _domint_sup(SRT_SUP);
+    DomInt _domint_disj(SRT_DISJ);
+    DomInt _domint_cmpl(SRT_CMPL);
+
+    /// Test for equality with a domain
+    class DomDom : public SetTest {
+    private:
+      Gecode::SetRelType srt;
+      Gecode::IntSet is;
+    public:
+      /// Create and register test
+      DomDom(Gecode::SetRelType srt0)
+        : SetTest("Dom::Dom::"+str(srt0),1,d1,true), srt(srt0)
+        , is(srt == Gecode::SRT_CMPL ? d1c: d1) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr(x.lub, x[0]);
+        IntSetRanges dr(is);
+        switch (srt) {
+        case SRT_EQ: return Iter::Ranges::equal(xr, dr);
+        case SRT_NQ: return !Iter::Ranges::equal(xr, dr);
+        case SRT_SUB: return Iter::Ranges::subset(xr, dr);
+        case SRT_SUP: return Iter::Ranges::subset(dr, xr);
+        case SRT_DISJ:
+          {
+            Gecode::Iter::Ranges::Inter<CountableSetRanges,IntSetRanges>
+              inter(xr, dr);
+            return !inter();
+          }
+        case SRT_CMPL:
+          {
+            Gecode::Set::RangesCompl<IntSetRanges> drc(dr);
+            return Iter::Ranges::equal(xr,drc);
+          }
+        }
+        GECODE_NEVER;
+        return false;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        Gecode::dom(home, x[0], srt, is);
+      }
+      /// Post reified constraint on \a x for \a b
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&,BoolVar b) {
+        Gecode::dom(home, x[0], srt, is, b);
+      }
+    };
+    DomDom _domdom_eq(SRT_EQ);
+    DomDom _domdom_nq(SRT_NQ);
+    DomDom _domdom_sub(SRT_SUB);
+    DomDom _domdom_sup(SRT_SUP);
+    DomDom _domdom_disj(SRT_DISJ);
+    DomDom _domdom_cmpl(SRT_CMPL);
+
+    /// Test for cardinality range
+    class CardRange : public SetTest {
+    public:
+      /// Create and register test
+      CardRange(void)
+        : SetTest("Dom::CardRange",1,d1,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr(x.lub, x[0]);
+        unsigned int card = Iter::Ranges::size(xr);
+        return card >= 2 && card <= 3;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        Gecode::cardinality(home, x[0], 2, 3);
+      }
+    };
+    CardRange _cardRange;
+
+}}}
+
+// STATISTICS: test-set

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

@@ -0,0 +1,473 @@
+/* -*- 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-20 10:27:10 +0100 (Wed, 20 Feb 2008) $ by $Author: tack $
+ *     $Revision: 6241 $
+ *
+ *  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 "test/int.hh"
+#include "gecode/minimodel.hh"
+
+using namespace Gecode;
+
+namespace Test { namespace Set {
+
+  /// Tests for combined int/set constraints
+  namespace Int {
+
+    /**
+      * \defgroup TaskTestSetInt Combined integer/set constraints
+      * \ingroup TaskTestSet
+      */
+    //@{
+
+    static const int d1r[4][2] = {
+      {-4,-3},{-1,-1},{1,1},{3,5}
+    };
+    static IntSet d1(d1r,4);
+
+    static IntSet d2(-1,3);
+    static IntSet d3(0,3);
+
+    static IntSet d4(0,4);
+
+    static IntSet ds_33(-3,3);
+
+    /// Test for cardinality constraint
+    class Card : public SetTest {
+    public:
+      /// Create and register test
+      Card(const char* t)
+        : SetTest(t,1,ds_33,false,1) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        unsigned int s = 0;
+        for (CountableSetRanges xr(x.lub, x[0]);xr();++xr) s+= xr.width();
+        if (x.intval() < 0)
+          return false;
+        return s==(unsigned int)x.intval();
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+        Gecode::cardinality(home, x[0], y[0]);
+      }
+    };
+    Card _card("Int::Card");
+
+    /// Test for minimal element constraint
+    class Min : public SetTest {
+    public:
+      /// Create and register test
+      Min(const char* t)
+        : SetTest(t,1,ds_33,false,1) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr0(x.lub, x[0]);
+        return xr0() && xr0.min()==x.intval();
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+        Gecode::min(home, x[0], y[0]);
+      }
+    };
+    Min _min("Int::Min");
+
+    /// Test for maximal element constraint
+    class Max : public SetTest {
+    public:
+      /// Create and register test
+      Max(const char* t)
+        : SetTest(t,1,ds_33,false,1) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr0(x.lub, x[0]);
+        IntSet x0(xr0);
+        return x0.size() > 0 && x0.max()==x.intval();
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+        Gecode::max(home, x[0], y[0]);
+      }
+    };
+    Max _max("Int::Max");
+
+    /// Test for element constraint
+    class Elem : public SetTest {
+    public:
+      /// Create and register test
+      Elem(const char* t)
+        : SetTest(t,1,ds_33,true,1) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        for(CountableSetValues xr(x.lub, x[0]);xr();++xr)
+          if (xr.val()==x.intval())
+            return true;
+        return false;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+        Gecode::rel(home, x[0], SRT_SUP, y[0]);
+      }
+      /// Post reified constraint on \a x for \a b
+      virtual void post(Space* home, SetVarArray& x, IntVarArray& y, BoolVar b) {
+        Gecode::rel(home, x[0], SRT_SUP, y[0], b);
+      }
+    };
+    Elem _elem("Int::Elem");
+
+    /// Test for negated element constraint
+    class NoElem : public SetTest {
+    public:
+      /// Create and register test
+      NoElem(const char* t)
+        : SetTest(t,1,ds_33,false,1) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        for(CountableSetValues xr(x.lub, x[0]);xr();++xr)
+          if (xr.val()==x.intval())
+            return false;
+        return true;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+        Gecode::rel(home, x[0], SRT_DISJ, y[0]);
+      }
+    };
+    NoElem _noelem("Int::NoElem");
+
+    /// Test for relation constraint
+    class Rel : public SetTest {
+    private:
+      Gecode::SetRelType srt;
+      bool inverse;
+    public:
+      /// Create and register test
+      Rel(Gecode::SetRelType srt0, bool inverse0)
+        : SetTest("Int::Rel::"+str(srt0)+(inverse0 ? "::i" : ""),
+                  1,ds_33,true,1)
+        , srt(srt0)
+        , inverse(inverse0) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr(x.lub, x[0]);
+        IntSet is(x.intval(), x.intval());
+        IntSetRanges dr(is);
+        Gecode::SetRelType rsrt = srt;
+        if (inverse) {
+          switch (srt) {
+            case SRT_SUB: rsrt = SRT_SUP; break;
+            case SRT_SUP: rsrt = SRT_SUB; break;
+            default: break;
+          }
+        }
+        switch (rsrt) {
+        case SRT_EQ: return Iter::Ranges::equal(xr, dr);
+        case SRT_NQ: return !Iter::Ranges::equal(xr, dr);
+        case SRT_SUB: return Iter::Ranges::subset(xr, dr);
+        case SRT_SUP: return Iter::Ranges::subset(dr, xr);
+        case SRT_DISJ:
+          {
+            Gecode::Iter::Ranges::Inter<CountableSetRanges,IntSetRanges>
+              inter(xr, dr);
+            return !inter();
+          }
+        case SRT_CMPL:
+          {
+            Gecode::Set::RangesCompl<IntSetRanges> drc(dr);
+            return Iter::Ranges::equal(xr,drc);
+          }
+        }
+        GECODE_NEVER;
+        return false;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+        if (!inverse)
+          Gecode::rel(home, x[0], srt, y[0]);
+        else
+          Gecode::rel(home, y[0], srt, x[0]);
+      }
+      /// Post reified constraint on \a x for \a b
+      virtual void post(Space* home, SetVarArray& x, IntVarArray& y,
+                        BoolVar b) {
+        if (!inverse)
+          Gecode::rel(home, x[0], srt, y[0], b);
+        else
+          Gecode::rel(home, y[0], srt, x[0], b);
+      }
+    };
+    Rel _rel_eq(Gecode::SRT_EQ,false);
+    Rel _rel_nq(Gecode::SRT_NQ,false);
+    Rel _rel_sub(Gecode::SRT_SUB,false);
+    Rel _rel_sup(Gecode::SRT_SUP,false);
+    Rel _rel_disj(Gecode::SRT_DISJ,false);
+    Rel _rel_cmpl(Gecode::SRT_CMPL,false);
+    Rel _rel_eqi(Gecode::SRT_EQ,true);
+    Rel _rel_nqi(Gecode::SRT_NQ,true);
+    Rel _rel_subi(Gecode::SRT_SUB,true);
+    Rel _rel_supi(Gecode::SRT_SUP,true);
+    Rel _rel_disji(Gecode::SRT_DISJ,true);
+    Rel _rel_cmpli(Gecode::SRT_CMPL,true);
+
+    /// Test for integer relation constraint
+    class IntRel : public SetTest {
+    private:
+      Gecode::IntRelType irt;
+      bool inverse;
+    public:
+      /// Create and register test
+      IntRel(Gecode::IntRelType irt0, bool inverse0)
+        : SetTest("Int::IntRel::"+Test::Int::Test::str(irt0)+
+                  (inverse0 ? "::i" : ""),1,ds_33,false,1)
+        , irt(irt0)
+        , inverse(inverse0) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetValues xr(x.lub, x[0]);
+        if (!xr())
+          return false;
+        for (; xr(); ++xr) {
+          switch (irt) {
+          case Gecode::IRT_EQ:
+            if (xr.val() != x.intval()) return false;
+            break;
+          case Gecode::IRT_NQ:
+            if (xr.val() == x.intval()) return false;
+            break;
+          case Gecode::IRT_GR:
+            if (!inverse && xr.val() <= x.intval()) return false;
+            if (inverse && xr.val() >= x.intval()) return false;
+            break;
+          case Gecode::IRT_GQ:
+            if (!inverse && xr.val() < x.intval()) return false;
+            if (inverse && xr.val() > x.intval()) return false;
+            break;
+          case Gecode::IRT_LE:
+            if (!inverse && xr.val() >= x.intval()) return false;
+            if (inverse && xr.val() <= x.intval()) return false;
+            break;
+          case Gecode::IRT_LQ:
+            if (!inverse && xr.val() > x.intval()) return false;
+            if (inverse && xr.val() < x.intval()) return false;
+            break;
+          default:
+            GECODE_NEVER;
+            return false;
+          }
+        }
+        return true;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+        if (!inverse)
+          Gecode::rel(home, x[0], irt, y[0]);
+        else
+          Gecode::rel(home, y[0], irt, x[0]);
+      }
+    };
+    IntRel _intrel_eq(Gecode::IRT_EQ,false);
+    IntRel _intrel_nq(Gecode::IRT_NQ,false);
+    IntRel _intrel_gr(Gecode::IRT_GR,false);
+    IntRel _intrel_gq(Gecode::IRT_GQ,false);
+    IntRel _intrel_le(Gecode::IRT_LE,false);
+    IntRel _intrel_lq(Gecode::IRT_LQ,false);
+    IntRel _intrel_eqi(Gecode::IRT_EQ,true);
+    IntRel _intrel_nqi(Gecode::IRT_NQ,true);
+    IntRel _intrel_gri(Gecode::IRT_GR,true);
+    IntRel _intrel_gqi(Gecode::IRT_GQ,true);
+    IntRel _intrel_lei(Gecode::IRT_LE,true);
+    IntRel _intrel_lqi(Gecode::IRT_LQ,true);
+
+
+    template <class I>
+    int weightI(const IntArgs& elements,
+                const IntArgs& weights,
+                I& iter) {
+      int sum = 0;
+      int i = 0;
+      for (Iter::Ranges::ToValues<I> v(iter); v(); ++v) {
+        // Skip all elements below the current
+        while (elements[i]<v.val()) i++;
+        assert(elements[i] == v.val());
+        sum += weights[i];
+      }
+      return sum;
+    }
+
+    /// Test for set weight constraint
+    class Weights : public SetTest {
+    public:
+      IntArgs elements;
+      IntArgs weights;
+
+      /// Create and register test
+      Weights(const char* t)
+        : SetTest(t,1,ds_33,false,1),
+          elements(7), weights(7) {
+        for (int i=-3; i<=3; i++)
+          elements[i+3] = i;
+        for (int i=0; i<7; i++)
+          weights[i] = 1;
+        weights[1] = -2;
+        weights[5] = 6;
+      }
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges x0(x.lub, x[0]);
+        return x.intval()==weightI(elements,weights,x0);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+        Gecode::weights(home, elements, weights, x[0], y[0]);
+      }
+    };
+    Weights _weights("Int::Weights");
+
+    /// Test for match constraint
+    class Match : public SetTest {
+    public:
+      /// Create and register test
+      Match(const char* t)
+        : SetTest(t,1,ds_33,false,3) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        if (x.ints()[0]>=x.ints()[1] ||
+            x.ints()[1]>=x.ints()[2])
+          return false;
+        CountableSetValues xr(x.lub, x[0]);
+        if (!xr())
+          return false;
+        if (xr.val() != x.ints()[0])
+          return false;
+        ++xr;
+        if (!xr())
+          return false;
+        if (xr.val() != x.ints()[1])
+          return false;
+        ++xr;
+        if (!xr())
+          return false;
+        if (xr.val() != x.ints()[2])
+          return false;
+        ++xr;
+        if (xr())
+          return false;
+        return true;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+        Gecode::match(home, x[0], y);
+      }
+    };
+    Match _match("Int::Match");
+
+    /// Test for integer channel constraint
+    class ChannelInt : public SetTest {
+    private:
+      int ssize, isize;
+    public:
+      /// Create and register test
+      ChannelInt(const char* t, const IntSet& d, int _ssize, int _isize)
+        : SetTest(t,_ssize,d,false,_isize), ssize(_ssize), isize(_isize) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        for (int i=0; i<isize; i++) {
+          if (x.ints()[i] < 0 || x.ints()[i] >= ssize)
+            return false;
+          Iter::Ranges::Singleton single(i,i);
+          CountableSetRanges csr(x.lub, x[x.ints()[i]]);
+          if (!Iter::Ranges::subset(single, csr))
+            return false;
+        }
+        for (int i=0; i<ssize; i++) {
+          int size = 0;
+          for (CountableSetValues csv(x.lub, x[i]); csv(); ++csv) {
+            if (csv.val() < 0 || csv.val() >= isize) return false;
+            if (x.ints()[csv.val()] != i) return false;
+            size++;
+          }
+        }
+        return true;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+        Gecode::channel(home, y, x);
+      }
+    };
+
+    ChannelInt _channelint1("Int::Channel::Int::1", d2, 2, 3);
+    ChannelInt _channelint2("Int::Channel::Int::2", d3, 3, 3);
+
+    /// Test for Boolean channel constraint
+    class ChannelBool : public SetTest {
+    private:
+      int isize;
+    public:
+      /// Create and register test
+      ChannelBool(const char* t, const IntSet& d, int _isize)
+        : SetTest(t,1,d,false,_isize), isize(_isize) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        for (int i=0; i<isize; i++) {
+          if (x.ints()[i] < 0 || x.ints()[i] > 1)
+            return false;
+        }
+        int cur = 0;
+        for (CountableSetValues csv(x.lub, x[0]); csv(); ++csv) {
+          if (csv.val() < 0 || csv.val() >= isize) return false;
+          if (x.ints()[csv.val()] != 1) return false;
+          for (; cur<csv.val(); cur++)
+            if (x.ints()[cur] != 0) return false;
+          cur = csv.val() + 1;
+        }
+        for (; cur<isize; cur++)
+          if (x.ints()[cur] != 0) return false;
+        return true;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+        BoolVarArgs b(y.size());
+        for (int i=y.size(); i--;)
+          b[i] = channel(home, y[i]);
+        Gecode::channel(home, b, x[0]);
+      }
+    };
+
+    ChannelBool _channelbool1("Int::Channel::Bool::1", d2, 3);
+    ChannelBool _channelbool2("Int::Channel::Bool::2", d3, 3);
+    ChannelBool _channelbool3("Int::Channel::Bool::3", d4, 5);
+  
+}}}
+
+// STATISTICS: test-set