1 files changed, 283 insertions, 0 deletions
diff --git a/fuzzylite/src/Complexity.cpp b/fuzzylite/src/Complexity.cpp
new file mode 100644
index 0000000..8a91c60
--- /dev/null
+++ b/fuzzylite/src/Complexity.cpp
@@ -0,0 +1,283 @@
+/*
+ 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/Complexity.h"
+
+#include "fl/Engine.h"
+
+#include "fl/variable/InputVariable.h"
+#include "fl/variable/OutputVariable.h"
+
+#include "fl/rule/RuleBlock.h"
+#include "fl/rule/Rule.h"
+
+namespace fl {
+
+    Complexity::Complexity(scalar all) :
+    _comparison(all), _arithmetic(all), _function(all) { }
+
+    Complexity::Complexity(scalar comparison, scalar arithmetic,
+            scalar function)
+    : _comparison(comparison), _arithmetic(arithmetic), _function(function) { }
+
+    Complexity::~Complexity() { }
+
+    Complexity& Complexity::operator+=(const Complexity& other) {
+        return this->plus(other);
+    }
+
+    Complexity& Complexity::operator-=(const Complexity& other) {
+        return this->minus(other);
+    }
+
+    Complexity& Complexity::operator*=(const Complexity& other) {
+        return this->multiply(other);
+    }
+
+    Complexity& Complexity::operator/=(const Complexity& other) {
+        return this->divide(other);
+    }
+
+    Complexity Complexity::operator+(const Complexity& rhs) const {
+        return Complexity(*this).plus(rhs);
+    }
+
+    Complexity Complexity::operator-(const Complexity& rhs) const {
+        return Complexity(*this).minus(rhs);
+    }
+
+    Complexity Complexity::operator*(const Complexity& rhs) const {
+        return Complexity(*this).multiply(rhs);
+    }
+
+    Complexity Complexity::operator/(const Complexity& rhs) const {
+        return Complexity(*this).divide(rhs);
+    }
+
+    bool Complexity::operator==(const Complexity& rhs) const {
+        return equals(rhs);
+    }
+
+    bool Complexity::operator!=(const Complexity& rhs) const {
+        return not equals(rhs);
+    }
+
+    bool Complexity::operator<(const Complexity& rhs) const {
+        return lessThan(rhs);
+    }
+
+    bool Complexity::operator<=(const Complexity& rhs) const {
+        return lessThanOrEqualsTo(rhs);
+    }
+
+    bool Complexity::operator>(const Complexity& rhs) const {
+        return greaterThan(rhs);
+    }
+
+    bool Complexity::operator>=(const Complexity& rhs) const {
+        return greaterThanOrEqualsTo(rhs);
+    }
+
+    Complexity& Complexity::plus(const Complexity& other) {
+        this->_arithmetic += other._arithmetic;
+        this->_comparison += other._comparison;
+        this->_function += other._function;
+        return *this;
+    }
+
+    Complexity& Complexity::plus(scalar x) {
+        return this->plus(Complexity().arithmetic(x).comparison(x).function(x));
+    }
+
+    Complexity& Complexity::minus(const Complexity& other) {
+        this->_comparison -= other._comparison;
+        this->_arithmetic -= other._arithmetic;
+        this->_function -= other._function;
+        return *this;
+    }
+
+    Complexity& Complexity::minus(scalar x) {
+        return this->minus(Complexity().arithmetic(x).comparison(x).function(x));
+    }
+
+    Complexity& Complexity::multiply(const Complexity& other) {
+        this->_comparison *= other._comparison;
+        this->_arithmetic *= other._arithmetic;
+        this->_function *= other._function;
+        return *this;
+    }
+
+    Complexity& Complexity::multiply(scalar x) {
+        return this->multiply(Complexity().arithmetic(x).comparison(x).function(x));
+    }
+
+    Complexity& Complexity::divide(const Complexity& other) {
+        this->_comparison /= other._comparison;
+        this->_arithmetic /= other._arithmetic;
+        this->_function /= other._function;
+        return *this;
+    }
+
+    Complexity& Complexity::divide(scalar x) {
+        return this->divide(Complexity().arithmetic(x).comparison(x).function(x));
+    }
+
+    bool Complexity::equals(const Complexity& x, scalar macheps) const {
+        return Op::isEq(_comparison, x._comparison, macheps) and
+                Op::isEq(_arithmetic, x._arithmetic, macheps) and
+                Op::isEq(_function, x._function, macheps);
+    }
+
+    bool Complexity::lessThan(const Complexity& x, scalar macheps) const {
+        return Op::isLt(_comparison, x._comparison, macheps) and
+                Op::isLt(_arithmetic, x._arithmetic, macheps) and
+                Op::isLt(_function, x._function, macheps);
+    }
+
+    bool Complexity::lessThanOrEqualsTo(const Complexity& x, scalar macheps) const {
+        return Op::isLE(_comparison, x._comparison, macheps) and
+                Op::isLE(_arithmetic, x._arithmetic, macheps) and
+                Op::isLE(_function, x._function, macheps);
+    }
+
+    bool Complexity::greaterThan(const Complexity& x, scalar macheps) const {
+        return Op::isGt(_comparison, x._comparison, macheps) and
+                Op::isGt(_arithmetic, x._arithmetic, macheps) and
+                Op::isGt(_function, x._function, macheps);
+    }
+
+    bool Complexity::greaterThanOrEqualsTo(const Complexity& x, scalar macheps) const {
+        return Op::isGE(_comparison, x._comparison, macheps) and
+                Op::isGE(_arithmetic, x._arithmetic, macheps) and
+                Op::isGE(_function, x._function, macheps);
+    }
+
+    Complexity& Complexity::comparison(scalar comparison) {
+        this->_comparison += comparison;
+        return *this;
+    }
+
+    void Complexity::setComparison(scalar comparison) {
+        this->_comparison = comparison;
+    }
+
+    scalar Complexity::getComparison() const {
+        return _comparison;
+    }
+
+    Complexity& Complexity::arithmetic(scalar arithmetic) {
+        this->_arithmetic += arithmetic;
+        return *this;
+    }
+
+    void Complexity::setArithmetic(scalar arithmetic) {
+        this->_arithmetic = arithmetic;
+    }
+
+    scalar Complexity::getArithmetic() const {
+        return _arithmetic;
+    }
+
+    Complexity& Complexity::function(scalar trigonometric) {
+        this->_function += trigonometric;
+        return *this;
+    }
+
+    void Complexity::setFunction(scalar trigonometric) {
+        this->_function = trigonometric;
+    }
+
+    scalar Complexity::getFunction() const {
+        return _function;
+    }
+
+    std::vector<Complexity::Measure> Complexity::measures() const {
+        std::vector<Measure> result;
+        result.push_back(Measure("arithmetic", _arithmetic));
+        result.push_back(Measure("comparison", _comparison));
+        result.push_back(Measure("function", _function));
+        return result;
+    }
+
+    scalar Complexity::sum() const {
+        return _arithmetic + _comparison + _function;
+    }
+
+    scalar Complexity::norm() const {
+        return std::sqrt(Complexity(*this).multiply(*this).sum());
+    }
+
+    std::string Complexity::toString() const {
+        std::vector<std::string> result;
+        result.push_back("a=" + Op::str(_arithmetic));
+        result.push_back("c=" + Op::str(_comparison));
+        result.push_back("f=" + Op::str(_function));
+        return "C[" + Op::join(result, ", ") + "]";
+    }
+
+    Complexity Complexity::compute(const Engine* engine) const {
+        return engine->complexity();
+    }
+
+    Complexity Complexity::compute(const InputVariable* inputVariable) const {
+        return inputVariable->complexity();
+    }
+
+    Complexity Complexity::compute(const OutputVariable* outputVariable) const {
+        return outputVariable->complexity();
+    }
+
+    Complexity Complexity::compute(const RuleBlock* ruleBlock) const {
+        return ruleBlock->complexity();
+    }
+
+    Complexity Complexity::compute(const std::vector<InputVariable*>& inputVariables) const {
+        Complexity result;
+        for (std::size_t i = 0; i < inputVariables.size(); ++i) {
+            result += inputVariables.at(i)->complexity();
+        }
+        return result;
+    }
+
+    Complexity Complexity::compute(const std::vector<OutputVariable*>& outputVariables,
+            bool complexityOfDefuzzification) const {
+        Complexity result;
+        for (std::size_t i = 0; i < outputVariables.size(); ++i) {
+            if (complexityOfDefuzzification)
+                result += outputVariables.at(i)->complexityOfDefuzzification();
+            else
+                result += outputVariables.at(i)->complexity();
+        }
+        return result;
+    }
+
+    Complexity Complexity::compute(const std::vector<Variable*>& variables) const {
+        Complexity result;
+        for (std::size_t i = 0; i < variables.size(); ++i) {
+            result += variables.at(i)->complexity();
+        }
+        return result;
+    }
+
+    Complexity Complexity::compute(const std::vector<RuleBlock*>& ruleBlocks) const {
+        Complexity result;
+        for (std::size_t i = 0; i < ruleBlocks.size(); ++i) {
+            result += ruleBlocks.at(i)->complexity();
+        }
+        return result;
+    }
+
+}