gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-2.1.1/gecode/set/view/print.cc

@@ -0,0 +1,141 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004, 2005
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-02-06 18:48:22 +0100 (Wed, 06 Feb 2008) $ by $Author: schulte $
+ *     $Revision: 6102 $
+ *
+ *  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 "gecode/set.hh"
+
+using namespace Gecode::Set;
+using namespace Gecode::Int;
+
+namespace Gecode { namespace Set {
+
+  /* 
+   * Printing a bound
+   *
+   */
+  template <class I>
+  static void
+  printBound(std::ostream& os, I& r) {
+    os << '{';
+    while (r()) {
+      if (r.min() == r.max()) {
+        os << r.min();
+      } else if (r.min()+1 == r.max()) {
+        os << r.min() << "," << r.max();
+      } else {
+        os << r.min() << ".." << r.max();
+      }
+      ++r;
+      if (!r()) break;
+      os << ',';
+    }
+    os << '}';
+  }
+    
+  /*
+   * Printing a variable or view from the data generaly available
+   *
+   */
+  template <class IL, class IU>
+  static void
+  printVar(std::ostream& os, const bool assigned, IL& lb, IU& ub,
+           unsigned int cardMin, unsigned int cardMax) {
+    if (assigned) {
+      printBound(os, ub);
+      os << "#(" << cardMin << ")";
+    } else {
+      printBound(os,lb);
+      os << "..";
+      printBound(os,ub);
+      if (cardMin==cardMax) {
+        os << "#(" <<cardMin << ")";
+      } else {
+        os << "#(" << cardMin << "," << cardMax << ")";
+      }
+    }
+  }
+
+}}
+
+std::ostream&
+operator<<(std::ostream& os, const SetVarImp& x) {
+  LubRanges<SetVarImp*> ub(&x);
+  GlbRanges<SetVarImp*> lb(&x);
+  printVar(os, x.assigned(), lb, ub, x.cardMin(), x.cardMax()) ;
+  return os;
+}
+
+std::ostream&
+operator<<(std::ostream& os, const SetView& x) {
+  LubRanges<SetView> ub(x);
+  GlbRanges<SetView> lb(x);
+  printVar(os, x.assigned(), lb, ub, x.cardMin(), x.cardMax()) ;
+  return os;
+}
+
+std::ostream&
+operator<<(std::ostream& os, const EmptyView&) {
+  return os << "{}#0";
+}
+
+std::ostream&
+operator<<(std::ostream& os, const UniverseView&) {
+  return os << "{" << Gecode::Set::Limits::min << ".."
+            << Gecode::Set::Limits::max << "}#("
+            << Gecode::Set::Limits::card << ")";
+}
+
+std::ostream&
+operator<<(std::ostream& os, const ConstantView& s) {
+  LubRanges<ConstantView> ub(s);
+  printBound(os, ub);
+  return os << "#(" << s.cardMin() << ")";
+}
+
+std::ostream&
+operator<<(std::ostream& os, const SingletonView& s) {
+  if (s.assigned()) {
+    return os << "{" << s.glbMin() << "}#(1)";
+  }
+  LubRanges<SingletonView> ub(s);
+  os << "{}..";
+  printBound(os, ub);
+  return os << "#(1)";
+}
+
+// STATISTICS: set-var

data/ext/gecode-2.1.1/gecode/set/view/set.icc

