dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/set/rel.hh

@@ -0,0 +1,322 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2011-08-25 00:34:16 +1000 (Thu, 25 Aug 2011) $ by $Author: tack $
+ *     $Revision: 12346 $
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_SET_REL_HH__
+#define __GECODE_SET_REL_HH__
+
+#include <gecode/set.hh>
+
+namespace Gecode { namespace Set { namespace Rel {
+
+  /**
+   * \namespace Gecode::Set::Rel
+   * \brief Standard set relation propagators
+   */
+
+  /**
+   * \brief %Propagator for the subset constraint
+   *
+   * Requires \code #include <gecode/set/rel.hh> \endcode
+   * \ingroup FuncSetProp
+   */
+
+  template<class View0, class View1>
+  class Subset :
+    public MixBinaryPropagator<View0,PC_SET_CGLB,View1,PC_SET_CLUB> {
+  protected:
+    using MixBinaryPropagator<View0,PC_SET_CGLB,View1,PC_SET_CLUB>::x0;
+    using MixBinaryPropagator<View0,PC_SET_CGLB,View1,PC_SET_CLUB>::x1;
+    /// Constructor for cloning \a p
+    Subset(Space& home, bool share,Subset& p);
+    /// Constructor for posting
+    Subset(Home home,View0, View1);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor*      copy(Space& home,bool);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
+    /// Post propagator \f$ x\subseteq y\f$
+    static  ExecStatus post(Home home,View0 x,View1 y);
+  };
+
+  /**
+   * \brief %Propagator for the negated subset constraint
+   *
+   * Requires \code #include <gecode/set/rel.hh> \endcode
+   * \ingroup FuncSetProp
+   */
+
+  template<class View0, class View1>
+  class NoSubset :
+    public MixBinaryPropagator<View0,PC_SET_CLUB,View1,PC_SET_CGLB> {
+  protected:
+    using MixBinaryPropagator<View0,PC_SET_CLUB,View1,PC_SET_CGLB>::x0;
+    using MixBinaryPropagator<View0,PC_SET_CLUB,View1,PC_SET_CGLB>::x1;
+    /// Constructor for cloning \a p
+    NoSubset(Space& home, bool share,NoSubset& p);
+    /// Constructor for posting
+    NoSubset(Home home,View0,View1);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor*      copy(Space& home,bool);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
+    /// Post propagator \f$ x\subseteq y\f$
+    static  ExecStatus post(Home home,View0 x,View1 y);
+  };
+
+  /**
+   * \brief %Reified subset propagator
+   *
+   * Requires \code #include <gecode/set/rel.hh> \endcode
+   * \ingroup FuncSetProp
+   */
+  template<class View0, class View1>
+  class ReSubset : public Propagator {
+  protected:
+    View0 x0;
+    View1 x1;
+    Gecode::Int::BoolView b;
+
+    /// Constructor for cloning \a p
+    ReSubset(Space& home, bool share,ReSubset&);
+    /// Constructor for posting
+    ReSubset(Home home,View0, View1, Gecode::Int::BoolView);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor*      copy(Space& home,bool);
+    /// Cost function (defined as PC_TERNARY_LO)
+    virtual PropCost cost(const Space& home, const ModEventDelta& med) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space& home);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
+    /// Post propagator for \f$ (x\subseteq y) \Leftrightarrow b \f$
+    static ExecStatus post(Home home,View0 x, View1 y,
+                           Gecode::Int::BoolView b);
+  };
+
+  /**
+   * \brief %Propagator for set equality
+   *
+   * Requires \code #include <gecode/set/rel.hh> \endcode
+   * \ingroup FuncSetProp
+   */
+  template<class View0, class View1>
+  class Eq : public MixBinaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY> {
+  protected:
+    using MixBinaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY>::x0;
+    using MixBinaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY>::x1;
+    /// Constructor for cloning \a p
+    Eq(Space& home, bool share,Eq& p);
+    /// Constructor for posting
+    Eq(Home home,View0, View1);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor*      copy(Space& home,bool);
+    /// Perform propagation
+    virtual ExecStatus  propagate(Space& home, const ModEventDelta& med);
+    /// Post propagator \f$ x=y \f$
+    static  ExecStatus  post(Home home,View0,View1);
+  };
+
+  /**
+   * \brief %Reified equality propagator
+   *
+   * Requires \code #include <gecode/set/rel.hh> \endcode
+   * \ingroup FuncSetProp
+   */
+  template<class View0, class View1>
+  class ReEq : public Propagator {
+  protected:
+    View0 x0;
+    View1 x1;
+    Gecode::Int::BoolView b;
+
+    /// Constructor for cloning \a p
+    ReEq(Space& home, bool share,ReEq&);
+    /// Constructor for posting
+    ReEq(Home home,View0, View1, Gecode::Int::BoolView);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor*      copy(Space& home,bool);
+    /// Cost function (defined as PC_TERNARY_LO)
+    virtual PropCost cost(const Space& home, const ModEventDelta& med) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space& home);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
+    /// Post propagator for \f$ (x=y) \Leftrightarrow b\f$
+    static ExecStatus post(Home home,View0 x, View1 y,
+                           Gecode::Int::BoolView b);
+  };
+
+  /**
+   * \brief %Propagator for set less than or equal
+   *
+   * Propagates strict inequality if \a strict is true.
+   *
+   * Requires \code #include <gecode/set/rel.hh> \endcode
+   * \ingroup FuncSetProp
+   */
+  template<class View0, class View1, bool strict=false>
+  class Lq : public MixBinaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY> {
+  protected:
+    using MixBinaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY>::x0;
+    using MixBinaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY>::x1;
+    /// Constructor for cloning \a p
+    Lq(Space& home, bool share,Lq& p);
+    /// Constructor for posting
+    Lq(Home home,View0, View1);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor*      copy(Space& home,bool);
+    /// Perform propagation
+    virtual ExecStatus  propagate(Space& home, const ModEventDelta& med);
+    /// Post propagator \f$ x\leq y \f$
+    static  ExecStatus  post(Home home,View0,View1);
+  };
+
+  /**
+   * \brief %Reified propagator for set less than or equal
+   *
+   * Propagates strict inequality if \a strict is true.
+   *
+   * Requires \code #include <gecode/set/rel.hh> \endcode
+   * \ingroup FuncSetProp
+   */
+  template<class View0, class View1, bool strict=false>
+  class ReLq : public Propagator {
+  protected:
+    View0 x0;
+    View1 x1;
+    Gecode::Int::BoolView b;
+
+    /// Constructor for cloning \a p
+    ReLq(Space& home, bool share,ReLq&);
+    /// Constructor for posting
+    ReLq(Home home,View0, View1, Gecode::Int::BoolView);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor*      copy(Space& home,bool);
+    /// Cost function (defined as PC_TERNARY_LO)
+    virtual PropCost cost(const Space& home, const ModEventDelta& med) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space& home);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
+    /// Post propagator for \f$ (x\leq y) \Leftrightarrow b\f$
+    static ExecStatus post(Home home,View0 x, View1 y,
+                           Gecode::Int::BoolView b);
+  };
+
+  /**
+   * \brief %Propagator for negated equality
+   *
+   * Requires \code #include <gecode/set/rel.hh> \endcode
+   * \ingroup FuncSetProp
+   */
+
+  template<class View0, class View1>
+  class Distinct :
+    public MixBinaryPropagator<View0,PC_SET_VAL,View1,PC_SET_VAL> {
+  protected:
+    using MixBinaryPropagator<View0,PC_SET_VAL,View1,PC_SET_VAL>::x0;
+    using MixBinaryPropagator<View0,PC_SET_VAL,View1,PC_SET_VAL>::x1;
+    /// Constructor for cloning \a p
+    Distinct(Space& home, bool share,Distinct& p);
+    /// Constructor for posting
+    Distinct(Home home,View0,View1);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor*      copy(Space& home,bool);
+    /// Perform propagation
+    virtual ExecStatus  propagate(Space& home, const ModEventDelta& med);
+    /// Post propagator \f$ x\neq y \f$
+    static  ExecStatus  post(Home home,View0,View1);
+  };
+
+  /**
+   * \brief %Propagator for negated equality
+   *
+   * This propagator actually propagates the distinctness, after the
+   * Distinct propagator waited for one variable to become
+   * assigned.
+   *
+   * Requires \code #include <gecode/set/rel.hh> \endcode
+   * \ingroup FuncSetProp
+   */
+  template<class View0>
+  class DistinctDoit : public UnaryPropagator<View0,PC_SET_ANY> {
+  protected:
+    using UnaryPropagator<View0,PC_SET_ANY>::x0;
+    /// The view that is already assigned
+    ConstSetView y;
+    /// Constructor for cloning \a p
+    DistinctDoit(Space& home, bool share,DistinctDoit&);
+    /// Constructor for posting
+    DistinctDoit(Home home, View0, ConstSetView);
+  public:
+    /// Copy propagator during cloning
+    virtual Actor*      copy(Space& home, bool);
+    /// Perform propagation
+    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);
+    /// Post propagator \f$ x\neq y \f$
+    static ExecStatus post(Home home, View0, ConstSetView);
+  };
+
+}}}
+
+#include <gecode/set/rel/common.hpp>
+#include <gecode/set/rel/subset.hpp>
+#include <gecode/set/rel/nosubset.hpp>
+#include <gecode/set/rel/re-subset.hpp>
+#include <gecode/set/rel/eq.hpp>
+#include <gecode/set/rel/re-eq.hpp>
+#include <gecode/set/rel/nq.hpp>
+#include <gecode/set/rel/lq.hpp>
+#include <gecode/set/rel/re-lq.hpp>
+
+#endif
+
+// STATISTICS: set-prop

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/set/rel/common.hpp

