From 86ca7448849aaaea6db34b1d2bcf8d99d7d7b12c Mon Sep 17 00:00:00 2001
From: Carlo Zancanaro <carlo@pc-4w14-0.cs.usyd.edu.au>
Date: Mon, 22 Oct 2012 14:44:57 +1100
Subject: Okay, the solver is now correct.

It runs in two separate passes:
 - improve strategy (for all)
 - evaluate fixpoint

Unfortunately this loses out on locality at the moment.

I really want a local solver, so I'll have to see what I can do about
that.
---
 impl/VariableAssignment.hpp | 47 +++++++++++++++++++++++++++++++++------------
 1 file changed, 35 insertions(+), 12 deletions(-)

(limited to 'impl/VariableAssignment.hpp')

diff --git a/impl/VariableAssignment.hpp b/impl/VariableAssignment.hpp
index a9247b5..2a63756 100644
--- a/impl/VariableAssignment.hpp
+++ b/impl/VariableAssignment.hpp
@@ -8,6 +8,9 @@ template<typename Domain>
 struct VariableAssignment {
   virtual ~VariableAssignment() { }
   virtual const Domain& operator[](const Variable<Domain>&) const = 0;
+  virtual const Domain& operator[](const Variable<Domain>& x) {
+    return (*const_cast<const VariableAssignment*>(this))[x];
+  }
 };
 
 #include "EquationSystem.hpp"
@@ -19,21 +22,40 @@ template<typename Domain>
 struct DynamicVariableAssignment : public VariableAssignment<Domain> {
   DynamicVariableAssignment(
     const EquationSystem<Domain>& system,
-    const DynamicMaxStrategy<Domain>& strat
+    DynamicMaxStrategy<Domain>& strat,
+    const Domain& value=infinity<Domain>()
   ) : _system(system),
       _strategy(strat),
-      _values(system.variableCount(), infinity<Domain>()),
+      _values(system.variableCount(), value),
       _stable(system.variableCount()),
       _influence(system.variableCount(),
-                 IdSet<Variable<Domain> >(system.variableCount()))
+                 IdSet<Variable<Domain> >(system.variableCount())),
+      _frozen(false)
   { }
 
+  void freeze() {
+    _frozen = true;
+  }
+
+  void thaw() {
+    _frozen = false;
+  }
+
+  bool is_frozen() {
+    return _frozen;
+  }
+
   const Domain& operator[](const Variable<Domain>& var) const {
-    solve(var);
     return _values[var];
   }
 
-  void invalidate(const Variable<Domain>& x) const {
+  const Domain& operator[](const Variable<Domain>& var) {
+    if (!_frozen)
+      solve(var);
+    return _values[var];
+  }
+
+  void invalidate(const Variable<Domain>& x) {
     log::fixpoint << indent() << "Invalidating " << x << std::endl;
     if (_stable.contains(x)) {
       _stable.remove(x);
@@ -53,7 +75,7 @@ struct DynamicVariableAssignment : public VariableAssignment<Domain> {
 
 private:
 
-  void solve(const Variable<Domain>& x) const {
+  void solve(const Variable<Domain>& x) {
     if (!_stable.contains(x)) {
       _stable.insert(x);
       log::fixpoint << indent() << "Stabilise " << x << std::endl;
@@ -90,7 +112,7 @@ private:
   }
 
   struct DependencyAssignment : public VariableAssignment<Domain> {
-    DependencyAssignment(const DynamicVariableAssignment& assignment, const Variable<Domain>& var)
+    DependencyAssignment(DynamicVariableAssignment& assignment, const Variable<Domain>& var)
       : _assignment(assignment), _var(var) { }
     const Domain& operator[](const Variable<Domain>& x) const {
       const Domain& result = _assignment[x];
@@ -98,15 +120,16 @@ private:
       return result;
     }
   private:
-    const DynamicVariableAssignment& _assignment;
+    DynamicVariableAssignment& _assignment;
     const Variable<Domain>& _var;
   };
 
   const EquationSystem<Domain>& _system;
-  const DynamicMaxStrategy<Domain>& _strategy;
-  mutable IdMap<Variable<Domain>, Domain> _values;
-  mutable IdSet<Variable<Domain> > _stable;
-  mutable IdMap<Variable<Domain>,IdSet<Variable<Domain> > > _influence;
+  DynamicMaxStrategy<Domain>& _strategy;
+  IdMap<Variable<Domain>, Domain> _values;
+  IdSet<Variable<Domain> > _stable;
+  IdMap<Variable<Domain>,IdSet<Variable<Domain> > > _influence;
+  bool _frozen;
 };
 
 #endif
-- 
cgit v1.2.3