@@ -0,0 +1,275 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-01-31 18:29:16 +0100 (Thu, 31 Jan 2008) $ by $Author: tack $
+ *     $Revision: 6017 $
+ *
+ *  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 {
+
+  /*
+   * Constructors and access
+   *
+   */
+
+  forceinline
+  SetView::SetView(void) {}
+  forceinline
+  SetView::SetView(const SetVar& y)
+    : VarViewBase<SetVarImp>(y.var()) {}
+  forceinline
+  SetView::SetView(SetVarImp* y)
+    : VarViewBase<SetVarImp>(y) {}
+  forceinline
+  SetView::SetView(Space* /*home*/, const Reflection::VarMap& vars,
+                   Reflection::Arg* arg)
+    : VarViewBase<SetVarImp>(SetVar(vars.var(arg->toVar())).var()) {}
+
+  /*
+   * Variable information
+   *
+   */
+
+  forceinline bool
+  SetView::assigned(void)  const { 
+    return varimp->assigned(); 
+  }
+
+  forceinline unsigned int
+  SetView::glbSize(void) const { return varimp->glbSize(); }
+
+  forceinline unsigned int
+  SetView::lubSize(void) const { return varimp->lubSize(); }
+
+  forceinline unsigned int
+  SetView::unknownSize(void) const { return varimp->lubSize() - varimp->glbSize(); }
+
+  forceinline bool
+  SetView::contains(int i) const { return (varimp->knownIn(i)); }
+
+  forceinline bool
+  SetView::notContains(int i) const { return (varimp->knownOut(i)); }
+
+  forceinline unsigned int
+  SetView::cardMin(void) const { return varimp->cardMin(); }
+
+  forceinline unsigned int
+  SetView::cardMax(void) const { return varimp->cardMax(); }
+
+  forceinline int
+  SetView::lubMin(void) const { return varimp->lubMin(); }
+
+  forceinline int
+  SetView::lubMax(void) const { return varimp->lubMax(); }
+
+  forceinline int
+  SetView::lubMinN(int n) const { return varimp->lubMinN(n); }
+
+  forceinline int
+  SetView::glbMin(void) const { return varimp->glbMin(); }
+
+  forceinline int
+  SetView::glbMax(void) const { return varimp->glbMax(); }
+
+  /*
+   * Tells
+   *
+   */
+
+  forceinline ModEvent
+  SetView::cardMin(Space* home, unsigned int m) {
+    return varimp-> cardMin(home, m);
+  }
+
+  forceinline ModEvent
+  SetView::cardMax(Space* home, unsigned int m) {
+    return varimp-> cardMax(home, m);
+  }
+
+  forceinline ModEvent
+  SetView::include (Space* home,int from, int to)
+  { return (varimp->include(home,from,to)); }
+
+  forceinline ModEvent
+  SetView::include (Space* home,int n)
+  { return (varimp->include(home,n)); }
+
+  forceinline ModEvent
+  SetView::exclude (Space* home,int n)
+  { return (varimp->exclude(home, n)); }
+
+  forceinline ModEvent
+  SetView::intersect (Space* home,int from, int to)
+  { return (varimp->intersect(home,from,to)); }
+
+  forceinline ModEvent
+  SetView::intersect (Space* home,int n)
+  { return (varimp->intersect(home,n)); }
+
+  template <class I> ModEvent
+  SetView::includeI (Space* home, I& iter)
+  { return (varimp->includeI(home, iter)); }
+
+  forceinline ModEvent
+  SetView::exclude (Space* home,int from, int to)
+  { return (varimp->exclude(home,from,to)); }
+
+  template <class I> ModEvent
+  SetView::excludeI(Space* home, I& iter) {
+    return varimp->excludeI(home, iter);
+  }
+
+  template <class I> ModEvent
+  SetView::intersectI(Space* home, I& iter) {
+    return varimp->intersectI(home, iter);
+  }
+
+
+
+  /*
+   * Cloning
+   *
+   */
+
+  forceinline void
+  SetView::update(Space* home, bool share, SetView& y) {
+    varimp = y.varimp->copy(home,share);
+  }
+
+  forceinline Reflection::Arg*
+  SetView::spec(const Space* home, Reflection::VarMap& m) const {
+    return varimp->spec(home, m);
+  }
+
+  inline Support::Symbol
+  SetView::type(void) {
+    return Support::Symbol("Gecode::Set::SetView");
+  }
+
+  /*
+   * Delta information for advisors
+   *
+   */
+
+  forceinline ModEvent
+  SetView::modevent(const Delta* d) { return SetVarImp::modevent(d); }
+  
+  forceinline int
+  SetView::glbMin(const Delta* d) const { return varimp->glbMin(d); }
+
+  forceinline int
+  SetView::glbMax(const Delta* d) const { return varimp->glbMax(d); }
+
+  forceinline bool
+  SetView::glbAny(const Delta* d) const { return varimp->glbAny(d); }
+
+  forceinline int
+  SetView::lubMin(const Delta* d) const { return varimp->lubMin(d); }
+
+  forceinline int
+  SetView::lubMax(const Delta* d) const { return varimp->lubMax(d); }
+
+  forceinline bool
+  SetView::lubAny(const Delta* d) const { return varimp->lubAny(d); }
+
+
+  /**
+   * \brief %Range iterator for least upper bound of set variable views
+   * \ingroup TaskActorSetView
+   */
+  template <>
+  class LubRanges<SetView> : public LubRanges<SetVarImp*> {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    LubRanges(void);
+    /// Initialize with ranges for view \a x
+    LubRanges(const SetView& x);
+    /// Initialize with ranges for view \a x
+    void init(const SetView& x);
+    //@}
+  };
+
+  forceinline
+  LubRanges<SetView>::LubRanges(void) {}
+
+  forceinline
+  LubRanges<SetView>::LubRanges(const SetView& x)
+    : LubRanges<SetVarImp*>(x.var()) {}
+
+  forceinline void
+  LubRanges<SetView>::init(const SetView& x) {
+    LubRanges<SetVarImp*>::init(x.var());
+  }
+
+
+  /**
+   * \brief %Range iterator for greatest lower bound of set variable views
+   * \ingroup TaskActorSetView
+   */
+  template <>
+  class GlbRanges<SetView> : public GlbRanges<SetVarImp*> {
+  public:
+    /// \name Constructors and initialization
+    //@{
+    /// Default constructor
+    GlbRanges(void);
+    /// Initialize with ranges for view \a x
+    GlbRanges(const SetView& x);
+    /// Initialize with ranges for view \a x
+    void init(const SetView& x);
+  };
+
+  forceinline
+  GlbRanges<SetView>::GlbRanges(void) {}
+
+  forceinline
+  GlbRanges<SetView>::GlbRanges(const SetView& x)
+    : GlbRanges<SetVarImp*>(x.var()) {}
+
+  forceinline void
+  GlbRanges<SetView>::init(const SetView& x) {
+    GlbRanges<SetVarImp*>::init(x.var());
+  }
+
+}}
+
+// STATISTICS: set-var
+

