gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/gecode/minimodel/arithmetic.cc

@@ -0,0 +1,137 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2006
+ *
+ *  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"
+
+#include <algorithm>
+
+namespace Gecode {
+
+#define GECODE_MM_RETURN_FAILED			\
+if (home->failed()) {				\
+  IntVar _x(home,0,0); return _x;		\
+}
+
+  IntVar
+  abs(Space* home, IntVar x, IntConLevel icl) {
+    GECODE_MM_RETURN_FAILED;
+    if (x.min() >= 0)
+      return x;
+    IntVar y(home,
+	     std::min(-x.max(),x.min()),
+	     std::max(-x.min(),x.max()));
+    abs(home, x, y, icl);
+    return y;
+  }
+
+  IntVar
+  min(Space* home, IntVar x, IntVar y, IntConLevel icl) {
+    GECODE_MM_RETURN_FAILED;
+    IntVar z(home,
+	     std::min(x.min(),y.min()),
+	     std::min(x.max(),y.max()));
+    min(home, x, y, z, icl);
+    return z;
+  }
+
+  IntVar
+  min(Space* home, const IntVarArgs& x, IntConLevel icl) {
+    GECODE_MM_RETURN_FAILED;
+    int min = Limits::Int::int_max;
+    int max = Limits::Int::int_max;
+    for (int i=x.size(); i--; ) {
+      min = std::min(min,x[i].min());
+      max = std::min(max,x[i].max());
+    }
+    IntVar y(home, min, max);
+    Gecode::min(home, x, y, icl);
+    return y;
+  }
+
+  IntVar
+  max(Space* home, IntVar x, IntVar y, IntConLevel icl) {
+    GECODE_MM_RETURN_FAILED;
+    IntVar z(home,
+	     std::max(x.min(),y.min()),
+	     std::max(x.max(),y.max()));
+    max(home, x, y, z, icl);
+    return z;
+  }
+
+  IntVar
+  max(Space* home, const IntVarArgs& x, IntConLevel icl) {
+    GECODE_MM_RETURN_FAILED;
+    int min = Limits::Int::int_min;
+    int max = Limits::Int::int_min;
+    for (int i=x.size(); i--; ) {
+      min = std::max(min,x[i].min());
+      max = std::max(max,x[i].max());
+    }
+    IntVar y(home, min, max);
+    Gecode::max(home, x, y, icl);
+    return y;
+  }
+
+  IntVar
+  mult(Space* home, IntVar x, IntVar y, IntConLevel icl) {
+    GECODE_MM_RETURN_FAILED;
+    IntVar z(home, Limits::Int::int_min, Limits::Int::int_max);
+    mult(home, x, y, z, icl);
+    return z;
+  }
+
+  IntVar
+  sqr(Space* home, IntVar x, IntConLevel icl) {
+    GECODE_MM_RETURN_FAILED;
+    IntVar y(home, 0, Limits::Int::int_max);
+    mult(home, x, x, y, icl);
+    return y;
+  }
+
+  IntVar
+  plus(Space* home, IntVar x, IntVar y, IntConLevel icl) {
+    GECODE_MM_RETURN_FAILED;
+    IntVar z(home,x.min()+y.min(),x.max()+y.max());
+    Int::Linear::Term ts[3];
+    ts[0].a =  1; ts[0].x = x;
+    ts[1].a =  1; ts[1].x = y;
+    ts[2].a = -1; ts[2].x = z;
+    Int::Linear::post(home, ts, 3, IRT_EQ, 0, icl);
+    return z;
+  }
+
+  IntVar
+  minus(Space* home, IntVar x, IntVar y, IntConLevel icl) {
+    GECODE_MM_RETURN_FAILED;
+    IntVar z(home,x.min()-y.max(),x.max()-y.min());
+    Int::Linear::Term ts[3];
+    ts[0].a =  1; ts[0].x = x;
+    ts[1].a = -1; ts[1].x = y;
+    ts[2].a = -1; ts[2].x = z;
+    Int::Linear::post(home, ts, 3, IRT_EQ, 0, icl);
+    return z;
+  }
+
+#undef GECODE_MM_RETURN_FAILED
+
+}
+
+// STATISTICS: minimodel-any

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

