remove anonymous functions (#12)

* remove anonymous functions

* update bisector defuzzifier and add tests

Author: lucaferranti

src/evaluation.jl

@@ -18,22 +18,34 @@ function (fo::FuzzyOr)(fis::AbstractFuzzySystem, inputs)
     fis.or(fo.left(fis, inputs), fo.right(fis, inputs))
 end
 
-function (fr::FuzzyRule)(fis::AbstractFuzzySystem, inputs)::Dictionary{Symbol, Function}
+function (fr::FuzzyRule)(fis::AbstractFuzzySystem, inputs;
+                         N = 100)
     map(fr.consequent) do c
-        mf = memberships(fis.outputs[c.subj])[c.prop]
-        c.subj => Base.Fix1(implication(fis), fr.antecedent(fis, inputs)) ∘ mf
-    end |> dictionary
+        l, h = low(fis.outputs[c.sub].domain), high(fis.outputs[c.sub].domain)
+        mf = broadcast(memberships(fis.outputs[c.subj])[c.prop], LinRange(l, h, N))
+        broadcast(implication(fis), fr.antecedent(fis, inputs), mf)
+    end
 end
 
-function (fis::MamdaniFuzzySystem)(inputs::T)::Dictionary{Symbol,
-                                                          float(eltype(T))
-                                                          } where {T <: NamedTuple}
-    rules = [rule(fis, inputs) for rule in fis.rules]
-    map(pairs(fis.outputs)) do (y, var)
-        fis.defuzzifier(domain(var)) do x
-            reduce(fis.aggregator, rule[y](x) for rule in rules if haskey(rule, y))
+function (fis::MamdaniFuzzySystem)(inputs::T) where {T <: NamedTuple}
+    Npoints = fis.defuzzifier.N + 1
+    S = float(eltype(T))
+    res = Dictionary{Symbol, Vector{S}}(keys(fis.outputs),
+                                        [zeros(S, Npoints) for _ in 1:length(fis.outputs)])
+    @inbounds for rule in fis.rules
+        w = rule.antecedent(fis, inputs)::S
+        for con in rule.consequent
+            var = fis.outputs[con.subj]
+            l, h = low(var.domain), high(var.domain)
+            mf = map(var.mfs[con.prop], LinRange(l, h, Npoints))
+            ruleres = broadcast(implication(fis), w, mf)
+            res[con.subj] = broadcast(fis.aggregator, res[con.subj], ruleres)
         end
     end
+
+    Dictionary(keys(fis.outputs), map(zip(res, fis.outputs)) do (y, var)
+                   fis.defuzzifier(y, var.domain)
+               end)
 end
 
 (fis::MamdaniFuzzySystem)(; inputs...) = fis(values(inputs))

src/options.jl

@@ -156,13 +156,13 @@ variable domain ``[a, b]`` the defuzzified output is the centroid computed as
 The integrals are computed numerically using the trapezoidal rule.
 """
 struct CentroidDefuzzifier <: AbstractDefuzzifier
-    "number of subintegrals for integration, default 100."
+    "number of subintervals for integration, default 100."
     N::Int
 end
 CentroidDefuzzifier() = CentroidDefuzzifier(100)
-function (cd::CentroidDefuzzifier)(f::Function, dom::Domain{T})::float(T) where {T}
-    l, h = low(dom), high(dom)
-    (_trapz(x -> x * f(x), l, h, cd.N) / _trapz(f, l, h, cd.N))
+function (cd::CentroidDefuzzifier)(y, dom::Domain{T})::float(T) where {T}
+    dx = (high(dom) - low(dom)) / cd.N
+    _trapz(dx, LinRange(low(dom), high(dom), cd.N + 1) .* y) / _trapz(dx, y)
 end
 
 @doc raw"""
@@ -186,20 +186,19 @@ struct BisectorDefuzzifier <: AbstractDefuzzifier
     N::Int
 end
 BisectorDefuzzifier() = BisectorDefuzzifier(100)
-function (bd::BisectorDefuzzifier)(f::Function, dom::Domain{T})::float(T) where {T}
+function (bd::BisectorDefuzzifier)(y, dom::Domain{T})::float(T) where {T}
     area_left = zero(T)
-    area_right = _trapz(f, low(dom), high(dom), bd.N)
-    cand = low(dom)
     h = (high(dom) - low(dom)) / bd.N
+    area_right = _trapz(h, y)
+    cand = LinRange(low(dom), high(dom), bd.N + 1)
+    i = firstindex(y)
     while area_left < area_right
-        trap = (f(cand) + f(cand + h)) * h / 2
+        trap = (y[i] + y[i + 1]) * h / 2
         area_left += trap
         area_right -= trap
-        cand += h
+        i += 1
     end
-    (f(cand - h) + f(cand)) * h / 2 >= area_left - area_right ? cand : cand - h
+    (y[i - 1] + y[i]) * h / 2 >= area_left - area_right ? cand[i] : cand[i - 1]
 end
 
-function _trapz(f, a, b, N)
-    (b - a) / N * (sum(f(xi) for xi in LinRange(a, b, N + 1)) + (f(a) + f(b)) / 2)
-end
+_trapz(dx, y) = (2sum(y) - first(y) - last(y)) * dx / 2

test/test_settings.jl

@@ -52,3 +52,12 @@ end
     @test EinsteinOr()(0.5, 0.5) == 0.8
     @test EinsteinOr()(1.0, 1.0) == 1.0
 end
+
+@testset "test defuzzifiers" begin
+    N = 800
+    mf = TrapezoidalMF(1, 2, 5, 7)
+    x = LinRange(0, 8, N + 1)
+    y = mf.(x)
+    @test BisectorDefuzzifier(N)(y, FuzzyLogic.Domain(0, 8)) ≈ 3.75
+    @test CentroidDefuzzifier(N)(y, FuzzyLogic.Domain(0, 8)) ≈ 3.7777777777777772
+end