gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-2.1.1/gecode/int/extensional/base.icc

@@ -0,0 +1,160 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Mikael Lagerkvist, 2007
+ *
+ *  Last modified:
+ *     $Date: 2008-01-13 15:02:42 +0100 (Sun, 13 Jan 2008) $ by $Author: schulte $
+ *     $Revision: 5862 $
+ *
+ *  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 Extensional {
+  /*
+   * The propagator proper
+   *
+   */
+
+  template <class View, bool subscribe>
+  forceinline
+  Base<View,subscribe>::Base(Space* home, ViewArray<View>& x0, const TupleSet& t)
+    : Propagator(home), x(x0), tupleSet(t), last_data(NULL) {
+    if (subscribe)
+      x.subscribe(home, this, PC_INT_DOM);
+
+    if (!ts()->finalized()) ts()->finalize();
+    init_last(home, ts()->last);
+
+    this->force(home);
+  }
+
+  template <class View, bool subscribe>
+  forceinline
+  Base<View,subscribe>::Base(Space* home, bool share, Base<View,subscribe>& p)
+    : Propagator(home,share,p), last_data(NULL) {
+    x.update(home, share, p.x);
+    tupleSet.update(home, share, p.tupleSet);
+
+    init_last(home, p.last_data);
+  }
+
+  template <class View, bool subscribe>
+  forceinline void
+  Base<View,subscribe>::init_last(Space* home, Tuple** source) {
+    if (last_data == NULL) {
+      int literals = ts()->domsize*x.size();
+      last_data = static_cast<Tuple**>(home->alloc(literals*sizeof(Tuple*)));
+      for (int i = literals; i--; ) {
+        last_data[i] = source[i];
+      }
+    }
+  }
+
+  template <class View, bool subscribe>
+  forceinline TupleSet::TupleSetI*
+  Base<View,subscribe>::ts(void) {
+    return tupleSet.implementation();
+  }
+
+  template <class View, bool subscribe>
+  PropCost
+  Base<View,subscribe>::cost(ModEventDelta) const {
+    return PC_QUADRATIC_HI;
+  }
+
+#define GECODE_LAST_TUPLE(l) (*(l))
+
+  template <class View, bool subscribe>
+  forceinline Tuple
+  Base<View,subscribe>::last(int var, int val) {
+    return GECODE_LAST_TUPLE(last_data[(var*ts()->domsize) + val]);
+  }
+
+  template <class View, bool subscribe>
+  forceinline Tuple
+  Base<View,subscribe>::last_next(int var, int val) {
+    assert(last(var, val) != NULL);
+    assert(last(var, val)[var] == val+ts()->min);
+    int pos = (var*ts()->domsize) + val;
+    ++(last_data[pos]);
+    if (last(var,val)[var] != (val+ts()->min))
+      last_data[pos] = ts()->nullptr;
+    return last(var, val);
+  }
+
+
+  template <class View, bool subscribe>
+  forceinline void
+  Base<View,subscribe>::init_dom(Space* home, Domain dom) {
+    int domsize = ts()->domsize;
+    for (int i = x.size(); i--; ) {
+      dom[i].init(home, domsize);
+      for (ViewValues<View> vv(x[i]); vv(); ++vv)
+        dom[i].set(vv.val()-ts()->min);
+    }
+  }
+
+  template <class View, bool subscribe>
+  forceinline bool
+  Base<View,subscribe>::valid(Tuple t, Domain dom) {
+    for (int i = x.size(); i--; )
+      if (!dom[i].get(t[i]-ts()->min))
+        return false;
+    return true;
+  }
+#undef GECODE_LAST_TUPLE
+  template <class View, bool subscribe>
+  forceinline Tuple
+  Base<View,subscribe>::find_support(Domain dom, int var, int val) {
+    Tuple l = last(var, val);
+    while (l != NULL && !valid(l, dom)) {
+      l = last_next(var, val);
+    }
+    return l;
+  }
+
+
+  template <class View, bool subscribe>
+  size_t
+  Base<View,subscribe>::dispose(Space* home) {
+    this->unforce(home);
+    (void) Propagator::dispose(home);
+    if (!home->failed()) {
+      if (subscribe)
+        x.cancel(home,this,PC_INT_DOM);
+      // take care of last_data
+      int literals = ts()->domsize*x.size();    
+      home->reuse(last_data, sizeof(Tuple*)*literals);
+    }
+    (void) tupleSet.~TupleSet();    
+    return sizeof(*this);
+  }
+}}}
+
+// STATISTICS: int-prop
+

