gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/minimodel/bool-rel.icc

@@ -0,0 +1,66 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:05:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3513 $
+ *
+ *  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 MiniModel {
+
+    /*
+     * Operations for Boolean relations
+     *
+     */
+    forceinline
+    BoolRel::BoolRel(const BoolExpr& e0, bool t0)
+      : e(e0), t(t0) {}
+
+    forceinline void
+    BoolRel::post(Space* home) const {
+      e.post(home,t);
+    }
+
+  }
+
+  /*
+   * Construction of linear relations
+   *
+   */
+  inline MiniModel::BoolRel
+  tt(const MiniModel::BoolExpr& e) {
+    return MiniModel::BoolRel(e,true);
+  }
+  inline MiniModel::BoolRel
+  ff(const MiniModel::BoolExpr& e) {
+    return MiniModel::BoolRel(e,false);
+  }
+
+  /*
+   * Posting
+   *
+   */
+  inline void
+  post(Space* home, const MiniModel::BoolRel& r, IntConLevel) {
+    if (home->failed()) return;
+    r.post(home);
+  }
+
+}
+
+// STATISTICS: minimodel-any

data/ext/gecode-1.3.1/gecode/minimodel/exception.icc

@@ -0,0 +1,59 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *     Mikael Lagerkvist, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:05:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3513 $
+ *
+ *  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 MiniModel {
+
+  /**
+   * \defgroup FuncThrowMiniModel MiniModel exceptions
+   * \ingroup FuncThrow
+   */
+
+  //@{
+
+  /// %Exception: Sizes of arguments does not match
+  class ArgumentSizeMismatch : public Exception  {
+  public:
+    /// Initialize with location \a l
+    ArgumentSizeMismatch(const char* l);
+  };
+
+  /// %Exception: Argument out of range
+  class ArgumentOutOfRange : public Exception  {
+  public:
+    /// Initialize with location \a l
+    ArgumentOutOfRange(const char* l);
+  };
+
+  //@}
+
+  inline
+  ArgumentSizeMismatch::ArgumentSizeMismatch(const char* l)
+    : Exception(l,"Sizes of argument arrays mismatch") {}
+
+  inline
+  ArgumentOutOfRange::ArgumentOutOfRange(const char* l)
+    : Exception(l,"Argument out of range") {}
+
+}}
+
+// STATISTICS: minimodel-any

data/ext/gecode-1.3.1/gecode/minimodel/lin-expr.cc

@@ -0,0 +1,103 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:05:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3513 $
+ *
+ *  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/minimodel.hh"
+
+namespace Gecode {
+
+  namespace MiniModel {
+
+    /*
+     * Operations for linear expressions
+     *
+     */
+
+    bool
+    LinExpr::Node::decrement(void) {
+      if (--use == 0) {
+	if (left != NULL) {
+	  if (left->decrement())
+	    delete left;
+	  if (right->decrement())
+	    delete right;
+	}
+	return true;
+      }
+      return false;
+    }
+
+    int
+    LinExpr::Node::fill(Int::Linear::Term t[], int i, int m) const {
+      if (left != NULL) {
+	return right->fill(t, left->fill(t, i, signLeft*m), signRight*m);
+      } else {
+	t[i].a=m*a; t[i].x=x;
+	return i+1;
+      }
+    }
+
+    void
+    LinExpr::post(Space* home, IntRelType irt, IntConLevel icl) const {
+      GECODE_AUTOARRAY(Int::Linear::Term, ts, n);
+      (void) ax->fill(ts,0,sign);
+      Int::Linear::post(home, ts, n, irt, sign*-c, icl);
+    }
+
+    void
+    LinExpr::post(Space* home, IntRelType irt, const BoolVar& b) const {
+      GECODE_AUTOARRAY(Int::Linear::Term, ts, n);
+      (void) ax->fill(ts,0,sign);
+      Int::Linear::post(home, ts, n, irt, sign*-c, b);
+    }
+
+    IntVar
+    LinExpr::post(Space* home, IntConLevel icl) const {
+      GECODE_AUTOARRAY(Int::Linear::Term, ts, n+1);
+      (void) ax->fill(ts,0,sign);
+      double min = sign*-c;
+      double max = sign*-c;
+      for (int i=n; i--; )
+	if (ts[i].a > 0) {
+	  min += ts[i].a*ts[i].x.min();
+	  max += ts[i].a*ts[i].x.max();
+	} else {
+	  max += ts[i].a*ts[i].x.min();
+	  min += ts[i].a*ts[i].x.max();
+	}
+      if (min < Limits::Int::int_min)
+	min = Limits::Int::int_min;
+      if (max > Limits::Int::int_max)
+	max = Limits::Int::int_max;
+      IntVar x(home, static_cast<int>(min), static_cast<int>(max));
+      ts[n].x = x;
+      ts[n].a = -1;
+      Int::Linear::post(home, ts, n+1, IRT_EQ, sign*-c, icl);
+      return x;
+    }
+
+
+  }
+
+}
+
+// STATISTICS: minimodel-any

