gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/gecode/set/rel/re-subset.icc

@@ -0,0 +1,174 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 09:31:51 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7288 $
+ *
+ *  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
+  ReSubset<View0,View1>::ReSubset(Space* home, View0 y0,
+                                  View1 y1, Gecode::Int::BoolView y2)
+    : Propagator(home), x0(y0), x1(y1), b(y2) {
+    b.subscribe(home,this, Gecode::Int::PC_INT_VAL);
+    x0.subscribe(home,this, PC_SET_ANY);
+    x1.subscribe(home,this, PC_SET_ANY);
+  }
+
+  template <class View0, class View1>
+  forceinline
+  ReSubset<View0,View1>::ReSubset(Space* home, bool share, ReSubset& p)
+    : Propagator(home,share,p) {
+    x0.update(home,share,p.x0);
+    x1.update(home,share,p.x1);
+    b.update(home,share,p.b);
+  }
+
+  template <class View0, class View1>
+  PropCost
+  ReSubset<View0,View1>::cost(ModEventDelta) const {
+    return PC_TERNARY_LO;
+  }
+
+  template <class View0, class View1>
+  Support::Symbol
+  ReSubset<View0,View1>::ati(void) {
+    return Reflection::mangle<View0,View1>("Gecode::Set::Rel::ReSubset");
+  }
+
+  template <class View0, class View1>
+  Reflection::ActorSpec
+  ReSubset<View0,View1>::spec(const Space* home,
+                              Reflection::VarMap& m) const {
+    Reflection::ActorSpec s(ati());
+    return s << x0.spec(home, m)
+             << x1.spec(home, m)
+             << b.spec(home, m);
+  }
+
+  template <class View0, class View1>
+  void
+  ReSubset<View0,View1>::post(Space* home, Reflection::VarMap& vars,
+                              const Reflection::ActorSpec& spec) {
+    spec.checkArity(3);
+    View0 x0(home, vars, spec[0]);
+    View1 x1(home, vars, spec[1]);
+    Gecode::Int::BoolView b(home, vars, spec[2]);
+    (void) new (home) ReSubset(home,x0,x1,b);
+  }
+
+  template <class View0, class View1>
+  size_t
+  ReSubset<View0,View1>::dispose(Space* home) {
+    assert(!home->failed());
+    b.cancel(home,this, Gecode::Int::PC_INT_VAL);
+    x0.cancel(home,this, PC_SET_ANY);
+    x1.cancel(home,this, PC_SET_ANY);
+    (void) Propagator::dispose(home);
+    return sizeof(*this);
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  ReSubset<View0,View1>::post(Space* home, View0 x0, View1 x1,
+                              Gecode::Int::BoolView b) {
+    (void) new (home) ReSubset<View0,View1>(home,x0,x1,b);
+    return ES_OK;
+  }
+
+  template <class View0, class View1>
+  Actor*
+  ReSubset<View0,View1>::copy(Space* home, bool share) {
+    return new (home) ReSubset<View0,View1>(home,share,*this);
+  }
+
+  template <class View0, class View1>
+  ExecStatus
+  ReSubset<View0,View1>::propagate(Space* home, ModEventDelta) {
+    if (b.one())
+      GECODE_REWRITE(this,(SubSet<View0,View1>::post(home,x0,x1)));
+    if (b.zero())
+      GECODE_REWRITE(this,(NoSubSet<View0,View1>::post(home,x0,x1)));
+
+    // check whether cardinalities still allow subset
+    if (x0.cardMin() > x1.cardMax()) {
+      GECODE_ME_CHECK(b.zero_none(home));
+      return ES_SUBSUMED(this,home);
+    }
+
+    // check lub(x0) subset glb(x1)
+    {
+      LubRanges<View0> x0ub(x0);
+      GlbRanges<View1> x1lb(x1);
+      Iter::Ranges::Diff<LubRanges<View0>,GlbRanges<View1> > d(x0ub,x1lb);
+      if (!d()) {
+        GECODE_ME_CHECK(b.one_none(home));
+        return ES_SUBSUMED(this,home);
+      }
+    }
+
+    // check glb(x0) subset lub(x1)
+    {
+      GlbRanges<View0> x0lb(x0);
+      LubRanges<View1> x1ub(x1);
+      Iter::Ranges::Diff<GlbRanges<View0>,LubRanges<View1> > d(x0lb,x1ub);
+      if (d()) {
+        GECODE_ME_CHECK(b.zero_none(home));
+        return ES_SUBSUMED(this,home);
+      } else if (x0.assigned() && x1.assigned()) {
+        GECODE_ME_CHECK(b.one_none(home));
+        return ES_SUBSUMED(this,home);
+      }
+    }
+    
+    if (x0.cardMin() > 0) {
+      LubRanges<View0> x0ub(x0);
+      LubRanges<View1> x1ub(x1);
+      Iter::Ranges::Inter<LubRanges<View0>,LubRanges<View1> >
+        i(x0ub,x1ub);
+      if (!i()) {
+        GECODE_ME_CHECK(b.zero_none(home));
+        return ES_SUBSUMED(this,home);
+      }
+    }
+    
+    return ES_FIX;
+  }
+
+}}}
+
+// STATISTICS: set-prop

