gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/set/distinct/atmostOne.icc

@@ -0,0 +1,50 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2005-11-24 18:03:01 +0100 (Thu, 24 Nov 2005) $ by $Author: tack $
+ *     $Revision: 2639 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+namespace Gecode { namespace Set { namespace Distinct {
+
+  /*
+   * "AtMostOneIntersection" propagator
+   *
+   */
+
+  forceinline
+  AtmostOne::AtmostOne(Space* home, ViewArray<SetView>& x, unsigned int _c)
+    : NaryPropagator<SetView, PC_SET_ANY>(home,x), c(_c) {}
+
+  forceinline
+  AtmostOne::AtmostOne(Space* home, bool share, AtmostOne& p)
+    : NaryPropagator<SetView, PC_SET_ANY>(home,share,p), c(p.c) {}
+
+  forceinline ExecStatus
+  AtmostOne::post(Space* home, ViewArray<SetView> x, unsigned int c) {
+    for (int i=x.size(); i--;) {
+      GECODE_ES_CHECK(x[i].cardMin(home, c));
+      GECODE_ES_CHECK(x[i].cardMax(home, c));
+    }
+
+    (void) new (home) AtmostOne(home,x,c);
+    return ES_OK;
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/distinct/binomial.cc

@@ -0,0 +1,46 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-04-11 15:58:37 +0200 (Tue, 11 Apr 2006) $ by $Author: tack $
+ *     $Revision: 3188 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#include "gecode/set.hh"
+#include "gecode/set/distinct/binomial.icc"
+
+namespace Gecode { namespace Set { namespace Distinct {
+
+  void
+  Binomial::init(unsigned int n) {
+    int n2 = (n-2)/2;
+    int nn = n2*(n2-1);
+    nn += n2;
+    if (n % 2 == 1)
+      nn += n2;
+
+    //    sar.ensure(n*(n-1)/2);
+    sar.ensure(nn);
+    unsigned int oldnmax = nmax;
+    nmax = n;
+    for (unsigned int i=oldnmax+1; i<=n; i++)
+      for (unsigned int j=2; j<=(i/2); j++)
+	y(i, j, y(i-1, j-1) + y(i-1, j));
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/distinct/binomial.icc

@@ -0,0 +1,157 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-07-11 12:00:17 +0200 (Tue, 11 Jul 2006) $ by $Author: schulte $
+ *     $Revision: 3344 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+namespace Gecode { namespace Set { namespace Distinct {
+
+  /**
+   * \brief Computing binomial coefficients using dynamic programming
+   */
+  class Binomial {
+  private:
+    /// The array holding the precomputed binomial coefficients
+    Support::SharedArray<int> sar;
+    /// The maximum binomial coefficient computed so far
+    unsigned int nmax;
+    
+    /**
+     * \brief Compute array index of binomial coefficient \f$C(i,j)\f$
+     *
+     * The index \a i must be at least 4. The index \a j must be
+     * between 2 and i/2.
+     *
+     */
+    unsigned int index(unsigned int i, unsigned int j);
+    /// Access the binomial coefficient \f$C(i,j)\f$, where \f$j\leq i\f$
+    unsigned int y(unsigned int i, unsigned int j);
+    /// Set the binomial coefficient \f$C(i,j)=c\f$, where \f$j\leq i\f$
+    void y(unsigned int i, unsigned int j, unsigned int c);
+    /// Initialize the array up to \f$C(n,n)\f$
+    GECODE_SET_EXPORT void init(unsigned int n);
+    
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    Binomial(void);
+    /// Copy constructor
+    Binomial(const Binomial& b);
+    /// Initialize with maximum precomputed binomial coefficient \f$C(\mathrm{nmax},\mathrm{nmax})\f$
+    Binomial(unsigned int nmax);
+    //@}
+    
+    /// \name Value access
+    //@{
+    /// Return binomial coefficient \f$C(n,m)\f$, where \f$m\leq n\f$
+    unsigned int c(unsigned int n, unsigned int m);
+    //@}
+
+    /// \name Cloning
+    //@{
+    /** \brief Update this binomial table to be a copy of \a b
+     * 
+     * If \a share is true, the copy is identical. Otherwise an independent
+     * copy is created.
+     */
+    void update(bool share, Binomial& b);
+    //@}
+  };
+  
+
+  /*
+   * Only half of the lower half of the matrix is represented, as only
+   * binomial coefficients with m<=n are defined, and the lower triangle
+   * is symmetric.
+   *
+   */
+  forceinline unsigned int
+  Binomial::index(unsigned int n, unsigned int m) {
+    assert(n >= 4);
+    assert(m >= 2);
+    assert(m <= n/2);
+    int n2 = (n-2)/2;
+    int nn = n2*(n2-1);
+    if (n % 2 == 1)
+      nn += n2;
+    return nn + m - 2;
+  }
+
+  forceinline unsigned int
+  Binomial::y(unsigned int n, unsigned int m) {
+    if (n==m || m==0)
+      return 1;
+    if (m==1 || m==n-1)
+      return n;
+    if (m > (n/2))
+      m = n-m;
+
+    return sar[ index(n,m) ];
+  }
+
+  forceinline void
+  Binomial::y(unsigned int n, unsigned int m, unsigned int c) {
+    if (n==m || m==0) {
+      assert(c==1);
+      return;
+    }
+    if (m==1 || m==n-1) {
+      assert(c==n);
+      return;
+    }
+    if (m > (n/2)) {
+      assert(c==y(n, n-m));
+      return;
+    }
+
+    sar[ index(n,m) ] = c;
+  }
+
+  forceinline
+  Binomial::Binomial(void) : sar(1), nmax(0) {
+    init(10);
+  }
+  
+  forceinline
+  Binomial::Binomial(const Binomial& b)
+    : sar(b.sar), nmax(b.nmax) {}
+  
+  forceinline
+  Binomial::Binomial(unsigned int _nmax)
+    : sar(1), nmax(0) {
+    init(_nmax);
+  }
+
+  forceinline unsigned int
+  Binomial::c(unsigned int n, unsigned int m) {
+    if (m>n)
+      return 0;
+    if (n>nmax)
+      init(n);
+    return y(n,m);
+  }
+
+  forceinline void
+  Binomial::update(bool share, Binomial& b) {
+    nmax = b.nmax;
+    sar.update(share, b.sar);
+  }
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/distinct/distinct.cc

@@ -0,0 +1,124 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-04-11 15:58:37 +0200 (Tue, 11 Apr 2006) $ by $Author: tack $
+ *     $Revision: 3188 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#include "gecode/set.hh"
+#include "gecode/set/distinct.hh"
+
+/*
+ * These propagators implement the scheme discussed in
+ *
+ * Andrew Sadler and Carment Gervet: Global Reasoning on Sets.
+ * FORMUL'01 workshop in conjunction with CP 2001.
+ *
+ * Todo: make the propagators incremental.
+ */
+
+namespace Gecode { namespace Set { namespace Distinct {
+
+  /*
+   * n-ary distinct with fixed cardinalities propagator
+   *
+   */
+
+  static ModEvent
+  nosubset(Space* home, SetView x, SetView y) {
+    GlbRanges<SetView> xglb(x);
+    GlbRanges<SetView> yglb(y);
+    Iter::Ranges::Diff<GlbRanges<SetView>, GlbRanges<SetView> >
+      diff(xglb, yglb);
+    if (!diff())
+      return ME_SET_FAILED;
+    if (diff.min() != diff.max())
+      return ME_SET_NONE;
+    int a = diff.min();
+    ++diff;
+    if (diff())
+      return ME_SET_NONE;
+    return y.exclude(home, a);
+  }
+
+  Actor*
+  Distinct::copy(Space* home, bool share) {
+    return new (home) Distinct(home,share,*this);
+  }
+
+  ExecStatus
+  Distinct::propagate(Space* home) {
+
+    int curClique = x.size();
+    int oldCliques = curClique;
+
+    while (curClique>1) {
+      
+      unsigned int li = x[0].glbSize();
+      curClique--;
+      SetView tmp = x[curClique];
+      x[curClique] = x[0];
+      x[0] = tmp;
+
+      GECODE_AUTOARRAY(LubRanges<SetView>, cliqueLubs, oldCliques);
+      cliqueLubs[0].init(x[curClique]);
+      unsigned int ki = 1; // size of the clique
+
+      // Find the clique of x[i], i.e. all sets with the same glb.
+      // The clique will be moved to the end of the array, but before
+      // oldCliques.
+      for (int j=0; j<curClique; ) {
+	GlbRanges<SetView> xjglb(x[j]);
+	GlbRanges<SetView> xiglb(x[curClique]);
+	if (Iter::Ranges::equal(xiglb, xjglb)) {
+	  curClique--;
+	  SetView tmp2 = x[curClique];
+	  x[curClique] = x[j];
+	  x[j] = tmp2;
+	  cliqueLubs[ki].init(x[curClique]);
+	  ki++;
+	} else {
+	  j++;
+	}
+      }
+
+      Iter::Ranges::NaryUnion<LubRanges<SetView> > cliqueLub(cliqueLubs, ki);
+      unsigned int ui = Iter::Ranges::size(cliqueLub);
+
+      unsigned int possible = bin.c(ui-li, c-li);
+
+      if (possible < ki)
+	return ES_FAILED;
+
+      if (possible == ki) {
+	for (int i=curClique; i--; ) {
+	  GECODE_ME_CHECK(nosubset(home, x[curClique], x[i]));
+	}
+	for (int i=oldCliques; i<x.size(); i++) {
+	  GECODE_ME_CHECK(nosubset(home, x[curClique], x[i]));
+	}
+      }
+
+      oldCliques = curClique;
+    }
+
+    return ES_NOFIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/distinct/distinct.icc

@@ -0,0 +1,58 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-06-19 11:03:38 +0200 (Mon, 19 Jun 2006) $ by $Author: tack $
+ *     $Revision: 3304 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+namespace Gecode { namespace Set { namespace Distinct {
+
+  /*
+   * n-ary distinct with fixed cardinalities propagator
+   *
+   */
+
+  forceinline
+  Distinct::Distinct(Space* home, ViewArray<SetView>& x, unsigned int _c)
+    : NaryPropagator<SetView, PC_SET_ANY>(home,x,true), bin(10), c(_c) {}
+
+  forceinline
+  Distinct::Distinct(Space* home, bool share, Distinct& p)
+    : NaryPropagator<SetView, PC_SET_ANY>(home,share,p), bin(0), c(p.c) {
+    bin.update(share, p.bin);
+  }
+
+  forceinline ExecStatus
+  Distinct::post(Space* home, ViewArray<SetView> x, unsigned int c) {
+    for (int i=x.size(); i--;) {
+      GECODE_ES_CHECK(x[i].cardMin(home, c));
+      GECODE_ES_CHECK(x[i].cardMax(home, c));
+    }
+
+    (void) new (home) Distinct(home,x,c);
+    return ES_OK;
+  }
+
+  forceinline size_t
+  Distinct::dispose(Space* home) {
+    bin.~Binomial();
+    return sizeof(*this);
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-1.3.1/gecode/set/dom.cc

@@ -0,0 +1,224 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-04-11 15:58:37 +0200 (Tue, 11 Apr 2006) $ by $Author: tack $
+ *     $Revision: 3188 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#include "gecode/set.hh"
+#include "gecode/iter.hh"
+#include "gecode/set/rel.hh"
+
+namespace Gecode {
+
+  void
+  dom(Space* home, SetVar s, SetRelType r, int i) {
+    IntSet d(i,i);
+    dom(home, s, r, d);
+  }
+
+  void
+  dom(Space* home, SetVar s, SetRelType r, int i, int j) {
+    IntSet d(i,j);
+    dom(home, s, r, d);
+  }
+
+  void
+  dom(Space* home, SetVar s, SetRelType r, const IntSet& is) {
+    if (home->failed()) return;
+
+    Set::SetView _s(s);
+
+    switch(r) {
+    case SRT_EQ:
+      {
+	if (is.size() == 1) {
+	  GECODE_ME_FAIL(home,_s.include(home, is.min(), is.max()));
+	  GECODE_ME_FAIL(home,_s.intersect(home, is.min(), is.max()));
+	} else {
+	  IntSetRanges rd1(is);
+	  GECODE_ME_FAIL(home,_s.includeI(home, rd1));
+	  IntSetRanges rd2(is);
+	  GECODE_ME_FAIL(home,_s.intersectI(home, rd2));
+	}
+      }
+      break;
+    case SRT_DISJ:
+      {
+	if (is.size() == 1) {
+	  GECODE_ME_FAIL(home,_s.exclude(home, is.min(), is.max()));
+	} else {
+	  IntSetRanges rd(is);
+	  GECODE_ME_FAIL(home,_s.excludeI(home, rd));
+	}
+      }
+      break;
+    case SRT_NQ:
+	if (is.size() == 1) {
+	  GECODE_ME_FAIL(home,_s.exclude(home, is.min(), is.max()));
+	} else {
+	  Set::ConstantView cv(home, is);
+	  GECODE_ES_FAIL(home,
+			 (Set::Rel::Distinct<Set::SetView,
+			  Set::ConstantView>::post(home, s, cv)));
+	}
+      break;
+    case SRT_SUB:
+      {
+ 	if (is.size() == 1) {
+ 	  GECODE_ME_FAIL(home,_s.intersect(home, is.min(), is.max()));
+ 	} else {
+	  IntSetRanges rd(is);
+	  GECODE_ME_FAIL(home,_s.intersectI(home, rd));
+ 	}
+      }
+      break;
+    case SRT_SUP:
+      {
+	if (is.size() == 1) {
+	  GECODE_ME_FAIL(home,_s.include(home, is.min(), is.max()));
+	} else {
+	  IntSetRanges rd(is);
+	  GECODE_ME_FAIL(home,_s.includeI(home, rd));
+	}
+      }
+      break;
+    case SRT_CMPL:
+      {
+	if (is.size() == 1) {
+	  GECODE_ME_FAIL(home,_s.exclude(home, is.min(), is.max()));
+	  GECODE_ME_FAIL(home,
+			 _s.include(home,
+				    Limits::Set::int_min,
+				    is.min()-1) );
+	  GECODE_ME_FAIL(home,
+			 _s.include(home, is.max()+1,
+				    Limits::Set::int_max) );
+	} else {
+	  IntSetRanges rd1(is);
+	  Set::RangesCompl<IntSetRanges > rdC1(rd1);
+	  GECODE_ME_FAIL(home,_s.includeI(home, rdC1));
+	  IntSetRanges rd2(is);
+	  Set::RangesCompl<IntSetRanges > rdC2(rd2);
+	  GECODE_ME_FAIL(home,_s.intersectI(home, rdC2));
+	}
+      }
+      break;
+    }
+  }
+
+  void
+  dom(Space* home, SetVar s, SetRelType r, int i, BoolVar b) {
+    IntSet d(i,i);
+    dom(home, s, r, d, b);
+  }
+
+  void
+  dom(Space* home, SetVar s, SetRelType r, int i, int j, BoolVar b) {
+    IntSet d(i,j);
+    dom(home, s, r, d, b);
+  }
+
+  void
+  dom(Space* home, SetVar s, SetRelType r, const IntSet& is, BoolVar b) {
+    if (home->failed()) return;
+    switch(r) {
+    case SRT_EQ:
+      {
+	Set::ConstantView cv(home, is);
+	GECODE_ES_FAIL(home,
+		       (Set::Rel::ReEq<Set::SetView,
+			Set::ConstantView>::post(home, s, cv, b)));
+      }
+      break;
+    case SRT_NQ:
+      {
+	BoolVar notb(home,0,1);
+	bool_not(home, b, notb);
+	Set::ConstantView cv(home, is);
+	GECODE_ES_FAIL(home,
+		       (Set::Rel::ReEq<Set::SetView,
+			Set::ConstantView>::post(home, s, cv, notb)));
+      }
+      break;
+    case SRT_SUB:
+      {
+	Set::ConstantView cv(home, is);
+	GECODE_ES_FAIL(home,
+		       (Set::Rel::ReSubset<Set::SetView,Set::ConstantView>
+			::post(home, s, cv, b)));
+      }
+      break;
+    case SRT_SUP:
+      {
+	Set::ConstantView cv(home, is);
+	GECODE_ES_FAIL(home,
+		       (Set::Rel::ReSubset<Set::ConstantView,Set::SetView>
+			::post(home, cv, s, b)));
+      }
+      break;
+    case SRT_DISJ:
+      {
+	// x||y <=> b is equivalent to
+	// ( y <= complement(x) and x<=complement(y) ) <=> b
+
+	// set up BoolVars for the conjunction
+	BoolVar b1(home, 0, 1);
+	BoolVar b2(home, 0, 1);
+	bool_and(home, b1, b2, b);	
+
+	// compute complement of is
+	IntSetRanges dr1(is);
+	Set::RangesCompl<IntSetRanges > dc1(dr1);
+	
+	// First conjunct: ( s <= complement(is) ) <=> b1
+	IntSet dcompl(dc1);
+	Set::ConstantView cvcompl(home, dcompl);
+	GECODE_ES_FAIL(home,
+		       (Set::Rel::ReSubset<Set::SetView,Set::ConstantView>
+			::post(home, s, cvcompl, b1)));
+
+	// Second conjunct: ( complement(s) <= d ) <=> b2
+	Set::ConstantView cv(home, is);
+	Set::SetView sv(s);
+	Set::ComplementView<Set::SetView> cs(sv);
+	GECODE_ES_FAIL(home,
+		       (Set::Rel::ReSubset<Set::ConstantView,Set::ComplementView<Set::SetView> >
+			::post(home, cv, cs, b2)));
+
+      }
+      break;
+    case SRT_CMPL:
+      {
+	Set::SetView sv(s);
+	Set::ComplementView<Set::SetView> cs(sv);
+	Set::ConstantView cv(home, is);
+	GECODE_ES_FAIL(home,
+		       (Set::Rel::ReEq<Set::ComplementView<Set::SetView>,
+			Set::ConstantView>
+			::post(home, cs, cv, b)));
+      }
+      break;
+    }
+  }
+
+}
+
+// STATISTICS: set-post