gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,87 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *
+ *  Last modified:
+ *     $Date: 2006-04-11 15:58:37 +0200 (Tue, 11 Apr 2006) $ by $Author: tack $
+ *     $Revision: 3188 $
+ *
+ *  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/arithmetic.hh"
+
+namespace Gecode {
+
+  using namespace Int;
+
+  void
+  abs(Space* home, IntVar x0, IntVar x1, IntConLevel cl) {
+    if (home->failed()) return;
+    switch (cl) {
+    case ICL_DOM:
+      GECODE_ES_FAIL(home,Arithmetic::AbsDom<IntView>::post(home,x0,x1));
+      break;
+    default:
+      GECODE_ES_FAIL(home,Arithmetic::AbsBnd<IntView>::post(home,x0,x1));
+      break;
+    }
+  }
+
+
+  void
+  max(Space* home, IntVar x0, IntVar x1, IntVar x2, IntConLevel) {
+    if (home->failed()) return;
+    GECODE_ES_FAIL(home,Arithmetic::Max<IntView>::post(home,x0,x1,x2));
+  }
+
+  void
+  max(Space* home, const IntVarArgs& x, IntVar y, IntConLevel) {
+    if (x.size() == 0)
+      throw ArgumentEmpty("Int::max");
+    if (home->failed()) return;
+    ViewArray<IntView> xv(home,x);
+    GECODE_ES_FAIL(home,Arithmetic::NaryMax<IntView>::post(home,xv,y));
+  }
+
+
+  void
+  min(Space* home, IntVar x0, IntVar x1, IntVar x2, IntConLevel) {
+    if (home->failed()) return;
+    MinusView m0(x0); MinusView m1(x1); MinusView m2(x2);
+    GECODE_ES_FAIL(home,Arithmetic::Max<MinusView>::post(home,m0,m1,m2));
+  }
+
+  void
+  min(Space* home, const IntVarArgs& x, IntVar y, IntConLevel) {
+    if (x.size() == 0)
+      throw ArgumentEmpty("Int::min");
+    if (home->failed()) return;
+    ViewArray<MinusView> m(home,x.size());
+    for (int i=x.size(); i--; )
+      m[i].init(x[i]);
+    MinusView my(y);
+    GECODE_ES_FAIL(home,Arithmetic::NaryMax<MinusView>::post(home,m,my));
+  }
+
+
+  void
+  mult(Space* home, IntVar x0, IntVar x1, IntVar x2, IntConLevel) {
+    if (home->failed()) return;
+    GECODE_ES_FAIL(home,Arithmetic::Mult<IntView>::post(home,x0,x1,x2));
+  }
+
+}
+
+// STATISTICS: int-post
+

data/ext/gecode-1.3.1/gecode/int/arithmetic.hh