data/ext/gecode-2.2.0/gecode/set/var-imp/set.cc

@@ -0,0 +1,215 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 09:39:08 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7297 $
+ *
+ *  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"
+
+
+namespace Gecode { namespace Set {
+
+  /*
+   * "Standard" tell operations
+   *
+   */
+  ModEvent
+  SetVarImp::cardMin_full(Space* home) {
+    ModEvent me = ME_SET_CARD;
+    if (_cardMin == lub.size()) {
+      glb.become(home, lub);
+      me = ME_SET_VAL;
+    }
+    SetDelta d;
+    return notify(home, me, &d);
+  }
+
+  ModEvent
+  SetVarImp::cardMax_full(Space* home) {
+    ModEvent me = ME_SET_CARD;
+    if (_cardMax == glb.size()) {
+      lub.become(home, glb);
+      me = ME_SET_VAL;
+    }
+    SetDelta d;
+    return notify(home, me, &d);
+  }
+
+  ModEvent
+  SetVarImp::processLubChange(Space* home, SetDelta& d) {
+    ModEvent me = ME_SET_LUB;
+    if (_cardMax > lub.size()) {
+      _cardMax = lub.size();
+      if (_cardMin > _cardMax) {
+        glb.become(home, lub);
+        _cardMin = glb.size();
+        _cardMax = glb.size();
+        return ME_SET_FAILED;
+      }
+      me = ME_SET_CLUB;
+    }
+    if (_cardMax == lub.size() && _cardMin == _cardMax) {
+      glb.become(home, lub);
+      me = ME_SET_VAL;
+      assert(d.glbMin() == 1);
+      assert(d.glbMax() == 0);
+    }
+    return notify(home, me, &d);
+  }
+
+  ModEvent
+  SetVarImp::processGlbChange(Space* home, SetDelta& d) {
+    ModEvent me = ME_SET_GLB;
+    if (_cardMin < glb.size()) {
+      _cardMin = glb.size();
+      if (_cardMin > _cardMax) {
+        glb.become(home, lub);
+        _cardMin = glb.size();
+        _cardMax = glb.size();
+        return ME_SET_FAILED;
+      }
+      me = ME_SET_CGLB;
+    }
+    if (_cardMin == glb.size() && _cardMin == _cardMax) {
+      lub.become(home, glb);
+      me = ME_SET_VAL;
+      assert(d.lubMin() == 1);
+      assert(d.lubMax() == 0);
+    }
+    return notify(home, me, &d);
+  }
+
+  /*
+   * Copying variables
+   *
+   */
+
+  forceinline
+  SetVarImp::SetVarImp(Space* home, bool share, SetVarImp& x)
+    : SetVarImpBase(home,share,x),
+      _cardMin(x._cardMin), _cardMax(x._cardMax) {
+    lub.update(home, x.lub);
+    if (x.assigned()) {
+      glb.become(home,lub);
+    } else {
+      glb.update(home,x.glb);
+    }
+  }
+
+
+  SetVarImp*
+  SetVarImp::perform_copy(Space* home, bool share) {
+    return new (home) SetVarImp(home,share,*this);
+  }
+
+  Reflection::Arg*
+  SetVarImp::spec(const Space*, Reflection::VarMap& m) const {
+    int specIndex = m.index(this);
+    if (specIndex != -1)
+      return Reflection::Arg::newVar(specIndex);
+
+    int glbsize = 0;
+    {
+      BndSetRanges lrs(glb);
+      while (lrs()) { glbsize++; ++lrs; }
+    }
+    
+    Reflection::IntArrayArg* glbdom = Reflection::Arg::newIntArray(glbsize*2);
+    BndSetRanges lr(glb);
+    for (int count=0; lr(); ++lr) {
+      (*glbdom)[count++] = lr.min();
+      (*glbdom)[count++] = lr.max();
+    }
+
+    int lubsize = 0;
+    {
+      BndSetRanges urs(lub);
+      while (urs()) { lubsize++; ++urs; }
+    }
+    
+    BndSetRanges ur(lub);
+    Reflection::IntArrayArg* lubdom = Reflection::Arg::newIntArray(lubsize*2);
+    for (int count=0; ur(); ++ur) {
+      (*lubdom)[count++] = ur.min();
+      (*lubdom)[count++] = ur.max();
+    }
+
+    Reflection::Arg* pair =
+      Reflection::Arg::newPair(
+        Reflection::Arg::newPair(glbdom, Reflection::Arg::newInt(_cardMin)),
+        Reflection::Arg::newPair(lubdom, Reflection::Arg::newInt(_cardMax)));
+
+    Reflection::VarSpec* spec = new Reflection::VarSpec(vti, pair, 
+                                                        assigned());
+    return (Reflection::Arg::newVar(m.put(this, spec)));
+  }
+
+  VarImpBase*
+  SetVarImp::create(Space* home, Reflection::VarSpec& spec) {
+    int cardMin = spec.dom()->first()->second()->toInt();
+    int cardMax = spec.dom()->second()->second()->toInt();
+    Reflection::IntArrayArgRanges 
+      glb(spec.dom()->first()->first()->toIntArray());
+    Reflection::IntArrayArgRanges 
+      lub(spec.dom()->second()->first()->toIntArray());
+    return new (home) SetVarImp(home, IntSet(glb), IntSet(lub),
+                                cardMin, cardMax);
+  }
+
+  void
+  SetVarImp::constrain(Space* home, VarImpBase* v,
+                       Reflection::VarSpec& spec) {
+    int cardMin = spec.dom()->first()->second()->toInt();
+    int cardMax = spec.dom()->second()->second()->toInt();
+    Reflection::IntArrayArgRanges 
+      glb(spec.dom()->first()->first()->toIntArray());
+    Reflection::IntArrayArgRanges 
+      lub(spec.dom()->second()->first()->toIntArray());
+    SetVarImp* s = static_cast<SetVarImp*>(v);
+    GECODE_ME_FAIL(home, s->cardMin(home, cardMin));
+    GECODE_ME_FAIL(home, s->cardMax(home, cardMax));
+    GECODE_ME_FAIL(home, s->includeI(home, glb));
+    GECODE_ME_FAIL(home, s->intersectI(home, lub));
+  }
+
+  namespace {
+    Reflection::VarImpRegistrar<SetVarImp> registerSetVarImp;
+  }
+
+}}
+
+// STATISTICS: set-var
+

