diff options
Diffstat (limited to 'impl/Expression.hpp')
-rw-r--r-- | impl/Expression.hpp | 143 |
1 files changed, 100 insertions, 43 deletions
diff --git a/impl/Expression.hpp b/impl/Expression.hpp index d3dfcf3..72318e4 100644 --- a/impl/Expression.hpp +++ b/impl/Expression.hpp @@ -1,68 +1,125 @@ #ifndef EXPRESSION_HPP #define EXPRESSION_HPP -#include <iostream> -#include "VariableAssignment.hpp" +#include <string> +#include <vector> +#include <sstream> +#include "IdMap.hpp" #include "Operator.hpp" -template<typename T> -struct Variable; -template<typename T> -struct MaxStrategy; - -int ExpressionCount; +template<typename Domain> +struct VariableAssignment; -template<typename T> +template<typename Domain> struct Expression { - Expression(Operator<T>* op, const std::vector< Expression<T>* >& args) - : _operator(op), _arguments(args) { } - virtual ~Expression() { - if (!dynamic_cast<Variable<T>*>(_operator)) { - delete _operator; - } + virtual ~Expression() { } + + virtual Domain eval(const VariableAssignment<Domain>&) const = 0; + + virtual void print(std::ostream&) const = 0; +}; + +template<typename Domain> +struct Constant : public Expression<Domain> { + Constant(const Domain& value) + : _value(value) { } + + virtual Domain eval(const VariableAssignment<Domain>&) const { + return _value; } - virtual T operator() (const VariableAssignment<T>& assignment) const { - return (*_operator)(_arguments, assignment); + + void print(std::ostream& cout) const { + cout << _value; } - protected: - Operator<T>* _operator; - std::vector< Expression<T>* > _arguments; + + private: + Domain _value; }; -template<typename T> -struct MaxExpression : public Expression<T> { - MaxExpression(const std::vector< Expression<T>* >& args) - : Expression<T>(new Maximum<T>, args) { } +template<typename Domain> +struct Variable : public Expression<Domain> { + Variable(const unsigned int& id, const std::string& name) + : _id(id), _name(name) { } + unsigned int id() const { return _id; } - unsigned int id(unsigned int id) { - return (_id = id); + std::string name() const { + return _name; } - Expression<T>* argument(unsigned int i) const { - if (i >= Expression<T>::_arguments.size()) { - throw "Error"; + + virtual Domain eval(const VariableAssignment<Domain>& rho) const { + return rho[*this]; + } + + void print(std::ostream& cout) const { + cout << name(); + } + + private: + const unsigned int _id; + const std::string _name; +}; + +template<typename Domain> +struct OperatorExpression : public Expression<Domain> { + OperatorExpression(const Operator<Domain>& op, const std::vector<Expression<Domain>*>& arguments) + : _operator(op), _arguments(arguments) { } + + virtual Domain eval(const VariableAssignment<Domain>& rho) 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)); } - return Expression<T>::_arguments[i]; + return _operator.eval(argumentValues); + } + + const std::vector<Expression<Domain>*> arguments() const { + return _arguments; } - virtual T operator() (const VariableAssignment<T>& assignment) const { - throw "error"; + + const Operator<Domain>& op() const { + return _operator; } - std::pair<T, unsigned int> bestStrategy(const VariableAssignment<T>& rho, const MaxStrategy<T>& strat) const { - std::pair<T, unsigned int> best = std::pair<T, unsigned int>(-infinity<T>(), 0); - for (unsigned int i = 0, size = Expression<T>::_arguments.size(); i < size; ++i) { - T value = strat(*Expression<T>::_arguments[i], rho); - if (value > best.first) - best = std::pair<T, unsigned int>(value, i); + + void print(std::ostream& cout) const { + cout << _operator << "("; + for (unsigned int i = 0, length = _arguments.size(); + i < length; + ++i) { + if (i > 0) + cout << ", "; + cout << *_arguments[i]; } - std::cerr << "Best strategy: (" << best.first << ", " << best.second << ")" << std::endl << std::endl; - return best; + cout << ")"; + } + + private: + const Operator<Domain>& _operator; + 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) { } + + unsigned int id() const { + return _id; } + private: - unsigned int _id; + const unsigned int _id; }; -#include "Variable.hpp" -#include "MaxStrategy.hpp" +template<typename T> +std::ostream& operator<<(std::ostream& cout, const Expression<T>& exp) { + exp.print(cout); + return cout; +} + +#include "VariableAssignment.hpp" #endif |