@@ -0,0 +1,292 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2002
+ *     Guido Tack, 2004
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_INT_ARITHMETIC_HH__
+#define __GECODE_INT_ARITHMETIC_HH__
+
+#include "gecode/int.hh"
+
+#include "gecode/int/rel.hh"
+#include "gecode/int/linear.hh"
+
+/**
+ * \namespace Gecode::Int::Arithmetic
+ * \brief Numerical (arithmetic) propagators
+ */
+
+namespace Gecode { namespace Int { namespace Arithmetic {
+
+  /**
+   * \brief Bounds-consistent absolute value propagator
+   *
+   * Requires \code #include "gecode/int/arithmetic.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class AbsBnd : public BinaryPropagator<View,PC_INT_BND> {
+  protected:
+    using BinaryPropagator<View,PC_INT_BND>::x0;
+    using BinaryPropagator<View,PC_INT_BND>::x1;
+
+    /// Constructor for cloning \a p
+    AbsBnd(Space* home, bool share, AbsBnd& p);
+    /// Constructor for posting
+    AbsBnd(Space* home, View x0, View x1);
+  public:
+
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /**
+     * \brief Cost function
+     *
+     * If a view has been assigned, the cost is PC_UNARY_LO.
+     * Otherwise it is PC_BINARY_LO.
+     */
+    virtual PropCost cost(void) const;
+    /// Perform propagation
+    virtual ExecStatus  propagate(Space* home);
+    /// Post bounds-consistent propagator \f$ |x_0|=x_1\f$
+    static  ExecStatus  post(Space* home, View x0, View x1);
+  };
+
+  /**
+   * \brief Perform bounds-consistent absolute value propagation
+   *
+   * This is actually the propagation algorithm for AbsBnd.
+   * It is available as separate function as it is reused for
+   * domain-consistent distinct propagators.
+   */
+  template <class View>
+  ExecStatus prop_bnd(Space* home, ViewArray<View>&);
+
+  /**
+   * \brief Domain-consistent absolute value propagator
+   *
+   * Requires \code #include "gecode/int/arithmetic.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class AbsDom : public BinaryPropagator<View,PC_INT_DOM> {
+  protected:
+    using BinaryPropagator<View,PC_INT_DOM>::x0;
+    using BinaryPropagator<View,PC_INT_DOM>::x1;
+
+    /// Constructor for cloning \a p
+    AbsDom(Space* home, bool share, AbsDom& p);
+    /// Constructor for posting
+    AbsDom(Space* home, View x0, View x1);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /**
+     * \brief Cost function
+     *
+     * If a view has been assigned, the cost is PC_UNARY_LO.
+     * If in stage for bounds propagation, the cost is
+     * PC_BINARY_LO. Otherwise it is PC_BINARY_HI.
+     */
+    virtual PropCost cost(void) const;
+    /// Perform propagation
+    virtual ExecStatus  propagate(Space* home);
+    /// Post domain-consistent propagator \f$ |x_0|=x_1\f$
+    static  ExecStatus  post(Space* home, View x0, View x1);
+  };
+
+  /**
+   * \brief Bounds-consistent ternary maximum propagator
+   *
+   * Requires \code #include "gecode/int/arithmetic.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class Max : public TernaryPropagator<View,PC_INT_BND> {
+  protected:
+    using TernaryPropagator<View,PC_INT_BND>::x0;
+    using TernaryPropagator<View,PC_INT_BND>::x1;
+    using TernaryPropagator<View,PC_INT_BND>::x2;
+
+    /// Constructor for cloning \a p
+    Max(Space* home, bool share, Max& p);
+    /// Constructor for posting
+    Max(Space* home, View x0, View x1, View x2);
+  public:
+    /// Constructor for rewriting \a p during cloning
+    Max(Space* home, bool share, Propagator& p, View x0, View x1, View x2);
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator \f$ \max\{x_0,x_1\}=x_2\f$
+    static  ExecStatus post(Space* home, View x0, View x1, View x2);
+  };
+
+  /**
+   * \brief Bounds-consistent n-ary maximum propagator
+   *
+   * Requires \code #include "gecode/int/arithmetic.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class NaryMax : public NaryOnePropagator<View,PC_INT_BND> {
+  protected:
+    using NaryOnePropagator<View,PC_INT_BND>::x;
+    using NaryOnePropagator<View,PC_INT_BND>::y;
+
+    /// Constructor for cloning \a p
+    NaryMax(Space* home, bool share, NaryMax& p);
+    /// Constructor for posting
+    NaryMax(Space* home, ViewArray<View>& x, View y);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Post propagator \f$ \max x=y\f$
+    static  ExecStatus post(Space* home, ViewArray<View>& x, View y);
+  };
+
+
+
+
+  /**
+   * \brief Bounds-consistent positive square propagator
+   *
+   * This propagator provides multiplication for positive views only.
+   */
+  template <class VA, class VB>
+  class SquarePlus : public Propagator {
+  protected:
+    VA x0; VB x1;
+  public:
+    /// Constructor for posting
+    SquarePlus(Space* home, VA x0, VB x1);
+    /// Post propagator \f$x_0\cdot x_0=x_1\f$
+    static ExecStatus post(Space* home, VA x0, VB x1);
+    /// Constructor for cloning \a p
+    SquarePlus(Space* home, bool share, SquarePlus<VA,VB>& p);
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Cost function (defined as PC_TERNARY_HI)
+    virtual PropCost cost(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+  /**
+   * \brief Bounds-consistent square propagator
+   *
+   * Requires \code #include "gecode/int/arithmetic.hh" \endcode
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class Square : public BinaryPropagator<View,PC_INT_BND> {
+  protected:
+    using BinaryPropagator<View,PC_INT_BND>::x0;
+    using BinaryPropagator<View,PC_INT_BND>::x1;
+
+    /// Constructor for cloning \a p
+    Square(Space* home, bool share, Square<View>& p);
+    /// Constructor for posting
+    Square(Space* home, View x0, View x1);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Cost function (defined as PC_BINARY_HI)
+    virtual PropCost cost(void) const;
+    /// Post propagator \f$x_0\cdot x_0=x_1\f$
+    static  ExecStatus post(Space* home, View x0, View x1);
+  };
+
+  /**
+   * \brief Bounds-consistent positive multiplication propagator
+   *
+   * This propagator provides multiplication for positive views only.
+   */
+  template <class VA, class VB, class VC>
+  class MultPlus : public Propagator {
+  protected:
+    VA x0; VB x1; VC x2;
+  public:
+    /// Constructor for posting
+    MultPlus(Space* home, VA x0, VB x1, VC x2);
+    /// Post propagator \f$x_0\cdot x_1=x_2\f$
+    static ExecStatus post(Space* home, VA x0, VB x1, VC x2);
+    /// Constructor for cloning \a p
+    MultPlus(Space* home, bool share, MultPlus<VA,VB,VC>& p);
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Cost function (defined as PC_TERNARY_HI)
+    virtual PropCost cost(void) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+  };
+
+  /**
+   * \brief Bounds-consistent multiplication propagator
+   *
+   * Requires \code #include "gecode/int/arithmetic.hh" \endcode
+   *
+   * \todo Currently this propagator only works for \a View
+   * being IntView. This will change when integer views are
+   * available in fully generic form.
+   *
+   * \ingroup FuncIntProp
+   */
+  template <class View>
+  class Mult : public TernaryPropagator<View,PC_INT_BND> {
+  protected:
+    using TernaryPropagator<View,PC_INT_BND>::x0;
+    using TernaryPropagator<View,PC_INT_BND>::x1;
+    using TernaryPropagator<View,PC_INT_BND>::x2;
+
+    /// Constructor for cloning \a p
+    Mult(Space* home, bool share, Mult<View>& p);
+  public:
+    /// Constructor for posting
+    Mult(Space* home, View x0, View x1, View x2);
+    /// Post propagator \f$x_0\cdot x_1=x_2\f$
+    static  ExecStatus post(Space* home, View x0, View x1, View x2);
+    /// Copy propagator during cloning
+    virtual Actor* copy(Space* home, bool share);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space* home);
+    /// Cost function (defined as PC_TERNARY_HI)
+    virtual PropCost cost(void) const;
+  };
+
+}}}
+
+#include "gecode/int/arithmetic/abs.icc"
+#include "gecode/int/arithmetic/max.icc"
+#include "gecode/int/arithmetic/mult.icc"
+
+#endif
+
+// STATISTICS: int-prop
+

