From 6ce553563bc795f389f639a3a8cdfe356de71441 Mon Sep 17 00:00:00 2001
From: Johannes 'josch' Schauer <josch@debian.org>
Date: Sun, 27 Jan 2019 13:56:24 +0100
Subject: new upstream version 6.0

---
 fuzzylite/fl/defuzzifier/WeightedDefuzzifier.h | 81 +++++++++++++++++---------
 1 file changed, 54 insertions(+), 27 deletions(-)

(limited to 'fuzzylite/fl/defuzzifier/WeightedDefuzzifier.h')

diff --git a/fuzzylite/fl/defuzzifier/WeightedDefuzzifier.h b/fuzzylite/fl/defuzzifier/WeightedDefuzzifier.h
index 2bf0495..2045772 100644
--- a/fuzzylite/fl/defuzzifier/WeightedDefuzzifier.h
+++ b/fuzzylite/fl/defuzzifier/WeightedDefuzzifier.h
@@ -1,25 +1,17 @@
 /*
- Author: Juan Rada-Vilela, Ph.D.
- Copyright (C) 2010-2014 FuzzyLite Limited
- All rights reserved
+ 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 GNU Lesser General Public License as published by the Free
- Software Foundation, either version 3 of the License, or (at your option)
- any later version.
+ the terms of the FuzzyLite License included with the software.
 
- fuzzylite is distributed in the hope that it will be useful, but WITHOUT
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
- for more details.
-
- You should have received a copy of the GNU Lesser General Public License
- along with fuzzylite.  If not, see <http://www.gnu.org/licenses/>.
-
- fuzzylite™ is a trademark of FuzzyLite Limited.
+ 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.
  */
 
 #ifndef FL_WEIGHTEDDEFUZZIFIER_H
@@ -30,33 +22,68 @@
 namespace fl {
     class Activated;
 
+    /**
+      The WeightedDefuzzifier class is the base class for defuzzifiers which
+      compute a weighted function on the fuzzy set without requiring to
+      integrate over the fuzzy set.
+
+      @author Juan Rada-Vilela, Ph.D.
+      @since 5.0
+     */
     class FL_API WeightedDefuzzifier : public Defuzzifier {
     public:
 
+        /**The Type enum indicates the type of the WeightedDefuzzifier based
+        the terms included in the fuzzy set.*/
         enum Type {
-            Automatic, TakagiSugeno, Tsukamoto
+            /**Automatic: Automatically inferred from the terms */
+            Automatic,
+            /**TakagiSugeno: Manually set to TakagiSugeno (or Inverse Tsukamoto)*/
+            TakagiSugeno,
+            /**Tsukamoto: Manually set to Tsukamoto*/
+            Tsukamoto
         };
-        static std::string typeName(Type);
+        /**
+          Returns a string representation of the given type
+          @param type is the type of a defuzzifier
+          @return a string representation of the given type
+         */
+        static std::string typeName(Type type);
+    private:
+        Type _type;
 
+    public:
         explicit WeightedDefuzzifier(Type type = Automatic);
         explicit WeightedDefuzzifier(const std::string& type);
         virtual ~WeightedDefuzzifier() FL_IOVERRIDE;
         FL_DEFAULT_COPY_AND_MOVE(WeightedDefuzzifier)
 
-        virtual void setType(Type type);
-        virtual Type getType() const;
+        /**
+          Sets the type of the weighted defuzzifier
+          @param type is the type of the weighted defuzzifier
+         */
+        void setType(Type type);
+        /**
+          Gets the type of the weighted defuzzifier
+          @return the type of the weighted defuzzifier
+         */
+        Type getType() const;
+        /**
+          Returns a string representation of the type of the defuzzifier
+          @return a string representation of the type of the defuzzifier
+         */
         virtual std::string getTypeName() const;
+        /**
+          Infers the type of the defuzzifier based on the given term. If the
+          given term is Constant, Linear or Function, then the type is
+          TakagiSugeno; otherwise, the type is Tsukamoto
+
+          @param term is the given term
+          @return the inferred type of the defuzzifier based on the given term
+         */
         virtual Type inferType(const Term* term) const;
-        virtual bool isMonotonic(const Term* term) const;
-
-        virtual scalar tsukamoto(const Term* monotonic, scalar activationDegree,
-                scalar minimum, scalar maximum) const;
-
-    protected:
-        Type _type;
 
     };
-
 }
 
 #endif  /* FL_WEIGHTEDDEFUZZIFIER_H */
-- 
cgit v1.2.3