gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/test/cpltset/partition.cc

@@ -0,0 +1,210 @@
+/* -*- 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-09 10:29:51 +0100 (Fri, 09 Nov 2007) $ by $Author: tack $
+ *     $Revision: 5228 $
+ *
+ *  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/cpltset.hh"
+
+using namespace Gecode;
+using namespace Test::Set;
+
+namespace Test { namespace CpltSet {
+
+  /// Tests for partition constraints
+  namespace Partition {
+
+    /**
+      * \defgroup TaskTestCpltSetPartition Partition constraints
+      * \ingroup TaskTestCpltSet
+      */
+    //@{
+
+    static const int d1r[2][2] = {
+      {-4,-4},{3,5}
+    };
+    static IntSet d1(d1r,2);
+
+    static IntSet ds_33(-3,3);
+    static IntSet ds_4(4,4);
+    static IntSet ds_13(1,3);
+
+    /// Test for partition constraint
+    class CpltSetPartition : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetPartition(const char* t) : CpltSetTest(t,2,ds_13,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr1(x.lub, x[0]);
+        CountableSetRanges xr2(x.lub, x[1]);
+
+        Iter::Ranges::Inter<CountableSetRanges, CountableSetRanges>
+          d(xr1, xr2);
+        Iter::Ranges::Union<CountableSetRanges, CountableSetRanges>
+          u(xr1, xr2);
+        IntSetRanges ir(ds_13);
+
+        bool empty = !d();
+        bool same  = Iter::Ranges::equal(u, ir);
+
+        return empty && same;
+      }
+
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        // Test lex-bit order
+        Gecode::partition(home, x);
+      }
+    };
+    CpltSetPartition _cpltsetpartition("Partition");
+
+    /// Test for partition with lexicographic order constraint
+    class CpltSetPartitionLex : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetPartitionLex(const char* t) : CpltSetTest(t,2,ds_13,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr1(x.lub, x[0]);
+        CountableSetRanges xr2(x.lub, x[1]);
+
+        Iter::Ranges::Inter<CountableSetRanges, CountableSetRanges>
+          d(xr1, xr2);
+        Iter::Ranges::Union<CountableSetRanges, CountableSetRanges>
+          u(xr1, xr2);
+        IntSetRanges ir(ds_13);
+
+        bool empty = !d();
+        bool same  = Iter::Ranges::equal(u, ir);
+
+        CountableSetValues xv1(x.lub, x[0]);
+        CountableSetValues xv2(x.lub, x[1]);
+        int a = iter2int(xv1, 3);
+        int b = iter2int(xv2, 3);
+    
+        return empty && same && (a < b);
+      }
+
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        Gecode::partitionLex(home, x, SRT_LE);
+      }
+    };
+    CpltSetPartitionLex _cpltsetpartitionlex("Partition::Lex");
+
+    /// Test for partition with result constraint
+    class CpltSetPartitionNaryOne : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetPartitionNaryOne(const char* t)
+      : CpltSetTest(t,3,ds_13,false, 0, 200, 10) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr1(x.lub, x[0]);
+        CountableSetRanges xr2(x.lub, x[1]);
+        CountableSetRanges xr3(x.lub, x[2]);
+
+        Iter::Ranges::Inter<CountableSetRanges, CountableSetRanges>
+          d(xr1, xr2);
+        Iter::Ranges::Union<CountableSetRanges, CountableSetRanges>
+          u(xr1, xr2);
+
+        bool empty = !d();
+        bool same  = Iter::Ranges::equal(u, xr3);
+
+        return empty && same;
+      }
+
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        // Test lex-bit order
+        int n = x.size() - 1;
+        CpltSetVarArgs z(n);
+        for (int i = 0; i < n; i++)
+          z[i] = x[i];
+        CpltSetVar y = x[n];
+        partition(home, z, y);
+      }
+    };
+    CpltSetPartitionNaryOne _cpltsetpartitionnaryone("Partition::NaryOne");
+
+    /// Test for bigger instance of partition constraint
+    class CpltSetPartitionNaryOneBigger : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetPartitionNaryOneBigger(const char* t)
+      : CpltSetTest(t,3,d1,false, 0, 200, 80) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr1(x.lub, x[0]);
+        CountableSetRanges xr2(x.lub, x[1]);
+        CountableSetRanges xr3(x.lub, x[2]);
+        Iter::Ranges::Cache<CountableSetRanges> cxr3(xr3);
+
+        Iter::Ranges::Inter<CountableSetRanges, CountableSetRanges>
+          d(xr1, xr2);
+        Iter::Ranges::Union<CountableSetRanges, CountableSetRanges>
+          u(xr1, xr2);
+
+        bool empty = !d();
+        bool same  = Iter::Ranges::equal(u, cxr3);
+
+        cxr3.reset();
+        Iter::Ranges::Singleton m(3,5);
+
+        bool fixed = Iter::Ranges::equal(m, cxr3);
+
+        return empty && same && fixed;
+      }
+
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        int n = x.size() - 1;
+        CpltSetVarArgs z(n);
+        for (int i = 0; i < n; i++)
+          z[i] = x[i];
+        CpltSetVar y = x[n];
+        partition(home, z, y);
+        dom(home, y, SRT_EQ, 3, 5);
+      }
+    };
+    CpltSetPartitionNaryOneBigger 
+      _cpltsetpartitionnaryonebigger("Partition::NaryOne::Bigger");
+
+    //@}
+
+}}}
+
+// STATISTICS: test-cpltset

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