@@ -0,0 +1,125 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2010-06-02 19:00:04 +1000 (Wed, 02 Jun 2010) $ by $Author: schulte $
+ *     $Revision: 11004 $
+ *
+ *  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.
+ *
+ */
+
+#define GECODE_SET_ME_CHECK_VAL(p,f) {                                \
+    ModEvent __me__ ## __LINE__ = (p);                                \
+    if (me_failed(__me__ ## __LINE__)) return ES_FAILED;        \
+    if (ME_GEN_ASSIGNED==(__me__ ## __LINE__))f=true; }
+
+#define GECODE_SET_ME_CHECK_VAL_B(modified, tell, f)        \
+  {                                                        \
+    ModEvent me = (tell);                                \
+    modified |= me_modified(me);                        \
+    if (ME_GEN_ASSIGNED==(me))f=true;                        \
+    GECODE_ME_CHECK(me);                                \
+  }
+
+namespace Gecode { namespace Set { namespace Rel {
+
+  forceinline
+  bool subsumesME(ModEvent me0, ModEvent me1, ModEvent me2, ModEvent me) {
+    ModEvent cme = SetVarImp::me_combine(me0,SetVarImp::me_combine(me1, me2));
+    return SetVarImp::me_combine(cme, me)==cme;
+  }
+  forceinline
+  bool subsumesME(ModEvent me0, ModEvent me1, ModEvent me) {
+    ModEvent cme = SetVarImp::me_combine(me0, me1);
+    return SetVarImp::me_combine(cme, me)==cme;
+  }
+  forceinline
+  bool subsumesME(ModEvent me0, ModEvent me) {
+    return SetVarImp::me_combine(me0, me)==me0;
+  }
+
+  forceinline
+  bool testSetEventLB(ModEvent me0, ModEvent me1, ModEvent me2) {
+    return subsumesME(me0, me1, me2, ME_SET_GLB);
+  }
+  forceinline
+  bool testSetEventUB(ModEvent me0, ModEvent me1, ModEvent me2) {
+    return subsumesME(me0, me1, me2, ME_SET_LUB);
+  }
+  forceinline
+  bool testSetEventAnyB(ModEvent me0, ModEvent me1, ModEvent me2) {
+    return ( me0!=ME_SET_CARD || me1!=ME_SET_CARD || me2!=ME_SET_CARD );
+  }
+  forceinline
+  bool testSetEventCard(ModEvent me0, ModEvent me1, ModEvent me2) {
+    return subsumesME(me0, me1, me2, ME_SET_CARD);
+  }
+  forceinline
+  bool testSetEventLB(ModEvent me0, ModEvent me1) {
+    return subsumesME(me0, me1, ME_SET_GLB);
+  }
+  forceinline
+  bool testSetEventUB(ModEvent me0, ModEvent me1) {
+    return subsumesME(me0, me1, ME_SET_LUB);
+  }
+  forceinline
+  bool testSetEventAnyB(ModEvent me0, ModEvent me1) {
+    return ( me0!=ME_SET_CARD || me1!=ME_SET_CARD );
+  }
+  forceinline
+  bool testSetEventCard(ModEvent me0, ModEvent me1) {
+    return subsumesME(me0, me1, ME_SET_CARD);
+  }
+  forceinline
+  bool testSetEventLB(ModEvent me0) {
+    return subsumesME(me0, ME_SET_GLB);
+  }
+  forceinline
+  bool testSetEventUB(ModEvent me0) {
+    return subsumesME(me0, ME_SET_LUB);
+  }
+  forceinline
+  bool testSetEventAnyB(ModEvent me0) {
+    return ( me0!=ME_SET_CARD );
+  }
+  forceinline
+  bool testSetEventCard(ModEvent me0) {
+    return subsumesME(me0, ME_SET_CARD);
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/set/rel/eq.hpp

@@ -0,0 +1,116 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2011-08-09 02:04:53 +1000 (Tue, 09 Aug 2011) $ by $Author: schulte $
+ *     $Revision: 12253 $
+ *
+ *  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 Set { namespace Rel {
+
+  template<class View0, class View1>
+  forceinline
+  Eq<View0,View1>::Eq(Home home, View0 x, View1 y)
+    : MixBinaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY>(home,x,y) {}
+
+  template<class View0, class View1>
+  forceinline
+  Eq<View0,View1>::Eq(Space& home, bool share, Eq& p)
+    : MixBinaryPropagator<View0,PC_SET_ANY,View1,PC_SET_ANY>(home,share,p) {}
+
+  template<class View0, class View1>
+  ExecStatus
+  Eq<View0,View1>::post(Home home, View0 x, View1 y) {
+    (void) new (home) Eq(home,x,y);
+    return ES_OK;
+  }
+
+  template<class View0, class View1>
+  Actor*
+  Eq<View0,View1>::copy(Space& home, bool share) {
+    return new (home) Eq(home,share,*this);
+  }
+
+  template<class View0, class View1>
+  ExecStatus
+  Eq<View0,View1>::propagate(Space& home, const ModEventDelta& med) {
+
+    ModEvent me0 = View0::me(med);
+    ModEvent me1 = View1::me(med);
+
+    Region r(home);
+
+    if (testSetEventLB(me0,me1)) {
+      GlbRanges<View0> x0lb(x0);
+      GlbRanges<View1> x1lb(x1);
+      Iter::Ranges::Union<GlbRanges<View0>,GlbRanges<View1> > lbu(x0lb,x1lb);
+      Iter::Ranges::Cache lbuc(r,lbu);
+      GECODE_ME_CHECK(x0.includeI(home,lbuc));
+      lbuc.reset();
+      GECODE_ME_CHECK(x1.includeI(home,lbuc));
+    }
+
+    if (testSetEventUB(me0,me1)) {
+      LubRanges<View0> x0ub(x0);
+      LubRanges<View1> x1ub(x1);
+      Iter::Ranges::Inter<LubRanges<View0>,LubRanges<View1> > ubi(x0ub,x1ub);
+      Iter::Ranges::Cache ubic(r,ubi);
+      GECODE_ME_CHECK(x0.intersectI(home,ubic));
+      ubic.reset();
+      GECODE_ME_CHECK(x1.intersectI(home,ubic));
+    }
+
+    if (testSetEventCard(me0,me1) ) {
+      unsigned int max = std::min(x0.cardMax(),x1.cardMax());
+      unsigned int min = std::max(x0.cardMin(),x1.cardMin());
+      GECODE_ME_CHECK ( x0.cardMax(home,max) );
+      GECODE_ME_CHECK ( x1.cardMax(home,max) );
+      GECODE_ME_CHECK ( x0.cardMin(home,min) );
+      GECODE_ME_CHECK ( x1.cardMin(home,min) );
+    }
+
+    if (x0.assigned()) {
+      assert (x1.assigned());
+      return home.ES_SUBSUMED(*this);
+    }
+    return shared(x0,x1) ? ES_NOFIX : ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop