gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,115 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3512 $
+ *
+ *  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/int.hh"
+
+#include "gecode/support/sort.hh"
+
+namespace Gecode {
+
+  /// Sort ranges according to increasing minimum
+  class IntSet::MinInc {
+  public:
+    bool operator()(const Range &x, const Range &y);
+  };
+
+  forceinline bool
+  IntSet::MinInc::operator()(const Range &x, const Range &y) {
+    return x.min < y.min;
+  }
+
+  void
+  IntSet::normalize(int n) {
+    // Sort ranges
+    MinInc lt_mi;
+    Support::quicksort<Range>(&sar[0], n, lt_mi);
+    // Conjoin continuous ranges
+    int min = sar[0].min;
+    int max = sar[0].max;
+    int i = 1;
+    int j = 0;
+    while (i < n) {
+      if (max+1 < sar[i].min) {
+	sar[j].min = min; sar[j].max = max; j++;
+	min = sar[i].min; max = sar[i].max; i++;
+      } else {
+	max = std::max(max,sar[i].max); i++;
+      }
+    }
+    sar[j].min = min; sar[j].max = max;
+    sar.size(j+1);
+  }
+
+  void
+  IntSet::init(const int r[], int n) {
+    if (n>0) {
+      for (int i = n; i--; ) {
+	sar[i].min=r[i]; sar[i].max=r[i];
+      }
+      normalize(n);
+    }
+  }
+
+  void
+  IntSet::init(const int r[][2], int n) {
+    if (n>0) {
+      int j = 0;
+      for (int i = 0; i < n; i++)
+	if (r[i][0] <= r[i][1]) {
+	  sar[j].min=r[i][0]; sar[j].max=r[i][1]; j++;
+	}
+      normalize(j);
+    }
+  }
+
+  void
+  IntSet::init(int n, int m) {
+    if (n <= m) {
+      sar[0].min = n; sar[0].max = m;
+    } else {
+      sar.size(0);
+    }
+  }
+
+  const IntSet IntSet::empty;
+
+}
+
+std::ostream&
+operator<<(std::ostream& os, const Gecode::IntSet& is) {
+  os << '<';
+  for (int i = 0; i < is.size(); ) {
+    int min = is.min(i);
+    int max = is.max(i);
+    if (min == max)
+      os << min;
+    else
+      os << min << ".." << max;
+    i++;
+    if (i < is.size())
+      os << ',';
+  }
+  return os << '>';
+}
+
+
+// STATISTICS: int-var
+

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

@@ -0,0 +1,151 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2003
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:03:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3512 $
+ *
+ *  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 {
+
+  /*
+   * Integer sets
+   *
+   */
+
+  forceinline
+  IntSet::IntSet(void) {}
+
+  forceinline
+  IntSet::IntSet(const IntSet& s) : sar(s.sar) {}
+
+  template <class I>
+  forceinline
+  IntSet::IntSet(I& i) {
+    int j=0;
+    while (i()) {
+      sar.ensure(j+1);
+      sar[j].min = i.min(); sar[j].max = i.max();
+      ++j; ++i;
+    }
+    sar.size(j);
+  }
+
+  forceinline
+  IntSet::IntSet(const int r[][2], int n) : sar(n) { init(r,n); }
+
+  forceinline
+  IntSet::IntSet(const int r[], int n) : sar(n) { init(r,n); }
+
+  forceinline
+  IntSet::IntSet(int n, int m) : sar(1) { init(n,m); }
+
+  forceinline void
+  IntSet::update(bool share, IntSet& s) {
+    sar.update(share, s.sar);
+  }
+
+  forceinline int
+  IntSet::min(int i) const {
+    return sar[i].min;
+  }
+
+  forceinline int
+  IntSet::max(int i) const {
+    return sar[i].max;
+  }
+
+  forceinline unsigned int
+  IntSet::width(int i) const {
+    return sar[i].max-sar[i].min+1;
+  }
+
+  forceinline int
+  IntSet::size(void) const {
+    return sar.size();
+  }
+
+  forceinline int
+  IntSet::min(void) const {
+    return sar[0].min;
+  }
+
+  forceinline int
+  IntSet::max(void) const {
+    return sar[sar.size()-1].max;
+  }
+
+
+  /*
+   * Range iterator for integer sets
+   *
+   */
+
+  forceinline
+  IntSetRanges::IntSetRanges(void) {}
+  forceinline
+  IntSetRanges::IntSetRanges(const IntSet& s)
+    : i(&s.sar[0]), e(&s.sar[s.size()]) {}
+  forceinline void
+  IntSetRanges::init(const IntSet& s) {
+    i = &s.sar[0]; e = &s.sar[s.size()];
+  }
+
+  forceinline void
+  IntSetRanges::operator++(void) {
+    i++;
+  }
+  forceinline bool
+  IntSetRanges::operator()(void) const {
+    return i<e;
+  }
+
+  forceinline int
+  IntSetRanges::min(void) const {
+    return i->min;
+  }
+  forceinline int
+  IntSetRanges::max(void) const {
+    return i->max;
+  }
+  forceinline unsigned int
+  IntSetRanges::width(void) const {
+    return i->max - i->min +1;
+  }
+
+  /*
+   * Value iterator for integer sets
+   *
+   */
+  forceinline
+  IntSetValues::IntSetValues(void) {}
+
+  forceinline
+  IntSetValues::IntSetValues(const IntSet& s) {
+    IntSetRanges r(s);
+    Iter::Ranges::ToValues<IntSetRanges>::init(r);
+  }
+
+  forceinline void
+  IntSetValues::init(const IntSet& s) {
+    IntSetRanges r(s);
+    Iter::Ranges::ToValues<IntSetRanges>::init(r);
+  }
+
+}
+
+// STATISTICS: int-var
+

