add more defuzzifiers (#22)

* add more defuzzifiers

* add defuzzifiers to parsers

* typos in docs

* add code generation for new defuzzifiers

* update changelog

Author: lucaferranti

docs/src/changelog.md

@@ -9,6 +9,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - ![](https://img.shields.io/badge/new%20feature-green.svg) added support for type-2 membership functions and type-2 systems.
 - ![](https://img.shields.io/badge/new%20feature-green.svg) added parser for Fuzzy Markup Language.
 - ![](https://img.shields.io/badge/new%20feature-green.svg) added generation of native Julia code.
+- ![](https://img.shields.io/badge/enhancement-blue.svg) added left maximum, right maximum and mean of maxima defuzzifiers.
 
 ## v0.1.1 -- 2023-02-25
 

src/FuzzyLogic.jl

@@ -22,7 +22,9 @@ export DifferenceSigmoidMF, LinearMF, GeneralizedBellMF, GaussianMF, ProductSigm
        ProdAnd, MinAnd, LukasiewiczAnd, DrasticAnd, NilpotentAnd, HamacherAnd, EinsteinAnd,
        ProbSumOr, MaxOr, BoundedSumOr, DrasticOr, NilpotentOr, EinsteinOr, HamacherOr,
        MinImplication, ProdImplication,
-       MaxAggregator, ProbSumAggregator, CentroidDefuzzifier, BisectorDefuzzifier,
+       MaxAggregator, ProbSumAggregator,
+       CentroidDefuzzifier, BisectorDefuzzifier, LeftMaximumDefuzzifier,
+       RightMaximumDefuzzifier, MeanOfMaximaDefuzzifier,
        KarnikMendelDefuzzifier, EKMDefuzzifier, IASCDefuzzifier, EIASCDefuzzifier,
        @mamfis, MamdaniFuzzySystem, @sugfis, SugenoFuzzySystem, set,
        LinearSugenoOutput, ConstantSugenoOutput,

src/options.jl

@@ -225,6 +225,91 @@ function (bd::BisectorDefuzzifier)(y, dom::Domain{T})::float(T) where {T}
     (y[i - 1] + y[i]) * h / 2 >= area_left - area_right ? cand[i] : cand[i - 1]
 end
 
+"""
+Left maximum defuzzifier. Returns the smallest value in the domain for which the membership function
+reaches its maximum.
+
+### Parameters
+
+$(TYPEDFIELDS)
+
+"""
+Base.@kwdef struct LeftMaximumDefuzzifier <: AbstractDefuzzifier
+    "number of subintervals, default 100."
+    N::Int = 100
+    "absolute tolerance to determine if a value is maximum, default `eps(Float64)`."
+    tol::Float64 = eps(Float64)
+end
+function (lmd::LeftMaximumDefuzzifier)(y, dom::Domain{T}) where {T}
+    res = float(low(dom))
+    maxval = first(y)
+    for (xi, yi) in zip(LinRange(low(dom), high(dom), lmd.N + 1), y)
+        if yi > maxval + lmd.tol
+            res = xi
+            maxval = yi
+        end
+    end
+    res
+end
+
+"""
+Right maximum defuzzifier. Returns the largest value in the domain for which the membership function
+reaches its maximum.
+
+### Parameters
+
+$(TYPEDFIELDS)
+
+"""
+Base.@kwdef struct RightMaximumDefuzzifier <: AbstractDefuzzifier
+    "number of subintervals, default 100."
+    N::Int = 100
+    "absolute tolerance to determine if a value is maximum, default `eps(Float64)`."
+    tol::Float64 = eps(Float64)
+end
+function (lmd::RightMaximumDefuzzifier)(y, dom::Domain{T}) where {T}
+    res = float(low(dom))
+    maxval = first(y)
+    for (xi, yi) in zip(LinRange(low(dom), high(dom), lmd.N + 1), y)
+        if yi >= maxval - lmd.tol
+            res = xi
+            maxval = yi
+        end
+    end
+    res
+end
+
+"""
+Mean of maxima defuzzifier. Returns the mean of the values in the domain for which the
+membership function reaches its maximum.
+
+### Parameters
+
+$(TYPEDFIELDS)
+"""
+Base.@kwdef struct MeanOfMaximaDefuzzifier <: AbstractDefuzzifier
+    "number of subintervals, default 100."
+    N::Int = 100
+    "absolute tolerance to determine if a value is maximum, default `eps(Float64)`."
+    tol::Float64 = eps(Float64)
+end
+function (lmd::MeanOfMaximaDefuzzifier)(y, dom::Domain{T}) where {T}
+    res = zero(float(T))
+    maxcnt = 0
+    maxval = first(y)
+    for (xi, yi) in zip(LinRange(low(dom), high(dom), lmd.N + 1), y)
+        if yi - maxval > lmd.tol # reset mean calculation
+            res = xi
+            maxval = yi
+            maxcnt = 1
+        elseif abs(yi - maxval) <= lmd.tol
+            res += xi
+            maxcnt += 1
+        end
+    end
+    return res / maxcnt
+end
+
 _trapz(dx, y) = (2sum(y) - first(y) - last(y)) * dx / 2
 
 abstract type Type2Defuzzifier <: AbstractDefuzzifier end

src/parsers/fcl.jl

@@ -10,6 +10,9 @@ export parse_fcl, @fcl_str
 const FCL_JULIA = Dict("COG" => CentroidDefuzzifier(),
                        "COGS" => "COGS", # dummy since hardcoded for sugeno
                        "COA" => BisectorDefuzzifier(),
+                       "LM" => LeftMaximumDefuzzifier(),
+                       "RM" => RightMaximumDefuzzifier(),
+                       "MOM" => MeanOfMaximaDefuzzifier(),
                        "ANDMIN" => MinAnd(),
                        "ANDPROD" => ProdAnd(),
                        "ANDBDIF" => LukasiewiczAnd(),

src/parsers/fml.jl

@@ -23,6 +23,9 @@ XML_JULIA = Dict("mamdaniRuleBase" => MamdaniFuzzySystem,
                  "rightLinearShape" => LinearMF,
                  "COG" => CentroidDefuzzifier(),
                  "COA" => BisectorDefuzzifier(),
+                 "MOM" => MeanOfMaximaDefuzzifier(),
+                 "LM" => LeftMaximumDefuzzifier(),
+                 "RM" => RightMaximumDefuzzifier(),
                  "ACCMAX" => MaxAggregator(),
                  "andMIN" => MinAnd(),
                  "andPROD" => ProdAnd(),

src/parsers/matlab_fis.jl

@@ -16,6 +16,9 @@ const MATLAB_JULIA = Dict("'mamdani'" => MamdaniFuzzySystem,
                           "agg'probor'" => ProbSumAggregator(),
                           "'centroid'" => CentroidDefuzzifier(),
                           "'bisector'" => BisectorDefuzzifier(),
+                          "'mom'" => MeanOfMaximaDefuzzifier(),
+                          "'lom'" => RightMaximumDefuzzifier(),
+                          "'som'" => LeftMaximumDefuzzifier(),
                           "'trapmf'" => TrapezoidalMF,
                           "'trimf'" => TriangularMF,
                           "'gaussmf'" => GaussianMF,

src/tojulia.jl

@@ -345,3 +345,53 @@ function to_expr(defuzz::BisectorDefuzzifier, mf, dom::Domain{T}) where {T <: Re
           (mf[i - 1] + mf[i]) * $(h / 2) >= area_left - area_right ? cand[i] : cand[i - 1]
       end)
 end
+
+function to_expr(defuzz::LeftMaximumDefuzzifier, mf, dom::Domain{T}) where {T <: Real}
+    :(let
+          res = $(float(low(dom)))
+          y = $mf
+          maxval = first(y)
+          for (xi, yi) in zip($(LinRange(low(dom), high(dom), defuzz.N + 1)), y)
+              if yi > maxval + $(defuzz.tol)
+                  res = xi
+                  maxval = yi
+              end
+          end
+          res
+      end)
+end
+
+function to_expr(defuzz::RightMaximumDefuzzifier, mf, dom::Domain{T}) where {T <: Real}
+    :(let
+          res = $(float(low(dom)))
+          y = $mf
+          maxval = first(y)
+          for (xi, yi) in zip($(LinRange(low(dom), high(dom), defuzz.N + 1)), y)
+              if yi >= maxval - $(defuzz.tol)
+                  res = xi
+                  maxval = yi
+              end
+          end
+          res
+      end)
+end
+
+function to_expr(defuzz::MeanOfMaximaDefuzzifier, mf, dom::Domain{T}) where {T <: Real}
+    :(let
+          res = $(zero(float(T)))
+          y = $mf
+          maxval = first(y)
+          maxcnt = 0
+          for (xi, yi) in zip($(LinRange(low(dom), high(dom), defuzz.N + 1)), y)
+              if yi - maxval > $(defuzz.tol) # reset mean calculation
+                  res = xi
+                  maxval = yi
+                  maxcnt = 1
+              elseif abs(yi - maxval) <= $(defuzz.tol)
+                  res += xi
+                  maxcnt += 1
+              end
+          end
+          res / maxcnt
+      end)
+end

test/test_settings.jl

@@ -115,4 +115,10 @@ end
           3.75
     @test CentroidDefuzzifier(N)(y, dom) ≈ eval(to_expr(CentroidDefuzzifier(N), y, dom)) ≈
           3.7777777777777772
+    @test LeftMaximumDefuzzifier(; N)(y, dom) ≈
+          eval(to_expr(LeftMaximumDefuzzifier(; N), y, dom)) ≈ 2
+    @test RightMaximumDefuzzifier(; N)(y, dom) ≈
+          eval(to_expr(RightMaximumDefuzzifier(; N), y, dom)) ≈ 5
+    @test MeanOfMaximaDefuzzifier(; N)(y, dom) ≈
+          eval(to_expr(MeanOfMaximaDefuzzifier(; N), y, dom)) ≈ 3.5
 end