gecoder-with-gecode 0.7.1 → 0.8.0

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

@@ -0,0 +1,131 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-02-26 10:40:46 +0100 (Tue, 26 Feb 2008) $ by $Author: schulte $
+ *     $Revision: 6311 $
+ *
+ *  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 MiniModel {
+
+  /*
+   * Operations for expressions
+   *
+   */
+
+  forceinline
+  BoolExpr::BoolExpr(const BoolExpr& e) : n(e.n) {
+    n->use++;
+  }
+
+  forceinline BoolVar
+  BoolExpr::post(Space* home, IntConLevel icl, PropKind pk) const {
+    return n->post(home,icl,pk);
+  }
+
+  forceinline void
+  BoolExpr::post(Space* home, bool t, IntConLevel icl, PropKind pk) const {
+    n->post(home,t,icl,pk);
+  }
+
+}}
+
+inline Gecode::MiniModel::BoolExpr
+operator&&(const Gecode::MiniModel::BoolExpr& l,
+           const Gecode::MiniModel::BoolExpr& r) {
+  return Gecode::MiniModel::BoolExpr(l,
+                                     Gecode::MiniModel::BoolExpr::NT_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::NT_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::NT_XOR,
+                                     r);
+}
+
+template <class Var>
+inline Gecode::MiniModel::BoolExpr
+operator~(const Gecode::MiniModel::LinRel<Var>& rl) {
+  return Gecode::MiniModel::BoolExpr(rl);
+}
+
+inline Gecode::MiniModel::BoolExpr
+operator!(const Gecode::MiniModel::BoolExpr& e) {
+  return Gecode::MiniModel::BoolExpr(e,
+                                     Gecode::MiniModel::BoolExpr::NT_NOT);
+}
+
+namespace Gecode {
+
+  inline MiniModel::BoolExpr
+  eqv(const MiniModel::BoolExpr& l,
+      const MiniModel::BoolExpr& r) {
+    return MiniModel::BoolExpr(l,
+                               MiniModel::BoolExpr::NT_EQV,
+                               r);
+  }
+
+  inline MiniModel::BoolExpr
+  imp(const MiniModel::BoolExpr& l,
+      const MiniModel::BoolExpr& r) {
+    return MiniModel::BoolExpr(l,
+                               MiniModel::BoolExpr::NT_IMP,
+                               r);
+  }
+
+
+  inline BoolVar
+  post(Space* home, const MiniModel::BoolExpr& e, 
+       IntConLevel icl, PropKind pk) {
+    return e.post(home,icl,pk);
+  }
+
+  inline BoolVar
+  post(Space*, const BoolVar& b, IntConLevel, PropKind) {
+    return b;
+  }
+
+
+}
+
+// STATISTICS: minimodel-any

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

@@ -0,0 +1,83 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2005
+ *
+ *  Last modified:
+ *     $Date: 2008-02-21 08:37:19 +0100 (Thu, 21 Feb 2008) $ by $Author: schulte $
+ *     $Revision: 6264 $
+ *
+ *  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 MiniModel {
+
+    /*
+     * Operations for Boolean relations
+     *
+     */
+    forceinline
+    BoolRel::BoolRel(const BoolExpr& e0, bool t0)
+      : e(e0), t(t0) {}
+
+    forceinline void
+    BoolRel::post(Space* home, IntConLevel icl, PropKind pk) const {
+      e.post(home,t,icl,pk);
+    }
+
+  }
+
+  /*
+   * 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 icl, PropKind pk) {
+    if (home->failed()) return;
+    r.post(home,icl,pk);
+  }
+
+}
+
+// STATISTICS: minimodel-any

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

@@ -0,0 +1,84 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *     Mikael Lagerkvist, 2005
+ *
+ *  Last modified:
+ *     $Date: 2008-02-25 08:42:39 +0100 (Mon, 25 Feb 2008) $ by $Author: schulte $
+ *     $Revision: 6293 $
+ *
+ *  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 MiniModel {
+
+  /**
+   * \defgroup FuncThrowMiniModel MiniModel exceptions
+   * \ingroup FuncThrow
+   */
+
+  //@{
+  /// %Exception: Too few arguments available in argument array
+  class GECODE_VTABLE_EXPORT TooFewArguments : public Exception  {
+  public:
+    /// Initialize with location \a l
+    TooFewArguments(const char* l);
+  };
+
+  /// %Exception: Sizes of arguments does not match
+  class GECODE_VTABLE_EXPORT ArgumentSizeMismatch : public Exception  {
+  public:
+    /// Initialize with location \a l
+    ArgumentSizeMismatch(const char* l);
+  };
+
+  /// %Exception: Argument out of range
+  class GECODE_VTABLE_EXPORT ArgumentOutOfRange : public Exception  {
+  public:
+    /// Initialize with location \a l
+    ArgumentOutOfRange(const char* l);
+  };
+  //@}
+
+  inline
+  TooFewArguments::TooFewArguments(const char* l)
+    : Exception(l,"Passed argument array has too few elements") {}
+
+  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-2.1.1/gecode/minimodel/lin-expr.icc