data/ext/gecode-2.2.0/gecode/set/var/set.icc

@@ -0,0 +1,303 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *     Christian Schulte <schulte@gecode.org>
+ *     Gabor Szokoli <szokoli@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2004
+ *     Christian Schulte, 2004
+ *     Gabor Szokoli, 2004
+ *
+ *  Last modified:
+ *     $Date: 2008-07-11 09:31:51 +0200 (Fri, 11 Jul 2008) $ by $Author: tack $
+ *     $Revision: 7288 $
+ *
+ *  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 {
+
+  /*
+   * Constructors and access
+   *
+   */
+
+  forceinline
+  SetVar::SetVar(void) {}
+
+  forceinline
+  SetVar::SetVar(const SetVar& x) 
+    : VarBase<Set::SetVarImp>(x.varimp) {}
+
+  forceinline
+  SetVar::SetVar(const Set::SetView& x) 
+    : VarBase<Set::SetVarImp>(x.var()) {}
+
+  forceinline
+  SetVar::SetVar(const Reflection::Var& x) 
+    : VarBase<Set::SetVarImp>(x.var<Set::SetVarImp>()) {}
+
+  forceinline void
+  SetVar::init(Space* home) {
+    varimp = new (home) Set::SetVarImp(home);
+  }
+
+  forceinline void
+  SetVar::init(Space* home,int lbMin,int lbMax,int ubMin,int ubMax,
+               unsigned int cardMin, unsigned int cardMax) {
+    varimp = new (home) Set::SetVarImp(home, lbMin, lbMax, ubMin, ubMax,
+                                       cardMin, cardMax);
+  }
+
+  forceinline void
+  SetVar::init(Space* home, const IntSet& glb,int ubMin,int ubMax,
+               unsigned int cardMin, unsigned int cardMax) {
+    varimp = new (home) Set::SetVarImp(home, glb, ubMin, ubMax, 
+                                       cardMin, cardMax);
+  }
+
+  forceinline void
+  SetVar::init(Space* home, int lbMin,int lbMax,const IntSet& lub,
+               unsigned int cardMin, unsigned int cardMax) {
+    varimp = new (home) Set::SetVarImp(home, lbMin, lbMax, lub, 
+                                       cardMin, cardMax);
+  }
+
+  forceinline void
+  SetVar::init(Space* home, const IntSet& glb, const IntSet& lub,
+               unsigned int cardMin, unsigned int cardMax) {
+    varimp = new (home) Set::SetVarImp(home, glb, lub, cardMin, cardMax);
+  }
+
+
+
+  /*
+   * Variable information
+   *
+   */
+
+  forceinline unsigned int
+  SetVar::glbSize(void) const { return varimp->glbSize(); }
+
+  forceinline unsigned int
+  SetVar::lubSize(void) const { return varimp->lubSize(); }
+
+  forceinline unsigned int
+  SetVar::unknownSize(void) const { return varimp->lubSize()-varimp->glbSize(); }
+
+  forceinline bool
+  SetVar::assigned(void)  const { return varimp->assigned(); }
+
+  forceinline bool
+  SetVar::contains(int i) const { return varimp->knownIn(i); }
+
+  forceinline bool
+  SetVar::notContains(int i) const { return varimp->knownOut(i); }
+
+  forceinline unsigned int
+  SetVar::cardMin(void) const { return varimp->cardMin(); }
+
+  forceinline unsigned int
+  SetVar::cardMax(void) const { return varimp->cardMax(); }
+
+  forceinline int
+  SetVar::lubMin(void) const { return varimp->lubMin(); }
+
+  forceinline int
+  SetVar::lubMax(void) const { return varimp->lubMax(); }
+
+  forceinline int
+  SetVar::glbMin(void) const { return varimp->glbMin(); }
+
+  forceinline int
+  SetVar::glbMax(void) const { return varimp->glbMax(); }
+
+  /*
+   * Cloning
+   *
+   */
+
+  forceinline void
+  SetVar::update(Space* home, bool share, SetVar& y) {
+    varimp = y.varimp->copy(home,share);
+  }
+
+
+  /*
+   * Range and value iterators for set variables
+   *
+   */
+
+  forceinline
+  SetVarGlbRanges::SetVarGlbRanges(void) {}
+
+  forceinline
+  SetVarGlbRanges::SetVarGlbRanges(const SetVar& s)
+    : iter(s.var()) {}
+
+  forceinline
+  bool
+  SetVarGlbRanges::operator()(void) const { return iter(); }
+
+  forceinline
+  void
+  SetVarGlbRanges::operator++(void) { ++iter; }
+
+  forceinline
+  int
+  SetVarGlbRanges::min(void) const { return iter.min(); }
+
+  forceinline
+  int
+  SetVarGlbRanges::max(void) const { return iter.max(); }
+
+  forceinline
+  unsigned int
+  SetVarGlbRanges::width(void) const { return iter.width(); }  
+
+  forceinline
+  SetVarLubRanges::SetVarLubRanges(void) {}
+
+  forceinline
+  SetVarLubRanges::SetVarLubRanges(const SetVar& s)
+    : iter(s.var()) {}
+
+  forceinline
+  bool
+  SetVarLubRanges::operator()(void) const { return iter(); }
+
+  forceinline
+  void
+  SetVarLubRanges::operator++(void) { ++iter; }
+
+  forceinline
+  int
+  SetVarLubRanges::min(void) const { return iter.min(); }
+
+  forceinline
+  int
+  SetVarLubRanges::max(void) const { return iter.max(); }
+
+  forceinline
+  unsigned int
+  SetVarLubRanges::width(void) const { return iter.width(); }  
+
+  forceinline
+  SetVarUnknownRanges::SetVarUnknownRanges(void) {}
+
+  forceinline
+  SetVarUnknownRanges::SetVarUnknownRanges(const SetVar& s) {
+    iter.init(s.var());
+  }
+
+  forceinline
+  bool
+  SetVarUnknownRanges::operator()(void) const { return iter(); }
+
+  forceinline
+  void
+  SetVarUnknownRanges::operator++(void) { ++iter; }
+
+  forceinline
+  int
+  SetVarUnknownRanges::min(void) const { return iter.min(); }
+
+  forceinline
+  int
+  SetVarUnknownRanges::max(void) const { return iter.max(); }
+
+  forceinline
+  unsigned int
+  SetVarUnknownRanges::width(void) const { return iter.width(); }  
+
+  forceinline
+  SetVarGlbValues::SetVarGlbValues(const SetVar& x) {
+    SetVarGlbRanges ivr(x);
+    iter.init(ivr);
+  }
+
+  forceinline bool
+  SetVarGlbValues::operator()(void) const {
+    return iter();
+  }
+
+  forceinline void
+  SetVarGlbValues::operator++(void) {
+    ++iter;
+  }
+
+  forceinline int
+  SetVarGlbValues::val(void) const {
+    return iter.val();
+  }
+
+  forceinline
+  SetVarLubValues::SetVarLubValues(const SetVar& x) {
+    SetVarLubRanges ivr(x);
+    iter.init(ivr);
+  }
+
+  forceinline bool
+  SetVarLubValues::operator()(void) const {
+    return iter();
+  }
+
+  forceinline void
+  SetVarLubValues::operator++(void) {
+    ++iter;
+  }
+
+  forceinline int
+  SetVarLubValues::val(void) const {
+    return iter.val();
+  }
+
+  forceinline
+  SetVarUnknownValues::SetVarUnknownValues(const SetVar& x) {
+    SetVarUnknownRanges ivr(x);
+    iter.init(ivr);
+  }
+
+  forceinline bool
+  SetVarUnknownValues::operator()(void) const {
+    return iter();
+  }
+
+  forceinline void
+  SetVarUnknownValues::operator++(void) {
+    ++iter;
+  }
+
+  forceinline int
+  SetVarUnknownValues::val(void) const {
+    return iter.val();
+  }
+
+}
+
+// STATISTICS: set-var
+