vector notation (#17)

* allow to pass vectors as inputs to fis

* support vector notation for variables

* for loops

* update changelog

Author: lucaferranti

docs/src/changelog.md

@@ -5,6 +5,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 ## Unreleased
 
 - ![](https://img.shields.io/badge/new%20feature-green.svg) support for weighted rules.
+- ![](https://img.shields.io/badge/new%20feature-green.svg) allow to specify input and output variables as vectors (e.g. `x[1:10]`) and support for loops to avoid repetitive code.
 
 ## v0.1.1 -- 2023-02-25
 

src/evaluation.jl

@@ -49,6 +49,9 @@ function (fis::MamdaniFuzzySystem)(inputs::T) where {T <: NamedTuple}
 end
 
 (fis::MamdaniFuzzySystem)(; inputs...) = fis(values(inputs))
+@inline function (fis::MamdaniFuzzySystem)(inputs::Union{AbstractVector, Tuple})
+    fis((; zip(collect(keys(fis.inputs)), inputs)...))
+end
 
 function (fis::SugenoFuzzySystem)(inputs::T) where {T <: NamedTuple}
     S = float(eltype(T))
@@ -66,3 +69,6 @@ function (fis::SugenoFuzzySystem)(inputs::T) where {T <: NamedTuple}
 end
 
 (fis::SugenoFuzzySystem)(; inputs...) = fis(values(inputs))
+@inline function (fis::SugenoFuzzySystem)(inputs::Union{AbstractVector, Tuple})
+    fis((; zip(collect(keys(fis.inputs)), inputs)...))
+end

src/parser.jl

@@ -166,6 +166,7 @@ function _fis(ex::Expr, type)
     @capture ex function name_(argsin__)::({argsout__} | argsout__)
         body_
     end
+    argsin, argsout = process_args(argsin), process_args(argsout)
     inputs, outputs, opts, rules = parse_body(body, argsin, argsout, type)
 
     fis = :($type(; name = $(QuoteNode(name)), inputs = $inputs,
@@ -174,6 +175,29 @@ function _fis(ex::Expr, type)
     return fis
 end
 
+process_args(x::Symbol) = [x]
+function process_args(ex::Expr)
+    if @capture(ex, x_[start_:stop_])
+        [Symbol(x, i) for i in start:stop]
+    else
+        throw(ArgumentError("invalid expression $ex"))
+    end
+end
+process_args(v::Vector) = mapreduce(process_args, vcat, v)
+
+"""
+convert a symbol or expression to variable name. A symbol is returned as such.
+An expression in the form `:(x[i])` is converted to a symbol `:xi`.
+"""
+to_var_name(ex::Symbol) = ex
+function to_var_name(ex::Expr)
+    if @capture(ex, x_[i_])
+        return Symbol(x, eval(i))
+    else
+        throw(ArgumentError("Invalid variable name $ex"))
+    end
+end
+
 function parse_variable(var, args)
     mfs = :(dictionary([]))
     ex = :(Variable())
@@ -197,32 +221,46 @@ function parse_body(body, argsin, argsout, type)
     outputs = :(dictionary([]))
     for line in body.args
         line isa LineNumberNode && continue
-        if @capture(line, var_:=begin args__ end)
-            if var in argsin
-                push!(inputs.args[2].args, parse_variable(var, args))
-            elseif var in argsout
-                # TODO: makes this more scalable
-                push!(outputs.args[2].args,
-                      type == :SugenoFuzzySystem ? parse_sugeno_output(var, args, argsin) :
-                      parse_variable(var, args))
-            else
-                throw(ArgumentError("Undefined variable $var"))
-            end
-        elseif @capture(line, var_=value_)
-            var in SETTINGS[type] ||
-                throw(ArgumentError("Invalid keyword $var in line $line"))
-            push!(opts, Expr(:kw, var, value isa Symbol ? :($value()) : value))
-        elseif @capture(line, ant_-->(cons__,) * w_Number)
-            push!(rules.args, parse_rule(ant, cons, w))
-        elseif @capture(line, ant_-->p_ == q_ * w_Number)
-            push!(rules.args, parse_rule(ant, [:($p == $q)], w))
-        elseif @capture(line, ant_-->(cons__,) | cons__)
-            push!(rules.args, parse_rule(ant, cons))
+        parse_line!(inputs, outputs, rules, opts, line, argsin, argsout, type)
+    end
+    return inputs, outputs, opts, rules
+end
+
+function parse_line!(inputs, outputs, rules, opts, line, argsin, argsout, type)
+    if @capture(line, var_:=begin args__ end)
+        var = to_var_name(var)
+        if var in argsin
+            push!(inputs.args[2].args, parse_variable(var, args))
+        elseif var in argsout
+            # TODO: makes this more scalable
+            push!(outputs.args[2].args,
+                  type == :SugenoFuzzySystem ? parse_sugeno_output(var, args, argsin) :
+                  parse_variable(var, args))
         else
-            throw(ArgumentError("Invalid expression $line"))
+            throw(ArgumentError("Undefined variable $var"))
         end
+    elseif @capture(line, for i_ in start_:stop_
+                        sts__
+                    end)
+        for j in start:stop
+            for st in sts
+                ex = MacroTools.postwalk(x -> x == i ? j : x, st)
+                parse_line!(inputs, outputs, rules, opts, ex, argsin, argsout, type)
+            end
+        end
+    elseif @capture(line, var_=value_)
+        var in SETTINGS[type] ||
+            throw(ArgumentError("Invalid keyword $var in line $line"))
+        push!(opts, Expr(:kw, var, value isa Symbol ? :($value()) : value))
+    elseif @capture(line, ant_-->(cons__,) * w_Number)
+        push!(rules.args, parse_rule(ant, cons, w))
+    elseif @capture(line, ant_-->p_ == q_ * w_Number)
+        push!(rules.args, parse_rule(ant, [:($p == $q)], w))
+    elseif @capture(line, ant_-->(cons__,) | cons__)
+        push!(rules.args, parse_rule(ant, cons))
+    else
+        throw(ArgumentError("Invalid expression $line"))
     end
-    return inputs, outputs, opts, rules
 end
 
 #################
@@ -243,9 +281,11 @@ function parse_antecedent(ant)
     elseif @capture(ant, left_||right_)
         return Expr(:call, :FuzzyOr, parse_antecedent(left), parse_antecedent(right))
     elseif @capture(ant, subj_==prop_)
-        return Expr(:call, :FuzzyRelation, QuoteNode(subj), QuoteNode(prop))
+        return Expr(:call, :FuzzyRelation, QuoteNode(to_var_name(subj)),
+                    QuoteNode(to_var_name(prop)))
     elseif @capture(ant, subj_!=prop_)
-        return Expr(:call, :FuzzyNegation, QuoteNode(subj), QuoteNode(prop))
+        return Expr(:call, :FuzzyNegation, QuoteNode(to_var_name(subj)),
+                    QuoteNode(to_var_name(prop)))
     else
         throw(ArgumentError("Invalid premise $ant"))
     end
@@ -254,7 +294,8 @@ end
 function parse_consequents(cons)
     newcons = map(cons) do c
         @capture(c, subj_==prop_) || throw(ArgumentError("Invalid consequence $c"))
-        Expr(:call, :FuzzyRelation, QuoteNode(subj), QuoteNode(prop))
+        Expr(:call, :FuzzyRelation, QuoteNode(to_var_name(subj)),
+             QuoteNode(to_var_name(prop)))
     end
     return Expr(:vect, newcons...)
 end

src/rules.jl

@@ -59,7 +59,7 @@ struct FuzzyRule{T <: AbstractFuzzyProposition} <: AbstractRule
     "consequences of the inference rule."
     consequent::Vector{FuzzyRelation}
 end
-Base.show(io::IO, r::FuzzyRule) = print(io, r.antecedent, " --> ", r.consequent...)
+Base.show(io::IO, r::FuzzyRule) = print(io, r.antecedent, " --> ", join(r.consequent, ", "))
 
 """
 Weighted fuzzy rule. In Mamdani systems, the result of implication is scaled by the weight.
@@ -75,7 +75,7 @@ struct WeightedFuzzyRule{T <: AbstractFuzzyProposition, S <: Real} <: AbstractRu
 end
 
 function Base.show(io::IO, r::WeightedFuzzyRule)
-    print(io, r.antecedent, " --> ", r.consequent..., " (", r.weight, ")")
+    print(io, r.antecedent, " --> ", join(r.consequent, ", "), " (", r.weight, ")")
 end
 
 @inline scale(w, ::FuzzyRule) = w

test/test_evaluation.jl

@@ -60,6 +60,7 @@ using FuzzyLogic, Test
     end
 
     @test fis(service = 2, food = 7)[:tip]≈9.36 atol=1e-2
+    @test fis([2, 7])[:tip]≈9.36 atol=1e-2
 end
 
 @testset "test Sugeno evaluation" begin
@@ -116,4 +117,5 @@ end
         service == excellent || food == delicious --> tip == generous
     end
     @test fis2(service = 7, food = 8)[:tip]≈19.639 atol=1e-3
+    @test fis2((7, 8))[:tip]≈19.639 atol=1e-3
 end

test/test_parser.jl

@@ -122,3 +122,52 @@ end
 
     @test fis.outputs[:tip].mfs == mfs
 end
+
+@testset "parse vector-like notation" begin
+    fis = @mamfis function denoise(x[1:3])::y[1:2]
+        for i in 1:3
+            x[i] := begin
+                domain = -1000:1000
+                POS = TriangularMF(-255.0, 255.0, 765.0)
+                NEG = TriangularMF(-765.0, -255.0, 255.0)
+            end
+        end
+
+        y1 := begin
+            domain = -1000:1000
+            POS = TriangularMF(-255.0, 255.0, 765.0)
+            NEG = TriangularMF(-765.0, -255.0, 255.0)
+        end
+
+        y2 := begin
+            domain = -1000:1000
+            POS = TriangularMF(-255.0, 255.0, 765.0)
+            NEG = TriangularMF(-765.0, -255.0, 255.0)
+        end
+
+        for i in 1:2
+            x[i] == POS && x[i + 1] == NEG --> (y[i] == POS, y[i % 2 + 1] == NEG)
+        end
+    end
+
+    var = Variable(Domain(-1000, 1000),
+                   Dictionary([:POS, :NEG],
+                              [
+                                  TriangularMF(-255.0, 255.0, 765.0),
+                                  TriangularMF(-765.0, -255.0, 255.0),
+                              ]))
+    for x in (:x1, :x2, :x3)
+        @test fis.inputs[x] == var
+    end
+
+    for y in (:y1, :y2)
+        @test fis.outputs[y] == var
+    end
+
+    @test fis.rules == [
+        FuzzyRule(FuzzyAnd(FuzzyRelation(:x1, :POS), FuzzyRelation(:x2, :NEG)),
+                  [FuzzyRelation(:y1, :POS), FuzzyRelation(:y2, :NEG)]),
+        FuzzyRule(FuzzyAnd(FuzzyRelation(:x2, :POS), FuzzyRelation(:x3, :NEG)),
+                  [FuzzyRelation(:y2, :POS), FuzzyRelation(:y1, :NEG)]),
+    ]
+end