1 files changed, 17 insertions, 22 deletions

diff --git a/impl/FixpointAlgorithm.hpp b/impl/FixpointAlgorithm.hpp
index f199476..4c84ff2 100644
--- a/impl/FixpointAlgorithm.hpp
+++ b/impl/FixpointAlgorithm.hpp
@@ -33,40 +33,23 @@ struct SmartFixpointAlgorithm : public FixpointAlgorithm<Domain> {
     DynamicVariableAssignment(const EquationSystem<Domain>& system)
       : _system(system),
         _evaluating(NULL),
-        _values(system.variableCount(), -infinity<Domain>()),
+        _values(system.variableCount(), infinity<Domain>()),
         _stable(system.variableCount()),
         _haveValue(system.variableCount()),
-        _influence(system.variableCount(), IdSet<Variable<Domain> >(system.variableCount())),
-        _id(0) { }
+        _influence(system.variableCount(), IdSet<Variable<Domain> >(system.variableCount())) { }
 
     const Domain& operator[](const Variable<Domain>& var) const {
-      _id++;
       solve(var);
-      for (unsigned int i = 0; i < _id; ++i) {
-        std::cout << "  ";
-      }
-      std::cout << "operator[] " << var.name() << " => " << _values[var] << std::endl;
-      _id--;
-      if (_evaluating) {
-        _influence[var].insert(*_evaluating);
-      }
       return _values[var];
     }
 
     private:
+
     void solve(const Variable<Domain>& x) const {
       if (!_stable.contains(x)) {
         _stable.insert(x);
-        for (unsigned int i = 0; i < _id; ++i) {
-          std::cout << "  ";
-        }
-        std::cout << "solve(" << x.name() << ") " << &x << " " << _evaluating << std::endl;
-        std::cout << _stable << std::endl;
 
-        const Variable<Domain>* oldEval = _evaluating;
-        _evaluating = &x;
-        Domain val = _system[x]->eval(*this);
-        _evaluating = oldEval;
+        Domain val = _system[x]->eval(DependencyAssignment(*this, x));
 
         if (val != _values[x]) {
           IdSet<Variable<Domain> > oldInfluence = _influence[x];
@@ -84,13 +67,25 @@ struct SmartFixpointAlgorithm : public FixpointAlgorithm<Domain> {
       }
     }
 
+    struct DependencyAssignment : public VariableAssignment<Domain> {
+      DependencyAssignment(const DynamicVariableAssignment& assignment, const Variable<Domain>& var)
+        : _assignment(assignment), _var(var) { }
+      const Domain& operator[](const Variable<Domain>& x) const {
+        const Domain& result = _assignment[x];
+        _assignment._influence[x].insert(_var);
+        return result;
+      }
+      private:
+      const DynamicVariableAssignment& _assignment;
+      const Variable<Domain>& _var;
+    };
+
     const EquationSystem<Domain>& _system;
     mutable const Variable<Domain>* _evaluating;
     mutable IdMap<Variable<Domain>,Domain> _values;
     mutable IdSet<Variable<Domain> > _stable;
     mutable IdSet<Variable<Domain> > _haveValue;
     mutable IdMap<Variable<Domain>,IdSet<Variable<Domain> > > _influence;
-    mutable unsigned int _id;
   };
 
   virtual VariableAssignment<Domain>* maxFixpoint(const EquationSystem<Domain>& system) const {