data/ext/gecode-1.3.1/gecode/minimodel/lin-expr.icc

@@ -0,0 +1,192 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2006-08-23 13:12:00 +0200 (Wed, 23 Aug 2006) $ by $Author: tack $
+ *     $Revision: 3553 $
+ *
+ *  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 MiniModel {
+
+  /*
+   * Operations for nodes
+   *
+   */
+  forceinline void*
+  LinExpr::Node::operator new(size_t size) {
+    return Memory::malloc(size);
+  }
+
+  forceinline void
+  LinExpr::Node::operator delete(void* p, size_t) {
+    Memory::free(p);
+  }
+
+
+  forceinline void
+  LinExpr::Node::increment(void) {
+    ++use;
+  }
+
+  forceinline
+  LinExpr::Node::Node(int a, const IntVar& x) :
+    use(1),
+    left(NULL), right(NULL), signLeft(0), signRight(0),
+    a(a), x(x) {}
+
+  forceinline
+  LinExpr::Node::Node(Node* l, int sL, Node* r, int sR) :
+    use(1),
+    left(l), right(r), signLeft(sL), signRight(sR) {
+    left->increment();
+    right->increment();
+  }
+
+  /*
+   * Operations for expressions
+   *
+   */
+
+  forceinline
+  LinExpr::LinExpr(void)
+    : ax(NULL), n(0) {}
+
+  inline
+  LinExpr::LinExpr(const IntVar& x, int a, int c0) :
+    ax(new Node(a, x)), n(1), c(c0), sign(1) {
+  }
+
+  inline
+  LinExpr::LinExpr(const LinExpr& t1, const LinExpr& t2, int m) :
+    ax(new Node(t1.ax, t1.sign, t2.ax, t2.sign*m)),
+    n(t1.n+t2.n),
+    c(t1.c+m*t2.c), sign(1) {}
+
+  forceinline
+  LinExpr::LinExpr(const LinExpr& t, int c0, int sign) :
+    ax(t.ax), n(t.n), c(sign*t.c+c0), sign(t.sign*sign) {
+    ax->increment();
+  }
+
+  forceinline
+  LinExpr::LinExpr(int a, const LinExpr& t) :
+    ax(t.ax), n(t.n), c(a*t.c), sign(a*t.sign) {
+    ax->increment();
+  }
+
+  inline const LinExpr&
+  LinExpr::operator=(const LinExpr& t) {
+    if (this != &t) {
+      if ((ax != NULL) && ax->decrement())
+	delete ax;
+      n    = t.n;
+      ax   = t.ax;
+      c    = t.c;
+      sign = t.sign;
+      ax->increment();
+    }
+    return *this;
+  }
+
+  forceinline
+  LinExpr::~LinExpr(void) {
+    if ((ax != NULL) && ax->decrement())
+      delete ax;
+  }
+
+}}
+
+inline Gecode::MiniModel::LinExpr
+operator+(int c,
+	  const Gecode::MiniModel::LinExpr& t) {
+  return Gecode::MiniModel::LinExpr(t,c,1);
+}
+inline Gecode::MiniModel::LinExpr
+operator+(const Gecode::MiniModel::LinExpr& t,
+	  int c) {
+  return Gecode::MiniModel::LinExpr(t,c,1);
+}
+inline Gecode::MiniModel::LinExpr
+operator+(const Gecode::MiniModel::LinExpr& t1,
+	  const Gecode::MiniModel::LinExpr& t2) {
+  return Gecode::MiniModel::LinExpr(t1,t2,1);
+}
+
+
+inline Gecode::MiniModel::LinExpr
+operator-(int c,
+	  const Gecode::MiniModel::LinExpr& t) {
+  return Gecode::MiniModel::LinExpr(t, c, -1);
+}
+inline Gecode::MiniModel::LinExpr
+operator-(const Gecode::MiniModel::LinExpr& t,
+	  int c) {
+  return Gecode::MiniModel::LinExpr(t, -c, 1);
+}
+inline Gecode::MiniModel::LinExpr
+operator-(const Gecode::MiniModel::LinExpr& t1,
+	  const Gecode::MiniModel::LinExpr& t2) {
+  return Gecode::MiniModel::LinExpr(t1, t2, -1);
+}
+
+
+inline Gecode::MiniModel::LinExpr
+operator-(const Gecode::MiniModel::LinExpr& t) {
+  return Gecode::MiniModel::LinExpr(t,0,-1);
+}
+
+
+inline Gecode::MiniModel::LinExpr
+operator*(int a, const Gecode::IntVar& x) {
+  return Gecode::MiniModel::LinExpr(x,a);
+}
+inline Gecode::MiniModel::LinExpr
+operator*(const Gecode::IntVar& x, int a) {
+  return Gecode::MiniModel::LinExpr(x,a);
+}
+inline Gecode::MiniModel::LinExpr
+operator*(const Gecode::MiniModel::LinExpr& t, int a) {
+  return Gecode::MiniModel::LinExpr(a,t);
+}
+inline Gecode::MiniModel::LinExpr
+operator*(int a, const Gecode::MiniModel::LinExpr& t) {
+  return Gecode::MiniModel::LinExpr(a,t);
+}
+
+namespace Gecode {
+
+  forceinline IntVar
+  post(Space* home, const IntVar& x, IntConLevel) {
+    return x;
+  }
+
+  inline IntVar
+  post(Space* home, int n, IntConLevel) {
+    IntVar x(home, n, n);
+    return x;
+  }
+
+  inline IntVar
+  post(Space* home, const MiniModel::LinExpr& e, IntConLevel icl) {
+    if (!home->failed())
+      return e.post(home,icl);
+    IntVar x(home,Limits::Int::int_min,Limits::Int::int_max);
+    return x;
+  }
+
+}
+
+// STATISTICS: minimodel-any