data/ext/gecode-2.1.1/gecode/int/extensional/basic.icc

@@ -0,0 +1,166 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Mikael Lagerkvist, 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.
+ *
+ */
+
+namespace Gecode { namespace Int { namespace Extensional {
+  /*
+   * The propagator proper
+   *
+   */
+
+  template <class View>
+  forceinline
+  Basic<View>::Basic(Space* home, ViewArray<View>& x, const TupleSet& t)
+    : Base<View>(home,x,t) {
+  }
+
+  template <class View>
+  ExecStatus
+  Basic<View>::post(Space* home, ViewArray<View>& x, const TupleSet& t) {
+    (void) new (home) Basic<View>(home,x,t);
+    return ES_OK;
+  }
+
+  template <class View>
+  forceinline
+  Basic<View>::Basic(Space* home, bool share, Basic<View>& p)
+    : Base<View>(home,share,p) {
+  }
+
+  template <class View>
+  PropCost
+  Basic<View>::cost(ModEventDelta med) const {
+    return (View::me(med) == ME_INT_VAL)
+      ? PC_QUADRATIC_HI : PC_CUBIC_HI;
+  }
+
+  template <class View>
+  Actor*
+  Basic<View>::copy(Space* home, bool share) {
+    return new (home) Basic<View>(home,share,*this);
+  }
+
+  template <class View>
+  Gecode::Support::Symbol
+  Basic<View>::ati(void) {
+    return Reflection::mangle<View>("Gecode::Int::Extensional::Basic");
+  }
+
+  template <class View>
+  Reflection::ActorSpec
+  Basic<View>::spec(const Space* home, Reflection::VarMap& m) const {
+    Reflection::ActorSpec s(ati());
+    return s << x.spec(home, m)
+             << tupleSet.spec(m);
+  }
+
+  template <class View>
+  void
+  Basic<View>::post(Space* home, Reflection::VarMap& vars,
+                    const Reflection::ActorSpec& spec) {
+    spec.checkArity(2);
+    ViewArray<View> x(home, vars, spec[0]);
+    TupleSet tupleSet(vars, spec[1]);
+    (void) new (home) Basic<View>(home,x,tupleSet);    
+  }
+
+
+  template <class View>
+  ExecStatus
+  Basic<View>::propagate(Space* home, ModEventDelta) {
+    ///// Domain consistent propagation
+    //// Set up datastructures
+    /// Bit-sets for amortized O(1) access to domains
+    GECODE_AUTOARRAY(BitSet, dom, x.size());
+    init_dom(home, dom);
+
+    /// Bit-sets for processed values.
+    GECODE_AUTOARRAY(BitSet, has_support, x.size());
+    for (int i = x.size(); i--; ) 
+      has_support[i].init(home, ts()->domsize);
+ 
+
+    /// Values to prune
+    GECODE_AUTOARRAY(int,nq, ts()->domsize*x.size());
+    int n_nq = 0;
+
+    
+    ExecStatus es = ES_FIX;
+
+    //// Run algorithm
+    /// Check consistency for each variable-value pair
+    for (int var = x.size(); var--; ) {
+      for (ViewValues<View> vv(x[var]); vv(); ++vv) {
+        // Value offset for indexing
+        int val = vv.val() - ts()->min;
+        if (!has_support[var].get(val)) {
+          // Find support for value vv.val() in variable var
+          Tuple l = find_support(dom, var, val);
+          if (l == NULL) {
+            // No possible supports left
+            nq[n_nq] = vv.val();
+            n_nq++;
+          } else {
+            // Mark values as supported 
+            // Only forward direction marking is needed since all
+            // previous values have been checked
+            for (int i = var; i--; ) {
+              has_support[i].set(l[i]- ts()->min);
+              assert(has_support[i].get(l[i]- ts()->min));
+            }
+          }
+        }
+      }
+
+      // Prune values for var which do not have support anymore
+      while (n_nq-- > 0) {
+        ModEvent me = x[var].nq(home,nq[n_nq]);
+        if (me_failed(me))
+          return ES_FAILED;
+        if (me_modified(me))
+          es = ES_NOFIX;
+      }
+      n_nq = 0;
+    }
+
+    for (int i = x.size(); i--; )
+      if (!x[i].assigned())
+        return es;
+    return ES_SUBSUMED(this, home);
+  }
+}}}
+// STATISTICS: int-prop
+

