gecoder-with-gecode 0.7.1 → 0.8.0

data/ext/gecode-2.1.1/gecode/set/projectors/set-expr.icc

@@ -0,0 +1,237 @@
+/* -*- 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, 2006
+ *     Christian Schulte, 2007
+ *
+ *  Last modified:
+ *     $Date: 2008-02-26 11:08:59 +0100 (Tue, 26 Feb 2008) $ by $Author: tack $
+ *     $Revision: 6312 $
+ *
+ *  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 {
+
+  /*
+   * Operations for set expression code
+   *
+   */
+
+  forceinline
+  SetExprCode::Stream::Stream(void) : n(0) {}
+
+  forceinline void 
+  SetExprCode::Stream::add(int i) {
+    is[n++] = i;
+  }
+
+  forceinline int 
+  SetExprCode::Stream::size(void) const {
+    return n;
+  }
+
+  forceinline int 
+  SetExprCode::Stream::operator[](int i) const {
+    return is[i];
+  }
+
+ 
+
+  forceinline
+  SetExprCode::SetExprCode(void) {}
+
+  forceinline
+  SetExprCode::SetExprCode(const SetExprCode::Stream& s) 
+    : c(s.size()) {
+    for (int i=s.size(); i--; )
+      c[i]=s[i];
+  }
+
+  forceinline
+  SetExprCode::SetExprCode(const SetExprCode& sc) : c(sc.c) {}
+
+  forceinline void
+  SetExprCode::update(Space* home, bool share, SetExprCode& sc) {
+    c.update(home, share, sc.c);
+  }
+  
+  forceinline int
+  SetExprCode::size(void) const { return c.size(); }
+
+  forceinline int
+  SetExprCode::operator[](int i) const { return c[i]; }
+
+
+  /*
+   * Operations for expressions
+   *
+   */
+
+  forceinline
+  SetExpr::SetExpr(void) : ax(NULL), sign(1) {}
+
+}
+
+inline Gecode::SetExpr
+operator-(const Gecode::SetExpr& s) { return Gecode::SetExpr(s, -1); }
+
+inline Gecode::SetExpr
+operator||(const Gecode::SetExpr& s, const Gecode::SetExpr& t) {
+  return Gecode::SetExpr(s, 1, Gecode::SetExpr::REL_UNION, t, 1);
+}
+
+inline Gecode::SetExpr
+operator&&(const Gecode::SetExpr& s, const Gecode::SetExpr& t) {
+  return Gecode::SetExpr(s, 1, Gecode::SetExpr::REL_INTER, t, 1);
+}
+
+inline Gecode::SetExpr
+operator-(const Gecode::SetExpr& s, const Gecode::SetExpr& t) {
+  return Gecode::SetExpr(s, 1, Gecode::SetExpr::REL_INTER, t, -1);
+}
+
+namespace Gecode {
+
+  /**
+   * \brief Range iterator for set expressions
+   */
+  class SetExprRanges {
+  private:
+    /// Reference-counted range iterators with virtual member functions
+    class Iter;
+    /// The actual iterator
+    Iter *i;
+    const SetExprRanges& operator=(const SetExprRanges&);
+  public:
+    /// \name Constructors and destructor
+    //@{    
+    /// Copy constructor
+    SetExprRanges(const SetExprRanges&);
+    /** Initialize with the views \a x, a set expression \a s,
+     *  and a flag whether \a s is to be interpreted in a monotone or
+     *  anti-monotone way
+     */
+    SetExprRanges(const ViewArray<Set::SetView>& x, SetExpr& s,
+                  bool monotone);
+    /** Initialize with the views \a x, a set expression code \a c,
+     *  and a flag whether \a c is to be interpreted in a monotone or
+     *  anti-monotone way
+     */
+    SetExprRanges(const ViewArray<Set::SetView>& x,
+                  const SetExprCode& s,
+                  bool monotone);
+    /// Destructor
+    ~SetExprRanges(void);
+    //@}
+
+    /// \name Iteration control
+    //@{
+    /// Move iterator to next range (if possible)
+    bool operator()(void);
+    /// Test whether iterator is still at a range or done
+    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 range (distance between minimum and maximum)
+    unsigned int width(void) const;
+    //@}
+  };
+
+  /**
+   * \brief Reference-counted range iterators with virtual member functions
+   *
+   */
+  class SetExprRanges::Iter {
+  public:
+    /// The actual iterator
+    Gecode::Iter::Ranges::Virt::Iterator* i;
+    /// Reference count
+    int num;
+
+    /// Construct from iterator
+    Iter(Gecode::Iter::Ranges::Virt::Iterator*);
+    /// Destructor
+    ~Iter(void);
+    /// Increment reference count
+    void increment(void);
+    /// Decrement reference count
+    bool decrement(void);
+  };
+
+  forceinline
+  SetExprRanges::Iter::Iter(Gecode::Iter::Ranges::Virt::Iterator* i0)
+    : i(i0), num(1) {}
+  
+  forceinline
+  SetExprRanges::Iter::~Iter(void) { delete i; }
+
+  forceinline void
+  SetExprRanges::Iter::increment(void) { ++num; }
+
+  forceinline bool
+  SetExprRanges::Iter::decrement(void) { return --num==0; }
+
+  forceinline
+  SetExprRanges::SetExprRanges(const SetExprRanges& s) : i(s.i) {
+    i->increment();
+  }
+
+  forceinline
+  SetExprRanges::~SetExprRanges(void) {
+    if (i->decrement())
+      delete i;
+  }
+
+  forceinline bool
+  SetExprRanges::operator()(void) { return (*(i->i))(); }
+  
+  forceinline void
+  SetExprRanges::operator++(void) { ++(*(i->i)); }
+
+  forceinline int
+  SetExprRanges::min(void) const { return i->i->min(); }
+
+  forceinline int
+  SetExprRanges::max(void) const { return i->i->max(); }
+
+  forceinline unsigned int
+  SetExprRanges::width(void) const { return i->i->width(); }
+
+}
+
+// STATISTICS: set-prop

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

