gecoder-with-gecode 0.9.0 → 0.9.1

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

@@ -0,0 +1,125 @@
+/* -*- 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 relation constraints
+  namespace Rel {
+
+    /**
+      * \defgroup TaskTestSetRel Relation constraints
+      * \ingroup TaskTestSet
+      */
+    //@{
+
+    static IntSet ds_33(-3,3);
+
+    /// Test for binary set relation constraint
+    class RelBin : public SetTest {
+    private:
+      Gecode::SetRelType srt;
+      bool shared;
+    public:
+      /// Create and register test
+      RelBin(Gecode::SetRelType srt0, bool shared0)
+        : SetTest("Rel::Bin::"+str(srt0)+"::S"+(shared0 ? "1":"0"),
+                  shared ? 1 : 2,ds_33,true)
+        , srt(srt0), shared(shared0){}
+      /// Test whether \a x is solution
+      bool solution(const SetAssignment& x) const {
+        int x1 = shared ? x[0] : x[1];
+        CountableSetRanges xr0(x.lub, x[0]);
+        CountableSetRanges xr1(x.lub, x1);
+        switch (srt) {
+        case SRT_EQ: return Iter::Ranges::equal(xr0, xr1);
+        case SRT_NQ: return !Iter::Ranges::equal(xr0, xr1);
+        case SRT_SUB: return Iter::Ranges::subset(xr0, xr1);
+        case SRT_SUP: return Iter::Ranges::subset(xr1, xr0);
+        case SRT_DISJ:
+          {
+            Iter::Ranges::Inter<CountableSetRanges,CountableSetRanges>
+              inter(xr0,xr1);
+            return !inter();
+          }
+        case SRT_CMPL:
+          {
+            Gecode::Set::RangesCompl<CountableSetRanges> rc(xr0);
+            return Iter::Ranges::equal(rc,xr1);
+          }
+        default:
+          GECODE_NEVER;
+        }
+        GECODE_NEVER;
+        return false;
+      }
+      /// Post constraint on \a x
+      void post(Space* home, SetVarArray& x, IntVarArray&) {
+        if (!shared)
+          Gecode::rel(home, x[0], srt, x[1]);
+        else
+          Gecode::rel(home, x[0], srt, x[0]);
+      }
+      /// Post reified constraint on \a x for \a b
+      void post(Space* home, SetVarArray& x, IntVarArray&, BoolVar b) {
+        if (!shared)
+          Gecode::rel(home, x[0], srt, x[1], b);
+        else
+          Gecode::rel(home, x[0], srt, x[0], b);
+      }
+    };
+    RelBin _relbin_eq(Gecode::SRT_EQ,false);
+    RelBin _relbin_nq(Gecode::SRT_NQ,false);
+    RelBin _relbin_sub(Gecode::SRT_SUB,false);
+    RelBin _relbin_sup(Gecode::SRT_SUP,false);
+    RelBin _relbin_disj(Gecode::SRT_DISJ,false);
+    RelBin _relbin_cmpl(Gecode::SRT_CMPL,false);
+    RelBin _relbin_shared_eq(Gecode::SRT_EQ,true);
+    RelBin _relbin_shared_nq(Gecode::SRT_NQ,true);
+    RelBin _relbin_shared_sub(Gecode::SRT_SUB,true);
+    RelBin _relbin_shared_sup(Gecode::SRT_SUP,true);
+    RelBin _relbin_shared_disj(Gecode::SRT_DISJ,true);
+    RelBin _relbin_shared_cmpl(Gecode::SRT_CMPL,true);
+
+    //@}
+
+}}}
+
+// STATISTICS: test-set

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

