Better implementation: smarter strategy iteration

Also add the beginnings of some log stuff, mayhaps.

1 files changed, 41 insertions, 1 deletions

diff --git a/impl/Expression.hpp b/impl/Expression.hpp
index 7fc4542..857064f 100644
--- a/impl/Expression.hpp
+++ b/impl/Expression.hpp
@@ -11,10 +11,17 @@ template<typename Domain>
 struct VariableAssignment;
 
 template<typename Domain>
+struct MaxStrategy;
+
+template<typename Domain>
 struct Expression {
   virtual ~Expression() { }
 
   virtual Domain eval(const VariableAssignment<Domain>&) const = 0;
+  virtual Domain eval(const VariableAssignment<Domain>& rho,
+                      const MaxStrategy<Domain>&) const {
+    return eval(rho);
+  }
 
   virtual void print(std::ostream&) const = 0;
 };
@@ -76,6 +83,16 @@ struct OperatorExpression : public Expression<Domain> {
     return _operator.eval(argumentValues);
   }
 
+  virtual Domain eval(const VariableAssignment<Domain>& rho, const MaxStrategy<Domain>& strat) const {
+    std::vector<Domain> argumentValues;
+    for (typename std::vector<Expression<Domain>*>::const_iterator it = _arguments.begin();
+         it != _arguments.end();
+         ++it) {
+      argumentValues.push_back((*it)->eval(rho, strat));
+    }
+    return _operator.eval(argumentValues);
+  }
+
   const std::vector<Expression<Domain>*> arguments() const {
     return _arguments;
   }
@@ -98,13 +115,36 @@ struct OperatorExpression : public Expression<Domain> {
 
   private:
   const Operator<Domain>& _operator;
+  protected:
   const std::vector<Expression<Domain>*> _arguments;
 };
 
 template<typename Domain>
 struct MaxExpression : public OperatorExpression<Domain> {
   MaxExpression(const unsigned int& id, const Maximum<Domain>& op, const std::vector<Expression<Domain>*>& arguments)
-    : OperatorExpression<Domain>(op, arguments), _id(id) { }
+    : OperatorExpression<Domain>(op, arguments), _id(id) {
+    log::debug << "Op id" << id;
+  }
+
+  virtual Domain eval(const VariableAssignment<Domain>& rho, const MaxStrategy<Domain>& strat) const {
+    return this->_arguments[strat.get(*this)]->eval(rho, strat);
+  }
+
+  unsigned int bestStrategy(const VariableAssignment<Domain>& rho, const MaxStrategy<Domain>& strat) const {
+    Domain bestValue = this->eval(rho, strat);
+    unsigned int bestIndex = strat.get(*this);
+
+    for (unsigned int i = 0, length = this->_arguments.size();
+         i < length;
+         ++i) {
+      const Domain value = this->_arguments[i]->eval(rho, strat);
+      if (bestValue < value) {
+        bestValue = value;
+        bestIndex = i;
+      }
+    }
+    return bestIndex;
+  }
 
   unsigned int id() const {
     return _id;