diff options
Diffstat (limited to 'impl/Operator.hpp')
-rw-r--r-- | impl/Operator.hpp | 173 |
1 files changed, 89 insertions, 84 deletions
diff --git a/impl/Operator.hpp b/impl/Operator.hpp index 87e4eea..3072abe 100644 --- a/impl/Operator.hpp +++ b/impl/Operator.hpp @@ -1,121 +1,126 @@ #ifndef OPERATOR_HPP #define OPERATOR_HPP -template<typename T> -T infinity() { } -template<> -float infinity() { - return INFINITY; -} - #include <vector> -#include "IdSet.hpp" - -template<typename T> -struct Variable; - -template<typename T> -struct VariableAssignment; -template<typename T> -struct Expression; -template<typename T> +template<typename Domain> struct Operator { - Operator(const std::string& name) : op_name(name) { } virtual ~Operator() { } - virtual T operator() (const std::vector< Expression<T>* >& args, const VariableAssignment<T>& rho) const = 0; - const std::string op_name; + + virtual Domain eval(const std::vector<Domain>&) const = 0; + + virtual void print(std::ostream&) const = 0; }; -template<typename T> -struct Maximum : public Operator<T> { - Maximum() : Operator<T>("max") { } - virtual T operator() (const std::vector< Expression<T>* >& args, const VariableAssignment<T>& assignment) const { - T value = -infinity<T>(); - for (typename std::vector< Expression<T>* >::const_iterator it = args.begin(); - it != args.end(); + +template<typename Domain> +struct Maximum : public Operator<Domain> { + virtual Domain eval(const std::vector<Domain>& arguments) const { + Domain result = -infinity<Domain>(); + for (typename std::vector<Domain>::const_iterator it = arguments.begin(); + it != arguments.end(); ++it) { - T temporary = (**it)(assignment); - value = (value < temporary ? value : temporary); - //if (value == infinity<T>()) break; + result = (result < *it ? *it : result); } - return value; + return result; + } + void print(std::ostream& cout) const { + cout << "max"; } }; -template<typename T> -struct Minimum : public Operator<T> { - Minimum() : Operator<T>("min") { } - virtual T operator() (const std::vector< Expression<T>* >& args, const VariableAssignment<T>& assignment) const { - T value = infinity<T>(); - for (typename std::vector< Expression<T>* >::const_iterator it = args.begin(); - it != args.end(); + +template<typename Domain> +struct Minimum : public Operator<Domain> { + virtual Domain eval(const std::vector<Domain>& arguments) const { + Domain result = infinity<Domain>(); + for (typename std::vector<Domain>::const_iterator it = arguments.begin(); + it != arguments.end(); ++it) { - T temporary = (**it)(assignment); - value = (temporary < value ? temporary : value); - //if (value == -infinity<T>()) break; + result = (*it < result ? *it : result); } - return value; + return result; + } + void print(std::ostream& cout) const { + cout << "min"; } }; -template<typename T> -struct Constant : public Operator<T> { - Constant(const std::string& value, const T& val) - : Operator<T>(value), _value(val) { } - T operator() (const std::vector< Expression<T>* >& args, const VariableAssignment<T>& ass) const { - return _value; +template<typename Domain> +struct Negation : public Operator<Domain> { + virtual Domain eval(const std::vector<Domain>& arguments) const { + if (arguments.size() > 1) + throw "Too many arguments to a negation."; + return -arguments[0]; + } + void print(std::ostream& cout) const { + cout << "-"; } - private: - const T _value; }; -template<typename T> -struct Addition: public Operator<T> { - Addition() : Operator<T>("add") { } - T operator() (const std::vector< Expression<T>* >& args, const VariableAssignment<T>& ass) const { - T sum = (*args[0])(ass); - for (unsigned int i = 1, size = args.size(); i < size; ++i) { - sum += (*args[i])(ass); +template<typename Domain> +struct Addition : public Operator<Domain> { + virtual Domain eval(const std::vector<Domain>& arguments) const { + Domain result = 0; + for (typename std::vector<Domain>::const_iterator it = arguments.begin(); + it != arguments.end(); + ++it) { + result += *it; } - return sum; + return result; + } + void print(std::ostream& cout) const { + cout << "add"; } }; -template<typename T> -struct Negate: public Operator<T> { - Negate() : Operator<T>("neg") { } - T operator() (const std::vector< Expression<T>* >& args, const VariableAssignment<T>& ass) const { - // assert(args.size() == 1); - return -(*args[0])(ass); +template<typename Domain> +struct Subtraction : public Operator<Domain> { + virtual Domain eval(const std::vector<Domain>& arguments) const { + Domain result = 0; + for (typename std::vector<Domain>::const_iterator it = arguments.begin(); + it != arguments.end(); + ++it) { + if (it == arguments.begin()) + result = *it; + else + result -= *it; + } + return result; + } + void print(std::ostream& cout) const { + cout << "sub"; } }; -template<typename T> -struct Comma: public Operator<T> { - Comma() : Operator<T>("comma") { } - T operator() (const std::vector< Expression<T>* >& args, const VariableAssignment<T>& ass) const { - if ((*args[0])(ass) == -infinity<T>()) { - std::cout << "Comma - neg inf" << std::endl; - return -infinity<T>(); - } else { - std::cout << "Comma - finite" << std::endl; - return (*args[1])(ass); +template<typename Domain> +struct Comma : public Operator<Domain> { + virtual Domain eval(const std::vector<Domain>& arguments) const { + if (arguments[0] == -infinity<Domain>()) { + return -infinity<Domain>(); } + return arguments[1]; + } + void print(std::ostream& cout) const { + cout << "comma"; } }; -template<typename T> -struct Guard: public Operator<T> { - Guard() : Operator<T>("guard") { } - T operator() (const std::vector< Expression<T>* >& args, const VariableAssignment<T>& ass) const { - if ((*args[0])(ass) < (*args[1])(ass)) { - return -infinity<T>(); - } else { - return (*args[2])(ass); +template<typename Domain> +struct Guard : public Operator<Domain> { + virtual Domain eval(const std::vector<Domain>& arguments) const { + if (arguments[0] < arguments[1]) { + return -infinity<Domain>(); } + return arguments[2]; + } + void print(std::ostream& cout) const { + cout << "guard"; } }; -#include "VariableAssignment.hpp" -#include "Expression.hpp" +template<typename T> +std::ostream& operator<<(std::ostream& cout, const Operator<T>& op) { + op.print(cout); + return cout; +} #endif |