data/ext/gecode-2.1.1/gecode/set/view/singleton.icc

@@ -0,0 +1,438 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Contributing authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-01-31 18:29:16 +0100 (Thu, 31 Jan 2008) $ by $Author: tack $
+ *     $Revision: 6017 $
+ *
+ *  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 {
+
+    forceinline
+    SingletonView::SingletonView(void) {}
+
+    forceinline
+    SingletonView::SingletonView(Gecode::Int::IntView& i0)
+      : DerivedViewBase<Gecode::Int::IntView>(i0) {}
+
+    forceinline
+    SingletonView::SingletonView(Space* home,
+                                 const Reflection::VarMap& vars,
+                                 Reflection::Arg* arg)
+  : DerivedViewBase<Gecode::Int::IntView>(Gecode::Int::IntView(home, vars, 
+                                                               arg)) {}
+
+    forceinline PropCond
+    SingletonView::pc_settoint(PropCond pc) {
+      switch(pc) {
+      case PC_SET_VAL:
+      case PC_SET_CGLB:
+      case PC_SET_CARD:
+        return Gecode::Int::PC_INT_VAL;
+      default:
+        return Gecode::Int::PC_INT_DOM;
+      }
+    }
+
+    forceinline ModEvent
+    SingletonView::me_inttoset(ModEvent me) {
+      switch(me) {
+      case Gecode::Int::ME_INT_FAILED: 
+        return ME_SET_FAILED;
+      case Gecode::Int::ME_INT_NONE: 
+        return ME_SET_NONE;
+      case Gecode::Int::ME_INT_VAL: 
+        return ME_SET_VAL;
+      case Gecode::Int::ME_INT_DOM: 
+        return ME_SET_LUB;
+      default:
+        return ME_SET_LUB;
+      }
+    }
+
+    forceinline ModEvent
+    SingletonView::me_settoint(ModEvent me) {
+      switch(me) {
+      case ME_SET_FAILED:
+        return Gecode::Int::ME_INT_FAILED;
+      case ME_SET_NONE:
+        return Gecode::Int::ME_INT_NONE;
+      case ME_SET_VAL:
+        return Gecode::Int::ME_INT_VAL;
+      default:
+        return Gecode::Int::ME_INT_DOM;
+      }
+    }
+
+    forceinline bool
+    SingletonView::assigned(void) const { return view.assigned(); }
+
+    forceinline unsigned int
+    SingletonView::glbSize(void) const { return view.assigned() ? 1 : 0; }
+
+    forceinline unsigned int
+    SingletonView::lubSize(void) const { return view.size(); }
+
+    forceinline unsigned int
+    SingletonView::unknownSize(void) const {
+      return lubSize() - glbSize();
+    }
+
+    forceinline bool
+    SingletonView::contains(int n) const { return view.assigned() ?
+                                             (view.val()==n) : false; }
+
+    forceinline bool
+    SingletonView::notContains(int n) const { return !view.in(n); }
+
+    forceinline unsigned int
+    SingletonView::cardMin() const { return 1; }
+
+    forceinline unsigned int
+    SingletonView::cardMax() const { return 1; }
+
+    forceinline int
+    SingletonView::lubMin() const { return view.min(); }
+
+    forceinline int
+    SingletonView::lubMax() const { return view.max(); }
+
+    forceinline int
+    SingletonView::glbMin() const { return view.assigned() ?
+                                      view.val() : BndSet::MIN_OF_EMPTY; }
+
+    forceinline int
+    SingletonView::glbMax() const { return view.assigned() ?
+                                      view.val() : BndSet::MAX_OF_EMPTY; }
+
+    forceinline ModEvent
+    SingletonView::cardMin(Space*, unsigned int c) {
+      return c<=1 ? ME_SET_NONE : ME_SET_FAILED;
+    }
+
+    forceinline ModEvent
+    SingletonView::cardMax(Space*, unsigned int c) {
+      return c<1 ? ME_SET_FAILED : ME_SET_NONE;
+    }
+
+    forceinline ModEvent
+    SingletonView::include(Space* home,int c) { 
+      return me_inttoset(view.eq(home,c)); 
+    }
+
+    forceinline ModEvent
+    SingletonView::intersect(Space* home,int c) { 
+      return me_inttoset(view.eq(home,c)); 
+    }
+
+    forceinline ModEvent
+    SingletonView::intersect(Space* home,int i, int j) { 
+      ModEvent me1 = me_inttoset(view.gq(home,i));
+      ModEvent me2 = me_inttoset(view.lq(home,j));
+      if (me_failed(me1) || me_failed(me2))
+        return ME_SET_FAILED;
+      switch (me1) {
+      case ME_SET_NONE:
+      case ME_SET_LUB:
+        return me2;
+      case ME_SET_VAL:
+        return ME_SET_VAL;
+      default:
+        GECODE_NEVER;
+        return ME_SET_VAL;
+      }
+    }
+
+    forceinline ModEvent
+    SingletonView::exclude(Space* home,int c) { 
+      return me_inttoset(view.nq(home,c)); 
+    }
+
+    forceinline ModEvent
+    SingletonView::include(Space* home, int j, int k) {
+      return j==k ? me_inttoset(view.eq(home,j)) : ME_SET_FAILED ;
+    }
+
+    forceinline ModEvent
+    SingletonView::exclude(Space* home, int j, int k) {
+      ModEvent me1 = me_inttoset(view.gr(home,j));
+      ModEvent me2 = me_inttoset(view.le(home,k));
+      if (me_failed(me1) || me_failed(me2))
+        return ME_SET_FAILED;
+      switch (me1) {
+      case ME_SET_NONE:
+      case ME_SET_LUB:
+        return me2;
+      case ME_SET_VAL:
+        return ME_SET_VAL;
+      default:
+        GECODE_NEVER;
+        return ME_SET_VAL;
+      }
+    }
+
+    template <class I> ModEvent
+    SingletonView::excludeI(Space* home, I& iter) {
+      return me_inttoset(view.minus_r(home,iter));
+    }
+
+    template <class I> ModEvent
+    SingletonView::includeI(Space* home, I& iter) {
+      if (!iter())
+        return ME_SET_NONE;
+
+      if (iter.min()!=iter.max())
+        return ME_SET_FAILED;
+
+      int val = iter.min();
+      ++iter;
+      if ( iter() )
+        return ME_SET_FAILED;
+
+      return me_inttoset(view.eq(home, val));
+    }
+
+    template <class I> ModEvent
+    SingletonView::intersectI(Space* home, I& iter) {
+      return me_inttoset(view.inter_r(home,iter));
+    }
+
+    forceinline void
+    SingletonView::subscribe(Space* home, Propagator* p, PropCond pc,
+                             bool process) {
+      view.subscribe(home,p,pc_settoint(pc),process);
+    }
+    forceinline void
+    SingletonView::cancel(Space* home, Propagator* p, PropCond pc) {
+      view.cancel(home,p,pc_settoint(pc));
+    }
+
+    forceinline void
+    SingletonView::subscribe(Space* home, Advisor* a) {
+      view.subscribe(home,a);
+    }
+    forceinline void
+    SingletonView::cancel(Space* home, Advisor* a) {
+      view.cancel(home,a);
+    }
+
+
+    forceinline void
+    SingletonView::schedule(Space* home, Propagator* p, ModEvent me) {
+      return Gecode::Int::IntView::schedule(home,p,me_settoint(me));
+    }
+    forceinline ModEvent
+    SingletonView::me(ModEventDelta med) {
+      return me_inttoset(Int::IntView::me(med));
+    }
+    forceinline ModEventDelta
+    SingletonView::med(ModEvent me) {
+      return SetView::med(me_settoint(me));
+    }
+
+    forceinline void
+    SingletonView::update(Space* home, bool share, SingletonView& y) {
+      view.update(home,share,y.view);
+    }
+
+    forceinline Reflection::Arg*
+    SingletonView::spec(const Space* home, Reflection::VarMap& m) const {
+      return view.spec(home, m);
+    }
+
+    inline Support::Symbol
+    SingletonView::type(void) {
+      return Support::Symbol("Gecode::Set::SingletonView");
+    }
+
+    /*
+     * Delta information for advisors
+     *
+     * For SingletonViews, a glb change means that the view is assigned.
+     * Thus, the delta for the glb is always equal to the delta for the lub.
+     *
+     */
+
+    forceinline ModEvent
+    SingletonView::modevent(const Delta* d) {
+      return me_inttoset(Int::IntView::modevent(d));
+    }
+
+    forceinline int
+    SingletonView::glbMin(const Delta* d) const { return view.min(d); }
+
+    forceinline int
+    SingletonView::glbMax(const Delta* d) const { return view.max(d); }
+
+    forceinline bool
+    SingletonView::glbAny(const Delta* d) const { return view.any(d); }
+
+    forceinline int
+    SingletonView::lubMin(const Delta* d) const { return view.min(d); }
+
+    forceinline int
+    SingletonView::lubMax(const Delta* d) const { return view.max(d); }
+
+    forceinline bool
+    SingletonView::lubAny(const Delta* d) const { return view.any(d); }
+
+    /*
+     * Iterators
+     *
+     */
+
+    /**
+     * \brief %Range iterator for least upper bound of singleton set view
+     * \ingroup TaskActorSetView
+     */
+    template <>
+    class LubRanges<SingletonView> : public Gecode::Int::IntVarImpFwd {
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      LubRanges(void);
+      /// Initialize with ranges for view \a x
+      LubRanges(const SingletonView& x);
+      /// Initialize with ranges for view \a x
+      void init(const SingletonView& x);
+      //@}
+    };
+
+    forceinline
+    LubRanges<SingletonView>::LubRanges(void) {}
+
+    forceinline
+    LubRanges<SingletonView>::LubRanges(const SingletonView& s) :
+      Gecode::Int::IntVarImpFwd(s.base().var()) {}
+
+    forceinline void
+    LubRanges<SingletonView>::init(const SingletonView& s) {
+      Gecode::Int::IntVarImpFwd::init(s.base().var());
+    }
+
+    /**
+     * \brief %Range iterator for greatest lower bound of singleton set view
+     * \ingroup TaskActorSetView
+     */
+    template <>
+    class GlbRanges<SingletonView> {
+    private:
+      int  val;
+      bool flag;
+    public:
+      /// \name Constructors and initialization
+      //@{
+      /// Default constructor
+      GlbRanges(void);
+      /// Initialize with ranges for view \a x
+      GlbRanges(const SingletonView& x);
+      /// Initialize with ranges for view \a x
+      void init(const SingletonView& x);
+
+      /// \name Iteration control
+      //@{
+      /// Test whether iterator is still at a range or done
+      bool operator()(void) const;
+      /// Move iterator to next range (if possible)
+      void operator++(void);
+      //@}
+
+      /// \name Range access
+      //@{
+      /// Return smallest value of range
+      int min(void) const;
+      /// Return largest value of range
+      int max(void) const;
+      /// Return width of ranges (distance between minimum and maximum)
+      unsigned int width(void) const;
+      //@}
+    };
+
+    forceinline
+    GlbRanges<SingletonView>::GlbRanges(void) {}
+
+    forceinline void
+    GlbRanges<SingletonView>::init(const SingletonView& s) {
+      if (s.base().assigned()) {
+        val = s.base().val();
+        flag = true;
+      } else {
+        val = 0;
+        flag = false;
+      }
+    }
+
+    forceinline
+    GlbRanges<SingletonView>::GlbRanges(const SingletonView& s) {
+      init(s);
+    }
+
+    forceinline bool
+    GlbRanges<SingletonView>::operator()(void) const { return flag; }
+
+    forceinline void
+    GlbRanges<SingletonView>::operator++(void) { flag=false; }
+
+    forceinline int
+    GlbRanges<SingletonView>::min(void) const { return val; }
+    forceinline int
+    GlbRanges<SingletonView>::max(void) const { return val; }
+    forceinline unsigned int
+    GlbRanges<SingletonView>::width(void) const { return 1; }
+
+  }
+
+  /*
+   * Testing
+   *
+   */
+  forceinline bool
+  same(const Set::SingletonView& x, const Set::SingletonView& y) {
+    return same(x.base(),y.base());
+  }
+  forceinline bool
+  before(const Set::SingletonView& x, const Set::SingletonView& y) {
+    return before(x.base(),y.base());
+  }
+
+
+}
+
+// STATISTICS: set-var
+