data/ext/gecode-1.3.1/gecode/minimodel/lin-rel.icc

@@ -0,0 +1,200 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-08-04 16:05:26 +0200 (Fri, 04 Aug 2006) $ by $Author: schulte $
+ *     $Revision: 3513 $
+ *
+ *  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 MiniModel {
+
+    /*
+     * Operations for linear expressions
+     *
+     */
+    forceinline
+    LinRel::LinRel(void) {}
+
+    forceinline
+    LinRel::LinRel(const LinExpr& l, IntRelType irt0, const LinExpr& r)
+      : e(l,r,-1), irt(irt0) {}
+
+    forceinline
+    LinRel::LinRel(const LinExpr& l, IntRelType irt0, int r)
+      : e(l,-r,1), irt(irt0) {}
+
+    forceinline
+    LinRel::LinRel(int l, IntRelType irt0, const LinExpr& r)
+      : e(r,-l,-1), irt(irt0) {}
+
+    forceinline IntRelType
+    LinRel::neg(IntRelType irt) {
+      switch (irt) {
+      case IRT_EQ: return IRT_NQ;
+      case IRT_NQ: return IRT_EQ;
+      case IRT_LQ: return IRT_GR;
+      case IRT_LE: return IRT_GQ;
+      case IRT_GQ: return IRT_LE;
+      case IRT_GR:
+      default:
+	assert(irt == IRT_GR);
+      }
+      return IRT_LQ;
+    }
+
+    inline void
+    LinRel::post(Space* home, bool t, IntConLevel icl) const {
+      if (t) {
+	e.post(home,irt,icl);
+      } else {
+	e.post(home,neg(irt),icl);
+      }
+    }
+
+    forceinline void
+    LinRel::post(Space* home, const BoolVar& b) const {
+      e.post(home,irt,b);
+    }
+
+  }
+
+}
+
+/*
+ * Construction of linear relations
+ *
+ */
+inline Gecode::MiniModel::LinRel
+operator==(int l,
+	   const Gecode::MiniModel::LinExpr& r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_EQ,r);
+}
+inline Gecode::MiniModel::LinRel
+operator==(const Gecode::MiniModel::LinExpr& l,
+	   int r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_EQ,r);
+}
+inline Gecode::MiniModel::LinRel
+operator==(const Gecode::MiniModel::LinExpr& l,
+	   const Gecode::MiniModel::LinExpr& r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_EQ,r);
+}
+
+inline Gecode::MiniModel::LinRel
+operator!=(int l,
+	   const Gecode::MiniModel::LinExpr& r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_NQ,r);
+}
+inline Gecode::MiniModel::LinRel
+operator!=(const Gecode::MiniModel::LinExpr& l,
+	   int r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_NQ,r);
+}
+inline Gecode::MiniModel::LinRel
+operator!=(const Gecode::MiniModel::LinExpr& l,
+	   const Gecode::MiniModel::LinExpr& r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_NQ,r);
+}
+
+inline Gecode::MiniModel::LinRel
+operator<(int l,
+	  const Gecode::MiniModel::LinExpr& r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_LE,r);
+}
+inline Gecode::MiniModel::LinRel
+operator<(const Gecode::MiniModel::LinExpr& l,
+	  int r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_LE,r);
+}
+inline Gecode::MiniModel::LinRel
+operator<(const Gecode::MiniModel::LinExpr& l,
+	  const Gecode::MiniModel::LinExpr& r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_LE,r);
+}
+
+inline Gecode::MiniModel::LinRel
+operator<=(int l,
+	   const Gecode::MiniModel::LinExpr& r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_LQ,r);
+}
+inline Gecode::MiniModel::LinRel
+operator<=(const Gecode::MiniModel::LinExpr& l,
+	   int r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_LQ,r);
+}
+inline Gecode::MiniModel::LinRel
+operator<=(const Gecode::MiniModel::LinExpr& l,
+	   const Gecode::MiniModel::LinExpr& r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_LQ,r);
+}
+
+inline Gecode::MiniModel::LinRel
+operator>(int l,
+	  const Gecode::MiniModel::LinExpr& r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_GR,r);
+}
+inline Gecode::MiniModel::LinRel
+operator>(const Gecode::MiniModel::LinExpr& l,
+	  int r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_GR,r);
+}
+inline Gecode::MiniModel::LinRel
+operator>(const Gecode::MiniModel::LinExpr& l,
+	  const Gecode::MiniModel::LinExpr& r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_GR,r);
+}
+
+inline Gecode::MiniModel::LinRel
+operator>=(int l,
+	   const Gecode::MiniModel::LinExpr& r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_GQ,r);
+}
+inline Gecode::MiniModel::LinRel
+operator>=(const Gecode::MiniModel::LinExpr& l,
+	   int r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_GQ,r);
+}
+inline Gecode::MiniModel::LinRel
+operator>=(const Gecode::MiniModel::LinExpr& l,
+	   const Gecode::MiniModel::LinExpr& r) {
+  return Gecode::MiniModel::LinRel(l,Gecode::IRT_GQ,r);
+}
+
+
+namespace Gecode {
+
+  /*
+   * Posting
+   *
+   */
+
+  forceinline void
+  post(Space* home, const MiniModel::LinRel& r, IntConLevel icl) {
+    if (home->failed()) return;
+    r.post(home,true,icl);
+  }
+  forceinline void
+  post(Space* home, bool r, IntConLevel) {
+    if (home->failed()) return;
+    if (!r)
+      home->fail();
+  }
+
+}
+
+// STATISTICS: minimodel-any