New upstream version 6.0+dfsg

5 files changed, 1265 insertions, 0 deletions

diff --git a/fuzzylite/src/rule/Antecedent.cpp b/fuzzylite/src/rule/Antecedent.cpp
new file mode 100644
index 0000000..5f0b0be
--- /dev/null
+++ b/fuzzylite/src/rule/Antecedent.cpp
@@ -0,0 +1,447 @@
+/*
+ fuzzylite (R), a fuzzy logic control library in C++.
+ Copyright (C) 2010-2017 FuzzyLite Limited. All rights reserved.
+ Author: Juan Rada-Vilela, Ph.D. <jcrada@fuzzylite.com>
+
+ This file is part of fuzzylite.
+
+ fuzzylite is free software: you can redistribute it and/or modify it under
+ the terms of the FuzzyLite License included with the software.
+
+ You should have received a copy of the FuzzyLite License along with
+ fuzzylite. If not, see <http://www.fuzzylite.com/license/>.
+
+ fuzzylite is a registered trademark of FuzzyLite Limited.
+ */
+
+#include "fl/rule/Antecedent.h"
+
+#include "fl/Engine.h"
+#include "fl/factory/HedgeFactory.h"
+#include "fl/factory/FactoryManager.h"
+#include "fl/hedge/Any.h"
+#include "fl/rule/Expression.h"
+#include "fl/rule/Rule.h"
+#include "fl/term/Aggregated.h"
+#include "fl/variable/InputVariable.h"
+#include "fl/variable/OutputVariable.h"
+
+#include <stack>
+
+namespace fl {
+
+    Antecedent::Antecedent()
+    : _text(""), _expression(fl::null) { }
+
+    Antecedent::~Antecedent() {
+        _expression.reset(fl::null);
+    }
+
+    void Antecedent::setText(const std::string& text) {
+        this->_text = text;
+    }
+
+    std::string Antecedent::getText() const {
+        return this->_text;
+    }
+
+    Expression* Antecedent::getExpression() const {
+        return this->_expression.get();
+    }
+
+    void Antecedent::setExpression(Expression* expression) {
+        this->_expression.reset(expression);
+    }
+
+    bool Antecedent::isLoaded() const {
+        return _expression.get() != fl::null;
+    }
+
+    scalar Antecedent::activationDegree(const TNorm* conjunction, const SNorm* disjunction) const {
+        return this->activationDegree(conjunction, disjunction, _expression.get());
+    }
+
+    scalar Antecedent::activationDegree(const TNorm* conjunction, const SNorm* disjunction,
+            const Expression* node) const {
+        if (not isLoaded()) {
+            throw Exception("[antecedent error] antecedent <" + getText() + "> is not loaded", FL_AT);
+        }
+        const Expression::Type expression = node->type();
+        if (expression == Expression::Proposition) {
+            const Proposition* proposition = static_cast<const Proposition*> (node);
+            if (not proposition->variable->isEnabled()) {
+                return 0.0;
+            }
+
+            if (not proposition->hedges.empty()) {
+                //if last hedge is "Any", apply hedges in reverse order and return degree
+                std::vector<Hedge*>::const_reverse_iterator rit = proposition->hedges.rbegin();
+                if (dynamic_cast<Any*> (*rit)) {
+                    scalar result = (*rit)->hedge(fl::nan);
+                    while (++rit != proposition->hedges.rend()) {
+                        result = (*rit)->hedge(result);
+                    }
+                    return result;
+                }
+            }
+            scalar result = fl::nan;
+            Variable::Type variableType = proposition->variable->type();
+            if (variableType == Variable::Input) {
+                result = proposition->term->membership(proposition->variable->getValue());
+            } else if (variableType == Variable::Output) {
+                result = static_cast<OutputVariable*> (proposition->variable)
+                        ->fuzzyOutput()->activationDegree(proposition->term);
+            }
+
+            if (not proposition->hedges.empty()) {
+                for (std::vector<Hedge*>::const_reverse_iterator rit = proposition->hedges.rbegin();
+                        rit != proposition->hedges.rend(); ++rit) {
+                    result = (*rit)->hedge(result);
+                }
+            }
+            return result;
+        }
+        //if node is an operator
+        if (expression == Expression::Operator) {
+            const Operator* fuzzyOperator = static_cast<const Operator*> (node);
+            if (not (fuzzyOperator->left and fuzzyOperator->right)) {
+                std::ostringstream ex;
+                ex << "[syntax error] left and right operands must exist";
+                throw Exception(ex.str(), FL_AT);
+            }
+            if (fuzzyOperator->name == Rule::andKeyword()) {
+                if (not conjunction) throw Exception("[conjunction error] "
+                        "the following rule requires a conjunction operator:\n" + _text, FL_AT);
+                return conjunction->compute(
+                        this->activationDegree(conjunction, disjunction, fuzzyOperator->left),
+                        this->activationDegree(conjunction, disjunction, fuzzyOperator->right));
+            }
+
+            if (fuzzyOperator->name == Rule::orKeyword()) {
+                if (not disjunction) throw Exception("[disjunction error] "
+                        "the following rule requires a disjunction operator:\n" + _text, FL_AT);
+                return disjunction->compute(
+                        this->activationDegree(conjunction, disjunction, fuzzyOperator->left),
+                        this->activationDegree(conjunction, disjunction, fuzzyOperator->right));
+            }
+            std::ostringstream ex;
+            ex << "[syntax error] operator <" << fuzzyOperator->name << "> not recognized";
+            throw Exception(ex.str(), FL_AT);
+
+        } else {
+            std::ostringstream ss;
+            ss << "[antecedent error] expected a Proposition or Operator, but found <";
+            if (node) ss << node->toString();
+            ss << ">";
+            throw Exception(ss.str(), FL_AT);
+        }
+    }
+
+
+    Complexity Antecedent::complexity(const TNorm* conjunction, const SNorm* disjunction) const {
+        return complexity(conjunction, disjunction, _expression.get());
+    }
+
+    Complexity Antecedent::complexity(const TNorm* conjunction, const SNorm* disjunction,
+            const Expression* node) const {
+        if (not isLoaded()) {
+            return Complexity();
+        }
+
+        Complexity result;
+        const Expression::Type expression = node->type();
+        if (expression == Expression::Proposition) {
+            const Proposition* proposition = static_cast<const Proposition*> (node);
+            if (not proposition->variable->isEnabled()) {
+                return result;
+            }
+
+            if (not proposition->hedges.empty()) {
+                //if last hedge is "Any", apply hedges in reverse order and return degree
+                std::vector<Hedge*>::const_reverse_iterator rit = proposition->hedges.rbegin();
+                if (dynamic_cast<Any*> (*rit)) {
+                    result += (*rit)->complexity();
+                    while (++rit != proposition->hedges.rend()) {
+                        result = (*rit)->complexity();
+                    }
+                    return result;
+                }
+            }
+            Variable::Type variableType = proposition->variable->type();
+            if (variableType == Variable::Input) {
+                result += proposition->term->complexity();
+            } else if (variableType == Variable::Output) {
+                OutputVariable* outputVariable = static_cast<OutputVariable*> (proposition->variable);
+                result += outputVariable->fuzzyOutput()->complexityOfActivationDegree();
+            }
+
+            if (not proposition->hedges.empty()) {
+                for (std::vector<Hedge*>::const_reverse_iterator rit = proposition->hedges.rbegin();
+                        rit != proposition->hedges.rend(); ++rit) {
+                    result += (*rit)->complexity();
+                }
+            }
+            return result;
+        }
+        //if node is an operator
+        if (expression == Expression::Operator) {
+            const Operator* fuzzyOperator = static_cast<const Operator*> (node);
+            if (not (fuzzyOperator->left and fuzzyOperator->right)) {
+                std::ostringstream ex;
+                ex << "[syntax error] left and right operands must exist";
+                throw Exception(ex.str(), FL_AT);
+            }
+            if (fuzzyOperator->name == Rule::andKeyword()) {
+                if (conjunction) {
+                    result += conjunction->complexity();
+                }
+                result += complexity(conjunction, disjunction, fuzzyOperator->left)
+                        + complexity(conjunction, disjunction, fuzzyOperator->right);
+                return result;
+            }
+
+            if (fuzzyOperator->name == Rule::orKeyword()) {
+                if (disjunction) {
+                    result += disjunction->complexity();
+                }
+                result += complexity(conjunction, disjunction, fuzzyOperator->left)
+                        + complexity(conjunction, disjunction, fuzzyOperator->right);
+                return result;
+            }
+        }
+        return Complexity();
+    }
+
+    void Antecedent::unload() {
+        _expression.reset(fl::null);
+    }
+
+    void Antecedent::load(const Engine* engine) {
+        load(getText(), engine);
+    }
+
+    void Antecedent::load(const std::string& antecedent, const Engine* engine) {
+        FL_DBG("Antecedent: " << antecedent);
+        unload();
+        setText(antecedent);
+        if (Op::trim(antecedent).empty()) {
+            throw Exception("[syntax error] antecedent is empty", FL_AT);
+        }
+        /*
+         Builds an proposition tree from the antecedent of a fuzzy rule.
+         The rules are:
+         1) After a variable comes 'is',
+         2) After 'is' comes a hedge or a term
+         3) After a hedge comes a hedge or a term
+         4) After a term comes a variable or an operator
+         */
+
+        Function function;
+
+        std::string postfix = function.toPostfix(antecedent);
+        FL_DBG("Postfix: " << postfix);
+        std::stringstream tokenizer(postfix);
+        std::string token;
+
+        enum FSM {
+            S_VARIABLE = 1, S_IS = 2, S_HEDGE = 4, S_TERM = 8, S_AND_OR = 16
+        };
+        int state = S_VARIABLE;
+        std::stack<Expression*> expressionStack;
+        Proposition* proposition = fl::null;
+        try {
+            while (tokenizer >> token) {
+                if (state bitand S_VARIABLE) {
+                    Variable* variable = fl::null;
+                    if (engine->hasInputVariable(token))
+                        variable = engine->getInputVariable(token);
+                    else if (engine->hasOutputVariable(token))
+                        variable = engine->getOutputVariable(token);
+                    if (variable) {
+                        proposition = new Proposition;
+                        proposition->variable = variable;
+                        expressionStack.push(proposition);
+
+                        state = S_IS;
+                        FL_DBG("Token <" << token << "> is variable");
+                        continue;
+                    }
+                }
+
+                if (state bitand S_IS) {
+                    if (token == Rule::isKeyword()) {
+                        state = S_HEDGE bitor S_TERM;
+                        FL_DBG("Token <" << token << "> is keyword");
+                        continue;
+                    }
+                }
+
+                if (state bitand S_HEDGE) {
+                    HedgeFactory* factory = FactoryManager::instance()->hedge();
+                    if (factory->hasConstructor(token)) {
+                        Hedge* hedge = factory->constructObject(token);
+                        proposition->hedges.push_back(hedge);
+                        if (dynamic_cast<Any*> (hedge)) {
+                            state = S_VARIABLE bitor S_AND_OR;
+                        } else {
+                            state = S_HEDGE bitor S_TERM;
+                        }
+                        FL_DBG("Token <" << token << "> is hedge");
+                        continue;
+                    }
+                }
+
+                if (state bitand S_TERM) {
+                    if (proposition->variable->hasTerm(token)) {
+                        proposition->term = proposition->variable->getTerm(token);
+                        state = S_VARIABLE bitor S_AND_OR;
+                        FL_DBG("Token <" << token << "> is term");
+                        continue;
+                    }
+                }
+
+                if (state bitand S_AND_OR) {
+                    if (token == Rule::andKeyword() or token == Rule::orKeyword()) {
+                        if (expressionStack.size() < 2) {
+                            std::ostringstream ex;
+                            ex << "[syntax error] logical operator <" << token << "> expects two operands,"
+                                    << "but found <" << expressionStack.size() << "> in antecedent";
+                            throw Exception(ex.str(), FL_AT);
+                        }
+                        Operator* fuzzyOperator = new Operator;
+                        fuzzyOperator->name = token;
+                        fuzzyOperator->right = expressionStack.top();
+                        expressionStack.pop();
+                        fuzzyOperator->left = expressionStack.top();
+                        expressionStack.pop();
+                        expressionStack.push(fuzzyOperator);
+
+                        state = S_VARIABLE bitor S_AND_OR;
+                        FL_DBG("Subtree: " << fuzzyOperator->toString() <<
+                                "(" << fuzzyOperator->left->toString() << ") " <<
+                                "(" << fuzzyOperator->right->toString() << ")");
+                        continue;
+                    }
+                }
+
+                //If reached this point, there was an error
+                if ((state bitand S_VARIABLE) or (state bitand S_AND_OR)) {
+                    std::ostringstream ex;
+                    ex << "[syntax error] antecedent expected variable or logical operator, but found <" << token << ">";
+                    throw Exception(ex.str(), FL_AT);
+                }
+                if (state bitand S_IS) {
+                    std::ostringstream ex;
+                    ex << "[syntax error] antecedent expected keyword <" << Rule::isKeyword() << ">, but found <" << token << ">";
+                    throw Exception(ex.str(), FL_AT);
+                }
+                if ((state bitand S_HEDGE) or (state bitand S_TERM)) {
+                    std::ostringstream ex;
+                    ex << "[syntax error] antecedent expected hedge or term, but found <" << token << ">";
+                    throw Exception(ex.str(), FL_AT);
+                }
+                std::ostringstream ex;
+                ex << "[syntax error] unexpected token <" << token << "> in antecedent";
+                throw Exception(ex.str(), FL_AT);
+            }
+
+            if (not ((state bitand S_VARIABLE) or (state bitand S_AND_OR))) { //only acceptable final state
+                if (state bitand S_IS) {
+                    std::ostringstream ex;
+                    ex << "[syntax error] antecedent expected keyword <" << Rule::isKeyword() << "> after <" << token << ">";
+                    throw Exception(ex.str(), FL_AT);
+                }
+                if ((state bitand S_HEDGE) or (state bitand S_TERM)) {
+                    std::ostringstream ex;
+                    ex << "[syntax error] antecedent expected hedge or term after <" << token << ">";
+                    throw Exception(ex.str(), FL_AT);
+                }
+            }
+
+            if (expressionStack.size() != 1) {
+                std::vector<std::string> errors;
+                while (expressionStack.size() > 1) {
+                    Expression* expression = expressionStack.top();
+                    expressionStack.pop();
+                    errors.push_back(expression->toString());
+                    delete expression;
+                }
+                std::ostringstream ex;
+                ex << "[syntax error] unable to parse the following expressions in antecedent <"
+                        << Op::join(errors, " ") << ">";
+                throw Exception(ex.str(), FL_AT);
+            }
+        } catch (...) {
+            for (std::size_t i = 0; i < expressionStack.size(); ++i) {
+                delete expressionStack.top();
+                expressionStack.pop();
+            }
+            throw;
+        }
+        setExpression(expressionStack.top());
+    }
+
+    std::string Antecedent::toString() const {
+        return toInfix(getExpression());
+    }
+
+    std::string Antecedent::toPrefix(const Expression* node) const {
+        if (not isLoaded()) {
+            throw Exception("[antecedent error] antecedent <" + _text + "> is not loaded", FL_AT);
+        }
+        if (not node) node = getExpression();
+
+        if (dynamic_cast<const Proposition*> (node)) {
+            return node->toString();
+        }
+        std::stringstream ss;
+        if (const Operator * fuzzyOperator = dynamic_cast<const Operator*> (node)) {
+            ss << fuzzyOperator->toString() << " "
+                    << toPrefix(fuzzyOperator->left) << " "
+                    << toPrefix(fuzzyOperator->right) << " ";
+        } else {
+            ss << "[antecedent error] unknown class of Expression <" << (node ? node->toString() : "null") << ">";
+        }
+        return ss.str();
+    }
+
+    std::string Antecedent::toInfix(const Expression* node) const {
+        if (not isLoaded()) {
+            throw Exception("[antecedent error] antecedent <" + _text + "> is not loaded", FL_AT);
+        }
+        if (not node) node = getExpression();
+        if (dynamic_cast<const Proposition*> (node)) {
+            return node->toString();
+        }
+        std::stringstream ss;
+        if (const Operator * fuzzyOperator = dynamic_cast<const Operator*> (node)) {
+            ss << toInfix(fuzzyOperator->left) << " "
+                    << fuzzyOperator->toString() << " "
+                    << toInfix(fuzzyOperator->right) << " ";
+        } else {
+            ss << "[antecedent error] unknown class of Expression <" << (node ? node->toString() : "null") << ">";
+        }
+        return ss.str();
+    }
+
+    std::string Antecedent::toPostfix(const Expression* node) const {
+        if (not isLoaded()) {
+            throw Exception("[antecedent error] antecedent <" + _text + "> is not loaded", FL_AT);
+        }
+        if (not node) node = getExpression();
+        if (dynamic_cast<const Proposition*> (node)) {
+            return node->toString();
+        }
+        std::stringstream ss;
+        if (const Operator * fuzzyOperator = dynamic_cast<const Operator*> (node)) {
+            ss << toPostfix(fuzzyOperator->left) << " "
+                    << toPostfix(fuzzyOperator->right) << " "
+                    << fuzzyOperator->toString() << " ";
+        } else {
+            ss << "[antecedent error] unknown class of Expression <" << (node ? node->toString() : "null") << ">";
+        }
+        return ss.str();
+    }
+
+
+}
diff --git a/fuzzylite/src/rule/Consequent.cpp b/fuzzylite/src/rule/Consequent.cpp
new file mode 100644
index 0000000..a90b1a9
--- /dev/null
+++ b/fuzzylite/src/rule/Consequent.cpp
@@ -0,0 +1,244 @@
+/*
+ fuzzylite (R), a fuzzy logic control library in C++.
+ Copyright (C) 2010-2017 FuzzyLite Limited. All rights reserved.
+ Author: Juan Rada-Vilela, Ph.D. <jcrada@fuzzylite.com>
+
+ This file is part of fuzzylite.
+
+ fuzzylite is free software: you can redistribute it and/or modify it under
+ the terms of the FuzzyLite License included with the software.
+
+ You should have received a copy of the FuzzyLite License along with
+ fuzzylite. If not, see <http://www.fuzzylite.com/license/>.
+
+ fuzzylite is a registered trademark of FuzzyLite Limited.
+ */
+
+#include "fl/rule/Consequent.h"
+
+#include "fl/Engine.h"
+#include "fl/factory/HedgeFactory.h"
+#include "fl/factory/FactoryManager.h"
+#include "fl/hedge/Any.h"
+#include "fl/rule/Expression.h"
+#include "fl/rule/Rule.h"
+#include "fl/term/Aggregated.h"
+#include "fl/variable/OutputVariable.h"
+
+namespace fl {
+
+    Consequent::Consequent() { }
+
+    Consequent::~Consequent() {
+        for (std::size_t i = 0; i < _conclusions.size(); ++i) {
+            delete _conclusions.at(i);
+        }
+        _conclusions.clear();
+    }
+
+    std::string Consequent::getText() const {
+        return this->_text;
+    }
+
+    void Consequent::setText(const std::string& text) {
+        this->_text = text;
+    }
+
+    const std::vector<Proposition*>& Consequent::conclusions() const {
+        return this->_conclusions;
+    }
+
+    std::vector<Proposition*>& Consequent::conclusions() {
+        return this->_conclusions;
+    }
+
+    Complexity Consequent::complexity(const TNorm* implication) const {
+        Complexity result;
+        result.comparison(1);
+
+        for (std::size_t i = 0; i < _conclusions.size(); ++i) {
+            Proposition* proposition = _conclusions.at(i);
+            result.comparison(2);
+            for (std::size_t h = 0; h < proposition->hedges.size(); ++h) {
+                result += proposition->hedges.at(h)->complexity();
+            }
+            result += static_cast<OutputVariable*> (proposition->variable)
+                    ->complexity(Activated(proposition->term, fl::nan, implication));
+        }
+        return result;
+    }
+
+    void Consequent::modify(scalar activationDegree, const TNorm* implication) {
+        if (not isLoaded()) {
+            throw Exception("[consequent error] consequent <" + getText() + "> is not loaded", FL_AT);
+        }
+        for (std::size_t i = 0; i < _conclusions.size(); ++i) {
+            Proposition* proposition = _conclusions.at(i);
+            if (proposition->variable->isEnabled()) {
+                if (not proposition->hedges.empty()) {
+                    for (std::vector<Hedge*>::const_reverse_iterator rit = proposition->hedges.rbegin();
+                            rit != proposition->hedges.rend(); ++rit) {
+                        activationDegree = (*rit)->hedge(activationDegree);
+                    }
+                }
+
+                static_cast<OutputVariable*> (proposition->variable)->fuzzyOutput()
+                        ->addTerm(proposition->term, activationDegree, implication);
+            }
+        }
+    }
+
+    bool Consequent::isLoaded() {
+        return not _conclusions.empty();
+    }
+
+    void Consequent::unload() {
+        for (std::size_t i = 0; i < _conclusions.size(); ++i) {
+            delete _conclusions.at(i);
+        }
+        _conclusions.clear();
+    }
+
+    void Consequent::load(const Engine* engine) {
+        load(getText(), engine);
+    }
+
+    void Consequent::load(const std::string& consequent, const Engine* engine) {
+        unload();
+        setText(consequent);
+
+        if (Op::trim(consequent).empty()) {
+            throw Exception("[syntax error] consequent is empty", FL_AT);
+        }
+
+        /**
+         Extracts the list of propositions from the consequent
+         The rules are:
+         1) After a variable comes 'is' or '=',
+         2) After 'is' comes a hedge or a term
+         3) After a hedge comes a hedge or a term
+         4) After a term comes operators 'and' or 'with'
+         5) After operator 'and' comes a variable
+         6) After operator 'with' comes a float
+         */
+        enum FSM {
+            S_VARIABLE = 1, S_IS = 2, S_HEDGE = 4, S_TERM = 8,
+            S_AND = 16, S_WITH = 32
+        };
+        int state = S_VARIABLE;
+
+        Proposition* proposition = fl::null;
+
+        std::stringstream tokenizer(consequent);
+        std::string token;
+        try {
+            while (tokenizer >> token) {
+                if (state bitand S_VARIABLE) {
+                    if (engine->hasOutputVariable(token)) {
+                        proposition = new Proposition;
+                        proposition->variable = engine->getOutputVariable(token);
+                        conclusions().push_back(proposition);
+                        state = S_IS;
+                        continue;
+                    }
+                }
+
+                if (state bitand S_IS) {
+                    if (token == Rule::isKeyword()) {
+                        state = S_HEDGE bitor S_TERM;
+                        continue;
+                    }
+                }
+
+                if (state bitand S_HEDGE) {
+                    HedgeFactory* factory = FactoryManager::instance()->hedge();
+                    if (factory->hasConstructor(token)) {
+                        Hedge* hedge = factory->constructObject(token);
+                        proposition->hedges.push_back(hedge);
+                        state = S_HEDGE bitor S_TERM;
+                        continue;
+                    }
+                }
+
+                if (state bitand S_TERM) {
+                    if (proposition->variable->hasTerm(token)) {
+                        proposition->term = proposition->variable->getTerm(token);
+                        state = S_AND bitor S_WITH;
+                        continue;
+                    }
+                }
+
+                if (state bitand S_AND) {
+                    if (token == Rule::andKeyword()) {
+                        state = S_VARIABLE;
+                        continue;
+                    }
+                }
+
+                //if reached this point, there was an error:
+                if (state bitand S_VARIABLE) {
+                    std::ostringstream ex;
+                    ex << "[syntax error] consequent expected output variable, but found <" << token << ">";
+                    throw Exception(ex.str(), FL_AT);
+                }
+                if (state bitand S_IS) {
+                    std::ostringstream ex;
+                    ex << "[syntax error] consequent expected keyword <" << Rule::isKeyword() << ">, "
+                            "but found <" << token << ">";
+                    throw Exception(ex.str(), FL_AT);
+                }
+
+                if ((state bitand S_HEDGE) or (state bitand S_TERM)) {
+                    std::ostringstream ex;
+                    ex << "[syntax error] consequent expected hedge or term, but found <" << token << ">";
+                    throw Exception(ex.str(), FL_AT);
+                }
+
+                if ((state bitand S_AND) or (state bitand S_WITH)) {
+                    std::ostringstream ex;
+                    ex << "[syntax error] consequent expected operator <" << Rule::andKeyword() << "> "
+                            << "or keyword <" << Rule::withKeyword() << ">, "
+                            << "but found <" << token << ">";
+                    throw Exception(ex.str(), FL_AT);
+                }
+
+                std::ostringstream ex;
+                ex << "[syntax error] unexpected token <" << token << "> in consequent";
+                throw Exception(ex.str(), FL_AT);
+            }
+
+            if (not ((state bitand S_AND) or (state bitand S_WITH))) { //only acceptable final state
+                if (state bitand S_VARIABLE) {
+                    std::ostringstream ex;
+                    ex << "[syntax error] consequent expected output variable after <" << token << ">";
+                    throw Exception(ex.str(), FL_AT);
+                }
+                if (state bitand S_IS) {
+                    std::ostringstream ex;
+                    ex << "[syntax error] consequent expected keyword <" << Rule::isKeyword() << "> "
+                            "after <" << token << ">";
+                    throw Exception(ex.str(), FL_AT);
+                }
+                if ((state bitand S_HEDGE) or (state bitand S_TERM)) {
+                    std::ostringstream ex;
+                    ex << "[syntax error] consequent expected hedge or term after <" << token << ">";
+                    throw Exception(ex.str(), FL_AT);
+                }
+            }
+        } catch (...) {
+            unload();
+            throw;
+        }
+    }
+
+    std::string Consequent::toString() const {
+        std::stringstream ss;
+        for (std::size_t i = 0; i < conclusions().size(); ++i) {
+            ss << conclusions().at(i)->toString();
+            if (i + 1 < conclusions().size())
+                ss << " " << Rule::andKeyword() << " ";
+        }
+        return ss.str();
+    }
+
+}
diff --git a/fuzzylite/src/rule/Expression.cpp b/fuzzylite/src/rule/Expression.cpp
new file mode 100644
index 0000000..9b0ab81
--- /dev/null
+++ b/fuzzylite/src/rule/Expression.cpp
@@ -0,0 +1,83 @@
+/*
+ fuzzylite (R), a fuzzy logic control library in C++.
+ Copyright (C) 2010-2017 FuzzyLite Limited. All rights reserved.
+ Author: Juan Rada-Vilela, Ph.D. <jcrada@fuzzylite.com>
+
+ This file is part of fuzzylite.
+
+ fuzzylite is free software: you can redistribute it and/or modify it under
+ the terms of the FuzzyLite License included with the software.
+
+ You should have received a copy of the FuzzyLite License along with
+ fuzzylite. If not, see <http://www.fuzzylite.com/license/>.
+
+ fuzzylite is a registered trademark of FuzzyLite Limited.
+ */
+
+#include "fl/rule/Expression.h"
+
+#include "fl/hedge/Hedge.h"
+#include "fl/term/Term.h"
+#include "fl/rule/Rule.h"
+#include "fl/variable/Variable.h"
+
+namespace fl {
+
+    Expression::Expression() { }
+
+    Expression::~Expression() { }
+
+    Proposition::Proposition() : Expression(),
+    variable(fl::null), term(fl::null) { }
+
+    Proposition::~Proposition() {
+        for (std::size_t i = 0; i < hedges.size(); ++i) {
+            delete hedges.at(i);
+        }
+        hedges.clear();
+    }
+
+    Expression::Type Proposition::type() const {
+        return Expression::Proposition;
+    }
+
+    std::string Proposition::toString() const {
+        std::ostringstream ss;
+        if (variable) {
+            ss << variable->getName();
+        } else {
+            ss << "?";
+        }
+        if (not hedges.empty()) {
+            ss << " " << Rule::isKeyword() << " ";
+            for (std::size_t i = 0; i < hedges.size(); ++i) {
+                ss << hedges.at(i)->name() << " ";
+            }
+        }
+
+        if (term) { //term is fl::null if hedge is any
+            if (hedges.empty()) {
+                ss << " " << Rule::isKeyword() << " ";
+            }
+            ss << term->getName();
+        }
+        return ss.str();
+    }
+
+    Operator::Operator() : Expression(),
+    name(""), left(fl::null), right(fl::null) { }
+
+    Operator::~Operator() {
+        if (left) delete left;
+        if (right) delete right;
+    }
+
+    Expression::Type Operator::type() const {
+        return Expression::Operator;
+    }
+
+    std::string Operator::toString() const {
+        return name;
+    }
+
+}
diff --git a/fuzzylite/src/rule/Rule.cpp b/fuzzylite/src/rule/Rule.cpp
new file mode 100644
index 0000000..0338cd9
--- /dev/null
+++ b/fuzzylite/src/rule/Rule.cpp
@@ -0,0 +1,264 @@
+/*
+ fuzzylite (R), a fuzzy logic control library in C++.
+ Copyright (C) 2010-2017 FuzzyLite Limited. All rights reserved.
+ Author: Juan Rada-Vilela, Ph.D. <jcrada@fuzzylite.com>
+
+ This file is part of fuzzylite.
+
+ fuzzylite is free software: you can redistribute it and/or modify it under
+ the terms of the FuzzyLite License included with the software.
+
+ You should have received a copy of the FuzzyLite License along with
+ fuzzylite. If not, see <http://www.fuzzylite.com/license/>.
+
+ fuzzylite is a registered trademark of FuzzyLite Limited.
+ */
+
+#include "fl/rule/Rule.h"
+
+#include "fl/Exception.h"
+#include "fl/imex/FllExporter.h"
+#include "fl/norm/Norm.h"
+#include "fl/Operation.h"
+
+namespace fl {
+
+    Rule::Rule(const std::string& text, scalar weight)
+    : _enabled(true), _text(text), _weight(weight), _activationDegree(0.0), _triggered(false),
+    _antecedent(new Antecedent), _consequent(new Consequent) { }
+
+    Rule::Rule(const Rule& other) : _enabled(other._enabled), _text(other._text),
+    _weight(other._weight), _activationDegree(other._activationDegree), _triggered(false),
+    _antecedent(new Antecedent), _consequent(new Consequent) { }
+
+    Rule& Rule::operator=(const Rule& other) {
+        if (this != &other) {
+            _enabled = other._enabled;
+            _text = other._text;
+            _weight = other._weight;
+            _activationDegree = other._activationDegree;
+            _triggered = other._triggered;
+            _antecedent.reset(new Antecedent);
+            _consequent.reset(new Consequent);
+        }
+        return *this;
+    }
+
+    Rule::~Rule() {
+        if (_antecedent.get()) _antecedent->unload();
+        if (_consequent.get()) _consequent->unload();
+    }
+
+    void Rule::setText(const std::string& text) {
+        this->_text = text;
+    }
+
+    std::string Rule::getText() const {
+        return this->_text;
+    }
+
+    void Rule::setWeight(scalar weight) {
+        this->_weight = weight;
+    }
+
+    scalar Rule::getWeight() const {
+        return this->_weight;
+    }
+
+    void Rule::setAntecedent(Antecedent* antecedent) {
+        this->_antecedent.reset(antecedent);
+    }
+
+    Antecedent* Rule::getAntecedent() const {
+        return this->_antecedent.get();
+    }
+
+    void Rule::setConsequent(Consequent* consequent) {
+        this->_consequent.reset(consequent);
+    }
+
+    Consequent* Rule::getConsequent() const {
+        return this->_consequent.get();
+    }
+
+    void Rule::setEnabled(bool active) {
+        this->_enabled = active;
+    }
+
+    bool Rule::isEnabled() const {
+        return this->_enabled;
+    }
+
+    void Rule::setActivationDegree(scalar activationDegree) {
+        this->_activationDegree = activationDegree;
+    }
+
+    scalar Rule::getActivationDegree() const {
+        return this->_activationDegree;
+    }
+
+    void Rule::deactivate() {
+        _activationDegree = 0.0;
+        _triggered = false;
+    }
+
+    scalar Rule::activateWith(const TNorm* conjunction, const SNorm* disjunction) {
+        if (not isLoaded()) {
+            throw Exception("[rule error] the following rule is not loaded: " + getText(), FL_AT);
+        }
+        _activationDegree = _weight * _antecedent->activationDegree(conjunction, disjunction);
+        return _activationDegree;
+    }
+
+    void Rule::trigger(const TNorm* implication) {
+        if (not isLoaded()) {
+            throw Exception("[rule error] the following rule is not loaded: " + getText(), FL_AT);
+        }
+        if (_enabled and Op::isGt(_activationDegree, 0.0)) {
+            FL_DBG("[firing with " << Op::str(_activationDegree) << "] " << toString());
+            _consequent->modify(_activationDegree, implication);
+            _triggered = true;
+        }
+    }
+
+    bool Rule::isTriggered() const {
+        return this->_triggered;
+    }
+
+    Complexity Rule::complexityOfActivation(const TNorm* conjunction, const SNorm* disjunction) const {
+        Complexity result;
+        result.comparison(1).arithmetic(1);
+        if (isLoaded()) {
+            result += _antecedent->complexity(conjunction, disjunction);
+        }
+        return result;
+    }
+
+    Complexity Rule::complexityOfFiring(const TNorm* implication) const {
+        Complexity result;
+        result.comparison(3);
+        if (isLoaded()) {
+            result += _consequent->complexity(implication);
+        }
+        return result;
+    }
+
+    Complexity Rule::complexity(const TNorm* conjunction, const SNorm* disjunction,
+            const TNorm* implication) const {
+        return complexityOfActivation(conjunction, disjunction)
+                + complexityOfFiring(implication);
+    }
+
+    bool Rule::isLoaded() const {
+        return _antecedent.get() and _consequent.get()
+                and _antecedent->isLoaded() and _consequent->isLoaded();
+    }
+
+    void Rule::unload() {
+        deactivate();
+        if (getAntecedent()) getAntecedent()->unload();
+        if (getConsequent()) getConsequent()->unload();
+    }
+
+    void Rule::load(const Engine* engine) {
+        load(getText(), engine);
+    }
+
+    void Rule::load(const std::string& rule, const Engine* engine) {
+        deactivate();
+        setEnabled(true);
+        setText(rule);
+        std::istringstream tokenizer(rule.substr(0, rule.find_first_of('#')));
+        std::string token;
+        std::ostringstream ossAntecedent, ossConsequent;
+        scalar weight = 1.0;
+
+        enum FSM {
+            S_NONE, S_IF, S_THEN, S_WITH, S_END
+        };
+        FSM state = S_NONE;
+        try {
+            while (tokenizer >> token) {
+
+                switch (state) {
+                    case S_NONE:
+                        if (token == Rule::ifKeyword()) state = S_IF;
+                        else {
+                            std::ostringstream ex;
+                            ex << "[syntax error] expected keyword <" << Rule::ifKeyword() <<
+                                    ">, but found <" << token << "> in rule: " << rule;
+                            throw Exception(ex.str(), FL_AT);
+                        }
+                        break;
+                    case S_IF:
+                        if (token == Rule::thenKeyword()) state = S_THEN;
+                        else ossAntecedent << token << " ";
+                        break;
+                    case S_THEN:
+                        if (token == Rule::withKeyword()) state = S_WITH;
+                        else ossConsequent << token << " ";
+                        break;
+                    case S_WITH:
+                        try {
+                            weight = Op::toScalar(token);
+                            state = S_END;
+                        } catch (Exception& e) {
+                            std::ostringstream ex;
+                            ex << "[syntax error] expected a numeric value as the weight of the rule: "
+                                    << rule;
+                            e.append(ex.str(), FL_AT);
+                            throw;
+                        }
+                        break;
+                    case S_END:
+                    {
+                        std::ostringstream ex;
+                        ex << "[syntax error] unexpected token <" << token << "> at the end of rule";
+                        throw Exception(ex.str(), FL_AT);
+                    }
+
+                    default:
+                        std::ostringstream ex;
+                        ex << "[syntax error] unexpected state <" << state << ">";
+                        throw Exception(ex.str(), FL_AT);
+                }
+            }
+            if (state == S_NONE) {
+                std::ostringstream ex;
+                ex << "[syntax error] " << (rule.empty() ? "empty rule" : ("ignored rule: " + rule));
+                throw Exception(ex.str(), FL_AT);
+            } else if (state == S_IF) {
+                std::ostringstream ex;
+                ex << "[syntax error] keyword <" << Rule::thenKeyword() << "> not found in rule: " << rule;
+                throw Exception(ex.str(), FL_AT);
+            } else if (state == S_WITH) {
+                std::ostringstream ex;
+                ex << "[syntax error] expected a numeric value as the weight of the rule: " << rule;
+                throw Exception(ex.str(), FL_AT);
+            }
+
+            getAntecedent()->load(ossAntecedent.str(), engine);
+            getConsequent()->load(ossConsequent.str(), engine);
+            setWeight(weight);
+
+        } catch (...) {
+            unload();
+            throw;
+        }
+    }
+
+    std::string Rule::toString() const {
+        return FllExporter().toString(this);
+    }
+
+    Rule* Rule::clone() const {
+        return new Rule(*this);
+    }
+
+    Rule* Rule::parse(const std::string& rule, const Engine* engine) {
+        FL_unique_ptr<Rule> result(new Rule);
+        result->load(rule, engine);
+        return result.release();
+    }
+
+}
diff --git a/fuzzylite/src/rule/RuleBlock.cpp b/fuzzylite/src/rule/RuleBlock.cpp
new file mode 100644
index 0000000..d4e2a82
--- /dev/null
+++ b/fuzzylite/src/rule/RuleBlock.cpp
@@ -0,0 +1,227 @@
+/*
+ fuzzylite (R), a fuzzy logic control library in C++.
+ Copyright (C) 2010-2017 FuzzyLite Limited. All rights reserved.
+ Author: Juan Rada-Vilela, Ph.D. <jcrada@fuzzylite.com>
+
+ This file is part of fuzzylite.
+
+ fuzzylite is free software: you can redistribute it and/or modify it under
+ the terms of the FuzzyLite License included with the software.
+
+ You should have received a copy of the FuzzyLite License along with
+ fuzzylite. If not, see <http://www.fuzzylite.com/license/>.
+
+ fuzzylite is a registered trademark of FuzzyLite Limited.
+ */
+
+#include "fl/rule/RuleBlock.h"
+
+#include "fl/activation/General.h"
+#include "fl/imex/FllExporter.h"
+#include "fl/norm/TNorm.h"
+#include "fl/norm/SNorm.h"
+#include "fl/rule/Rule.h"
+#include "fl/Operation.h"
+
+namespace fl {
+
+    RuleBlock::RuleBlock(const std::string& name)
+    : _enabled(true), _name(name), _description("") { }
+
+    RuleBlock::RuleBlock(const RuleBlock& other) : _enabled(true), _name(other._name),
+    _description(other._description) {
+        copyFrom(other);
+    }
+
+    RuleBlock& RuleBlock::operator=(const RuleBlock& other) {
+        if (this != &other) {
+            for (std::size_t i = 0; i < _rules.size(); ++i) {
+                delete _rules.at(i);
+            }
+            _rules.clear();
+            _conjunction.reset(fl::null);
+            _disjunction.reset(fl::null);
+            _implication.reset(fl::null);
+            _activation.reset(fl::null);
+
+            copyFrom(other);
+        }
+        return *this;
+    }
+
+    void RuleBlock::copyFrom(const RuleBlock& source) {
+        _enabled = source._enabled;
+        _name = source._name;
+        _description = source._description;
+        if (source._conjunction.get()) _conjunction.reset(source._conjunction->clone());
+        if (source._disjunction.get()) _disjunction.reset(source._disjunction->clone());
+        if (source._implication.get()) _implication.reset(source._implication->clone());
+        if (source._activation.get()) _activation.reset(source._activation->clone());
+        for (std::size_t i = 0; i < source._rules.size(); ++i) {
+            _rules.push_back(source._rules.at(i)->clone());
+        }
+    }
+
+    RuleBlock::~RuleBlock() {
+        for (std::size_t i = 0; i < _rules.size(); ++i) {
+            delete _rules.at(i);
+        }
+        _rules.clear();
+    }
+
+    Complexity RuleBlock::complexity() const {
+        Complexity result;
+        result.comparison(1);
+        if (_activation.get()) {
+            result += _activation->complexity(this);
+        } else {
+            for (std::size_t i = 0; i < _rules.size(); ++i) {
+                result += _rules.at(i)->complexity(
+                        _conjunction.get(), _disjunction.get(), _implication.get());
+            }
+        }
+        return result;
+    }
+
+    void RuleBlock::activate() {
+        if (not _activation.get()) {
+            _activation.reset(new General);
+        }
+        _activation->activate(this);
+    }
+
+    void RuleBlock::unloadRules() const {
+        for (std::size_t i = 0; i < _rules.size(); ++i) {
+            _rules.at(i)->unload();
+        }
+    }
+
+    void RuleBlock::loadRules(const Engine* engine) {
+        std::ostringstream exceptions;
+        bool throwException = false;
+        for (std::size_t i = 0; i < _rules.size(); ++i) {
+            Rule* rule = _rules.at(i);
+            if (rule->isLoaded()) {
+                rule->unload();
+            }
+            try {
+                rule->load(engine);
+            } catch (std::exception& ex) {
+                throwException = true;
+                exceptions << ex.what() << "\n";
+            }
+        }
+        if (throwException) {
+            Exception exception("[ruleblock error] the following "
+                    "rules could not be loaded:\n" + exceptions.str(), FL_AT);
+            throw exception;
+        }
+    }
+
+    void RuleBlock::reloadRules(const Engine* engine) {
+        unloadRules();
+        loadRules(engine);
+    }
+
+    void RuleBlock::setName(std::string name) {
+        this->_name = name;
+    }
+
+    std::string RuleBlock::getName() const {
+        return this->_name;
+    }
+
+    void RuleBlock::setDescription(const std::string& description) {
+        this->_description = description;
+    }
+
+    std::string RuleBlock::getDescription() const {
+        return this->_description;
+    }
+
+    void RuleBlock::setConjunction(TNorm* tnorm) {
+        this->_conjunction.reset(tnorm);
+    }
+
+    TNorm* RuleBlock::getConjunction() const {
+        return this->_conjunction.get();
+    }
+
+    void RuleBlock::setDisjunction(SNorm* snorm) {
+        this->_disjunction.reset(snorm);
+    }
+
+    SNorm* RuleBlock::getDisjunction() const {
+        return this->_disjunction.get();
+    }
+
+    void RuleBlock::setImplication(TNorm* implication) {
+        this->_implication.reset(implication);
+    }
+
+    TNorm* RuleBlock::getImplication() const {
+        return this->_implication.get();
+    }
+
+    void RuleBlock::setActivation(Activation* activation) {
+        this->_activation.reset(activation);
+    }
+
+    Activation* RuleBlock::getActivation() const {
+        return this->_activation.get();
+    }
+
+    void RuleBlock::setEnabled(bool enabled) {
+        this->_enabled = enabled;
+    }
+
+    bool RuleBlock::isEnabled() const {
+        return this->_enabled;
+    }
+
+    std::string RuleBlock::toString() const {
+        return FllExporter().toString(this);
+    }
+
+    /**
+     * Operations for std::vector _rules
+     */
+    void RuleBlock::addRule(Rule* rule) {
+        _rules.push_back(rule);
+    }
+
+    void RuleBlock::insertRule(Rule* rule, std::size_t index) {
+        _rules.insert(_rules.begin() + index, rule);
+    }
+
+    Rule* RuleBlock::getRule(std::size_t index) const {
+        return _rules.at(index);
+    }
+
+    Rule* RuleBlock::removeRule(std::size_t index) {
+        Rule* result = _rules.at(index);
+        _rules.erase(_rules.begin() + index);
+        return result;
+    }
+
+    std::size_t RuleBlock::numberOfRules() const {
+        return _rules.size();
+    }
+
+    const std::vector<Rule*>& RuleBlock::rules() const {
+        return this->_rules;
+    }
+
+    void RuleBlock::setRules(const std::vector<Rule*>& rules) {
+        this->_rules = rules;
+    }
+
+    std::vector<Rule*>& RuleBlock::rules() {
+        return this->_rules;
+    }
+
+    RuleBlock* RuleBlock::clone() const {
+        return new RuleBlock(*this);
+    }
+
+}