@@ -0,0 +1,299 @@
+/* -*- 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-07-11 10:35:42 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7339 $
+ *
+ *  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 set element constraints
+  namespace Element {
+
+    /**
+      * \defgroup TaskTestSetElement Element constraints
+      * \ingroup TaskTestSet
+      */
+    //@{
+
+    static IntSet ds_12(-1,2);
+    static IntSet ds_13(-1,3);
+
+    /// Test for ElementUnion constraint
+    class ElementUnion : public SetTest {
+    public:
+      /// Create and register test
+      ElementUnion(const char* t)
+        : SetTest(t,5,ds_12,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        int selected = 0;
+        for (CountableSetValues sel2(x.lub, x[3]); sel2();
+             ++sel2, selected++);
+        CountableSetValues x4v(x.lub, x[4]);
+        if (selected==0)
+          return !x4v();
+        GECODE_AUTOARRAY(CountableSetRanges, sel, selected);
+        CountableSetValues selector(x.lub, x[3]);
+        for (int i=selected; i--;++selector) {
+          if (selector.val()>=3 || selector.val()<0)
+            return false;
+          sel[i].init(x.lub, x[selector.val()]);
+        }
+        Iter::Ranges::NaryUnion<CountableSetRanges> u(sel, selected);
+
+        CountableSetRanges z(x.lub, x[4]);
+        return Iter::Ranges::equal(u, z);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        SetVarArgs xs(x.size()-2);
+        for (int i=x.size()-2; i--;)
+          xs[i]=x[i];
+        Gecode::elementsUnion(home, xs, x[x.size()-2], x[x.size()-1]);
+      }
+    };
+    ElementUnion _elementunion("Element::Union");
+
+    /// Test for ElementUnion constraint
+    class ElementUnionConst : public SetTest {
+    private:
+      const IntSet i0;
+      const IntSet i1;
+      const IntSet i2;
+    public:
+      /// Create and register test
+      ElementUnionConst(const char* t)
+        : SetTest(t,2,ds_13,false), i0(-3,-3), i1(-1,1), i2(0,2) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        int selected = 0;
+        for (CountableSetValues sel2(x.lub, x[0]); sel2();
+             ++sel2, selected++);
+        CountableSetValues x4v(x.lub, x[1]);
+        if (selected==0)
+          return !x4v();
+        IntSet iss[] = {i0, i1, i2};
+        GECODE_AUTOARRAY(IntSetRanges, sel, selected);
+        CountableSetValues selector(x.lub, x[0]);
+        for (int i=selected; i--;++selector) {
+          if (selector.val()>=3 || selector.val()<0)
+            return false;
+          sel[i].init(iss[selector.val()]);
+        }
+        Iter::Ranges::NaryUnion<IntSetRanges> u(sel, selected);
+
+        CountableSetRanges z(x.lub, x[1]);
+        return Iter::Ranges::equal(u, z);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        IntSetArgs xs(3);
+        xs[0] = i0; xs[1] = i1; xs[2] = i2;
+        Gecode::elementsUnion(home, xs, x[0], x[1]);
+      }
+    };
+    ElementUnionConst _elementunionconst("Element::UnionConst");
+
+    /// Test for ElementInter constraint
+    class ElementInter : public SetTest {
+    public:
+      /// Create and register test
+      ElementInter(const char* t)
+        : SetTest(t,5,ds_12,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        int selected = 0;
+        for (CountableSetValues sel2(x.lub, x[3]); sel2();
+             ++sel2, selected++);
+        CountableSetRanges x4r(x.lub, x[4]);
+        if (selected==0)
+          return Iter::Ranges::size(x4r)==Gecode::Set::Limits::card;
+        GECODE_AUTOARRAY(CountableSetRanges, sel, selected);
+        CountableSetValues selector(x.lub, x[3]);
+        for (int i=selected; i--;++selector) {
+          if (selector.val()>=3 || selector.val()<0)
+            return false;
+          sel[i].init(x.lub, x[selector.val()]);
+        }
+        Iter::Ranges::NaryInter<CountableSetRanges> u(sel, selected);
+
+        CountableSetRanges z(x.lub, x[4]);
+        return Iter::Ranges::equal(u, z);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        SetVarArgs xs(x.size()-2);
+        for (int i=x.size()-2; i--;)
+          xs[i]=x[i];
+        Gecode::elementsInter(home, xs, x[x.size()-2], x[x.size()-1]);
+      }
+    };
+    ElementInter _elementinter("Element::Inter");
+
+    /// Test for ElementInter constraint
+    class ElementInterIn : public SetTest {
+    public:
+      /// Create and register test
+      ElementInterIn(const char* t)
+        : SetTest(t,5,ds_12,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        int selected = 0;
+        for (CountableSetValues sel2(x.lub, x[3]); sel2();
+             ++sel2, selected++);
+        CountableSetRanges x4r(x.lub, x[4]);
+        if (selected==0)
+          return Iter::Ranges::size(x4r)==4;
+        GECODE_AUTOARRAY(CountableSetRanges, sel, selected);
+        CountableSetValues selector(x.lub, x[3]);
+        for (int i=selected; i--;++selector) {
+          if (selector.val()>=3 || selector.val()<0)
+            return false;
+          sel[i].init(x.lub, x[selector.val()]);
+        }
+        Iter::Ranges::NaryInter<CountableSetRanges> u(sel, selected);
+
+        CountableSetRanges z(x.lub, x[4]);
+        return Iter::Ranges::equal(u, z);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        SetVarArgs xs(x.size()-2);
+        for (int i=x.size()-2; i--;)
+          xs[i]=x[i];
+        Gecode::elementsInter(home, xs, x[x.size()-2], x[x.size()-1], ds_12);
+      }
+    };
+    ElementInterIn _elementinterin("Element::InterIn");
+
+    /// Test for ElementDisjoint constraint
+    class ElementDisjoint : public SetTest {
+    public:
+      /// Create and register test
+      ElementDisjoint(const char* t)
+        : SetTest(t,4,ds_12,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        int selected = 0;
+        for (CountableSetValues sel2(x.lub, x[3]); sel2();
+             ++sel2, selected++) {
+          if (sel2.val() < 0)
+            return false;
+        };
+        if (selected <= 1)
+          return true;
+        GECODE_AUTOARRAY(CountableSetRanges, sel, selected);
+        CountableSetValues selector(x.lub, x[3]);
+        unsigned int cardsum = 0;
+        for (int i=selected; i--;++selector) {
+          if (selector.val()>=3 || selector.val()<0)
+            return false;
+          sel[i].init(x.lub, x[selector.val()]);
+          CountableSetRanges xicard(x.lub, x[selector.val()]);
+          cardsum += Iter::Ranges::size(xicard);
+        }
+        Iter::Ranges::NaryUnion<CountableSetRanges> u(sel, selected);
+        return Iter::Ranges::size(u) == cardsum;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        SetVarArgs xs(x.size()-1);
+        for (int i=x.size()-1; i--;)
+          xs[i]=x[i];
+        Gecode::elementsDisjoint(home, xs, x[x.size()-1]);
+      }
+    };
+    ElementDisjoint _elementdisjoint("Element::Disjoint");
+
+    /// Test for ElementElement constraint
+    class ElementSet : public SetTest {
+    public:
+      /// Create and register test
+      ElementSet(const char* t)
+        : SetTest(t,4,ds_12,false,true) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        if (x.intval() < 0 || x.intval() > 2)
+          return false;
+        CountableSetRanges z(x.lub, x[3]);
+        CountableSetRanges y(x.lub, x[x.intval()]);
+        return Iter::Ranges::equal(y, z);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+        SetVarArgs xs(x.size()-1);
+        for (int i=x.size()-1; i--;)
+          xs[i]=x[i];
+        Gecode::element(home, xs, y[0], x[x.size()-1]);
+      }
+    };
+    ElementSet _elementset("Element::Set");
+
+    /// Test for ElementUnion constraint
+    class ElementSetConst : public SetTest {
+    private:
+      const IntSet i0;
+      const IntSet i1;
+      const IntSet i2;
+    public:
+      /// Create and register test
+      ElementSetConst(const char* t)
+        : SetTest(t,1,ds_13,false,true), i0(-3,-3), i1(-1,1), i2(0,2) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        if (x.intval() < 0 || x.intval() > 2)
+          return false;
+        CountableSetRanges xr(x.lub, x[0]);
+        IntSet iss[] = {i0, i1, i2};
+        IntSetRanges isr(iss[x.intval()]);
+        return Iter::Ranges::equal(xr, isr);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray& y) {
+        IntSetArgs xs(3);
+        xs[0] = i0; xs[1] = i1; xs[2] = i2;
+        Gecode::element(home, xs, y[0], x[0]);
+      }
+    };
+    ElementSetConst _elementsetconst("Element::SetConst");
+
+    //@}
+
+}}}
+
+// STATISTICS: test-set

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