data/ext/gecode-2.1.1/gecode/int/extensional/bitset.icc

@@ -0,0 +1,113 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Mikael Lagerkvist, 2007
+ *     Christian Schulte, 2007
+ *
+ *  Last modified:
+ *     $Date: 2007-12-10 08:54:45 +0100 (Mon, 10 Dec 2007) $ by $Author: schulte $
+ *     $Revision: 5650 $
+ *
+ *  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 <climits>
+
+namespace Gecode { namespace Int { namespace Extensional {
+
+  /// Simple bitsets
+  class BitSet {
+    /// Basetype for bits
+    typedef unsigned int Base;
+    /// Stored bits
+    Base* data;
+    /// Size of bitset
+    unsigned int size;
+  public:
+    /// Default (empty) initialization of BitSet
+    BitSet(void);
+    /// BitSet with space for \a s bits. The bits are  set to \a value.
+    BitSet(Space* home, int s, bool value = false);
+    /// Copy BitSet \a bs
+    BitSet(Space* home, const BitSet& bs);
+    /// Initialize BitSet for \a s bits. The bits are  set to \a value.
+    void init(Space *home, int s, bool value=false);
+    /// Access value at bit \a i
+    bool get(unsigned int i);
+    /// Set value at bit \a i to \a value
+    void set(unsigned int i, bool value=true);
+  };
+  
+  forceinline void
+  BitSet::init(Space* home, int s, bool value) {
+    size = static_cast<int>(std::ceil(static_cast<double>(s)
+                                      /(CHAR_BIT*sizeof(Base))));
+    data = static_cast<Base*>(home->alloc(size*sizeof(Base)));
+    Base ival = value ? ~0 : 0;
+    for (int i = size; i--; ) data[i] = ival;
+  }
+
+  forceinline
+  BitSet::BitSet(void) : data(NULL), size(0) {}
+
+  forceinline
+  BitSet::BitSet(Space *home, int s, bool value) 
+    : data(NULL), size(0) {
+    init(home, s, value);
+  }
+  forceinline
+  BitSet::BitSet(Space *home, const BitSet& bs)
+    : data(static_cast<Base*>(home->alloc(bs.size*sizeof(Base)))), 
+      size(bs.size) {
+    for (int i = size; i--; ) data[i] = bs.data[i];
+  }
+  forceinline bool
+  BitSet::get(unsigned int i) {
+    unsigned int pos = i / (sizeof(Base)*CHAR_BIT);
+    unsigned int bit = i % (sizeof(Base)*CHAR_BIT);
+    assert(pos < size);
+    return data[pos] & ((Base)1 << bit);
+  }
+  forceinline void
+  BitSet::set(unsigned int i, bool value) {
+    unsigned int pos = i / (sizeof(Base)*CHAR_BIT);
+    unsigned int bit = i % (sizeof(Base)*CHAR_BIT);
+    assert(pos < size);
+    if (value)
+      data[pos] |= 1 << bit;
+    else
+      data[pos] &= ~(1 << bit);
+  }
+
+}}}
+
+// STATISTICS: int-other
+

