gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/gecode/int/channel.cc

@@ -0,0 +1,165 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 10:46:48 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7346 $
+ *
+ *  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 {
+
+  void
+  channel(Space* home, const IntVarArgs& x, unsigned int xoff,
+          const IntVarArgs& y, unsigned int yoff,
+          IntConLevel icl, PropKind) {
+    using namespace Int;
+    using namespace Channel;
+    int n = x.size();
+    if (n != y.size())
+      throw ArgumentSizeMismatch("Int::channel");
+    if (x.same() || y.same())
+      throw ArgumentSame("Int::channel");
+    if (home->failed()) return;
+    if (n == 0)
+      return;
+
+    if (xoff < 2 && yoff < 2 && xoff == yoff) {
+      if (icl == ICL_DOM) {
+        DomInfo<IntView>* di
+          = DomInfo<IntView>::allocate(home,2*(n+xoff));
+        for (int i=n; i--; ) {
+          di[xoff+i    ].init(x[i],n+xoff);
+          di[2*xoff+i+n].init(y[i],n+xoff);
+        }
+        if (xoff == 1) {
+          IntVar x0(home,0,0);
+          di[0].init(x0, n+xoff);
+          IntVar y0(home,0,0);
+          di[n+xoff].init(y0, n+xoff);
+        }
+        if (x.same(y)) {
+          GECODE_ES_FAIL(home,(Dom<IntView,true>::post(home,n+xoff,di)));
+        } else {
+          GECODE_ES_FAIL(home,(Dom<IntView,false>::post(home,n+xoff,di)));
+        }
+      } else {
+        ValInfo<IntView>* vi
+          = ValInfo<IntView>::allocate(home,2*(n+xoff));
+        for (int i=n; i--; ) {
+          vi[xoff+i    ].init(x[i],n+xoff);
+          vi[2*xoff+i+n].init(y[i],n+xoff);
+        }
+        if (xoff == 1) {
+          IntVar x0(home,0,0);
+          vi[0].init(x0, n+xoff);
+          IntVar y0(home,0,0);
+          vi[n+xoff].init(y0, n+xoff);
+        }
+        if (x.same(y)) {
+          GECODE_ES_FAIL(home,(Val<IntView,true>::post(home,n+xoff,vi)));
+        } else {
+          GECODE_ES_FAIL(home,(Val<IntView,false>::post(home,n+xoff,vi)));
+        }
+      }
+    } else {
+      if (icl == ICL_DOM) {
+        DomInfo<OffsetView>* di
+          = DomInfo<OffsetView>::allocate(home,2*n);
+        for (int i=n; i--; ) {
+          di[i  ].init(OffsetView(x[i],-xoff),n);
+          di[i+n].init(OffsetView(y[i],-yoff),n);
+        }
+        if (x.same(y)) {
+          GECODE_ES_FAIL(home,(Dom<OffsetView,true>::post(home,n,di)));
+        } else {
+          GECODE_ES_FAIL(home,(Dom<OffsetView,false>::post(home,n,di)));
+        }
+      } else {
+        ValInfo<OffsetView>* vi
+          = ValInfo<OffsetView>::allocate(home,2*n);
+        for (int i=n; i--; ) {
+          vi[i  ].init(OffsetView(x[i],-xoff),n);
+          vi[i+n].init(OffsetView(y[i],-yoff),n);
+        }
+        if (x.same(y)) {
+          GECODE_ES_FAIL(home,(Val<OffsetView,true>::post(home,n,vi)));
+        } else {
+          GECODE_ES_FAIL(home,(Val<OffsetView,false>::post(home,n,vi)));
+        }
+      }
+    }
+
+  }
+
+  void
+  channel(Space* home, const IntVarArgs& x, const IntVarArgs& y,
+          IntConLevel icl, PropKind pk) {
+    channel(home, x, 0, y, 0, icl, pk);
+  }
+  void
+  channel(Space* home, BoolVar x0, IntVar x1, IntConLevel, PropKind) {
+    using namespace Int;
+    if (home->failed()) return;
+    GECODE_ES_FAIL(home,Channel::LinkSingle::post(home,x0,x1));
+  }
+
+  void
+  channel(Space* home, const BoolVarArgs& x, IntVar y, int o, 
+          IntConLevel, PropKind) {
+    using namespace Int;
+    if (x.same())
+      throw ArgumentSame("Int::channel");
+    Limits::check(o,"Int::channel");
+    if (home->failed()) return;
+    ViewArray<BoolView> xv(home,x);
+    GECODE_ES_FAIL(home,Channel::LinkMulti::post(home,xv,y,o));
+  }
+
+  namespace {
+    using namespace Int;
+    GECODE_REGISTER2(Channel::Dom<IntView, false>);
+    GECODE_REGISTER2(Channel::Dom<IntView, true>);
+    GECODE_REGISTER2(Channel::Val<IntView, false>);
+    GECODE_REGISTER2(Channel::Val<IntView, true>);
+    GECODE_REGISTER2(Channel::Dom<OffsetView, false>);
+    GECODE_REGISTER2(Channel::Dom<OffsetView, true>);
+    GECODE_REGISTER2(Channel::Val<OffsetView, false>);
+    GECODE_REGISTER2(Channel::Val<OffsetView, true>);
+    GECODE_REGISTER1(Channel::LinkSingle);
+    GECODE_REGISTER1(Channel::LinkMulti);
+  }
+
+}
+
+// STATISTICS: int-post