@@ -0,0 +1,207 @@
+/*
+ *  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 {
+
+    bool
+    BoolExpr::Node::decrement(void) {
+      if (--use == 0) {
+	if ((l != NULL) && l->decrement())
+	  delete l;
+	if ((r != NULL) && r->decrement())
+	  delete r;
+	return true;
+      }
+      return false;
+    }
+
+    BoolVar
+    BoolExpr::Node::post(Space* home) const {
+      if (t == BT_VAR)
+	return x;
+      BoolVar b(home,0,1);
+      post(home,b);
+      return b;
+    }
+
+    int
+    BoolExpr::Node::post(Space* home, NodeType t,
+			 BoolVarArgs& b, int i) const {
+      if (this->t != t) {
+	b[i] = post(home);
+	return i+1;
+      } else {
+	return l->post(home,t,b,r->post(home,t,b,i));
+      }
+    }
+
+    void
+    BoolExpr::Node::post(Space* home, BoolVar b) const {
+      assert(t != BT_VAR);
+      switch (t) {
+      case BT_NOT:
+	bool_not(home, l->post(home), b);
+	break;
+      case BT_AND:
+	if (same > 2) {
+	  BoolVarArgs ba(same);
+	  (void) post(home,BT_AND,ba,0);
+	  bool_and(home, ba, b);
+	} else {
+	  bool_and(home, l->post(home), r->post(home), b);
+	}
+	break;
+      case BT_OR:
+	if (same > 2) {
+	  BoolVarArgs ba(same);
+	  (void) post(home,BT_OR,ba,0);
+	  bool_or(home, ba, b);
+	} else {
+	  bool_or(home, l->post(home), r->post(home), b);
+	}
+	break;
+      case BT_IMP:
+	bool_imp(home, l->post(home), r->post(home), b);
+	break;
+      case BT_XOR:
+	bool_xor(home, l->post(home), r->post(home), b);
+	break;
+      case BT_EQV:
+	bool_eqv(home, l->post(home), r->post(home), b);
+	break;
+      default:
+	GECODE_NEVER;
+      case BT_RLIN:
+	rl.post(home,b);
+	break;
+      }
+    }
+
+    void
+    BoolExpr::Node::post(Space* home, bool b) const {
+      if (b) {
+	switch (t) {
+	case BT_VAR:
+	  rel(home, x, IRT_EQ, 1);
+	  break;
+	case BT_NOT:
+	  l->post(home,false);
+	  break;
+	case BT_OR:
+	  if (same > 2) {
+	    BoolVarArgs ba(same);
+	    (void) post(home,BT_OR,ba,0);
+	    bool_or(home, ba, true);
+	  } else {
+	    bool_or(home, l->post(home), r->post(home), true);
+	  }
+	  break;
+	case BT_AND:
+	  l->post(home,true);
+	  r->post(home,true);
+	  break;
+	case BT_EQV:
+	  if ((l->t == BT_VAR) && (r->t != BT_VAR)) {
+	    r->post(home,l->x);
+	  } else if ((l->t != BT_VAR) && (r->t == BT_VAR)) {
+	    l->post(home,r->x);
+	  } else if ((l->t != BT_VAR) && (r->t != BT_VAR)) {
+	    BoolVar b(home,0,1);
+	    l->post(home,b);
+	    r->post(home,b);
+	  } else {
+	    BoolVar b(home,1,1);
+	    post(home,b);
+	  }
+	  break;
+	case BT_RLIN:
+	  rl.post(home,true,ICL_DEF);
+	  break;
+	default:
+	  {
+	    BoolVar b(home,1,1);
+	    post(home,b);
+	  }
+	  break;
+	}
+      } else {
+	switch (t) {
+	case BT_VAR:
+	  rel(home, x, IRT_EQ, 0);
+	  break;
+	case BT_NOT:
+	  l->post(home,true);
+	  break;
+	case BT_OR:
+	  l->post(home,false);
+	  r->post(home,false);
+	  break;
+	case BT_AND:
+	  if (same > 2) {
+	    BoolVarArgs ba(same);
+	    (void) post(home,BT_AND,ba,0);
+	    bool_and(home, ba, false);
+	  } else {
+	    bool_and(home, l->post(home), r->post(home), false);
+	  }
+	  break;
+	case BT_IMP:
+	  l->post(home,true);
+	  r->post(home,false);
+	  break;
+	case BT_XOR:
+	  if ((l->t == BT_VAR) && (r->t != BT_VAR)) {
+	    r->post(home,l->x);
+	  } else if ((l->t != BT_VAR) && (r->t == BT_VAR)) {
+	    l->post(home,r->x);
+	  } else if ((l->t != BT_VAR) && (r->t != BT_VAR)) {
+	    BoolVar b(home,0,1);
+	    l->post(home,b);
+	    r->post(home,b);
+	  } else {
+	    BoolVar b(home,0,0);
+	    post(home,b);
+	  }
+	  break;
+	case BT_RLIN:
+	  rl.post(home,false,ICL_DEF);
+	  break;
+	default:
+	  {
+	    BoolVar b(home,0,0);
+	    post(home,b);
+	  }
+	  break;
+	}
+      }
+    }
+
+  }
+
+}
+
+// STATISTICS: minimodel-any

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

@@ -0,0 +1,191 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 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.
+ *
+ */
+
+namespace Gecode { namespace MiniModel {
+
+  /*
+   * Operations for nodes
+   *
+   */
+  forceinline void*
+  BoolExpr::Node::operator new(size_t size) {
+    return Memory::malloc(size);
+  }
+
+  forceinline void
+  BoolExpr::Node::operator delete(void* p, size_t) {
+    Memory::free(p);
+  }
+
+  forceinline
+  BoolExpr::Node::Node(void) : use(1) {};
+
+  /*
+   * Operations for expressions
+   *
+   */
+
+  forceinline
+  BoolExpr::BoolExpr(const BoolExpr& e) : n(e.n) {
+    n->use++;
+  }
+
+  inline
+  BoolExpr::BoolExpr(const BoolVar& x) : n(new Node) {
+    n->same = 1;
+    n->t    = BT_VAR;
+    n->l    = NULL;
+    n->r    = NULL;
+    n->x    = x;
+  }
+
+  inline
+  BoolExpr::BoolExpr(const BoolExpr& l, NodeType t, const BoolExpr& r)
+    : n(new Node) {
+    unsigned int ls = ((l.n->t == t) || l.n->t == BT_VAR) ? l.n->same : 0;
+    unsigned int rs = ((r.n->t == t) || r.n->t == BT_VAR) ? r.n->same : 0;
+    n->same = ls+rs;
+    n->t    = t;
+    n->l    = l.n;
+    n->l->use++;
+    n->r    = r.n;
+    n->r->use++;
+  }
+
+  inline
+  BoolExpr::BoolExpr(const BoolExpr& l, NodeType t)
+    : n(new Node) {
+    assert(t == BT_NOT);
+    n->same = 1;
+    n->t    = BT_NOT;
+    n->l    = l.n;
+    n->l->use++;
+    n->r    = NULL;
+  }
+
+  inline
+  BoolExpr::BoolExpr(const LinRel& rl)
+    : n(new Node) {
+    n->same = 1;
+    n->t    = BT_RLIN;
+    n->l    = NULL;
+    n->r    = NULL;
+    n->rl   = rl;
+  }
+
+
+  inline const BoolExpr&
+  BoolExpr::operator=(const BoolExpr& e) {
+    if (this != &e) {
+      if (n->decrement())
+	delete n;
+      n = e.n;
+      n->use++;
+    }
+    return *this;
+  }
+
+  forceinline
+  BoolExpr::~BoolExpr(void) {
+    if (n->decrement())
+      delete n;
+  }
+
+  forceinline BoolVar
+  BoolExpr::post(Space* home) const {
+    return n->post(home);
+  }
+
+  forceinline void
+  BoolExpr::post(Space* home, bool t) const {
+    n->post(home,t);
+  }
+
+}}
+
+inline Gecode::MiniModel::BoolExpr
+operator&&(const Gecode::MiniModel::BoolExpr& l,
+	   const Gecode::MiniModel::BoolExpr& r) {
+  return Gecode::MiniModel::BoolExpr(l,
+				     Gecode::MiniModel::BoolExpr::BT_AND,
+				     r);
+}
+
+inline Gecode::MiniModel::BoolExpr
+operator||(const Gecode::MiniModel::BoolExpr& l,
+	   const Gecode::MiniModel::BoolExpr& r) {
+  return Gecode::MiniModel::BoolExpr(l,
+				     Gecode::MiniModel::BoolExpr::BT_OR,
+				     r);
+}
+
+inline Gecode::MiniModel::BoolExpr
+operator^(const Gecode::MiniModel::BoolExpr& l,
+	  const Gecode::MiniModel::BoolExpr& r) {
+  return Gecode::MiniModel::BoolExpr(l,
+				     Gecode::MiniModel::BoolExpr::BT_XOR,
+				     r);
+}
+
+inline Gecode::MiniModel::BoolExpr
+operator~(const Gecode::MiniModel::LinRel& rl) {
+  return Gecode::MiniModel::BoolExpr(rl);
+}
+
+inline Gecode::MiniModel::BoolExpr
+operator!(const Gecode::MiniModel::BoolExpr& e) {
+  return Gecode::MiniModel::BoolExpr(e,
+				     Gecode::MiniModel::BoolExpr::BT_NOT);
+}
+
+namespace Gecode {
+
+  inline MiniModel::BoolExpr
+  eqv(const MiniModel::BoolExpr& l,
+      const MiniModel::BoolExpr& r) {
+    return MiniModel::BoolExpr(l,
+			       MiniModel::BoolExpr::BT_EQV,
+			       r);
+  }
+
+  inline MiniModel::BoolExpr
+  imp(const MiniModel::BoolExpr& l,
+      const MiniModel::BoolExpr& r) {
+    return MiniModel::BoolExpr(l,
+			       MiniModel::BoolExpr::BT_IMP,
+			       r);
+  }
+
+
+  inline BoolVar
+  post(Space* home, const MiniModel::BoolExpr& e, IntConLevel) {
+    return e.post(home);
+  }
+
+  inline BoolVar
+  post(Space* home, const BoolVar& b, IntConLevel) {
+    return b;
+  }
+
+
+}
+
+// STATISTICS: minimodel-any