gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/test/cpltset.hh

@@ -0,0 +1,125 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2005
+ *     Christian Schulte, 2005
+ *
+ *  Last modified:
+ *     $Date: 2007-11-08 15:53:26 +0100 (Thu, 08 Nov 2007) $ by $Author: tack $
+ *     $Revision: 5219 $
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_TEST_CPLTSET_HH__
+#define __GECODE_TEST_CPLTSET_HH__
+
+#include "gecode/cpltset.hh"
+
+#include "test/test.hh"
+#include "test/set.hh"
+#include "test/int.hh"
+
+namespace Test {
+  
+  /// Testing finite sets with complete domain representation
+  namespace CpltSet {
+
+    /**
+     * \defgroup TaskTestCpltSet Testing finite sets with complete domain representation
+     * \ingroup TaskTest
+     */
+
+    /**
+     * \defgroup TaskTestCpltSetSupport General CpltSet test support
+     * \ingroup TaskTestCpltSet
+     */
+    //@{
+
+    /**
+     * \brief Base class for tests with CpltSet constraints
+     *
+     */
+    class CpltSetTest : public Base {
+    private:
+      int     arity;
+      Gecode::IntSet  lub;
+      bool    reified;
+      int    withInt;
+      int ivs;
+      int ics;
+
+      void removeFromLub(int, Gecode::CpltSetVar&, int,
+                         const Gecode::IntSet&);
+      void addToGlb(int, Gecode::CpltSetVar&, int, const Gecode::IntSet&);
+    public:
+      CpltSetTest(const std::string& s, int a, const Gecode::IntSet& d,
+                  bool r=false, int w=0, int mn=10000, int mc=1000) 
+        : Base("CpltSet::"+s), arity(a), lub(d), reified(r), withInt(w), 
+          ivs(mn), ics(mc)  {
+        Gecode::CpltSet::manager.dispose();
+        Gecode::CpltSet::manager.init(mn, mc);
+      }
+
+      /// Check for solution
+      virtual bool solution(const Test::Set::SetAssignment&) const = 0;
+      /// Post propagator
+      virtual void post(Gecode::Space* home, Gecode::CpltSetVarArray& x,
+                        Gecode::IntVarArray& y) = 0;
+      /// Post reified propagator
+      virtual void post(Gecode::Space*, Gecode::CpltSetVarArray&,
+                        Gecode::IntVarArray&, Gecode::BoolVar) {}
+      /// Perform test
+      virtual bool run(void);
+
+      template <class I>
+      int iter2int(I& r, int) const{
+        if (!r()) {
+          return 0;
+        }
+        int v = 0;
+        // compute the bit representation of the assignment 
+        // and convert it to the corresponding integer
+        while(r()) {
+          v  |= (1 << r.val()); // due to reversed lex ordering
+          ++r;
+        }
+        return v;
+      }
+  
+      /// Provide manager access
+      int varsize(void) { return ivs; }
+      int cachesize(void) { return ics; }
+
+    };
+    //@}
+}}
+
+#endif
+
+// STATISTICS: test-cpltset

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