data/ext/gecode-2.1.1/gecode/int/extensional/dfa.cc

@@ -0,0 +1,565 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-03-05 19:42:31 +0100 (Wed, 05 Mar 2008) $ by $Author: tack $
+ *     $Revision: 6431 $
+ *
+ *  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.hh"
+
+namespace Gecode { namespace Int { namespace Extensional {
+
+  /**
+   * \brief Sort transition array by input state
+   */
+  class TransByI_State {
+  public:
+    forceinline bool
+    operator()(const DFA::Transition& x, const DFA::Transition& y) {
+      return x.i_state < y.i_state;
+    }
+    forceinline static void
+    sort(DFA::Transition t[], int n) {
+      TransByI_State tbis;
+      Support::quicksort<DFA::Transition,TransByI_State>(t,n,tbis);
+    }
+  };
+
+  /**
+   * \brief Sort transition array by symbol (value)
+   */
+  class TransBySymbol {
+  public:
+    forceinline bool
+    operator()(const DFA::Transition& x, const DFA::Transition& y) {
+      return x.symbol < y.symbol;
+    }
+    forceinline static void
+    sort(DFA::Transition t[], int n) {
+      TransBySymbol tbs;
+      Support::quicksort<DFA::Transition,TransBySymbol>(t,n,tbs);
+    }
+  };
+
+  /**
+   * \brief Sort transition array by symbol and then input states
+   */
+  class TransBySymbolI_State {
+  public:
+    forceinline bool
+    operator()(const DFA::Transition& x, const DFA::Transition& y) {
+      return ((x.symbol < y.symbol) ||
+              (x.symbol == y.symbol) && (x.i_state < y.i_state));
+    }
+    forceinline static void
+    sort(DFA::Transition t[], int n) {
+      TransBySymbolI_State tbsi;
+      Support::quicksort<DFA::Transition,TransBySymbolI_State>(t,n,tbsi);
+    }
+  };
+
+  /**
+   * \brief Sort transition array by output state
+   */
+  class TransByO_State {
+  public:
+    forceinline bool
+    operator()(const DFA::Transition& x, const DFA::Transition& y) {
+      return x.o_state < y.o_state;
+    }
+    forceinline static void
+    sort(DFA::Transition t[], int n) {
+      TransByO_State tbos;
+      Support::quicksort<DFA::Transition,TransByO_State>(t,n,tbos);
+    }
+  };
+
+
+  /**
+   * \brief Stategroup is used to compute a partition of states
+   */
+  class StateGroup {
+  public:
+    int state;
+    int group;
+  };
+
+  /**
+   * \brief Sort groups stated by group and then state
+   */
+  class StateGroupByGroup {
+  public:
+    forceinline bool
+    operator()(const StateGroup& x, const StateGroup& y) {
+      return ((x.group < y.group) ||
+              (x.group == y.group) && (x.state < y.state));
+    }
+    static void
+    sort(StateGroup sg[], int n) {
+      StateGroupByGroup o;
+      Support::quicksort<StateGroup,StateGroupByGroup>(sg,n,o);
+    }
+  };
+
+  /**
+   * \brief %GroupStates is used to index %StateGroup by group
+   */
+  class GroupStates {
+  public:
+    StateGroup* fst;
+    StateGroup* lst;
+  };
+
+  /// Information about states
+  enum StateInfo {
+    SI_NONE       = 0, ///< State is not reachable
+    SI_FROM_START = 1, ///< State is reachable from start state
+    SI_TO_FINAL   = 2, ///< Final state is reachable from state
+    SI_FINAL      = 4, ///< State is final
+  };
+
+}}}
+
+namespace Gecode {
+
+  DFA::DFA(int start, Transition t_spec[], int f_spec[], bool minimize) {
+    using namespace Int;
+    using namespace Extensional;
+    // Compute number of states and transitions
+    int n_states = start;
+    int n_trans  = 0;
+    for (Transition* t = &t_spec[0]; t->i_state >= 0; t++) {
+      n_states = std::max(n_states,t->i_state);
+      n_states = std::max(n_states,t->o_state);
+      n_trans++;
+    }
+    for (int* f = &f_spec[0]; *f >= 0; f++)
+      n_states = std::max(n_states,*f);
+    n_states++;
+
+    // Temporary structure for transitions
+    GECODE_AUTOARRAY(Transition, trans, n_trans);
+    for (int i = n_trans; i--; )
+      trans[i] = t_spec[i];
+    // Temporary structures for finals
+    GECODE_AUTOARRAY(int,  final,    n_states+1);
+    GECODE_AUTOARRAY(bool, is_final, n_states+1);
+    int n_finals = 0;
+    for (int i = n_states+1; i--; )
+      is_final[i] = false;
+    for (int* f = &f_spec[0]; *f != -1; f++) {
+      is_final[*f]      = true;
+      final[n_finals++] = *f;
+    }
+
+    if (minimize) {
+      // Sort transitions by symbol and i_state
+      TransBySymbolI_State::sort(trans, n_trans);
+      GECODE_AUTOARRAY(Transition*, idx, n_trans+1);
+      //  idx[i]...idx[i+1]-1 gives where transitions for symbol i start
+      int n_symbols = 0;
+      {
+        int j = 0;
+        while (j < n_trans) {
+          idx[n_symbols++] = &trans[j];
+          int s = trans[j].symbol;
+          while ((j < n_trans) && (s == trans[j].symbol))
+            j++;
+        }
+        idx[n_symbols] = &trans[j];
+        assert(j == n_trans);
+      }
+      // Map states to groups
+      GECODE_AUTOARRAY(int,         s2g,  n_states+1);
+      GECODE_AUTOARRAY(StateGroup,  part, n_states+1);
+      GECODE_AUTOARRAY(GroupStates, g2s,  n_states+1);
+      // Initialize: final states is group one, all other group zero
+      for (int i = n_states+1; i--; ) {
+        part[i].state = i;
+        part[i].group = is_final[i] ? 1 : 0;
+        s2g[i]        = part[i].group;
+      }
+      // Important: the state n_state is the dead state, conceptually
+      // if there is no transition for a symbol and input state, it is
+      // assumed that there is an implicit transition to n_state
+
+      // Set up the indexing data structure, sort by group
+      StateGroupByGroup::sort(part,n_states+1);
+      int n_groups;
+      if (part[0].group == part[n_states].group) {
+        // No final states, just one group
+        g2s[0].fst = &part[0]; g2s[0].lst = &part[n_states+1];
+        n_groups = 1;
+      } else  {
+        int i = 0;
+        assert(part[0].group == 0);
+        do i++; while (part[i].group == 0);
+        g2s[0].fst = &part[0]; g2s[0].lst = &part[i];
+        g2s[1].fst = &part[i]; g2s[1].lst = &part[n_states+1];
+        n_groups = 2;
+      }
+
+      // Do the refinement
+      {
+        int m_groups;
+        do {
+          m_groups = n_groups;
+          // Iterate over symbols
+          for (int sidx = n_symbols; sidx--; ) {
+            // Iterate over groups
+            for (int g = n_groups; g--; ) {
+              // Ignore singleton groups
+              if (g2s[g].lst-g2s[g].fst > 1) {
+                // Apply transitions to group states
+                // This exploits that both transitions as well as
+                // stategroups are sorted by (input) state
+                Transition* t     = idx[sidx];
+                Transition* t_lst = idx[sidx+1];
+                for (StateGroup* sg = g2s[g].fst; sg<g2s[g].lst; sg++) {
+                  while ((t < t_lst) && (t->i_state < sg->state))
+                    t++;
+                  // Compute group resulting from transition
+                  if ((t < t_lst) && (t->i_state == sg->state))
+                    sg->group = s2g[t->o_state];
+                  else
+                    sg->group = s2g[n_states]; // Go to dead state
+                }
+                // Sort group by groups from transitions
+                StateGroupByGroup::sort(g2s[g].fst,
+                                        static_cast<int>(g2s[g].lst-g2s[g].fst));
+                // Group must be split?
+                if (g2s[g].fst->group != (g2s[g].lst-1)->group) {
+                  // Skip first group
+                  StateGroup* sg = g2s[g].fst+1;
+                  while ((sg-1)->group == sg->group)
+                    sg++;
+                  // Start splitting
+                  StateGroup* lst = g2s[g].lst;
+                  g2s[g].lst = sg;
+                  while (sg < lst) {
+                    s2g[sg->state] = n_groups;
+                    g2s[n_groups].fst  = sg++;
+                    while ((sg < lst) && ((sg-1)->group == sg->group)) {
+                      s2g[sg->state] = n_groups; sg++;
+                    }
+                    g2s[n_groups++].lst = sg;
+                  }
+                }
+              }
+            }
+          }
+        } while (n_groups != m_groups);
+        // New start state
+        start = s2g[start];
+        // Compute new final states
+        n_finals = 0;
+        for (int g = n_groups; g--; )
+          for (StateGroup* sg = g2s[g].fst; sg < g2s[g].lst; sg++)
+            if (is_final[sg->state]) {
+              final[n_finals++] = g;
+              break;
+            }
+        // Compute representatives
+        GECODE_AUTOARRAY(int, s2r, n_states+1);
+        for (int i = n_states+1; i--; )
+          s2r[i] = -1;
+        for (int g = n_groups; g--; )
+          s2r[g2s[g].fst->state] = g;
+        // Clean transitions
+        int j = 0;
+        for (int i = 0; i<n_trans; i++)
+          if (s2r[trans[i].i_state] != -1) {
+            trans[j].i_state = s2g[trans[i].i_state];
+            trans[j].symbol  = trans[i].symbol;
+            trans[j].o_state = s2g[trans[i].o_state];
+            j++;
+          }
+        n_trans  = j;
+        n_states = n_groups;
+      }
+    }
+
+    // Do a reachability analysis for all states starting from start state
+    GECODE_AUTOSTACK(int, -1, visit, n_states);
+    GECODE_AUTOARRAY(int, state, n_states);
+    for (int i=n_states; i--; )
+      state[i] = SI_NONE;
+
+    {
+      // Sort all transitions according to i_state and create index structure
+      //  idx[i]...idx[i+1]-1 gives where transitions for state i start
+      TransByI_State::sort(trans, n_trans);
+      GECODE_AUTOARRAY(Transition*, idx, n_states+1);
+      {
+        int j = 0;
+        for (int i=0; i<n_states; i++) {
+          idx[i] = &trans[j];
+          while ((j < n_trans) && (i == trans[j].i_state))
+            j++;
+        }
+        idx[n_states] = &trans[j];
+        assert(j == n_trans);
+      }
+
+      state[start] = SI_FROM_START;
+      visit.push(start);
+      while (!visit.empty()) {
+        int s = visit.pop();
+        for (Transition* t = idx[s]; t < idx[s+1]; t++)
+          if (!(state[t->o_state] & SI_FROM_START)) {
+            state[t->o_state] |= SI_FROM_START;
+            visit.push(t->o_state);
+          }
+      }
+    }
+
+    // Do a reachability analysis for all states to a final state
+    {
+      // Sort all transitions according to o_state and create index structure
+      //  idx[i]...idx[i+1]-1 gives where transitions for state i start
+      TransByO_State::sort(trans, n_trans);
+      GECODE_AUTOARRAY(Transition*, idx, n_states+1);
+      {
+        int j = 0;
+        for (int i=0; i<n_states; i++) {
+          idx[i] = &trans[j];
+          while ((j < n_trans) && (i == trans[j].o_state))
+            j++;
+        }
+        idx[n_states] = &trans[j];
+        assert(j == n_trans);
+      }
+
+      for (int i = n_finals; i--; ) {
+        state[final[i]] |= (SI_TO_FINAL | SI_FINAL);
+        visit.push(final[i]);
+      }
+      while (!visit.empty()) {
+        int s = visit.pop();
+        for (Transition* t = idx[s]; t < idx[s+1]; t++)
+          if (!(state[t->i_state] & SI_TO_FINAL)) {
+            state[t->i_state] |= SI_TO_FINAL;
+            visit.push(t->i_state);
+          }
+      }
+    }
+
+    // Now all reachable states are known (also the final ones)
+    GECODE_AUTOARRAY(int, re, n_states);
+    for (int i = n_states; i--; )
+      re[i] = -1;
+
+    // Renumber states
+    int m_states = 0;
+    // Start state gets zero
+    re[start] = m_states++;
+
+    // Renumber final states
+    for (int i = n_states; i--; )
+      if ((state[i] == (SI_FINAL | SI_FROM_START | SI_TO_FINAL)) && (re[i] < 0))
+        re[i] = m_states++;
+    // If start state is final, final states start from zero, otherwise from one
+    int final_fst = (state[start] & SI_FINAL) ? 0 : 1;
+    int final_lst = m_states;
+    // final_fst...final_lst-1 are the final states
+
+    // Renumber remaining states
+    for (int i = n_states; i--; )
+      if ((state[i] == (SI_FROM_START | SI_TO_FINAL)) && (re[i] < 0))
+        re[i] = m_states++;
+
+    // Count number of remaining transitions
+    int m_trans = 0;
+    for (int i = n_trans; i--; )
+      if ((re[trans[i].i_state] >= 0) && (re[trans[i].o_state] >= 0))
+        m_trans++;
+
+    // All done... Construct the automaton
+    DFAI* d = new DFAI(m_trans);
+    d->n_states  = m_states;
+    d->n_trans   = m_trans;
+    d->final_fst = final_fst;
+    d->final_lst = final_lst;
+    {
+      int j = 0;
+      Transition* r = &d->trans[0];
+      for (int i = 0; i<n_trans; i++)
+        if ((re[trans[i].i_state] >= 0) && (re[trans[i].o_state] >= 0)) {
+          r[j].symbol  = trans[i].symbol;
+          r[j].i_state = re[trans[i].i_state];
+          r[j].o_state = re[trans[i].o_state];
+          j++;
+        }
+      TransBySymbol::sort(r,m_trans);
+    }
+    {
+      // Count number of symbols
+      unsigned int n_symbols = 0;
+      for (int i = 0; i<m_trans; ) {
+        int s = d->trans[i++].symbol;
+        n_symbols++;
+        while ((i<m_trans) && (d->trans[i].symbol == s))
+          i++;
+      }
+      d->n_symbols = n_symbols;
+    }
+    d->fill();
+    object(d);
+  }
+
+  DFA::DFA(Reflection::VarMap& vm, Reflection::Arg* arg) {
+    if (arg->isSharedReference()) {
+      DFAI* d = 
+        static_cast<DFAI*>(vm.getSharedObject(arg->toSharedReference()));
+      object(d);
+      return;
+    }
+    
+    Reflection::IntArrayArg* a = arg->toSharedObject()->toIntArray();
+
+    // All done... Construct the automaton
+
+    int n_trans = (a->size() - 4) / 3;
+    DFAI* d = new DFAI(n_trans);
+    d->n_states  = (*a)[0];
+    d->n_symbols = (*a)[1];
+    d->final_fst = (*a)[2];
+    d->final_lst = (*a)[3];
+    d->n_trans   = n_trans;
+    for (int i=0; i<n_trans; i++) {
+      d->trans[i].i_state = (*a)[4+3*i+0];
+      d->trans[i].symbol  = (*a)[4+3*i+1];
+      d->trans[i].o_state = (*a)[4+3*i+2];
+    }
+    d->fill();
+    object(d);    
+    vm.putMasterObject(object());
+  }
+
+  Reflection::Arg*
+  DFA::spec(Reflection::VarMap& vm) const {
+    int sharedIndex = vm.getSharedIndex(object());
+    if (sharedIndex >= 0)
+      return Reflection::Arg::newSharedReference(sharedIndex);
+    Reflection::IntArrayArg* a = 
+      Reflection::Arg::newIntArray(static_cast<int>(4+3*n_transitions()));
+    (*a)[0] = n_states();
+    (*a)[1] = n_symbols();
+    (*a)[2] = final_fst();
+    (*a)[3] = final_lst();
+    const DFAI* o = static_cast<DFAI*>(object());
+    for (unsigned int i=0; i<n_transitions(); i++ ) {
+      (*a)[4+3*i+0] = o->trans[i].i_state;
+      (*a)[4+3*i+1] = o->trans[i].symbol;
+      (*a)[4+3*i+2] = o->trans[i].o_state;
+    }
+    vm.putMasterObject(object());
+    return Reflection::Arg::newSharedObject(a);    
+  }
+
+  SharedHandle::Object*
+  DFA::DFAI::copy(void) const {
+    DFAI* d = new DFAI(n_trans);
+    d->n_states  = n_states;
+    d->n_symbols = n_symbols;
+    d->n_trans   = n_trans;
+    d->final_fst = final_fst;
+    d->final_lst = final_lst;
+    memcpy(&d->trans[0], &trans[0], sizeof(Transition)*n_trans);
+    d->fill();
+    return d;
+  }
+
+  void
+  DFA::DFAI::fill(void) {
+    // Compute smallest logarithm larger than n_symbols
+    n_log = 1;
+    while (n_symbols >= static_cast<unsigned int>(1<<n_log))
+      n_log++;
+    // Allocate memory
+    table = static_cast<HashEntry*>
+      (Memory::malloc(sizeof(HashEntry)*(1<<n_log)));
+    // Initialize table
+    for (int i=(1<<n_log); i--; )
+      table[i].fst = table[i].lst = NULL;
+    int mask = (1 << n_log) - 1;
+    // Enter transitions to table
+    for (unsigned int i = 0; i<n_trans; ) {
+      int s = trans[i].symbol;
+      Transition* fst = &trans[i];
+      i++;
+      while ((i<n_trans) && (trans[i].symbol == s))
+        i++;
+      Transition* lst = &trans[i];
+      // Enter with linear collision resolution
+      int p = s & mask;
+      while (table[p].fst != NULL)
+        p = (p+1) & mask;
+      table[p].symbol = s;
+      table[p].fst    = fst;
+      table[p].lst    = lst;
+    }
+  }
+
+}
+
+std::ostream&
+operator<<(std::ostream& os, const Gecode::DFA& dfa) {
+  os << "Start state: 0" << std::endl
+     << "States:      0..." << dfa.n_states()-1 << std::endl
+     << "Transitions:";
+  for (int s = 0; s < static_cast<int>(dfa.n_states()); s++) {
+    Gecode::DFA::Transitions t(dfa);
+    int n = 0;
+    while (t()) {
+      if (t.i_state() == s) {
+        if ((n % 4) == 0)
+          os << std::endl << "\t";
+        os << "[" << t.i_state() << "]"
+           << "- " << t.symbol() << " >"
+           << "[" << t.o_state() << "]  ";
+        ++n;
+      }
+      ++t;
+    }
+  }
+  os << std::endl << "Final states: "
+     << std::endl
+     << "\t[" << dfa.final_fst() << "] ... ["
+     << dfa.final_lst()-1 << "]"
+     << std::endl;
+  return os;
+}
+
+// STATISTICS: int-prop
+