@@ -0,0 +1,374 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-02-27 02:25:24 +0100 (Wed, 27 Feb 2008) $ by $Author: schulte $
+ *     $Revision: 6315 $
+ *
+ *  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 MiniModel {
+
+  /*
+   * Operations for nodes
+   *
+   */
+  template <class Var>
+  forceinline
+  LinExpr<Var>::Node::Node(void) : use(1) {
+  }
+  
+  template <class Var>
+  forceinline void*
+  LinExpr<Var>::Node::operator new(size_t size) {
+    return Memory::malloc(size);
+  }
+
+  template <class Var>
+  forceinline void
+  LinExpr<Var>::Node::operator delete(void* p, size_t) {
+    Memory::free(p);
+  }
+
+  template <class Var>
+  bool
+  LinExpr<Var>::Node::decrement(void) {
+    if (--use == 0) {
+      if ((l != NULL) && l->decrement())
+        delete l;
+      if ((r != NULL) && r->decrement())
+        delete r;
+      return true;
+    }
+    return false;
+  }
+  
+  template <class Var>
+  int
+  LinExpr<Var>::Node::fill(Int::Linear::Term<View> t[], 
+                           int i, int m, int c_i, int& c_o) const {
+    switch (this->t) {
+    case NT_VAR:
+      c_o = c_i;
+      if (a != 0) {
+        t[i].a=m*a; t[i].x=x;
+        return i+1;
+      } else {
+        return i;
+      }
+    case NT_ADD:
+      if (l == NULL) {
+        return r->fill(t,i,m,c_i+m*c,c_o);
+      } else {
+        int c_m = 0;
+        i = l->fill(t,i,m,c_i,c_m);
+        return r->fill(t,i,m,c_m,c_o);
+      }
+    case NT_SUB:
+      if (l == NULL) {
+        return r->fill(t,i,-m,c_i+m*c,c_o);
+      } else {
+        int c_m = 0;
+        i = l->fill(t,i,m,c_i,c_m);
+        return r->fill(t,i,-m,c_m,c_o);
+      }
+    case NT_MUL:
+      return l->fill(t,i,a*m,c_i,c_o);
+    default:
+      GECODE_NEVER;
+    }
+    GECODE_NEVER;
+    return 0;
+  }
+
+
+  /*
+   * Operations for expressions
+   *
+   */
+
+  template <class Var>
+  inline
+  LinExpr<Var>::LinExpr(void) :
+    n(new Node) {
+    n->n = 0;
+    n->t = NT_VAR;
+    n->l = n->r = NULL;
+    n->a = 0;
+  }
+  
+  template <class Var>
+  inline
+  LinExpr<Var>::LinExpr(const Var& x, int a) :
+    n(new Node) {
+    n->n = 1;
+    n->t = NT_VAR;
+    n->l = n->r = NULL;
+    n->a = a;
+    n->x = x;
+  }
+  
+  template <class Var>
+  inline
+  LinExpr<Var>::LinExpr(const LinExpr& e0, NodeType t, const LinExpr& e1) :
+    n(new Node) {
+    n->n = e0.n->n+e1.n->n;
+    n->t = t;
+    n->l = e0.n; n->l->use++;
+    n->r = e1.n; n->r->use++;
+  }
+  
+  template <class Var>
+  inline
+  LinExpr<Var>::LinExpr(const LinExpr& e, NodeType t, int c) :
+    n(new Node) {
+    n->n = e.n->n;
+    n->t = t;
+    n->l = NULL;
+    n->r = e.n; n->r->use++;
+    n->c = c;
+  }
+  
+  template <class Var>
+  inline
+  LinExpr<Var>::LinExpr(int a, const LinExpr& e) :
+    n(new Node) {
+    n->n = e.n->n;
+    n->t = NT_MUL;
+    n->l = e.n; n->l->use++;
+    n->r = NULL;
+    n->a = a;
+  }
+  
+  template <class Var>
+  inline
+  LinExpr<Var>::LinExpr(const LinExpr<Var>& e) 
+    : n(e.n) {
+    n->use++;
+  }
+
+  template <class Var>
+  inline const LinExpr<Var>&
+  LinExpr<Var>::operator=(const LinExpr<Var>& e) {
+    if (this != &e) {
+      if (n->decrement())
+        delete n;
+      n = e.n; n->use++;
+    }
+    return *this;
+  }
+
+  template <class Var>
+  forceinline
+  LinExpr<Var>::~LinExpr(void) {
+    if (n->decrement())
+      delete n;
+  }
+
+  template <class Var>
+  inline void
+  LinExpr<Var>::post(Space* home, IntRelType irt, 
+                     IntConLevel icl, PropKind pk) const {
+    GECODE_AUTOARRAY(Int::Linear::Term<View>, ts, n->n);
+    int c_o = 0;
+    int i = n->fill(ts,0,1,0,c_o);
+    Int::Linear::post(home, ts, i, irt, -c_o, icl, pk);
+  }
+
+  template <class Var>
+  inline void
+  LinExpr<Var>::post(Space* home, IntRelType irt, const BoolVar& b,
+                     IntConLevel icl, PropKind pk) const {
+    GECODE_AUTOARRAY(Int::Linear::Term<View>, ts, n->n);
+    int c_o = 0;
+    int i = n->fill(ts,0,1,0,c_o);
+    Int::Linear::post(home, ts, i, irt, -c_o, b, icl, pk);
+  }
+
+  template <>
+  inline IntVar
+  LinExpr<IntVar>::post(Space* home, IntConLevel icl, PropKind pk) const {
+    GECODE_AUTOARRAY(Int::Linear::Term<Int::IntView>, ts, n->n+1);
+    int c_o = 0;
+    int i = n->fill(ts,0,1,0,c_o);
+    int min, max;
+    Int::Linear::estimate(&ts[0],i,c_o,min,max);
+    IntVar x(home, min, max);
+    ts[i].x = x; ts[i].a = -1;
+    Int::Linear::post(home, ts, i+1, IRT_EQ, -c_o, icl, pk);
+    return x;
+  }
+
+  template <>
+  inline IntVar
+  LinExpr<BoolVar>::post(Space* home, IntConLevel icl, PropKind pk) const {
+    GECODE_AUTOARRAY(Int::Linear::Term<Int::BoolView>, ts, n->n+1);
+    int c_o = 0;
+    int i = n->fill(ts,0,1,0,c_o);
+    int min, max;
+    Int::Linear::estimate(&ts[0],i,c_o,min,max);
+    IntVar x(home, min, max);
+    Int::Linear::post(home, ts, i, IRT_EQ, x, -c_o, icl, pk);
+    return x;
+  }
+
+}}
+
+inline Gecode::MiniModel::LinExpr<Gecode::IntVar>
+operator+(int c,
+          const Gecode::MiniModel::LinExpr<Gecode::IntVar>& e) {
+  return Gecode::MiniModel::LinExpr<Gecode::IntVar>(e,Gecode::MiniModel::LinExpr<Gecode::IntVar>::NT_ADD,c);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::IntVar>
+operator+(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& e,
+          int c) {
+  return Gecode::MiniModel::LinExpr<Gecode::IntVar>(e,Gecode::MiniModel::LinExpr<Gecode::IntVar>::NT_ADD,c);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::IntVar>
+operator+(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& e1,
+          const Gecode::MiniModel::LinExpr<Gecode::IntVar>& e2) {
+  return Gecode::MiniModel::LinExpr<Gecode::IntVar>(e1,Gecode::MiniModel::LinExpr<Gecode::IntVar>::NT_ADD,e2);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::IntVar>
+operator-(int c,
+          const Gecode::MiniModel::LinExpr<Gecode::IntVar>& e) {
+  return Gecode::MiniModel::LinExpr<Gecode::IntVar>(e,Gecode::MiniModel::LinExpr<Gecode::IntVar>::NT_SUB,c);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::IntVar>
+operator-(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& e,
+          int c) {
+  return Gecode::MiniModel::LinExpr<Gecode::IntVar>(e,Gecode::MiniModel::LinExpr<Gecode::IntVar>::NT_ADD,-c);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::IntVar>
+operator-(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& e1,
+          const Gecode::MiniModel::LinExpr<Gecode::IntVar>& e2) {
+  return Gecode::MiniModel::LinExpr<Gecode::IntVar>(e1,Gecode::MiniModel::LinExpr<Gecode::IntVar>::NT_SUB,e2);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::IntVar>
+operator-(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& e) {
+  return Gecode::MiniModel::LinExpr<Gecode::IntVar>(e,Gecode::MiniModel::LinExpr<Gecode::IntVar>::NT_SUB,0);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::IntVar>
+operator*(int a, const Gecode::IntVar& x) {
+  return Gecode::MiniModel::LinExpr<Gecode::IntVar>(x,a);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::IntVar>
+operator*(const Gecode::IntVar& x, int a) {
+  return Gecode::MiniModel::LinExpr<Gecode::IntVar>(x,a);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::IntVar>
+operator*(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& e, int a) {
+  return Gecode::MiniModel::LinExpr<Gecode::IntVar>(a,e);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::IntVar>
+operator*(int a, const Gecode::MiniModel::LinExpr<Gecode::IntVar>& e) {
+  return Gecode::MiniModel::LinExpr<Gecode::IntVar>(a,e);
+}
+
+
+inline Gecode::MiniModel::LinExpr<Gecode::BoolVar>
+operator+(int c,
+          const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& e) {
+  return Gecode::MiniModel::LinExpr<Gecode::BoolVar>(e,Gecode::MiniModel::LinExpr<Gecode::BoolVar>::NT_ADD,c);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::BoolVar>
+operator+(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& e,
+          int c) {
+  return Gecode::MiniModel::LinExpr<Gecode::BoolVar>(e,Gecode::MiniModel::LinExpr<Gecode::BoolVar>::NT_ADD,c);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::BoolVar>
+operator+(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& e1,
+          const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& e2) {
+  return Gecode::MiniModel::LinExpr<Gecode::BoolVar>(e1,Gecode::MiniModel::LinExpr<Gecode::BoolVar>::NT_ADD,e2);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::BoolVar>
+operator-(int c,
+          const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& e) {
+  return Gecode::MiniModel::LinExpr<Gecode::BoolVar>(e,Gecode::MiniModel::LinExpr<Gecode::BoolVar>::NT_SUB,c);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::BoolVar>
+operator-(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& e,
+          int c) {
+  return Gecode::MiniModel::LinExpr<Gecode::BoolVar>(e,Gecode::MiniModel::LinExpr<Gecode::BoolVar>::NT_ADD,-c);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::BoolVar>
+operator-(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& e1,
+          const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& e2) {
+  return Gecode::MiniModel::LinExpr<Gecode::BoolVar>(e1,Gecode::MiniModel::LinExpr<Gecode::BoolVar>::NT_SUB,e2);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::BoolVar>
+operator-(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& e) {
+  return Gecode::MiniModel::LinExpr<Gecode::BoolVar>(e,Gecode::MiniModel::LinExpr<Gecode::BoolVar>::NT_SUB,0);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::BoolVar>
+operator*(int a, const Gecode::BoolVar& x) {
+  return Gecode::MiniModel::LinExpr<Gecode::BoolVar>(x,a);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::BoolVar>
+operator*(const Gecode::BoolVar& x, int a) {
+  return Gecode::MiniModel::LinExpr<Gecode::BoolVar>(x,a);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::BoolVar>
+operator*(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& e, int a) {
+  return Gecode::MiniModel::LinExpr<Gecode::BoolVar>(a,e);
+}
+inline Gecode::MiniModel::LinExpr<Gecode::BoolVar>
+operator*(int a, const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& e) {
+  return Gecode::MiniModel::LinExpr<Gecode::BoolVar>(a,e);
+}
+
+
+namespace Gecode {
+
+  forceinline IntVar
+  post(Space*, const IntVar& x, IntConLevel, PropKind) {
+    return x;
+  }
+
+  inline IntVar
+  post(Space* home, int n, IntConLevel, PropKind) {
+    IntVar x(home, n, n);
+    return x;
+  }
+
+  template <class Var>
+  inline IntVar
+  post(Space* home, const MiniModel::LinExpr<Var>& e, 
+       IntConLevel icl, PropKind pk) {
+    if (!home->failed())
+      return e.post(home,icl,pk);
+    IntVar x(home,Int::Limits::min,Int::Limits::max);
+    return x;
+  }
+
+}
+
+// STATISTICS: minimodel-any