gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-2.1.1/gecode/int/channel/link-multi.icc

@@ -0,0 +1,70 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2007
+ *
+ *  Last modified:
+ *     $Date: 2007-08-09 15:30:21 +0200 (Thu, 09 Aug 2007) $ by $Author: tack $
+ *     $Revision: 4790 $
+ *
+ *  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.
+ *
+ */
+
+namespace Gecode { namespace Int { namespace Channel {
+
+  forceinline
+  LinkMulti::LinkMulti(Space* home, ViewArray<BoolView>& x, IntView y, int o0)
+    : MixNaryOnePropagator<BoolView,PC_BOOL_VAL,IntView,PC_INT_DOM>
+  (home,x,y), o(o0) {}
+
+  forceinline ExecStatus
+  LinkMulti::post(Space* home, ViewArray<BoolView>& x, IntView y, int o) {
+    int n=x.size();
+    GECODE_ME_CHECK(y.gq(home,o));
+    GECODE_ME_CHECK(y.lq(home,o+n-1));
+    assert(n > 0);
+    if (n == 1) {
+      GECODE_ME_CHECK(x[0].one(home));
+      assert(y.val() == o);
+    } else if (y.assigned()) {
+      int j=y.val()-o;
+      GECODE_ME_CHECK(x[j].one(home));
+      for (int i=0; i<j; i++)
+        GECODE_ME_CHECK(x[i].zero(home));
+      for (int i=j+1; i<n; i++)
+        GECODE_ME_CHECK(x[i].zero(home));
+    } else {
+      (void) new (home) LinkMulti(home,x,y,o);
+    }
+    return ES_OK;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/gecode-2.1.1/gecode/int/channel/link-single.cc

@@ -0,0 +1,97 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2007
+ *
+ *  Last modified:
+ *     $Date: 2008-01-31 18:29:16 +0100 (Thu, 31 Jan 2008) $ by $Author: tack $
+ *     $Revision: 6017 $
+ *
+ *  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 "gecode/int/channel.hh"
+
+namespace Gecode { namespace Int { namespace Channel {
+
+  forceinline
+  LinkSingle::LinkSingle(Space* home, bool share, LinkSingle& p)
+    : MixBinaryPropagator<BoolView,PC_BOOL_VAL,IntView,PC_INT_VAL>
+  (home,share,p) {}
+
+  Actor*
+  LinkSingle::copy(Space* home, bool share) {
+    return new (home) LinkSingle(home,share,*this);
+  }
+
+  PropCost
+  LinkSingle::cost(ModEventDelta) const {
+    return PC_UNARY_LO;
+  }
+
+  Support::Symbol
+  LinkSingle::ati(void) {
+    return Support::Symbol("Gecode::Int::Channel::LinkSingle");
+  }
+
+  Reflection::ActorSpec
+  LinkSingle::spec(const Space* home, Reflection::VarMap& m) const {
+    return MixBinaryPropagator<BoolView,PC_BOOL_VAL,IntView,PC_INT_VAL>
+      ::spec(home, m, ati());
+  }
+
+  void
+  LinkSingle::post(Space* home, Reflection::VarMap& vars,
+                   const Reflection::ActorSpec& spec) {
+    spec.checkArity(2);
+    BoolView b(home, vars, spec[0]);
+    IntView x(home, vars, spec[1]);
+    (void) new (home) LinkSingle(home, b, x);
+  }
+
+  ExecStatus
+  LinkSingle::propagate(Space* home, ModEventDelta) {
+    if (x0.zero()) {
+      GECODE_ME_CHECK(x1.eq(home,0));
+    } else if (x0.one()) {
+      GECODE_ME_CHECK(x1.eq(home,1));
+    } else {
+      assert(x0.none() && x1.assigned());
+      if (x1.val() == 0) {
+        GECODE_ME_CHECK(x0.zero_none(home));
+      } else {
+        assert(x1.val() == 1);
+        GECODE_ME_CHECK(x0.one_none(home));
+      }
+    }
+    return ES_SUBSUMED(this,sizeof(*this));
+  }
+
+}}}
+
+// STATISTICS: int-prop

data/ext/gecode-2.1.1/gecode/int/channel/link-single.icc

@@ -0,0 +1,71 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2007
+ *
+ *  Last modified:
+ *     $Date: 2007-08-09 15:30:21 +0200 (Thu, 09 Aug 2007) $ by $Author: tack $
+ *     $Revision: 4790 $
+ *
+ *  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.
+ *
+ */
+
+namespace Gecode { namespace Int { namespace Channel {
+
+  forceinline
+  LinkSingle::LinkSingle(Space* home, BoolView x0, IntView x1)
+    : MixBinaryPropagator<BoolView,PC_BOOL_VAL,IntView,PC_INT_VAL>
+  (home,x0,x1) {}
+
+  forceinline ExecStatus
+  LinkSingle::post(Space* home, BoolView x0, IntView x1) {
+    if (x1.assigned()) {
+      switch (x1.val()) {
+      case 0:
+        GECODE_ME_CHECK(x0.zero(home)); break;
+      case 1:
+        GECODE_ME_CHECK(x0.one(home)); break;
+      default:
+        return ES_FAILED;
+      }
+    } else if (x0.zero()) {
+      GECODE_ME_CHECK(x1.eq(home,0));
+    } else if (x0.one()) {
+      GECODE_ME_CHECK(x1.eq(home,1));
+    } else {
+      GECODE_ME_CHECK(x1.gq(home,0));
+      GECODE_ME_CHECK(x1.lq(home,1));
+      (void) new (home) LinkSingle(home,x0,x1);
+    }
+    return ES_OK;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+

data/ext/gecode-2.1.1/gecode/int/channel/val.icc

@@ -0,0 +1,276 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *     Mikael Lagerkvist, 2006
+ *
+ *  Last modified:
+ *     $Date: 2008-01-31 18:29:16 +0100 (Thu, 31 Jan 2008) $ by $Author: tack $
+ *     $Revision: 6017 $
+ *
+ *  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.
+ *
+ */
+
+namespace Gecode { namespace Int { namespace Channel {
+
+  /**
+   * \brief Combine view with information for value propagation
+   *
+   */
+  template <class View>
+  class ValInfo {
+  public:
+    /// The view
+    View view;
+    /// Whether it has been propagated that view is assigned
+    bool a;
+    /// Allocate memory from space \a home for \a n elements
+    static ValInfo<View>* allocate(Space* home, int n);
+    /// Initialize
+    void init(View x, int n);
+    /// Update during cloning
+    void update(Space* home, bool share, ValInfo<View>& vi);
+    /// Check whether propagation for assignment is to be done
+    bool doval(void) const;
+    /// Check whether propagation for domain is to be done
+    bool dodom(void) const;
+    /// Record that view got assigned
+    void assigned(void);
+    /// Record that one value got removed
+    void removed(int i);
+    /// Update the cardinality and bounds information after pruning
+    void done(void);
+  };
+
+  template <class View>
+  forceinline ValInfo<View>*
+  ValInfo<View>::allocate(Space* home, int n) {
+    return static_cast<ValInfo<View>*>
+      (home->alloc(n*sizeof(ValInfo<View>)));
+  }
+
+  template <class View>
+  forceinline void
+  ValInfo<View>::init(View x, int) {
+    view = x; a = false;
+  }
+
+  template <class View>
+  forceinline void
+  ValInfo<View>::update(Space* home, bool share, ValInfo<View>& vi) {
+    view.update(home,share,vi.view); a = vi.a;
+  }
+
+  template <class View>
+  forceinline bool
+  ValInfo<View>::doval(void) const {
+    return !a && view.assigned();
+  }
+
+  template <class View>
+  forceinline bool
+  ValInfo<View>::dodom(void) const {
+    return false;
+  }
+
+  template <class View>
+  forceinline void
+  ValInfo<View>::assigned(void) {
+    a = true;
+  }
+
+  template <class View>
+  forceinline void
+  ValInfo<View>::removed(int) {}
+
+  template <class View>
+  forceinline void
+  ValInfo<View>::done(void) {}
+
+
+  // Propagate assigned views for x
+  template <class View, class Info>
+  ExecStatus
+  doprop_val(Space* home, int n, Info* x, Info* y,
+             int& n_na, ProcessStack& xa, ProcessStack& ya) {
+    do {
+      int i = xa.pop();
+      int j = x[i].view.val();
+      // Assign the y variable to i (or test if already assigned!)
+      {
+        ModEvent me = y[j].view.eq(home,i);
+        if (me_failed(me))
+          return ES_FAILED;
+        // Record that y[j] has been assigned and must be propagated
+        if (me_modified(me))
+          ya.push(j);
+      }
+      // Prune the value j from all x variables
+      for (int k=i; k--; ) {
+        ModEvent me = x[k].view.nq(home,j);
+        if (me_failed(me))
+          return ES_FAILED;
+        if (me_modified(me))
+          if (me == ME_INT_VAL) {
+            // Record that x[k] has been assigned and must be propagated
+            xa.push(k);
+          } else {
+            // One value has been removed and this removal does not need
+            // to be propagated again: after all y[j] = i, so it holds
+            // that y[j] != k.
+            x[k].removed(j);
+          }
+      }
+      // The same for the other views
+      for (int k=i+1; k<n; k++) {
+        ModEvent me = x[k].view.nq(home,j);
+        if (me_failed(me))
+          return ES_FAILED;
+        if (me_modified(me))
+          if (me == ME_INT_VAL) {
+            // Record that x[k] has been assigned and must be propagated
+            xa.push(k);
+          } else {
+            // One value has been removed and this removal does not need
+            // to be propagated again: after all y[j] = i, so it holds
+            // that y[j] != k.
+            x[k].removed(j);
+          }
+      }
+      x[i].assigned(); n_na--;
+    } while (!xa.empty());
+    return ES_OK;
+  }
+
+  // Just do a test whether a call to the routine is necessary
+  template <class View, class Info>
+  forceinline ExecStatus
+  prop_val(Space* home, int n, Info* x, Info* y,
+           int& n_na, ProcessStack& xa, ProcessStack& ya) {
+    if (xa.empty())
+      return ES_OK;
+    return doprop_val<View,Info>(home,n,x,y,n_na,xa,ya);
+  }
+
+  /*
+   * The actual propagator
+   *
+   */
+  template <class View, bool shared>
+  forceinline
+  Val<View,shared>::Val(Space* home, int n, ValInfo<View>* xy)
+    : Base<ValInfo<View>,PC_INT_VAL>(home,n,xy) {}
+
+  template <class View, bool shared>
+  forceinline
+  Val<View,shared>::Val(Space* home, bool share, Val<View,shared>& p)
+    : Base<ValInfo<View>,PC_INT_VAL>(home,share,p) {}
+
+  template <class View, bool shared>
+  Actor*
+  Val<View,shared>::copy(Space* home, bool share) {
+    return new (home) Val<View,shared>(home,share,*this);
+  }
+
+  template <class View, bool shared>
+  ExecStatus
+  Val<View,shared>::propagate(Space* home, ModEventDelta) {
+    GECODE_AUTOSTACK(int,-1, xa, n);
+    GECODE_AUTOSTACK(int,-1, ya, n);
+
+    ValInfo<View>* x = xy;
+    ValInfo<View>* y = xy+n;
+
+    // Scan x and y for assigned but not yet propagated views
+    for (int i = n; i--; ) {
+      if (x[i].doval()) xa.push(i);
+      if (y[i].doval()) ya.push(i);
+    }
+
+    do {
+      // Propagate assigned views for x
+      GECODE_ES_CHECK((prop_val<View,ValInfo<View> >(home,n,x,y,n_na,xa,ya)));
+      // Propagate assigned views for y
+      GECODE_ES_CHECK((prop_val<View,ValInfo<View> >(home,n,y,x,n_na,ya,xa)));
+      assert(ya.empty());
+    } while (!xa.empty());
+
+    if (n_na == 0) 
+      return ES_SUBSUMED(this,home);
+    return shared ? ES_NOFIX : ES_FIX;
+  }
+
+  template <class View, bool shared>
+  Support::Symbol
+  Val<View,shared>::ati(void) {
+    return Reflection::mangle<View,shared>("Gecode::Int::Channel::Val");
+  }
+
+  template <class View, bool shared>
+  Reflection::ActorSpec
+  Val<View,shared>::spec(const Space* home, Reflection::VarMap& m) const {
+    return Base<ValInfo<View>,PC_INT_VAL>::spec(home, m, ati());
+  }
+
+  template <class View, bool shared>
+  void
+  Val<View,shared>::post(Space* home, Reflection::VarMap& vars,
+                         const Reflection::ActorSpec& spec) {
+    const int n = spec.noOfArgs();
+    ValInfo<View>* vi
+      = ValInfo<View>::allocate(home,n);
+    for (int i=0; i<n; i++) {
+      vi[i].init(View(home, vars, spec[i]),n/2);
+    }
+    (void) new (home) Val<View,shared>(home,n/2,vi);
+  }
+
+  template <class View, bool shared>
+  ExecStatus
+  Val<View,shared>::post(Space* home, int n, ValInfo<View>* xy) {
+    assert(n > 0);
+    if (n == 1) {
+      GECODE_ME_CHECK(xy[0].view.eq(home,0));
+      GECODE_ME_CHECK(xy[1].view.eq(home,0));
+      return ES_OK;
+    }
+    for (int i=2*n; i--; ) {
+      GECODE_ME_CHECK(xy[i].view.gq(home,0));
+      GECODE_ME_CHECK(xy[i].view.le(home,n));
+    }
+    (void) new (home) Val<View,shared>(home,n,xy);
+    return ES_OK;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+