@@ -0,0 +1,155 @@
+/*
+ *  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 intersection constraints
+  namespace AtMost {
+
+    /**
+      * \defgroup TaskTestCpltSetAtMost Intersection 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 atmost intersection constraint
+    class CpltSetAtmost : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetAtmost(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);
+        int c = 0;
+        while (d()) {
+          c += d.width();
+          ++d;
+        }
+        return (c <= 1);
+      }
+
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        // Test lex-bit order
+        Gecode::atmost(home, x[0], x[1], 1);
+      }
+    };
+    CpltSetAtmost _cpltsetatmost("Atmost::1");
+
+    /// Test for atmost intersection with lexicographic order constraint
+    class CpltSetAtmostLexLe : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetAtmostLexLe(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);
+        int c = 0;
+        while (d()) {
+          c += d.width();
+          ++d;
+        }
+
+        CountableSetValues xv1(x.lub, x[0]);
+        CountableSetValues xv2(x.lub, x[1]);
+        int a = iter2int(xv1, 3);
+        int b = iter2int(xv2, 3);
+    
+        return (c <= 1) && a < b;
+      }
+
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        // Test lex-bit order
+        Gecode::atmostLex(home, x[0], x[1], 1, SRT_LE);
+      }
+    };
+    CpltSetAtmostLexLe _cpltsetatmostlexle("Atmost::Lex::Le");
+
+    /// Test for atmost intersection with IntSet constraint
+    class CpltSetAtmostIntSet : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetAtmostIntSet(const char* t) : CpltSetTest(t,1,ds_33,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr1(x.lub, x[0]);
+        IntSetRanges ir(ds_33);
+        Iter::Ranges::Inter<CountableSetRanges, IntSetRanges>  d(xr1, ir);
+        int c = 0;
+        while (d()) {
+          c += d.width();
+          ++d;
+        }
+    
+        return (c <= 1);
+      }
+
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        // Test lex-bit order
+        Gecode::atmost(home, x[0], ds_33, 1);
+      }
+    };
+    CpltSetAtmostIntSet _cpltsetatmostintset("Atmost::IntSet");
+
+    //@}
+
+}}}
+
+// STATISTICS: test-cpltset

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

@@ -0,0 +1,138 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2005
+ *
+ *  Last modified:
+ *     $Date: 2008-02-06 18:48:22 +0100 (Wed, 06 Feb 2008) $ by $Author: schulte $
+ *     $Revision: 6102 $
+ *
+ *  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 cardinality constraints
+  namespace Cardinality {
+
+    /**
+      * \defgroup TaskTestCpltSetCardinality Cardinality 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 simple cardinality range constraint
+    class CpltSetCardMinMax : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetCardMinMax(const char* t) : CpltSetTest(t,1,d1,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr1(x.lub, x[0]);
+
+        int c = 0;
+        while (xr1()) {
+          c += xr1.width();
+          ++xr1;
+        }
+        return (0<= c && c <= 3);
+      }
+
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        Gecode::cardinality(home, x[0], 0, 3);
+      }
+    };
+    CpltSetCardMinMax _cpltsetcardminmax("Card::MinMax");
+
+    /// Test for simple cardinality constraint
+    class CpltSetCardEq : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetCardEq(const char* t) : CpltSetTest(t,1,d1,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr1(x.lub, x[0]);
+    
+        int c = 0;
+        while (xr1()) {
+          c += xr1.width();
+          ++xr1;
+        }
+        return (c == 3);
+      }
+
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        Gecode::cardinality(home, x[0], 3, 3);
+      }
+    };
+    CpltSetCardEq _cpltsetcardeq("Card::Eq");
+
+    /// Test for simple cardinality range constraint
+    class CpltSetCardMinInf : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetCardMinInf(const char* t) : CpltSetTest(t,1,d1,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr1(x.lub, x[0]);
+    
+        int c = 0;
+        while (xr1()) {
+          c += xr1.width();
+          ++xr1;
+        }
+        return (c >= 1);
+      }
+
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        Gecode::cardinality(home, x[0], 1, Gecode::Set::Limits::max);
+      }
+    };
+    CpltSetCardMinInf _cpltsetcardmininf("Card::MinInf");
+
+    //@}
+
+}}}
+
+// STATISTICS: test-cpltset

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

@@ -0,0 +1,137 @@
+/*
+ *  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 domain constraints
+  namespace Dom {
+
+    /**
+      * \defgroup TaskTestCpltSetDom Domain 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);
+
+    /// Test for domain equality with range constraint
+    class CpltSetDomEqRange : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetDomEqRange(const char* t) : CpltSetTest(t,1,ds_33,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr(x.lub, x[0]);
+        IntSetRanges dr(ds_33);
+        return Iter::Ranges::equal(xr, dr);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        Gecode::dom(home, x[0], SRT_EQ, ds_33);
+      }
+    };
+    CpltSetDomEqRange _cpltsetdomeqrange("Dom::EqRange");
+
+    /// Test for domain equality with full domain constraint
+    class CpltSetDomEqDom : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetDomEqDom(const char* t) : CpltSetTest(t,1,d1,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr(x.lub, x[0]);
+        IntSetRanges dr(d1);
+        return Iter::Ranges::equal(xr, dr);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        Gecode::dom(home, x[0], SRT_EQ, d1);
+      }
+    };
+    CpltSetDomEqDom _cpltsetdomeq("Dom::EqDom");
+
+    /// Test for domain superset with range constraint
+    class CpltSetDomSupRange : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetDomSupRange(const char* t) : CpltSetTest(t,1,ds_33,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr(x.lub, x[0]);
+        IntSetRanges dr(ds_33);
+        return Iter::Ranges::subset(dr, xr);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        Gecode::dom(home, x[0], SRT_SUP, ds_33);
+      }
+    };
+    CpltSetDomSupRange _cpltsetdomsuprange("Dom::SupRange");
+
+    /// Test for domain superset with full domain constraint
+    class CpltSetDomSupDom : public CpltSetTest {
+    public:
+      /// Create and register test
+      CpltSetDomSupDom(const char* t) : CpltSetTest(t,1,d1,false) {}
+      /// Test whether \a x is solution
+      virtual bool solution(const SetAssignment& x) const {
+        CountableSetRanges xr(x.lub, x[0]);
+        IntSetRanges dr(d1);
+        return Iter::Ranges::subset(dr, xr);
+      }
+      /// Post constraint on \a x
+      virtual void post(Space* home, CpltSetVarArray& x, IntVarArray&) {
+        Gecode::dom(home, x[0], SRT_SUP, d1);
+      }
+    };
+    CpltSetDomSupDom _cpltsetdomsup("Dom::SupDom");
+
+    //@}
+
+}}}
+
+// STATISTICS: test-cpltset