type-2 membership functions and sugeno (#18)

* first draft of type-2 mfs and interval types

* add docstring and tests for intervals and membership functiosn

* test for type-2 sugeno

* fix plotting for type-2 fis

* test for type-2 mf plotting

Author: lucaferranti

docs/make.jl

@@ -78,7 +78,7 @@ function generate_memberships()
             ```
 
             """)
-            docstring = match(r"```julia\nmf = (\w+\(.+\))\n```", string(Docs.doc(mf)))
+            docstring = match(r"```julia\nmf = (.+)\n```", string(Docs.doc(mf)))
             if !isnothing(docstring)
                 mfex = only(docstring.captures)
                 write(f, """

src/FuzzyLogic.jl

@@ -3,6 +3,7 @@ module FuzzyLogic
 using Dictionaries, Reexport
 
 include("docstrings.jl")
+include("intervals.jl")
 include("membership_functions.jl")
 include("variables.jl")
 include("rules.jl")
@@ -16,7 +17,7 @@ include("readwrite.jl")
 
 export DifferenceSigmoidMF, LinearMF, GeneralizedBellMF, GaussianMF, ProductSigmoidMF,
        SigmoidMF, TrapezoidalMF, TriangularMF, SShapeMF, ZShapeMF, PiShapeMF,
-       PiecewiseLinearMF,
+       PiecewiseLinearMF, WeightedMF, Type2MF, ..,
        ProdAnd, MinAnd, LukasiewiczAnd, DrasticAnd, NilpotentAnd, HamacherAnd,
        ProbSumOr, MaxOr, BoundedSumOr, DrasticOr, NilpotentOr, EinsteinOr,
        MinImplication, ProdImplication,

src/evaluation.jl

@@ -1,7 +1,7 @@
 # utilities to evaluate a fuzzy inference system
 
 function (fr::FuzzyRelation)(fis::AbstractFuzzySystem,
-                             inputs::T)::float(eltype(T)) where {T <: NamedTuple}
+                             inputs::T) where {T <: NamedTuple}
     memberships(fis.inputs[fr.subj])[fr.prop](inputs[fr.subj])
 end
 
@@ -29,11 +29,11 @@ end
 
 function (fis::MamdaniFuzzySystem)(inputs::T) where {T <: NamedTuple}
     Npoints = fis.defuzzifier.N + 1
-    S = float(eltype(T))
+    S = outputtype(typeof(fis.defuzzifier), 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
+        w = rule.antecedent(fis, inputs)
         for con in rule.consequent
             var = fis.outputs[con.subj]
             l, h = low(var.domain), high(var.domain)
@@ -43,9 +43,9 @@ function (fis::MamdaniFuzzySystem)(inputs::T) where {T <: NamedTuple}
         end
     end
 
-    Dictionary(keys(fis.outputs), map(zip(res, fis.outputs)) do (y, var)
-                   fis.defuzzifier(y, var.domain)
-               end)
+    Dictionary{Symbol, float(S)}(keys(fis.outputs), map(zip(res, fis.outputs)) do (y, var)
+                                     fis.defuzzifier(y, var.domain)
+                                 end)
 end
 
 (fis::MamdaniFuzzySystem)(; inputs...) = fis(values(inputs))
@@ -59,7 +59,7 @@ function (fis::SugenoFuzzySystem)(inputs::T) where {T <: NamedTuple}
                                 zeros(float(eltype(T)), length(fis.outputs)))
     weights_sum = zero(S)
     for rule in fis.rules
-        w = scale(rule.antecedent(fis, inputs), rule)::S
+        w = scale(rule.antecedent(fis, inputs), rule)
         weights_sum += w
         for con in rule.consequent
             res[con.subj] += w * memberships(fis.outputs[con.subj])[con.prop](inputs)
@@ -72,3 +72,6 @@ end
 @inline function (fis::SugenoFuzzySystem)(inputs::Union{AbstractVector, Tuple})
     fis((; zip(collect(keys(fis.inputs)), inputs)...))
 end
+
+outputtype(::Type{T}, S) where {T <: AbstractDefuzzifier} = float(eltype(S))
+outputtype(::Type{T}, S) where {T <: Type2Defuzzifier} = Interval{float(eltype(S))}

src/intervals.jl

@@ -0,0 +1,34 @@
+struct Interval{T <: Real}
+    lo::T
+    hi::T
+end
+
+Base.convert(::Type{Interval{T}}, x::Real) where {T <: Real} = Interval(T(x), T(x))
+Base.convert(::Type{T}, x::Interval) where {T <: AbstractFloat} = (x.lo + x.hi) / 2
+
+Base.float(::Type{Interval{T}}) where {T <: Real} = T
+
+Base.:+(a::Interval) = a
+Base.:-(a::Interval) = Interval(-a.hi, -a.lo)
+Base.:+(a::Interval, b::Interval) = Interval(a.lo + b.lo, a.hi + b.hi)
+Base.:-(a::Interval, b::Interval) = Interval(a.lo - b.hi, a.hi - b.lo)
+
+function Base.:*(a::Interval, b::Interval)
+    Interval(extrema((a.lo * b.lo, a.lo * b.hi, a.hi * b.lo, a.hi * b.hi))...)
+end
+
+function Base.:/(a::Interval, b::Interval)
+    Interval(extrema((a.lo / b.lo, a.lo / b.hi, a.hi / b.lo, a.hi / b.hi))...)
+end
+Base.min(a::Interval, b::Interval) = Interval(min(a.lo, b.lo), min(a.hi, b.hi))
+Base.max(a::Interval, b::Interval) = Interval(max(a.lo, b.lo), max(a.hi, b.hi))
+Base.zero(::Type{Interval{T}}) where {T <: Real} = Interval(zero(T), zero(T))
+
+for op in (:+, :-, :*, :/, :min, :max)
+    @eval Base.$op(a::Interval, b::Real) = $op(a, Interval(b, b))
+    @eval Base.$op(a::Real, b::Interval) = $op(Interval(a, a), b)
+end
+
+function Base.:≈(a::Interval, b::Interval; kwargs...)
+    ≈(a.lo, b.lo; kwargs...) && ≈(a.hi, b.hi; kwargs...)
+end

src/membership_functions.jl

@@ -311,3 +311,51 @@ end
 
 # TODO: more robust soultion for all mfs
 Base.:(==)(mf1::PiecewiseLinearMF, mf2::PiecewiseLinearMF) = mf1.points == mf2.points
+
+"""
+A membership function scaled by a parameter ``0 ≤ w ≤ 1``.
+
+$(TYPEDFIELDS)
+
+### Example
+
+```julia
+mf = 0.5 * TriangularMF(1, 2, 3)
+```
+"""
+struct WeightedMF{MF <: AbstractMembershipFunction, T <: Real} <: AbstractMembershipFunction
+    "membership function."
+    mf::MF
+    "scaling factor."
+    w::T
+end
+(wmf::WeightedMF)(x) = wmf.w * wmf.mf(x)
+
+Base.show(io::IO, wmf::WeightedMF) = print(io, wmf.w, wmf.mf)
+
+Base.:*(w::Real, mf::AbstractMembershipFunction) = WeightedMF(mf, w)
+Base.:*(mf::AbstractMembershipFunction, w::Real) = WeightedMF(mf, w)
+
+"""
+A type-2 membership function.
+
+$(TYPEDFIELDS)
+
+### Example
+
+```julia
+mf = 0.7 * TriangularMF(3, 5, 7) .. TriangularMF(1, 5, 9)
+```
+"""
+struct Type2MF{MF1 <: AbstractMembershipFunction, MF2 <: AbstractMembershipFunction} <:
+       AbstractMembershipFunction
+    "lower membership function."
+    lo::MF1
+    "upper membership function."
+    hi::MF2
+end
+(mf2::Type2MF)(x) = Interval(mf2.lo(x), mf2.hi(x))
+
+..(mf1::AbstractMembershipFunction, mf2::AbstractMembershipFunction) = Type2MF(mf1, mf2)
+
+Base.show(io::IO, mf2::Type2MF) = print(io, mf2.lo, " .. ", mf2.hi)

src/options.jl

@@ -202,3 +202,5 @@ function (bd::BisectorDefuzzifier)(y, dom::Domain{T})::float(T) where {T}
 end
 
 _trapz(dx, y) = (2sum(y) - first(y) - last(y)) * dx / 2
+
+abstract type Type2Defuzzifier <: AbstractDefuzzifier end

src/plotting.jl

@@ -6,6 +6,14 @@ using RecipesBase
     x -> mf(x), low, high
 end
 
+@recipe function f(mf::Type2MF, low::Real, high::Real)
+    legend --> nothing
+    fillrange := x -> mf.hi(x)
+    fillalpha --> 0.25
+    lw --> 3
+    x -> mf.lo(x), low, high
+end
+
 @recipe f(mf::AbstractPredicate, dom::Domain) = mf, low(dom), high(dom)
 
 # plot sugeno membership functions

test/runtests.jl

@@ -1,6 +1,7 @@
 using SafeTestsets, Test
 
 testfiles = [
+    "test_intervals.jl",
     "test_membership_functions.jl",
     "test_settings.jl",
     "test_parser.jl",

test/test_evaluation.jl

@@ -119,3 +119,32 @@ end
     @test fis2(service = 7, food = 8)[:tip]≈19.639 atol=1e-3
     @test fis2((7, 8))[:tip]≈19.639 atol=1e-3
 end
+
+@testset "Type-2 Sugeno" begin
+    fis = @sugfis function tipper(service, food)::tip
+        service := begin
+            domain = 0:10
+            poor = 0.6 * GaussianMF(0.0, 1.5) .. GaussianMF(0.0, 1.5)
+            good = 0.6 * GaussianMF(5.0, 1.5) .. GaussianMF(5.0, 1.5)
+            excellent = 0.9 * GaussianMF(10.0, 1.5) .. GaussianMF(10.0, 1.5)
+        end
+
+        food := begin
+            domain = 0:10
+            rancid = 0.8 * TrapezoidalMF(-2, 0, 1, 3) .. TrapezoidalMF(-2, 0, 1, 4)
+            delicious = 0.8 * TrapezoidalMF(8, 9, 10, 12) .. TrapezoidalMF(7, 9, 10, 12)
+        end
+
+        tip := begin
+            domain = 0:30
+            cheap = 5.002
+            average = 15
+            generous = 24.998
+        end
+
+        service == poor || food == rancid --> tip == cheap * 0.5
+        service == good --> tip == average
+        service == excellent || food == delicious --> tip == generous
+    end
+    @test fis(service = 2, food = 3)[:tip]≈FuzzyLogic.Interval(5.304, 19.792) atol=1e-3
+end

test/test_intervals.jl

@@ -0,0 +1,22 @@
+using FuzzyLogic, Test
+using FuzzyLogic: Interval
+
+@testset "interval operations" begin
+    a = Interval(0.1, 1.0)
+    b = Interval(0.2, 0.8)
+
+    @test Interval(1.0, 2.0) ≈ Interval(nextfloat(1.0), prevfloat(2.0))
+    @test +a == a
+    @test -a == Interval(-1.0, -0.1)
+    @test a + b ≈ Interval(0.3, 1.8)
+    @test a - b ≈ Interval(-0.7, 0.8)
+    @test a * b ≈ Interval(0.02, 0.8)
+    @test a / b ≈ Interval(0.125, 5.0)
+    @test min(a, b) == Interval(0.1, 0.8)
+    @test max(a, b) == Interval(0.2, 1.0)
+    @test zero(Interval{Float64}) == Interval(0.0, 0.0)
+
+    @test convert(Interval{Float64}, 1.0) == Interval(1.0, 1.0)
+    @test convert(Float64, Interval(0.0, 1.0)) == 0.5
+    @test float(Interval{BigFloat}) == BigFloat
+end