summaryrefslogtreecommitdiff
path: root/fuzzylite/src/variable/Variable.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'fuzzylite/src/variable/Variable.cpp')
-rw-r--r--fuzzylite/src/variable/Variable.cpp295
1 files changed, 295 insertions, 0 deletions
diff --git a/fuzzylite/src/variable/Variable.cpp b/fuzzylite/src/variable/Variable.cpp
new file mode 100644
index 0000000..516b466
--- /dev/null
+++ b/fuzzylite/src/variable/Variable.cpp
@@ -0,0 +1,295 @@
+/*
+ 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/variable/Variable.h"
+
+#include "fl/imex/FllExporter.h"
+#include "fl/norm/Norm.h"
+#include "fl/term/Constant.h"
+#include "fl/term/Linear.h"
+
+#include <queue>
+
+namespace fl {
+
+ Variable::Variable(const std::string& name, scalar minimum, scalar maximum)
+ : _name(name), _description(""),
+ _value(fl::nan), _minimum(minimum), _maximum(maximum),
+ _enabled(true), _lockValueInRange(false) { }
+
+ Variable::Variable(const Variable& other) {
+ copyFrom(other);
+ }
+
+ Variable& Variable::operator=(const Variable& other) {
+ if (this != &other) {
+ for (std::size_t i = 0; i < _terms.size(); ++i) {
+ delete _terms.at(i);
+ }
+ _terms.clear();
+ copyFrom(other);
+ }
+ return *this;
+ }
+
+ void Variable::copyFrom(const Variable& other) {
+ _name = other._name;
+ _description = other._description;
+ _value = other._value;
+ _minimum = other._minimum;
+ _maximum = other._maximum;
+ _enabled = other._enabled;
+ _lockValueInRange = other._lockValueInRange;
+ for (std::size_t i = 0; i < other._terms.size(); ++i) {
+ _terms.push_back(other._terms.at(i)->clone());
+ }
+ }
+
+ Variable::~Variable() {
+ for (std::size_t i = 0; i < _terms.size(); ++i) {
+ delete _terms.at(i);
+ }
+ }
+
+ void Variable::setName(const std::string& name) {
+ this->_name = name;
+ }
+
+ std::string Variable::getName() const {
+ return this->_name;
+ }
+
+ void Variable::setDescription(const std::string& description) {
+ this->_description = description;
+ }
+
+ std::string Variable::getDescription() const {
+ return this->_description;
+ }
+
+ void Variable::setValue(scalar value) {
+ this->_value = _lockValueInRange
+ ? Op::bound(value, _minimum, _maximum)
+ : value;
+ }
+
+ scalar Variable::getValue() const {
+ return this->_value;
+ }
+
+ void Variable::setRange(scalar minimum, scalar maximum) {
+ setMinimum(minimum);
+ setMaximum(maximum);
+ }
+
+ scalar Variable::range() const {
+ return getMaximum() - getMinimum();
+ }
+
+ void Variable::setMinimum(scalar minimum) {
+ this->_minimum = minimum;
+ }
+
+ scalar Variable::getMinimum() const {
+ return this->_minimum;
+ }
+
+ void Variable::setMaximum(scalar maximum) {
+ this->_maximum = maximum;
+ }
+
+ scalar Variable::getMaximum() const {
+ return this->_maximum;
+ }
+
+ void Variable::setEnabled(bool enabled) {
+ this->_enabled = enabled;
+ }
+
+ bool Variable::isEnabled() const {
+ return this->_enabled;
+ }
+
+ void Variable::setLockValueInRange(bool lockValueInRange) {
+ this->_lockValueInRange = lockValueInRange;
+ }
+
+ bool Variable::isLockValueInRange() const {
+ return this->_lockValueInRange;
+ }
+
+ Variable::Type Variable::type() const {
+ return None;
+ }
+
+ Complexity Variable::complexity() const {
+ Complexity result;
+ if (isEnabled()) {
+ for (std::size_t i = 0; i < _terms.size(); ++i) {
+ result += _terms.at(i)->complexity();
+ }
+ }
+ return result;
+ }
+
+ std::string Variable::fuzzify(scalar x) const {
+ std::ostringstream ss;
+ for (std::size_t i = 0; i < terms().size(); ++i) {
+ Term* term = _terms.at(i);
+ scalar fx = fl::nan;
+ try {
+ fx = term->membership(x);
+ } catch (...) {
+ //ignore
+ }
+ if (i == 0) {
+ ss << Op::str(fx);
+ } else {
+ if (Op::isNaN(fx) or Op::isGE(fx, 0.0))
+ ss << " + " << Op::str(fx);
+ else
+ ss << " - " << Op::str(std::abs(fx));
+ }
+ ss << "/" << term->getName();
+ }
+ return ss.str();
+ }
+
+ Term* Variable::highestMembership(scalar x, scalar* yhighest) const {
+ Term* result = fl::null;
+ scalar ymax = 0.0;
+ for (std::size_t i = 0; i < _terms.size(); ++i) {
+ scalar y = fl::nan;
+ Term* term = _terms.at(i);
+ try {
+ y = term->membership(x);
+ } catch (...) {
+ //ignore
+ }
+ if (Op::isGt(y, ymax)) {
+ ymax = y;
+ result = term;
+ }
+ }
+ if (yhighest) *yhighest = ymax;
+ return result;
+ }
+
+ std::string Variable::toString() const {
+ return FllExporter().toString(this);
+ }
+
+ /**
+ * Operations for datatype _terms
+ */
+
+ typedef std::pair<Term*, scalar> TermCentroid;
+
+ struct Ascending {
+
+ bool operator()(const TermCentroid& a, const TermCentroid& b) const {
+ return a.second > b.second;
+ }
+ };
+
+ void Variable::sort() {
+ std::priority_queue <TermCentroid, std::vector<TermCentroid>, Ascending> termCentroids;
+ Centroid defuzzifier;
+ FL_DBG("Sorting...");
+ for (std::size_t i = 0; i < _terms.size(); ++i) {
+ Term* term = _terms.at(i);
+ scalar centroid = fl::inf;
+ try {
+ if (dynamic_cast<const Constant*> (term) or dynamic_cast<const Linear*> (term)) {
+ centroid = term->membership(0);
+ } else {
+ centroid = defuzzifier.defuzzify(term, getMinimum(), getMaximum());
+ }
+ } catch (...) { //ignore error possibly due to Function not loaded
+ centroid = fl::inf;
+ }
+ termCentroids.push(TermCentroid(term, centroid));
+ FL_DBG(term->toString() << " -> " << centroid)
+ }
+
+ std::vector<Term*> sortedTerms;
+ while (termCentroids.size() > 0) {
+ sortedTerms.push_back(termCentroids.top().first);
+ FL_DBG(termCentroids.top().first->toString() << " -> " << termCentroids.top().second);
+ termCentroids.pop();
+ }
+ setTerms(sortedTerms);
+ }
+
+ void Variable::addTerm(Term* term) {
+ _terms.push_back(term);
+ }
+
+ void Variable::insertTerm(Term* term, std::size_t index) {
+ _terms.insert(_terms.begin() + index, term);
+ }
+
+ Term* Variable::getTerm(std::size_t index) const {
+ return _terms.at(index);
+ }
+
+ Term* Variable::getTerm(const std::string& name) const {
+ for (std::size_t i = 0; i < terms().size(); ++i) {
+ if (_terms.at(i)->getName() == name) {
+ return terms().at(i);
+ }
+ }
+ throw Exception("[variable error] term <" + name + "> "
+ "not found in variable <" + getName() + ">", FL_AT);
+ }
+
+ bool Variable::hasTerm(const std::string& name) const {
+ for (std::size_t i = 0; i < _terms.size(); ++i) {
+ if (_terms.at(i)->getName() == name) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ Term* Variable::removeTerm(std::size_t index) {
+ Term* result = _terms.at(index);
+ _terms.erase(_terms.begin() + index);
+ return result;
+ }
+
+ std::size_t Variable::numberOfTerms() const {
+ return _terms.size();
+ }
+
+ const std::vector<Term*>& Variable::terms() const {
+ return this->_terms;
+ }
+
+ void Variable::setTerms(const std::vector<Term*>& terms) {
+ this->_terms = terms;
+ }
+
+ std::vector<Term*>& Variable::terms() {
+ return this->_terms;
+ }
+
+ Variable* Variable::clone() const {
+ return new Variable(*this);
+ }
+
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-29 01:04:05 +0000