@@ -0,0 +1,158 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2005
+ *
+ *  Last modified:
+ *     $Date: 2007-09-13 21:30:38 +0200 (Thu, 13 Sep 2007) $ by $Author: tack $
+ *     $Revision: 5029 $
+ *
+ *  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/cpltset.hh"
+
+using namespace Gecode;
+using namespace Test::Set;
+
+namespace Test { namespace CpltSet {
+
+  /// Tests for relation constraints
+  namespace Rel {
+
+    /**
+      * \defgroup TaskTestCpltSetRel Relation constraints
+      * \ingroup TaskTestCpltSet
+      */
+    //@{
+
+    static const int d1r[4][2] = {
+      {-4,-3},{-1,-1},{1,1},{3,5}
+    };
+    static IntSet d1(d1r,4);
+
+    static IntSet ds_33(-3,3);
+    static IntSet ds_4(4,4);
+    static IntSet ds_13(1,3);
+
+    /// Test for lexicographic less relation constraint
+    class CpltSetRelLe : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetRelLe(const char* t) : CpltSetTest(t,2,ds_13,false) {}
+
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetValues xr1(x.lub, x[0]);
+        CountableSetValues xr2(x.lub, x[1]);
+        // in lex-bit order empty is the smallest
+        int a = (iter2int(xr1, 3));
+        int b = (iter2int(xr2, 3));
+        return a < b;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        // Test lex-bit order
+        Gecode::rel(home, x[0], SRT_LE, x[1]);
+      }
+    };
+    CpltSetRelLe _cpltsetrelle("Rel::Le");
+
+    /// Test for lexicographic less-or-equal relation constraint
+    class CpltSetRelLq : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetRelLq(const char* t) : CpltSetTest(t,2,ds_13,false) {}
+
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetValues xr1(x.lub, x[0]);
+        CountableSetValues xr2(x.lub, x[1]);
+        // in lex-bit order empty is the smallest
+        int a = (iter2int(xr1, 3));
+        int b = (iter2int(xr2, 3));
+        return a <= b;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        // Test lex-bit order
+        Gecode::rel(home, x[0], SRT_LQ, x[1]);
+      }
+    };
+    CpltSetRelLq _cpltsetrellq("Rel::Lq");
+
+    /// Test for lexicographic less diff constraint
+    class CpltSetRelLeDiff : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetRelLeDiff(const char* t) : CpltSetTest(t,2,ds_33,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetValues xr1(x.lub, x[0]);
+        CountableSetValues xr2(x.lub, x[1]);
+        // in lex-bit order empty is the smallest
+        int a = (iter2int(xr1,3));
+        int b = (iter2int(xr2,3));
+        return a < b;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        // Test lex-bit order
+        Gecode::dom(home, x[0], SRT_DISJ, ds_13);
+        Gecode::dom(home, x[1], SRT_SUB, ds_13);
+        Gecode::rel(home, x[0], SRT_LE, x[1]);
+      }
+    };
+    CpltSetRelLe _cpltsetrellediff("Rel::Le::Diff");
+
+    /// Test for disjoint constraint
+    class CpltSetRelDisj : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetRelDisj(const char* t) : CpltSetTest(t,2,ds_13,false) {}
+
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr1(x.lub, x[0]);
+        CountableSetRanges xr2(x.lub, x[1]);
+        Gecode::Iter::Ranges::Inter<CountableSetRanges, CountableSetRanges> 
+          inter(xr1, xr2);
+        return !inter();
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        // Test lex-bit order
+        Gecode::rel(home, x[0], SRT_DISJ, x[1]);
+      }
+    };
+    CpltSetRelDisj _cpltsetreldisj("Rel::Disj");
+
+    //@}
+
+}}}
+
+// STATISTICS: test-cpltset

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