data/ext/gecode-1.3.1/gecode/int/arithmetic/abs.icc

@@ -0,0 +1,213 @@
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2004
+ *     Guido Tack, 2006
+ *
+ *  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/iter.hh"
+#include <algorithm>
+
+namespace Gecode { namespace Int { namespace Arithmetic {
+
+  template <class View, template <class View0,class View1> class Eq>
+  ExecStatus
+  prop_bnd(Space* home, View x0, View x1) {
+    if (x0.assigned()) {
+      GECODE_ME_CHECK(x1.eq(home,(x0.val() < 0) ? -x0.val() : x0.val()));
+      return ES_SUBSUMED;
+    }
+
+    if (x1.assigned()) {
+      if (x0.min() >= 0) {
+	GECODE_ME_CHECK(x0.eq(home,x1.val()));
+      } else if (x0.max() <= 0) {
+	GECODE_ME_CHECK(x0.eq(home,-x1.val()));
+      } else if (x1.val() == 0) {
+	GECODE_ME_CHECK(x0.eq(home,0));
+      } else {
+	Iter::Ranges::Array::Range r[2]
+	  = { {-x1.val(),-x1.val()}, {x1.val(),x1.val()} };
+	Iter::Ranges::Array i(r,2);
+	GECODE_ME_CHECK(x0.inter(home,i));
+      }
+      return ES_SUBSUMED;
+    }
+
+    if (x0.min() >= 0) {
+      return (Eq<View,View>::post(home,x0,x1) == ES_FAILED)
+	? ES_FAILED : ES_SUBSUMED;
+    }
+
+    if (x0.max() <= 0) {
+      MinusView mx0(x0);
+      return (Eq<MinusView,View>::post(home,mx0,x1) == ES_FAILED)
+	? ES_FAILED : ES_SUBSUMED;
+    }
+
+    GECODE_ME_CHECK(x1.lq(home,std::max(x0.max(),-x0.min())));
+    GECODE_ME_CHECK(x0.lq(home,x1.max()));
+    GECODE_ME_CHECK(x0.gq(home,-x1.max()));
+    return ES_NOFIX;
+  }
+
+  template <class View>
+  forceinline
+  AbsBnd<View>::AbsBnd(Space* home, View x0, View x1)
+    : BinaryPropagator<View,PC_INT_BND>(home,x0,x1) {}
+
+  template <class View>
+  ExecStatus
+  AbsBnd<View>::post(Space* home, View x0, View x1) {
+    GECODE_ME_CHECK(x1.gq(home,0));
+    if (!same(x0,x1)) {
+      (void) new (home) AbsBnd<View>(home,x0,x1);
+    }
+    return ES_OK;
+  }
+
+
+  template <class View>
+  forceinline
+  AbsBnd<View>::AbsBnd(Space* home, bool share, AbsBnd<View>& p)
+    : BinaryPropagator<View,PC_INT_BND>(home,share,p) {}
+
+  template <class View>
+  Actor*
+  AbsBnd<View>::copy(Space* home,bool share) {
+    return new (home) AbsBnd<View>(home,share,*this);
+  }
+
+  template <class View>
+  PropCost
+  AbsBnd<View>::cost(void) const {
+    if (View::pme(this) == ME_INT_VAL)
+      return PC_UNARY_LO;
+    return PC_BINARY_LO;
+  }
+
+  template <class View>
+  ExecStatus
+  AbsBnd<View>::propagate(Space* home) {
+    return prop_bnd<View,Rel::EqBnd>(home, x0, x1);
+  }
+
+  template <class View>
+  forceinline
+  AbsDom<View>::AbsDom(Space* home, View x0, View x1)
+    : BinaryPropagator<View,PC_INT_DOM>(home,x0,x1) {}
+
+  template <class View>
+  ExecStatus
+  AbsDom<View>::post(Space* home, View x0, View x1) {
+    if (x0.min() >= 0) {
+      return Rel::EqDom<View,View>::post(home,x0,x1);
+    } else if (x0.max() <= 0) {
+      MinusView mx0(x0);
+      return Rel::EqDom<MinusView,View>::post(home,mx0,x1);
+    }
+    GECODE_ME_CHECK(x1.gq(home,0));
+    if (!same(x0,x1)) {
+      (void) new (home) AbsDom<View>(home,x0,x1);
+    }
+    return ES_OK;
+  }
+
+  template <class View>
+  forceinline
+  AbsDom<View>::AbsDom(Space* home, bool share, AbsDom<View>& p)
+    : BinaryPropagator<View,PC_INT_DOM>(home,share,p) {}
+
+  template <class View>
+  Actor*
+  AbsDom<View>::copy(Space* home,bool share) {
+    return new (home) AbsDom<View>(home,share,*this);
+  }
+
+  template <class View>
+  PropCost
+  AbsDom<View>::cost(void) const {
+    if (View::pme(this) == ME_INT_VAL)
+      return PC_UNARY_LO;
+    if (View::pme(this) == ME_INT_DOM)
+      return PC_BINARY_HI;
+    return PC_BINARY_LO;
+  }
+
+  template <class View>
+  ExecStatus
+  AbsDom<View>::propagate(Space* home) {
+
+    if (View::pme(this) != ME_INT_DOM) {
+      ExecStatus es = prop_bnd<View,Rel::EqDom>(home, x0, x1);
+      if (es != ES_NOFIX)
+	return es;
+      return this->ES_NOFIX_PARTIAL(View::pme(ME_INT_DOM));
+    }
+
+    Iter::Ranges::Singleton positive(0, Limits::Int::int_max);
+    Iter::Ranges::Singleton negative(Limits::Int::int_min, 0);
+
+    IntVarRanges xr1(x0);
+    IntVarRanges xr2(x0);
+
+    Iter::Ranges::Inter<Iter::Ranges::Singleton,
+      IntVarRanges> posInter(positive, xr1);
+    Iter::Ranges::Inter<Iter::Ranges::Singleton,
+      IntVarRanges> negInter(negative, xr2);
+    Iter::Ranges::Minus<Iter::Ranges::Inter<Iter::Ranges::Singleton,
+      IntVarRanges> > mneg(negInter);
+    Iter::Ranges::Union<Iter::Ranges::Inter<Iter::Ranges::Singleton,
+      IntVarRanges>,
+      Iter::Ranges::Minus<Iter::Ranges::Inter<
+      Iter::Ranges::Singleton,
+      IntVarRanges> > >
+      u(posInter, mneg);
+
+    GECODE_ME_CHECK(x1.inter(home, u));
+
+    IntVarRanges x1r1(x1);
+    IntVarRanges x1r2(x1);
+
+    Iter::Ranges::Minus<IntVarRanges> x1m(x1r2);
+    Iter::Ranges::Union<IntVarRanges,
+      Iter::Ranges::Minus<IntVarRanges> > u2(x1r1,x1m);
+    GECODE_ME_CHECK(x0.inter(home, u2));
+
+    if (x1.assigned())
+      return ES_SUBSUMED;
+
+    if (x0.min() >= 0) {
+      return (Rel::EqDom<View,View>::post(home,x0,x1) == ES_FAILED)
+	? ES_FAILED : ES_SUBSUMED;
+    }
+
+    if (x0.max() <= 0) {
+      MinusView mx0(x0);
+      return (Rel::EqDom<MinusView,View>::post(home,mx0,x1) == ES_FAILED)
+	? ES_FAILED : ES_SUBSUMED;
+    }
+
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: int-prop
+