gecoder-with-gecode 0.7.1 → 0.8.0

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

@@ -0,0 +1,324 @@
+/* -*- 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-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 linear expressions
+     *
+     */
+    template<class Var>
+    forceinline
+    LinRel<Var>::LinRel(void) {}
+
+    template<class Var>
+    forceinline
+    LinRel<Var>::LinRel(const LinExpr<Var>& l, IntRelType irt0, 
+                        const LinExpr<Var>& r)
+      : e(l-r), irt(irt0) {}
+
+    template<class Var>
+    forceinline
+    LinRel<Var>::LinRel(const LinExpr<Var>& l, IntRelType irt0, int r)
+      : e(l-r), irt(irt0) {}
+
+    template<class Var>
+    forceinline
+    LinRel<Var>::LinRel(int l, IntRelType irt0, const LinExpr<Var>& r)
+      : e(l-r), irt(irt0) {}
+
+    template<class Var>
+    forceinline IntRelType
+    LinRel<Var>::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: return IRT_LQ;
+      default: GECODE_NEVER;
+      }
+      return IRT_LQ;
+    }
+
+    template<class Var>
+    inline void
+    LinRel<Var>::post(Space* home, bool t,
+                      IntConLevel icl, PropKind pk) const {
+      if (t) {
+        e.post(home,irt,icl,pk);
+      } else {
+        e.post(home,neg(irt),icl,pk);
+      }
+    }
+
+    template<class Var>
+    forceinline void
+    LinRel<Var>::post(Space* home, const BoolVar& b,
+                      IntConLevel icl, PropKind pk) const {
+      e.post(home,irt,b,icl,pk);
+    }
+
+  }
+
+}
+
+/*
+ * Construction of linear relations
+ *
+ */
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator==(int l,
+           const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_EQ,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator==(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
+           int r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_EQ,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator==(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
+           const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_EQ,r);
+}
+
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator!=(int l,
+           const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_NQ,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator!=(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
+           int r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_NQ,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator!=(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
+           const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_NQ,r);
+}
+
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator<(int l,
+          const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_LE,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator<(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
+          int r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_LE,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator<(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
+          const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_LE,r);
+}
+
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator<=(int l,
+           const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_LQ,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator<=(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
+           int r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_LQ,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator<=(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
+           const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_LQ,r);
+}
+
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator>(int l,
+          const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_GR,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator>(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
+          int r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_GR,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator>(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
+          const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_GR,r);
+}
+
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator>=(int l,
+           const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_GQ,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator>=(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
+           int r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_GQ,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::IntVar>
+operator>=(const Gecode::MiniModel::LinExpr<Gecode::IntVar>& l,
+           const Gecode::MiniModel::LinExpr<Gecode::IntVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::IntVar>(l,Gecode::IRT_GQ,r);
+}
+
+
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator==(int l,
+           const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_EQ,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator==(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
+           int r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_EQ,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator==(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
+           const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_EQ,r);
+}
+
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator!=(int l,
+           const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_NQ,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator!=(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
+           int r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_NQ,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator!=(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
+           const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_NQ,r);
+}
+
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator<(int l,
+          const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_LE,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator<(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
+          int r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_LE,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator<(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
+          const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_LE,r);
+}
+
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator<=(int l,
+           const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_LQ,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator<=(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
+           int r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_LQ,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator<=(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
+           const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_LQ,r);
+}
+
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator>(int l,
+          const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_GR,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator>(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
+          int r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_GR,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator>(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
+          const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_GR,r);
+}
+
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator>=(int l,
+           const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_GQ,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator>=(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
+           int r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_GQ,r);
+}
+inline Gecode::MiniModel::LinRel<Gecode::BoolVar>
+operator>=(const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& l,
+           const Gecode::MiniModel::LinExpr<Gecode::BoolVar>& r) {
+  return Gecode::MiniModel::LinRel<Gecode::BoolVar>(l,Gecode::IRT_GQ,r);
+}
+
+
+namespace Gecode {
+
+  /*
+   * Posting
+   *
+   */
+
+  template<class Var>
+  forceinline void
+  post(Space* home, const MiniModel::LinRel<Var>& r, 
+       IntConLevel icl, PropKind pk) {
+    if (home->failed()) return;
+    r.post(home,true,icl,pk);
+  }
+  forceinline void
+  post(Space* home, bool r, IntConLevel, PropKind) {
+    if (home->failed()) return;
+    if (!r)
+      home->fail();
+  }
+
+}
+
+// STATISTICS: minimodel-any

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

@@ -0,0 +1,144 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Mikael Lagerkvist <lagerkvist@gecode.org>
+ *
+ *  Copyright:
+ *     Mikael Lagerkvist, 2005
+ *
+ *  Bugfixes provided by:
+ *     Olof Sivertsson <olof@olofsivertsson.com>
+ *
+ *  Last modified:
+ *     $Date: 2007-08-09 15:30:21 +0200 (Thu, 09 Aug 2007) $ by $Author: tack $
+ *     $Revision: 4790 $
+ *
+ *  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.
+ *
+ */
+
+#include <algorithm>
+
+namespace Gecode { namespace MiniModel {
+
+  template <class A>
+  inline
+  Matrix<A>::Slice::Slice(Matrix<A>& a,
+                          unsigned int fc, unsigned int tc,
+                          unsigned int fr, unsigned int tr)
+    : _r(0), _fc(fc), _tc(tc), _fr(fr), _tr(tr) {
+    if (tc > a.width() || tr > a.height())
+      throw ArgumentOutOfRange("MiniModel::Matrix::Slice::Slice");
+    if (fc >= tc || fr >= tr)
+      throw ArgumentOutOfRange("MiniModel::Matrix::Slice::Slice");
+
+    _r = args_type((tc-fc)*(tr-fr));
+
+    int i = 0;
+    for (unsigned int h = fr; h < tr; ++h) {
+      for (unsigned int w = fc; w < tc; ++w) {
+        _r[i++] = a(w, h);
+      }
+    }
+  }
+
+  template <class A>
+  typename Matrix<A>::Slice&
+  Matrix<A>::Slice::reverse(void) {
+    for (int i = 0; i < _r.size()/2; ++i)
+      std::swap(_r[i], _r[_r.size()-i-1]);
+    return *this;
+  }
+
+  template <class A>
+  inline
+  Matrix<A>::Slice::operator typename Matrix<A>::args_type(void) {
+    return _r;
+  }
+  template <class A>
+  inline
+  Matrix<A>::Slice::operator Matrix<typename Matrix<A>::args_type>(void) {
+    return Matrix<args_type>(_r, _tc-_fc, _tr-_fr);
+  }
+
+
+  template <class A>
+  inline
+  Matrix<A>::Matrix(A a, unsigned int w, unsigned int h)
+    : _a(a), _w(w), _h(h) {
+    if (_w * _h != static_cast<unsigned int>(_a.size()))
+      throw ArgumentSizeMismatch("MiniModel::Matrix::Matrix(A, w, h)");
+  }
+
+  template <class A>
+  inline
+  Matrix<A>::Matrix(A a, unsigned int n)
+    : _a(a), _w(n), _h(n) {
+    if (n*n != static_cast<unsigned int>(_a.size()))
+      throw ArgumentSizeMismatch("MiniModel::Matrix::Matrix(A, n)");
+  }
+
+  template <class A>
+  inline unsigned int
+  Matrix<A>::width(void) const  { return _w; }
+  template <class A>
+  inline unsigned int
+  Matrix<A>::height(void) const { return _h; }
+  template <class A>
+  inline typename Matrix<A>::args_type const
+  Matrix<A>::get_array(void) {
+    return args_type(_a);
+  }
+
+  template <class A>
+  inline typename Matrix<A>::value_type&
+  Matrix<A>::operator()(unsigned int c, unsigned int r) {
+    if (c >= _w || r >= _h)
+      throw ArgumentOutOfRange("MiniModel::Matrix::operator()");
+
+    return _a[r*_w + c];
+  }
+
+  template <class A>
+  inline typename Matrix<A>::Slice
+  Matrix<A>::slice(unsigned int fc, unsigned int tc,
+                   unsigned int fr, unsigned int tr) {
+    return Slice(*this, fc, tc, fr, tr);
+  }
+
+  template <class A>
+  inline typename Matrix<A>::Slice
+  Matrix<A>::row(int r) {
+    return slice(0, width(), r, r+1);
+  }
+
+  template <class A>
+  inline typename Matrix<A>::Slice
+  Matrix<A>::col(int c) {
+    return slice(c, c+1, 0, height());
+  }
+
+}}
+
+// STATISTICS: minimodel-any