added more norms and plots to documentation (#10)

* added more norms and plots to documentation

* add tests

Author: lucaferranti

.gitignore

@@ -9,4 +9,5 @@ indigo.css
 /docs/src/tutorials/
 /docs/src/applications/
 /docs/src/notebooks/
-/docs/src/api/memberships.md
+/docs/src/api/memberships.md
+/docs/src/api/logical.md

docs/make.jl

@@ -92,8 +92,51 @@ function generate_memberships()
     end
 end
 
+function generate_norms()
+    connectives = [
+        subtypes(FuzzyLogic.AbstractAnd),
+        subtypes(FuzzyLogic.AbstractOr),
+        subtypes(FuzzyLogic.AbstractImplication),
+    ]
+    titles = ["Conjuction", "Disjunction", "Implication"]
+    open(joinpath(@__DIR__, "src", "api", "logical.md"), "w") do f
+        write(f, """```@setup logicals
+        using FuzzyLogic
+        using Plots
+        ```
+
+        # Logical connectives
+        """)
+        for (t, c) in zip(titles, connectives)
+            write(f, """
+            ## $t methods
+
+            """)
+
+            for ci in c
+                write(f, """
+                ### $(nameof(ci))
+
+                ```@docs
+                $ci
+                ```
+
+                ```@example logicals
+                x = y = 0:0.01:1 # hide
+                contourf(x, y, (x, y) -> $ci()(x, y)) # hide
+                ```
+                """)
+            end
+        end
+    end
+end
+
+# Logical connectives
+
 generate_memberships()
 
+generate_norms()
+
 ###############
 # CREATE HTML #
 ###############

docs/src/api/logical.md

@@ -2,6 +2,10 @@
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## unreleased
+
+- added support Lukasiewicz, drastic, nilpotent and Hamacher T-norms and corresponding S-norms.
+
 ## v0.1.0 -- 2023-01-10
 
 [view release on GitHub](https://github.com/lucaferranti/FuzzyLogic.jl/releases/tag/v0.1.0)
@@ -11,7 +15,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - initial domain specific language design and parser
 - initial membership functions: triangular, trapezoidal, gaussian, bell, linear, sigmoid, sum of sigmoids, product of sigmoids, s-shaped, z-shaped, pi-shaped.
 - initial implementation of Mamdani and Sugeno inference systems (type 1)
-  - min, prod and Łukasiewicz t-norms with corresponding conorms
+  - min and prod t-norms with corresponding conorms
   - min and prod implication
   - max and probabilistic sum aggregation method
   - centroid and bisector defuzzifier

docs/src/changelog.md

@@ -14,7 +14,9 @@ include("plotting.jl")
 
 export DifferenceSigmoidMF, LinearMF, GeneralizedBellMF, GaussianMF, ProductSigmoidMF,
        SigmoidMF, TrapezoidalMF, TriangularMF, SShapeMF, ZShapeMF, PiShapeMF,
-       ProdAnd, MinAnd, ProbSumOr, MaxOr, MinImplication, ProdImplication,
+       ProdAnd, MinAnd, LukasiewiczAnd, DrasticAnd, NilpotentAnd, HamacherAnd,
+       ProbSumOr, MaxOr, BoundedSumOr, DrasticOr, NilpotentOr, EinsteinOr,
+       MinImplication, ProdImplication,
        MaxAggregator, ProbSumAggregator, CentroidDefuzzifier, BisectorDefuzzifier,
        @mamfis, MamdaniFuzzySystem, @sugfis, SugenoFuzzySystem,
        LinearSugenoOutput, ConstantSugenoOutput

src/FuzzyLogic.jl

@@ -17,6 +17,45 @@ Product T-norm defining conjuction as ``A ∧ B = AB``.
 struct ProdAnd <: AbstractAnd end
 (pa::ProdAnd)(x, y) = x * y
 
+"""
+Lukasiewicz T-norm defining conjuction as ``A ∧ B = \\max(0, A + B - 1)``.
+"""
+struct LukasiewiczAnd <: AbstractAnd end
+(la::LukasiewiczAnd)(x, y) = max(0, x + y - 1)
+
+"""
+Drastic T-norm defining conjuction as ``A ∧ B = \\min(A, B)`` is ``A = 1`` or ``B = 1`` and
+``A ∧ B = 0`` otherwise.
+"""
+struct DrasticAnd <: AbstractAnd end
+function (da::DrasticAnd)(x::T, y::S) where {T <: Real, S <: Real}
+    TS = promote_type(T, S)
+    isone(x) && return TS(y)
+    isone(y) && return TS(x)
+    zero(TS)
+end
+
+"""
+Nilpotent T-norm defining conjuction as ``A ∧ B = \\min(A, B)`` when ``A + B > 1`` and
+``A ∧ B = 0`` otherwise.
+"""
+struct NilpotentAnd <: AbstractAnd end
+function (na::NilpotentAnd)(x::T, y::S) where {T <: Real, S <: Real}
+    m = min(x, y)
+    x + y > 1 && return m
+    return zero(m)
+end
+
+"""
+Hamacher T-norm defining conjuction as ``A ∧ B = \\frac{AB}{A + B - AB}`` if ``A ≂̸ 0 ≂̸ B``
+and ``A ∧ B = 0`` otherwise.
+"""
+struct HamacherAnd <: AbstractAnd end
+function (ha::HamacherAnd)(x::T, y::S) where {T <: Real, S <: Real}
+    iszero(x) && iszero(y) && return zero(float(promote_type(T, S)))
+    (x * y) / (x + y - x * y)
+end
+
 ## S-Norms
 
 abstract type AbstractOr <: AbstractFISSetting end
@@ -33,6 +72,40 @@ Probabilistic sum S-norm defining disjunction as ``A ∨ B = A + B - AB``.
 struct ProbSumOr <: AbstractOr end
 (pso::ProbSumOr)(x, y) = x + y - x * y
 
+"""
+Bounded sum S-norm defining disjunction as ``A ∨ B = \\min(1, A + B)``.
+"""
+struct BoundedSumOr <: AbstractOr end
+(la::BoundedSumOr)(x, y) = min(1, x + y)
+
+"""
+Drastic S-norm defining disjunction as ``A ∨ B = \\min(1, A + B)``.
+"""
+struct DrasticOr <: AbstractOr end
+function (da::DrasticOr)(x::T, y::S) where {T <: Real, S <: Real}
+    TS = promote_type(T, S)
+    iszero(x) && return TS(y)
+    iszero(y) && return TS(x)
+    one(TS)
+end
+
+"""
+Nilpotent S-norm defining disjunction as ``A ∨ B = \\max(A, B)`` when ``A + B < 1`` and
+``A ∧ B = 1`` otherwise.
+"""
+struct NilpotentOr <: AbstractOr end
+function (na::NilpotentOr)(x::T, y::S) where {T <: Real, S <: Real}
+    m = max(x, y)
+    x + y < 1 && return m
+    return one(m)
+end
+
+"""
+Einstein S-norm defining disjunction as ``A ∨ B = \\frac{A + B}{1 + AB}``.
+"""
+struct EinsteinOr <: AbstractOr end
+(ha::EinsteinOr)(x, y) = (x + y) / (1 + x * y)
+
 ## Implication
 
 abstract type AbstractImplication <: AbstractFISSetting end

src/options.jl

@@ -2,6 +2,7 @@ using SafeTestsets, Test
 
 testfiles = [
     "test_membership_functions.jl",
+    "test_settings.jl",
     "test_parser.jl",
     "test_evaluation.jl",
     "test_plotting.jl",

test/runtests.jl

@@ -0,0 +1,54 @@
+using FuzzyLogic
+using Test
+
+@testset "test T--norms" begin
+    @test MinAnd()(0.4, 0.2) == 0.2
+    @test MinAnd()(1.0, 1.0) == 1.0
+    @test MinAnd()(0.0, 0.0) == 0.0
+
+    @test ProdAnd()(0.4, 0.2) ≈ 0.08
+    @test ProdAnd()(1.0, 1.0) == 1.0
+    @test ProdAnd()(0.0, 0.0) == 0.0
+
+    @test DrasticAnd()(1.0, 0.2) == 0.2
+    @test DrasticAnd()(0.3, 1.0) == 0.3
+    @test DrasticAnd()(0.9, 0.9) == 0.0
+
+    @test LukasiewiczAnd()(0.4, 0.2) == 0
+    @test LukasiewiczAnd()(0.7, 0.5) ≈ 0.2
+    @test LukasiewiczAnd()(0.5, 0.5) ≈ 0
+
+    @test NilpotentAnd()(0.4, 0.2) == 0.0
+    @test NilpotentAnd()(0.5, 0.7) == 0.5
+    @test NilpotentAnd()(0.5, 0.5) == 0.0
+
+    @test HamacherAnd()(0.0, 0.0) == 0.0
+    @test HamacherAnd()(0.4, 0.2) ≈ 0.15384615384615388
+    @test HamacherAnd()(1.0, 1.0) == 1.0
+end
+
+@testset "test S-norms" begin
+    @test MaxOr()(0.4, 0.2) == 0.4
+    @test MaxOr()(1.0, 1.0) == 1.0
+    @test MaxOr()(0.0, 0.0) == 0.0
+
+    @test ProbSumOr()(0.5, 0.5) == 0.75
+    @test ProbSumOr()(1.0, 0.2) == 1.0
+    @test ProbSumOr()(1.0, 0.0) == 1.0
+
+    @test BoundedSumOr()(0.2, 0.3) == 0.5
+    @test BoundedSumOr()(0.6, 0.6) == 1.0
+    @test BoundedSumOr()(0.0, 0.0) == 0.0
+
+    @test DrasticOr()(0.2, 0.0) == 0.2
+    @test DrasticOr()(0.0, 0.2) == 0.2
+    @test DrasticOr()(0.01, 0.01) == 1.0
+
+    @test NilpotentOr()(0.2, 0.3) == 0.3
+    @test NilpotentOr()(0.5, 0.6) == 1.0
+    @test NilpotentOr()(0.7, 0.1) == 0.7
+
+    @test EinsteinOr()(0.0, 0.0) == 0.0
+    @test EinsteinOr()(0.5, 0.5) == 0.8
+    @test EinsteinOr()(1.0, 1.0) == 1.0
+end