@@ -0,0 +1,125 @@
+/* -*- 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-19 10:36:44 +0100 (Tue, 19 Feb 2008) $ by $Author: tack $
+ *     $Revision: 6228 $
+ *
+ *  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 sequence constraints
+  namespace Sequence {
+
+    /**
+      * \defgroup TaskTestSetSequence Sequence constraints
+      * \ingroup TaskTestSet
+      */
+    //@{
+
+    static IntSet ds_33(-1,2);
+
+    /// Test for sequence constraint
+    class Sequence : public SetTest {
+    public:
+      /// Create and register test
+      Sequence(const char* t)
+        : SetTest(t,4,ds_33,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        int max = Gecode::Set::Limits::min - 1;
+        for (int i=0; i<4; i++) {
+          CountableSetRanges xir(x.lub, x[i]);
+          IntSet xi(xir);
+          if (xi.size() > 0) {
+            int oldMax = max;
+            max = xi.max();
+            if (xi.min() <= oldMax)
+              return false;
+          }
+        }
+        return true;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        Gecode::sequence(home, x);
+      }
+    };
+    Sequence _sequence("Sequence::Sequence");
+
+    /// Test for sequential-union constraint
+    class SeqU : public SetTest {
+    private:
+      int n;
+    public:
+      /// Create and register test
+      SeqU(int n0)
+        : SetTest("Sequence::SeqU"+str(n0),n0+1,ds_33,false), n(n0) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        int max = Gecode::Set::Limits::min - 1;
+        for (int i=0; i<n; i++) {
+          CountableSetRanges xir(x.lub, x[i]);
+          IntSet xi(xir);
+          if (xi.size() > 0) {
+            int oldMax = max;
+            max = xi.max();
+            if (xi.min() <= oldMax)
+              return false;
+          }
+        }
+        GECODE_AUTOARRAY(CountableSetRanges, isrs, n);
+        for (int i=n; i--; )
+          isrs[i].init(x.lub, x[i]);
+        Iter::Ranges::NaryUnion<CountableSetRanges> u(isrs, n);
+        CountableSetRanges xnr(x.lub, x[n]);
+        return Iter::Ranges::equal(u, xnr);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, SetVarArray& x, IntVarArray&) {
+        SetVarArgs xs(x.size()-1);
+        for (int i=x.size()-1; i--;)
+          xs[i]=x[i];
+        Gecode::sequentialUnion(home, xs, x[x.size()-1]);
+      }
+    };
+    SeqU _sequ0(0);
+    SeqU _sequ1(1);
+    SeqU _sequ3(3);
+
+}}}
+
+// STATISTICS: test-set