From f7d846f18354e254353bc417ed1a666c59ef3ea2 Mon Sep 17 00:00:00 2001
From: Carlo Zancanaro <carlo@carlo-laptop>
Date: Mon, 9 Jul 2012 03:36:11 +1000
Subject: Better implementation: smarter strategy iteration

Also add the beginnings of some log stuff, mayhaps.
---
 impl/Expression.hpp | 42 +++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 41 insertions(+), 1 deletion(-)

(limited to 'impl/Expression.hpp')

diff --git a/impl/Expression.hpp b/impl/Expression.hpp
index 7fc4542..857064f 100644
--- a/impl/Expression.hpp
+++ b/impl/Expression.hpp
@@ -10,11 +10,18 @@
 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;
-- 
cgit v1.2.3