data/ext/gecode-1.3.1/gecode/int/linear.cc

@@ -0,0 +1,247 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-08-08 12:17:23 +0200 (Tue, 08 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3533 $
+ *
+ *  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/int/linear.hh"
+
+namespace Gecode {
+
+  using namespace Int;
+
+  /*
+   * Exported post functions
+   *
+   */
+
+  void
+  linear(Space* home,
+	 const IntVarArgs& x, IntRelType r, int c, IntConLevel icl) {
+    if (home->failed()) return;
+    GECODE_AUTOARRAY(Linear::Term, t, x.size());
+    for (int i = x.size(); i--; ) {
+      t[i].a=1; t[i].x=x[i];
+    }
+    Linear::post(home,t,x.size(),r,c,icl);
+  }
+
+  void
+  linear(Space* home,
+	 const IntVarArgs& x, IntRelType r, int c, BoolVar b, IntConLevel icl) {
+    if (home->failed()) return;
+    GECODE_AUTOARRAY(Linear::Term, t, x.size());
+    for (int i = x.size(); i--; ) {
+      t[i].a=1; t[i].x=x[i];
+    }
+    Linear::post(home,t,x.size(),r,c,b);
+  }
+
+  void
+  linear(Space* home,
+	 const IntArgs& a, const IntVarArgs& x, IntRelType r, int c,
+	 IntConLevel icl) {
+    if (a.size() != x.size())
+      throw ArgumentSizeMismatch("Int::linear");
+    if (home->failed()) return;
+    GECODE_AUTOARRAY(Linear::Term, t, x.size());
+    for (int i = x.size(); i--; ) {
+      t[i].a=a[i]; t[i].x=x[i];
+    }
+    Linear::post(home,t,x.size(),r,c,icl);
+  }
+
+  void
+  linear(Space* home,
+	 const IntArgs& a, const IntVarArgs& x, IntRelType r, int c, BoolVar b,
+	 IntConLevel) {
+    if (a.size() != x.size())
+      throw ArgumentSizeMismatch("Int::linear");
+    if (home->failed()) return;
+    GECODE_AUTOARRAY(Linear::Term, t, x.size());
+    for (int i = x.size(); i--; ) {
+      t[i].a=a[i]; t[i].x=x[i];
+    }
+    Linear::post(home,t,x.size(),r,c,b);
+  }
+
+  void
+  linear(Space* home,
+	 const IntVarArgs& x, IntRelType r, IntVar y, IntConLevel icl) {
+    if (home->failed()) return;
+    GECODE_AUTOARRAY(Linear::Term, t, x.size()+1);
+    for (int i = x.size(); i--; ) {
+      t[i].a=1; t[i].x=x[i];
+    }
+    t[x.size()].a=-1; t[x.size()].x=y;
+    Linear::post(home,t,x.size()+1,r,0,icl);
+  }
+
+  void
+  linear(Space* home,
+	 const IntVarArgs& x, IntRelType r, IntVar y, BoolVar b,
+	 IntConLevel) {
+    if (home->failed()) return;
+    GECODE_AUTOARRAY(Linear::Term, t, x.size()+1);
+    for (int i = x.size(); i--; ) {
+      t[i].a=1; t[i].x=x[i];
+    }
+    t[x.size()].a=-1; t[x.size()].x=y;
+    Linear::post(home,t,x.size()+1,r,0,b);
+  }
+
+  void
+  linear(Space* home,
+	 const IntArgs& a, const IntVarArgs& x, IntRelType r, IntVar y,
+	 IntConLevel icl) {
+    if (a.size() != x.size())
+      throw ArgumentSizeMismatch("Int::linear");
+    if (home->failed()) return;
+    GECODE_AUTOARRAY(Linear::Term, t, x.size()+1);
+    for (int i = x.size(); i--; ) {
+      t[i].a=a[i]; t[i].x=x[i];
+    }
+    t[x.size()].a=-1; t[x.size()].x=y;
+    Linear::post(home,t,x.size()+1,r,0,icl);
+  }
+
+  void
+  linear(Space* home,
+	 const IntArgs& a, const IntVarArgs& x, IntRelType r, IntVar y,
+	 BoolVar b, IntConLevel) {
+    if (a.size() != x.size())
+      throw ArgumentSizeMismatch("Int::linear");
+    if (home->failed()) return;
+    GECODE_AUTOARRAY(Linear::Term, t, x.size()+1);
+    for (int i = x.size(); i--; ) {
+      t[i].a=a[i]; t[i].x=x[i];
+    }
+    t[x.size()].a=-1; t[x.size()].x=y;
+    Linear::post(home,t,x.size()+1,r,0,b);
+  }
+
+
+  void
+  linear(Space* home, const BoolVarArgs& x, IntRelType r, int c,
+	 IntConLevel) {
+    if (home->failed()) return;
+    switch (r) {
+    case IRT_EQ:
+      {
+	ViewArray<BoolView> xv(home,x);
+	GECODE_ES_FAIL(home,Linear::EqBoolInt<BoolView>::post(home,xv,c));
+	break;
+      }
+    case IRT_NQ:
+      {
+	ViewArray<BoolView> xv(home,x);
+	GECODE_ES_FAIL(home,Linear::NqBoolInt<BoolView>::post(home,xv,c));
+	break;
+      }
+    case IRT_GQ:
+      {
+	ViewArray<BoolView> xv(home,x);
+	GECODE_ES_FAIL(home,Linear::GqBoolInt<BoolView>::post(home,xv,c));
+	break;
+      }
+    case IRT_GR:
+      {
+	ViewArray<BoolView> xv(home,x);
+	GECODE_ES_FAIL(home,Linear::GqBoolInt<BoolView>::post(home,xv,c+1));
+	break;
+      }
+    case IRT_LQ:
+      {
+	ViewArray<NegBoolView> xv(home,x.size());
+	for (int i=x.size(); i--; ) {
+	  BoolView y(x[i]); xv[i] = y;
+	}
+	GECODE_ES_FAIL(home,Linear::GqBoolInt<NegBoolView>
+		       ::post(home,xv,x.size()-c));
+	break;
+      }
+    case IRT_LE:
+      {
+	ViewArray<NegBoolView> xv(home,x.size());
+	for (int i=x.size(); i--; ) {
+	  BoolView y(x[i]); xv[i] = y;
+	}
+	GECODE_ES_FAIL(home,Linear::GqBoolInt<NegBoolView>
+		       ::post(home,xv,x.size()-c+1));
+	break;
+      }
+    default:
+      throw UnknownRelation("Int::linear");
+    }
+  }
+
+  void
+  linear(Space* home, const BoolVarArgs& x, IntRelType r, IntVar y,
+	 IntConLevel) {
+    if (home->failed()) return;
+    ViewArray<BoolView> xv(home,x);
+    switch (r) {
+    case IRT_EQ:
+      GECODE_ES_FAIL(home,(Linear::EqBoolView<BoolView,IntView>
+			   ::post(home,xv,y,0)));
+      break;
+    case IRT_NQ:
+      GECODE_ES_FAIL(home,(Linear::NqBoolView<BoolView,IntView>
+			   ::post(home,xv,y,0)));
+      break;
+    case IRT_LQ:
+      {
+	int n = x.size();
+	ViewArray<NegBoolView> xv(home,n);
+	for (int i=n; i--; ) {
+	  BoolView y(x[i]); xv[i]=y;
+	}
+	MinusView my(y);
+	GECODE_ES_FAIL(home,(Linear::GqBoolView<NegBoolView,MinusView>
+			     ::post(home,xv,my,n)));
+	break;
+      }
+    case IRT_LE:
+      {
+	int n = x.size();
+	ViewArray<NegBoolView> xv(home,n);
+	for (int i=n; i--; ) {
+	  BoolView y(x[i]); xv[i]=y;
+	}
+	MinusView my(y);
+	GECODE_ES_FAIL(home,(Linear::GqBoolView<NegBoolView,MinusView>
+			     ::post(home,xv,my,n+1)));
+	break;
+      }
+    case IRT_GQ:
+      GECODE_ES_FAIL(home,(Linear::GqBoolView<BoolView,IntView>
+			   ::post(home,xv,y,0)));
+      break;
+    case IRT_GR:
+      GECODE_ES_FAIL(home,(Linear::GqBoolView<BoolView,IntView>
+			   ::post(home,xv,y,1)));
+      break;
+    default:
+      throw UnknownRelation("Int::linear");
+    }
+  }
+
+}
+
+// STATISTICS: int-post
+