@@ -0,0 +1,216 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2005
+ *
+ *  Last modified:
+ *     $Date: 2007-11-09 10:29:51 +0100 (Fri, 09 Nov 2007) $ by $Author: tack $
+ *     $Revision: 5228 $
+ *
+ *  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/cpltset.hh"
+
+using namespace Gecode;
+using namespace Test::Set;
+
+namespace Test { namespace CpltSet {
+
+  /// Tests for selection constraints
+  namespace Selection {
+
+    /**
+      * \defgroup TaskTestCpltSetSelect Selection constraints
+      * \ingroup TaskTestCpltSet
+      */
+    //@{
+
+    static IntSet ds_012(0,2);
+    static IntSet ds_1012(-1,2);
+
+    // BE CAREFUL with number of variables and domain size
+    // current instance ( |ds_012 = {-1#2}| = 4 and |x| = 2 + 2 = 4 ) => 2^16
+    // takes at least 5 min to test
+
+    /// Test for selected union constraint
+    class CpltSetSelectUnion : public CpltSetTest {
+    private:
+      int selector_pos;
+      int union_pos;
+      int xsize;
+    public:
+      // using cache size of 10000 gives fastest time of 0m48s per iteration
+      /// Create and register test
+      CpltSetSelectUnion(const char* t)
+      : CpltSetTest(t, 4, ds_012, false, 0, 100, 10000), xsize(4) {
+        union_pos = xsize - 1;
+        selector_pos = xsize - 2;
+      }
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        int selected = 0;
+        // count the number of selected sets
+        CountableSetValues count_sel(x.lub, x[selector_pos]);
+        for ( ; count_sel(); ++count_sel, selected++);
+  
+        CountableSetValues xunion(x.lub, x[union_pos]);
+        if (selected==0) {
+          bool valid = !xunion();
+          return valid;
+        }
+
+        GECODE_AUTOARRAY(CountableSetRanges, sel, selected);
+        CountableSetValues selector(x.lub, x[selector_pos]);
+        for (int i=selected; i--;++selector) {
+          if (selector.val()>=selector_pos || 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[union_pos]);
+        bool valid = Iter::Ranges::equal(u,z);
+        return valid;
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        int vars = selector_pos;
+        CpltSetVarArgs xs(vars);
+        for (int i=vars; i--;)
+          xs[i]=x[i];
+        Gecode::selectUnion(home, xs, x[selector_pos], x[union_pos]);
+      }
+    };
+    CpltSetSelectUnion _cpltsetselectUnion("Select::SelectUnion");
+
+    /// Test for selected non-empty subset constraint
+    class CpltSetSelectNonEmptySub : public CpltSetTest {
+    private:
+      int selector_pos;
+      int union_pos;
+      int xsize;
+    public:
+      /// Create and register test
+      CpltSetSelectNonEmptySub(const char* t)
+      : CpltSetTest(t, 4, ds_1012,false, 0, 8000, 15000), xsize(4) {
+        /// using 1012 leads to 5min testtime for ONE iteration !
+        union_pos = xsize - 1;
+        selector_pos = xsize - 2;   
+      }
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        int selected = 0;
+        // count the number of selected sets
+        CountableSetValues count_sel(x.lub, x[selector_pos]);
+        for ( ; count_sel(); ++count_sel, selected++);
+ 
+        CountableSetRanges xunion(x.lub, x[union_pos]);
+        if (selected==0) {
+          GECODE_AUTOARRAY(CountableSetRanges, sel, selector_pos);
+    
+          bool valid = true;
+          for (int i = selector_pos; i--; ) {
+            sel[i].init(x.lub, x[i]);
+            CountableSetRanges t(x.lub, x[union_pos]);
+            bool non_empty_union = t();
+            bool non_empty = sel[i]();
+            bool subset = Iter::Ranges::subset(sel[i], t);
+
+            if (!non_empty_union) {
+              return true;
+            } else {
+              valid &= (!non_empty || !subset);
+            }
+          }
+          return valid;
+        }
+  
+        if (!xunion()) {
+          return false;
+        }
+        // some sets have been selected
+        GECODE_AUTOARRAY(CountableSetRanges, sel, selected);
+  
+        CountableSetValues selector(x.lub, x[selector_pos]);
+        for (int i=selected; i--;++selector) {
+          if (selector.val()>=selector_pos || selector.val()<0) {
+            return false;
+          }
+          sel[i].init(x.lub, x[selector.val()]);
+        }
+
+        Iter::Ranges::NaryUnion<CountableSetRanges> u(sel, selected);
+
+        bool select_valid = true;
+          CountableSetValues select_val(x.lub, x[selector_pos]);
+          for (int i = 0; i < selector_pos; i++) {
+            CountableSetRanges cur_sel(x.lub, x[i]);
+            bool subset = false;
+            bool non_empty = false;
+            CountableSetRanges tunion(x.lub, x[union_pos]);
+            non_empty = cur_sel();
+            subset = Iter::Ranges::subset(cur_sel, tunion);
+
+            if (select_val()) {
+              if (i == select_val.val()) {
+                select_valid &= (subset && non_empty);
+                ++select_val;
+              } else {
+                select_valid &= (!non_empty || !subset);
+              }
+            } else {
+              select_valid &= (!non_empty || !subset);
+            }
+          }
+
+        bool valid = select_valid && Iter::Ranges::subset(u, xunion);
+        return valid;
+      }
+
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        int vars = selector_pos;
+        CpltSetVarArgs xs(vars);
+        for (int i=vars; i--;)
+          xs[i]=x[i];
+
+        Gecode::selectNonEmptySub(home, xs, x[selector_pos], x[union_pos]);
+      }
+    };
+
+    // Disabled due to time restrictions
+    // We need randomized tests to test large set domains
+    // CpltSetSelectNonEmptySub 
+    //   _cpltsetselectNonEmptySub("Select::SelectNonEmptySub");
+
+    //@}
+
+}}}
+
+// STATISTICS: test-cpltset