data/ext/gecode-2.2.0/gecode/int/channel.hh

@@ -0,0 +1,259 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 09:28:48 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7285 $
+ *
+ *  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_INT_CHANNEL_HH__
+#define __GECODE_INT_CHANNEL_HH__
+
+#include "gecode/int.hh"
+#include "gecode/int/distinct.hh"
+
+/**
+ * \namespace Gecode::Int::Channel
+ * \brief %Channel propagators
+ */
+
+namespace Gecode { namespace Int { namespace Channel {
+
+  /// Processing stack
+  typedef Support::SentinelStack<int> ProcessStack;
+
+  /**
+   * \brief Base-class for channel propagators
+   *
+   */
+  template <class Info, PropCond pc>
+  class Base : public Propagator {
+  protected:
+    /// Number of views (actually twice as many for both x and y)
+    int n;
+    /// Total number of not assigned views (not known to be assigned)
+    int n_na;
+    /// View and information for both \a x and \a y
+    Info* xy;
+    /// Constructor for cloning \a p
+    Base(Space* home, bool share, Base<Info,pc>& p);
+    /// Constructor for posting
+    Base(Space* home, int n, Info* xy);
+    // Specification for this propagator
+    Reflection::ActorSpec spec(const Space* home, Reflection::VarMap& m,
+                                const Support::Symbol& name) const;
+  public:
+    /// Propagation cost
+    virtual PropCost cost(ModEventDelta med) const;
+    /// Specification for this propagator
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+
+  /**
+   * \brief Combine view with information for value propagation
+   *
+   */
+  template <class View> class ValInfo;
+
+  /**
+   * \brief Naive channel propagator
+   *
+   * Only propagates if views become assigned. If \a shared is true,
+   * the same views can be contained in both \a x and \a y.
+   *
+   * Requires \code #include "gecode/int/channel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View, bool shared>
+  class Val : public Base<ValInfo<View>,PC_INT_VAL> {
+ protected:
+    using Base<ValInfo<View>,PC_INT_VAL>::n;
+    using Base<ValInfo<View>,PC_INT_VAL>::n_na;
+    using Base<ValInfo<View>,PC_INT_VAL>::xy;
+    /// Constructor for cloning \a p
+    Val(Space* home, bool share, Val& p);
+    /// Constructor for posting
+    Val(Space* home, int n, ValInfo<View>* xy);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home, ModEventDelta med);
+    /// Post propagator for channeling
+    static  ExecStatus post(Space* home, int n, ValInfo<View>* xy);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Post according to specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Name of this propagator
+    static Support::Symbol ati(void);
+  };
+
+  /**
+   * \brief Combine view with information for domain propagation
+   *
+   */
+  template <class View> class DomInfo;
+
+  /**
+   * \brief Domain consistent channel propagator
+   *
+   * If \a shared is true, the same views can be contained in both 
+   * \a x and \a y.   
+   *
+   * Requires \code #include "gecode/int/channel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View, bool shared>
+  class Dom : public Base<DomInfo<View>,PC_INT_DOM> {
+  protected:
+    using Base<DomInfo<View>,PC_INT_DOM>::n;
+    using Base<DomInfo<View>,PC_INT_DOM>::n_na;
+    using Base<DomInfo<View>,PC_INT_DOM>::xy;
+    /// Propagation controller for propagating distinct
+    Distinct::DomCtrl<View> dc;
+    /// Constructor for cloning \a p
+    Dom(Space* home, bool share, Dom& p);
+    /// Constructor for posting
+    Dom(Space* home, int n, DomInfo<View>* xy);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Propagation cost
+    virtual PropCost cost(ModEventDelta med) const;
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home, ModEventDelta med);
+    /// Post propagator for channeling on \a xy
+    static  ExecStatus post(Space* home, int n, DomInfo<View>* xy);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Post according to specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Name of this propagator
+    static Support::Symbol ati(void);
+  };
+
+  /**
+   * \brief Link propagator for a single Boolean view
+   *
+   * Requires \code #include "gecode/int/channel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  class LinkSingle :
+    public MixBinaryPropagator<BoolView,PC_BOOL_VAL,IntView,PC_INT_VAL> {
+  private:
+    using MixBinaryPropagator<BoolView,PC_BOOL_VAL,IntView,PC_INT_VAL>::x0;
+    using MixBinaryPropagator<BoolView,PC_BOOL_VAL,IntView,PC_INT_VAL>::x1;
+
+    /// Constructor for cloning \a p
+    LinkSingle(Space* home, bool share, LinkSingle& p);
+    /// Constructor for posting
+    LinkSingle(Space* home, BoolView x0, IntView x1);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Cost function (defined as PC_UNARY_LO)
+    virtual PropCost cost(ModEventDelta med) const;
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home, ModEventDelta med);
+    /// Post propagator for \f$ x_0 = x_1\f$
+    static  ExecStatus post(Space* home, BoolView x0, IntView x1);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Post according to specification
+    GECODE_INT_EXPORT
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Name of this propagator
+    GECODE_INT_EXPORT
+    static Support::Symbol ati(void);
+  };
+
+  /**
+   * \brief Link propagator for multiple Boolean views
+   *
+   * Requires \code #include "gecode/int/channel.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  class LinkMulti :
+    public MixNaryOnePropagator<BoolView,PC_BOOL_VAL,IntView,PC_INT_DOM> {
+  private:
+    using MixNaryOnePropagator<BoolView,PC_BOOL_VAL,IntView,PC_INT_DOM>::x;
+    using MixNaryOnePropagator<BoolView,PC_BOOL_VAL,IntView,PC_INT_DOM>::y;
+    /// Offset value
+    int o;
+    /// Constructor for cloning \a p
+    LinkMulti(Space* home, bool share, LinkMulti& p);
+    /// Constructor for posting
+    LinkMulti(Space* home, ViewArray<BoolView>& x, IntView y, int o0);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Cost function (PC_UNARY_LO if \a y is assigned, PC_LINEAR_LO otherwise)
+    virtual PropCost cost(ModEventDelta med) const;
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home, ModEventDelta med);
+    /// Post propagator for \f$ x_i = 1\leftrightarrow y=i+o\f$
+    GECODE_INT_EXPORT
+    static  ExecStatus post(Space* home, 
+                            ViewArray<BoolView>& x, IntView y, int o);
+    /// Specification for this propagator
+    virtual Reflection::ActorSpec spec(const Space* home,
+                                        Reflection::VarMap& m) const;
+    /// Post according to specification
+    static void post(Space* home, Reflection::VarMap& vars,
+                     const Reflection::ActorSpec& spec);
+    /// Name of this propagator
+    GECODE_INT_EXPORT
+    static Support::Symbol ati(void);
+  };
+
+}}}
+
+#include "gecode/int/channel/base.icc"
+#include "gecode/int/channel/val.icc"
+#include "gecode/int/channel/dom.icc"
+
+#include "gecode/int/channel/link-single.icc"
+#include "gecode/int/channel/link-multi.icc"
+
+#endif
+
+// STATISTICS: int-prop
+

data/ext/gecode-2.2.0/gecode/int/channel/dom.icc

@@ -0,0 +1,348 @@
+/* -*- 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-07-11 10:46:48 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7346 $
+ *
+ *  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 domain propagation
+   *
+   */
+  template <class View>
+  class DomInfo {
+  public:
+    View         view;
+    unsigned int card;
+    int          min;
+    int          max;
+    /// Allocate memory from space \a home for \a n elements
+    static DomInfo<View>* allocate(Space* home, int n);
+    /// Initialize
+    void init(View x, int n);
+    /// Update during cloning
+    void update(Space* home, bool share, DomInfo<View>& vcb);
+    /// 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 DomInfo<View>*
+  DomInfo<View>::allocate(Space* home, int n) {
+    return static_cast<DomInfo<View>*>
+      (home->alloc(n*sizeof(DomInfo<View>)));
+  }
+
+  template <class View>
+  forceinline void
+  DomInfo<View>::init(View x, int n) {
+    view = x;
+    card = static_cast<unsigned int>(n);
+    min  = 0;
+    max  = n-1;
+  }
+
+  template <class View>
+  forceinline void
+  DomInfo<View>::update(Space* home, bool share, DomInfo<View>& di) {
+    view.update(home,share,di.view);
+    card = di.card;
+    min  = di.min;
+    max  = di.max;
+  }
+
+  template <class View>
+  forceinline bool
+  DomInfo<View>::doval(void) const {
+    return (card != 1) && view.assigned();
+  }
+
+  template <class View>
+  forceinline bool
+  DomInfo<View>::dodom(void) const {
+    return card != view.size();
+  }
+
+  template <class View>
+  forceinline void
+  DomInfo<View>::assigned(void) {
+    card = 1;
+  }
+
+  template <class View>
+  forceinline void
+  DomInfo<View>::removed(int i) {
+    card--;
+    if (i == min)
+      min++;
+    else if (i == max)
+      max--;
+  }
+
+  template <class View>
+  forceinline void
+  DomInfo<View>::done(void) {
+    card = view.size();
+    min  = view.min();
+    max  = view.max();
+  }
+
+  // Propagate domain information from x to y
+  template <class View>
+  ExecStatus
+  prop_dom(Space* home, int n, DomInfo<View>* x, DomInfo<View>* y,
+           ProcessStack& ya) {
+    for (int i = n; i--; )
+      // Only views with not yet propagated missing values
+      if (x[i].dodom()) {
+        // Iterate the values in the complement of x[i]
+        ViewRanges<View>
+          xir(x[i].view);
+        Iter::Ranges::ComplVal<ViewRanges<View> >
+          xirc(x[i].min,x[i].max,xir);
+        Iter::Ranges::ToValues<Iter::Ranges::ComplVal<ViewRanges<View> > >
+          jv(xirc);
+        while (jv()) {
+          // j is not in the domain of x[i], so prune i from y[j]
+          int j = jv.val();
+          ModEvent me = y[j].view.nq(home,i);
+          if (me_failed(me))
+            return ES_FAILED;
+          if (me_modified(me)) {
+            if (me == ME_INT_VAL) {
+              // Record that y[j] has been assigned and must be propagated
+              ya.push(j);
+            } else {
+              // Obvious as x[i] is different from j
+              y[j].removed(i);
+            }
+          }
+          ++jv;
+        }
+        // Update which values have been propagated and what are the new bounds
+        x[i].done();
+      }
+    return ES_OK;
+  }
+
+  /*
+   * The actual propagator
+   *
+   */
+  template <class View, bool shared>
+  forceinline
+  Dom<View,shared>::Dom(Space* home, int n, DomInfo<View>* xy)
+    : Base<DomInfo<View>,PC_INT_DOM>(home,n,xy) {}
+
+  template <class View, bool shared>
+  forceinline
+  Dom<View,shared>::Dom(Space* home, bool share, Dom<View,shared>& p)
+    : Base<DomInfo<View>,PC_INT_DOM>(home,share,p) {}
+
+  template <class View, bool shared>
+  Actor*
+  Dom<View,shared>::copy(Space* home, bool share) {
+    return new (home) Dom<View,shared>(home,share,*this);
+  }
+
+  template <class View, bool shared>
+  PropCost
+  Dom<View,shared>::cost(ModEventDelta med) const {
+    return (View::me(med) == ME_INT_VAL) ? PC_QUADRATIC_LO : PC_CUBIC_HI;
+  }
+
+  template <class View, bool shared>
+  Support::Symbol
+  Dom<View,shared>::ati(void) {
+    return Reflection::mangle<View>("Gecode::Int::Channel::Dom",shared);
+  }
+
+  template <class View, bool shared>
+  Reflection::ActorSpec
+  Dom<View,shared>::spec(const Space* home, Reflection::VarMap& m) const {
+    return Base<DomInfo<View>,PC_INT_DOM>::spec(home, m, ati());
+  }
+
+  template <class View, bool shared>
+  void
+  Dom<View,shared>::post(Space* home, Reflection::VarMap& vars,
+                         const Reflection::ActorSpec& spec) {
+    const int n = spec.noOfArgs();
+    DomInfo<View>* vi
+      = DomInfo<View>::allocate(home,n);
+    for (int i=0; i<n; i++) {
+      vi[i].init(View(home, vars, spec[i]),n/2);
+    }
+    (void) new (home) Dom<View,shared>(home,n/2,vi);
+  }
+
+  template <class View, bool shared>
+  ExecStatus
+  Dom<View,shared>::propagate(Space* home, ModEventDelta med) {
+    GECODE_AUTOSTACK(int,-1, xa, n);
+    GECODE_AUTOSTACK(int,-1, ya, n);
+
+    DomInfo<View>* x = xy;
+    DomInfo<View>* y = xy+n;
+
+    if (View::me(med) == ME_INT_VAL) {
+      // 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);
+      }
+
+      if (shared) {
+        do {
+          // Propagate assigned views for x
+          GECODE_ES_CHECK((prop_val<View,DomInfo<View> >
+                           (home,n,x,y,n_na,xa,ya)));
+          // Propagate assigned views for y
+          GECODE_ES_CHECK((prop_val<View,DomInfo<View> >
+                           (home,n,y,x,n_na,ya,xa)));
+          assert(ya.empty());
+        } while (!xa.empty() || !ya.empty());
+        return ES_NOFIX_PARTIAL(this,View::med(ME_INT_DOM));
+      } else {
+        do {
+          // Propagate assigned views for x
+          GECODE_ES_CHECK((prop_val<View,DomInfo<View> >
+                           (home,n,x,y,n_na,xa,ya)));
+          // Propagate assigned views for y
+          GECODE_ES_CHECK((prop_val<View,DomInfo<View> >
+                           (home,n,y,x,n_na,ya,xa)));
+          assert(ya.empty());
+        } while (!xa.empty());
+        return ES_FIX_PARTIAL(this,View::med(ME_INT_DOM));
+      }
+    }
+
+    // Process changed views for y
+    // This propagates from y to x and possibly records xs that
+    // got assigned
+    GECODE_ES_CHECK(prop_dom(home,n,y,x,xa));
+
+    // Process assigned views for x
+    GECODE_ES_CHECK((prop_val<View,DomInfo<View> >(home,n,x,y,n_na,xa,ya)));
+
+    // Perform domain consistent propagation for distinct on the x views
+    if (dc.available()) {
+      GECODE_ES_CHECK(dc.sync());
+    } else {
+      GECODE_AUTOARRAY(View,xv,n);
+      for (int i=n; i--; )
+        xv[i] = x[i].view;
+      GECODE_ES_CHECK(dc.init(home,n,&xv[0]));
+    }
+    bool assigned;
+    GECODE_ES_CHECK(dc.propagate(home,assigned));
+    if (assigned) {
+      // This has assigned some more views in x which goes unnoticed
+      // (that is, not recorded in xa). This must be checked and propagated
+      // to the y views, however the distinctness on x is already
+      // propagated.
+      for (int i=n; i--; )
+        if (x[i].doval()) {
+          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;
+          if (me_modified(me)) {
+            // Record that y[j] has been assigned and must be propagated
+            assert(me == ME_INT_VAL);
+            // Otherwise the modification event would not be ME_INT_VAL
+            ya.push(j);
+          }
+          x[i].assigned(); n_na--;
+        }
+    }
+
+    // Process changed views for x
+    // This propagates from x to y and possibly records ys that
+    // got assigned
+    GECODE_ES_CHECK(prop_dom(home,n,x,y,ya));
+
+    // Process assigned view again (some might have been found above)
+    while (!xa.empty() || !ya.empty()) {
+      // Process assigned views for x
+      GECODE_ES_CHECK((prop_val<View,DomInfo<View> >(home,n,x,y,n_na,xa,ya)));
+      // Process assigned views for y
+      GECODE_ES_CHECK((prop_val<View,DomInfo<View> >(home,n,y,x,n_na,ya,xa)));
+    };
+
+    if (shared) {
+      for (int i=2*n; i--; )
+        if (!xy[i].view.assigned())
+          return ES_NOFIX;
+      return ES_SUBSUMED(this,home);
+    } else {
+      return (n_na == 0) ? ES_SUBSUMED(this,home) : ES_FIX;
+    }
+  }
+
+  template <class View, bool shared>
+  ExecStatus
+  Dom<View,shared>::post(Space* home, int n, DomInfo<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) Dom<View,shared>(home,n,xy);
+    return ES_OK;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+