@@ -0,0 +1,125 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004, 2005
+ *
+ *  Last modified:
+ *     $Date: 2008-01-29 13:37:51 +0100 (Tue, 29 Jan 2008) $ by $Author: tack $
+ *     $Revision: 5993 $
+ *
+ *  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 {
+
+  /**
+   * \defgroup TaskPropSetPat Patterns for set propagators
+   *
+   * The optional last Boolean argument to the constructor for creation
+   * defines whether deletion must be forced.
+   * \ingroup TaskActor
+   */
+
+  //@{
+
+
+  /**
+   * \brief Set/Int connection propagator
+   *
+   * Stores single view of type \a View with propagation condition \a pcs
+   * and an integer variable with propagation condition \a pci.
+   */
+  template <class View, PropCond pcs, PropCond pci>
+  class IntSetPropagator : public Propagator {
+  protected:
+    View x0;
+    Gecode::Int::IntView x1;
+    /// Constructor for cloning
+    IntSetPropagator(Space* home,bool,IntSetPropagator&);
+    /// Constructor for creation
+    IntSetPropagator(Space* home,View,Gecode::Int::IntView);
+  public:
+    /// Cost function (defined as PC_BINARY_LO)
+    virtual PropCost cost(ModEventDelta med) const;
+    /// Delete propagator and return its size
+    virtual size_t dispose(Space* home);
+    /// Return specification given a variable map \a m and a \a name
+    Reflection::ActorSpec spec(const Space* home, Reflection::VarMap& m,
+                                const Support::Symbol& name) const;
+  };
+
+  //@}
+
+  template <class View, PropCond pcs, PropCond pci>
+  IntSetPropagator<View,pcs,pci>::IntSetPropagator
+  (Space* home, View y0, Gecode::Int::IntView y1)
+    : Propagator(home), x0(y0), x1(y1) {
+    x0.subscribe(home,this,pcs);
+    x1.subscribe(home,this,pci);
+  }
+
+  template <class View, PropCond pcs, PropCond pci>
+  forceinline
+  IntSetPropagator<View,pcs,pci>::IntSetPropagator
+  (Space* home, bool share, IntSetPropagator<View,pcs,pci>& p)
+    : Propagator(home,share,p) {
+    x0.update(home,share,p.x0);
+    x1.update(home,share,p.x1);
+  }
+
+  template <class View, PropCond pcs, PropCond pci>
+  PropCost
+  IntSetPropagator<View,pcs,pci>::cost(ModEventDelta) const {
+    return PC_BINARY_LO;
+  }
+
+  template <class View, PropCond pcs, PropCond pci>
+  size_t
+  IntSetPropagator<View,pcs,pci>::dispose(Space* home) {
+    if (!home->failed()) {
+      x0.cancel(home,this,pcs);
+      x1.cancel(home,this,pci);
+    }
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  template <class View, PropCond pcs, PropCond pci>
+  Reflection::ActorSpec
+  IntSetPropagator<View,pcs,pci>::spec(const Space* home,
+                                       Reflection::VarMap& m,
+                                       const Support::Symbol& name) const {
+    Reflection::ActorSpec s(name);
+    return s << x0.spec(home, m)
+             << x1.spec(home, m);
+  }
+
+}
+
+// STATISTICS: set-prop
+

data/ext/gecode-2.1.1/gecode/set/rel-op-const.cc

@@ -0,0 +1,332 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Contributing authors:
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004, 2005
+ *
+ *  Last modified:
+ *     $Date: 2008-02-20 18:17:24 +0100 (Wed, 20 Feb 2008) $ by $Author: tack $
+ *     $Revision: 6253 $
+ *
+ *  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"
+#include "gecode/set/rel.hh"
+#include "gecode/set/rel-op.hh"
+
+namespace Gecode {
+  using namespace Gecode::Set;
+  using namespace Gecode::Set::Rel;
+  using namespace Gecode::Set::RelOp;
+
+  void
+  rel(Space* home, const IntSet& x, SetOpType op, SetVar y, SetRelType r,
+      SetVar z) {
+    Set::Limits::check(x, "Set::rel");
+    ConstantView xv(home, x);
+    rel_op_post<ConstantView,SetView,SetView>(home, xv, op, y, r, z);
+  }  
+
+  void
+  rel(Space* home, SetVar x, SetOpType op, const IntSet& y, SetRelType r,
+      SetVar z) {
+    Set::Limits::check(y, "Set::rel");
+    ConstantView yv(home, y);
+
+    if (op==SOT_MINUS) {
+      switch(r) {
+      case SRT_EQ:
+        {
+          GlbRanges<ConstantView> yr(yv);
+          RangesCompl<GlbRanges<ConstantView> > yrc(yr);
+          IntSet yc(yrc);
+          ConstantView cy(home, yc);
+          GECODE_ES_FAIL(home,
+                         (Intersection<ConstantView,
+                          SetView,SetView>
+                          ::post(home,cy,x,z)));
+        }
+        break;
+      case SRT_NQ:
+        {
+          SetVar tmp(home);
+          GECODE_ES_FAIL(home,
+                         (Distinct<SetView,SetView>
+                          ::post(home,z,tmp)));
+          GlbRanges<ConstantView> yr(yv);
+          RangesCompl<GlbRanges<ConstantView> > yrc(yr);
+          IntSet yc(yrc);
+          ConstantView cy(home, yc);
+          GECODE_ES_FAIL(home,
+                         (Intersection<ConstantView,
+                          SetView,SetView>
+                          ::post(home,cy,x,tmp)));
+        }
+        break;
+      case SRT_SUB:
+        {
+          GlbRanges<ConstantView> yr(yv);
+          RangesCompl<GlbRanges<ConstantView> > yrc(yr);
+          IntSet yc(yrc);
+          ConstantView cy(home, yc);
+          GECODE_ES_FAIL(home,
+                         (SuperOfInter<ConstantView,SetView,SetView>
+                          ::post(home,cy,x,z)));
+
+        }
+        break;
+      case SRT_SUP:
+        {
+          SetVar tmp(home);
+          GECODE_ES_FAIL(home,
+                         (SubSet<SetView,SetView>::post(home,z,tmp)));
+          
+          GlbRanges<ConstantView> yr(yv);
+          RangesCompl<GlbRanges<ConstantView> > yrc(yr);
+          IntSet yc(yrc);
+          ConstantView cy(home, yc);
+
+          SetView xv(x);
+          GECODE_ES_FAIL(home,
+                         (Intersection<ConstantView,
+                          SetView,SetView>
+                          ::post(home,cy,xv,tmp)));
+        }
+        break;
+      case SRT_DISJ:
+        {
+          SetVar tmp(home);
+          EmptyView emptyset;
+          GECODE_ES_FAIL(home,(SuperOfInter<SetView,SetView,EmptyView>
+                               ::post(home, z, tmp, emptyset)));
+
+          GlbRanges<ConstantView> yr(yv);
+          RangesCompl<GlbRanges<ConstantView> > yrc(yr);
+          IntSet yc(yrc);
+          ConstantView cy(home, yc);
+          GECODE_ES_FAIL(home,
+                         (Intersection<ConstantView,
+                          SetView,SetView>
+                          ::post(home,cy,x,tmp)));
+        }
+        break;
+      case SRT_CMPL:
+        {
+          SetView xv(x);
+          ComplementView<SetView> cx(xv);
+          GECODE_ES_FAIL(home,
+                         (Union<ConstantView,
+                          ComplementView<SetView>,
+                          SetView>::post(home, yv, cx, z)));
+        }
+        break;
+      }
+    } else {
+      rel_op_post<ConstantView,SetView,SetView>(home, yv, op, x, r, z);
+    }
+  }  
+
+  void
+  rel(Space* home, SetVar x, SetOpType op, SetVar y, SetRelType r,
+      const IntSet& z) {
+    Set::Limits::check(z, "Set::rel");
+    if (r == SRT_CMPL) {
+      IntSetRanges zr(z);
+      RangesCompl<IntSetRanges> zrc(zr);
+      IntSet zc(zrc);
+      ConstantView cz(home, zc);
+      rel_eq<SetView,SetView,ConstantView>(home, x, op, y, cz);
+    } else {
+      ConstantView zv(home, z);
+      rel_op_post_nocompl<SetView,SetView,ConstantView>(home, x, op, y, r, zv);
+    }
+  }  
+
+  void
+  rel(Space* home, const IntSet& x, SetOpType op, SetVar y, SetRelType r,
+      const IntSet& z) {
+    Set::Limits::check(x, "Set::rel");
+    Set::Limits::check(z, "Set::rel");
+    ConstantView xv(home, x);
+    if (r == SRT_CMPL) {
+      IntSetRanges zr(z);
+      RangesCompl<IntSetRanges> zrc(zr);
+      IntSet zc(zrc);
+      ConstantView cz(home, zc);
+      rel_eq<ConstantView,SetView,ConstantView>(home, xv, op, y, cz);
+    } else {
+      ConstantView zv(home, z);
+      rel_op_post_nocompl<ConstantView,SetView,ConstantView>(home, xv, op, y, r, zv);
+    }
+  }  
+
+  void
+  rel(Space* home, SetVar x, SetOpType op, const IntSet& y, SetRelType r,
+      const IntSet& z) {
+    Set::Limits::check(y, "Set::rel");
+    Set::Limits::check(z, "Set::rel");
+    ConstantView yv(home, y);
+    ConstantView zv(home, z);
+
+    if (op==SOT_MINUS) {
+      switch(r) {
+      case SRT_EQ:
+        {
+          GlbRanges<ConstantView> yr(yv);
+          RangesCompl<GlbRanges<ConstantView> > yrc(yr);
+          IntSet yc(yrc);
+          ConstantView cy(home, yc);
+          GECODE_ES_FAIL(home,
+                         (Intersection<ConstantView,
+                          SetView,ConstantView>
+                          ::post(home,cy,x,zv)));
+        }
+        break;
+      case SRT_NQ:
+        {
+          SetVar tmp(home);
+          GECODE_ES_FAIL(home,
+                         (Distinct<SetView,ConstantView>
+                          ::post(home,tmp,zv)));
+          GlbRanges<ConstantView> yr(yv);
+          RangesCompl<GlbRanges<ConstantView> > yrc(yr);
+          IntSet yc(yrc);
+          ConstantView cy(home, yc);
+          GECODE_ES_FAIL(home,
+                         (Intersection<ConstantView,
+                          SetView,SetView>
+                          ::post(home,cy,x,tmp)));
+        }
+        break;
+      case SRT_SUB:
+        {
+          GlbRanges<ConstantView> yr(yv);
+          RangesCompl<GlbRanges<ConstantView> > yrc(yr);
+          IntSet yc(yrc);
+          ConstantView cy(home, yc);
+          GECODE_ES_FAIL(home,
+                         (SuperOfInter<ConstantView,SetView,ConstantView>
+                          ::post(home,cy,x,zv)));
+
+        }
+        break;
+      case SRT_SUP:
+        {
+          // z <= tmp
+          SetVar tmp(home,z,Limits::min, Limits::max);
+          SetView xv(x);
+
+          GlbRanges<ConstantView> yr(yv);
+          RangesCompl<GlbRanges<ConstantView> > yrc(yr);
+          IntSet yc(yrc);
+          ConstantView cy(home, yc);
+          
+          GECODE_ES_FAIL(home,
+                         (Intersection<ConstantView,
+                          SetView,SetView>
+                          ::post(home,cy,xv,tmp)));
+        }
+        break;
+      case SRT_DISJ:
+        {
+          SetVar tmp(home);
+          SetView tmpv(tmp);
+          IntSetRanges zi(z);
+          GECODE_ME_FAIL(home, tmpv.excludeI(home, zi));
+          
+          GlbRanges<ConstantView> yr(yv);
+          RangesCompl<GlbRanges<ConstantView> > yrc(yr);
+          IntSet yc(yrc);
+          ConstantView cy(home, yc);
+          GECODE_ES_FAIL(home,
+                         (Intersection<ConstantView,
+                          SetView,SetView>
+                          ::post(home,cy,x,tmp)));
+        }
+        break;
+      case SRT_CMPL:
+        {
+          SetView xv(x);
+          ComplementView<SetView> cx(xv);
+          GECODE_ES_FAIL(home,
+                         (Union<ConstantView,
+                          ComplementView<SetView>,
+                          ConstantView>::post(home, yv, cx, zv)));
+        }
+        break;
+      }
+    } else {
+      if (r == SRT_CMPL) {
+        IntSetRanges zr(z);
+        RangesCompl<IntSetRanges> zrc(zr);
+        IntSet zc(zrc);
+        ConstantView cz(home, zc);
+        rel_eq<ConstantView,SetView,ConstantView>(home, yv, op, x, cz);
+      } else {
+        rel_op_post_nocompl<ConstantView,SetView,ConstantView>(home, yv, op, x, r, zv);
+      }
+    }
+  }  
+
+  namespace {
+
+    GECODE_REGISTER3(RelOp::Union<ConstantView, ComplementView<SetView>, ConstantView>);
+    GECODE_REGISTER3(RelOp::Union<ConstantView, ComplementView<SetView>, SetView>);
+    GECODE_REGISTER3(RelOp::Union<ConstantView, SetView, ComplementView<SetView> >);
+    GECODE_REGISTER3(RelOp::Union<ConstantView, SetView, ConstantView>);
+    GECODE_REGISTER3(RelOp::Union<ConstantView, SetView, SetView>);
+    GECODE_REGISTER3(RelOp::Union<SetView, SetView, ConstantView>);
+
+    GECODE_REGISTER3(RelOp::Intersection<ConstantView, ComplementView<SetView>, ConstantView>);
+    GECODE_REGISTER3(RelOp::Intersection<ConstantView, ComplementView<SetView>, SetView>);
+    GECODE_REGISTER3(RelOp::Intersection<ConstantView, ComplementView<SetView>, ComplementView<SetView> >);
+    GECODE_REGISTER3(RelOp::Intersection<ConstantView, SetView, ComplementView<SetView> >);
+    GECODE_REGISTER3(RelOp::Intersection<ConstantView, SetView, ConstantView>);
+    GECODE_REGISTER3(RelOp::Intersection<ConstantView, SetView, SetView>);
+    GECODE_REGISTER3(RelOp::Intersection<SetView, ComplementView<SetView>, ConstantView>);
+    GECODE_REGISTER3(RelOp::Intersection<SetView, SetView, ConstantView>);
+
+    GECODE_REGISTER3(RelOp::SubOfUnion<ConstantView, SetView, ConstantView>);
+    GECODE_REGISTER3(RelOp::SubOfUnion<ConstantView, SetView, SetView>);
+    GECODE_REGISTER3(RelOp::SubOfUnion<SetView, SetView, ConstantView>);
+
+    GECODE_REGISTER3(RelOp::SuperOfInter<ConstantView, ComplementView<SetView>, ConstantView>);
+    GECODE_REGISTER3(RelOp::SuperOfInter<ConstantView, ComplementView<SetView>, SetView>);
+    GECODE_REGISTER3(RelOp::SuperOfInter<ConstantView, SetView, EmptyView>);
+    GECODE_REGISTER3(RelOp::SuperOfInter<ConstantView, SetView, ConstantView>);
+    GECODE_REGISTER3(RelOp::SuperOfInter<ConstantView, SetView, SetView>);
+    GECODE_REGISTER3(RelOp::SuperOfInter<SetView, ComplementView<SetView>, ConstantView>);
+    GECODE_REGISTER3(RelOp::SuperOfInter<SetView, SetView, ConstantView>);
+  }
+
+}
+
+// STATISTICS: set-post