ZAPIS DZIAŁAŃ NA LOGICE ROZMYTEJ W JĘZYKU ARLANG
================================================

Działania na logice rozmytej są zapisywane w języku Arlang z wykorzystaniem
następujących procedur i funkcji:

FZ.RESET    - procedura realizująca kasowanie wszystkich zmiennych rozmytych


FZ.DECLARE  - procedura tworząca pojedynczą zmienną rozmytą

    Składnia: FZ.DECLARE (zmienna, zbiór1:wartość1, zbiór2:wartość2, ...)

       gdzie: zmienna - nazwa zmiennej rozmytej
              zbiór1, zbiór2... - nazwy zbiorów rozmytych, do których może
                                  przynależeć deklarowana zmienna
              wartość1, wartość2... - wartości zmiennej rozmytej, dla których
                                      stopień przynależności do zbiorów
                                      zbiór1, zbiór2... osiąga wartość 1
    
    Uwagi:   - Nazwy zmiennych rozmytych muszą się zaczynać od znaku %
             - Małe i duże litery w nazwach zmiennych i zbiorów rozmytych
               są rozróżniane
             - Funkcje przynależności zmiennych rozmytych mają postać liniową
               z pojedynczym maksimum (wierzchołkiem). Dokładniejsze informacje
               na ten temat można znaleźć w materiałach z wykładów)
             - Zbiory rozmyte muszą być podawane w kolejności według rosnących
               wartości zmiennej rozmytej odpowiadających wierzchołkom (czyli
               musi być wartość1 < wartość2 < wartość3 < ...
             - Dla wartości zmiennej rozmytej mniejszych pierwszej (wartość1)
               i ostatniej wartości podanej jako parametr procedury FZ.DECLARE
               zakłada się, że stopień przynależności do odpowiedniego zbioru
               wynosi 1
                       
    Przykład: FZ.DECLARE (%predkosc, minimalna:10, mala:20, srednia:40, duza:70)


FZ.INPUT    - procedura realizująca fuzyfikację pojedynczego sygnału wejściowego

    Składnia: FZ.INPUT (zmienna, wyrażenie)

       gdzie: zmienna - nazwa zmiennej rozmytej określanej w wyniku fuzyfikacji
                        sygnału wejściowego
              wyrażenie - wyrażenie arytmetyczne, którego wynik stanowi wartość
                          fuzyfikowanego sygnału wejściowego
    
    Przykład: FZ.INPUT (%predkosc, vF)


FZ.IF        - procedura umożliwiająca zapis pojedynczej reguły wnioskowania

    Składnia: FZ.IF (warunek) THEN (zmienna:zbiór)

       gdzie: warunek - warunek logiczny (patrz dalej)
              zmienna - nazwa zmiennej rozmytej, której przynależność do zbioru
                        rozmytego określa się na podstawie reguły wnioskowania
              zbiór   - nazwa zbioru rozmytego

    Uwagi:   - Warunek logiczny składa się z elementarnych wyrażeń logicznych
               powiązanych ze sobą operatorami koniunkcji (.AND.) i/lub
               alternatywy (.OR.)
             - Pojedyncze elementarne wyrażenie logiczne ma postać:
                     zmienna:zbiór
               gdzie:
                     zmienna - nazwa zmiennej rozmytej
                     zbiór   - nazwa zbioru rozmytego
             - Wartość elementarnego wyrażenia logicznego jest wartością funkcji
               przynależności danej zmiennej rozmytej do danego zbioru rozmytego
             - Stopień złożoności warunków logicznych jest nieograniczony
             - Operator koniunkcji (.AND.) ma pierwszeństwo przed operatorem
               alternatywy (.OR.). Kolejność wykonywania operacji logicznych
               może być zmieniona dzięki zastosowaniu nawiasów
    
    Przykład: FZ.IF (%predkosc:mala .AND. %polozenie:blisko) THEN (%moment:maly)


FZ.OUTPUT    - funkcja zwracająca wartość pojedynczego sygnału wyjściowego,
               uzyskaną w wyniku defuzyfikacji zmiennej rozmytej

    Składnia: FZ.OUTPUT (zmienna)

       gdzie: zmienna - nazwa zmiennej rozmytej, na podstawie której jest
                        obliczana wartość sygnału wyjsciowego
    
    Przykład: M1 := FZ.OUTPUT (%moment)


Przyklad procedury opisującej prosty sterownik rozmyty:
-------------------------------------------------------
$ Sygnały wyjściowe M1, M2 obliczane są na podstawie sygnałów
$ wejściowych vF, vP, alfa1, alfa2

procedure sterownik_fuzzy
parameters vF,vP,alfa1,alfa2

fz.declare(%vF,male:0,duze:1.2)
fz.declare(%vP,male:0,duze:0.8)
fz.declare(%a1,male:0,duze:90°)
fz.declare(%a2,male:-90°,duze:0)
fz.declare(%moment1,m1:-5.3,m2:-3)
fz.declare(%moment2,m1:-0.5,m2:2.8)

fz.input(%vF:vF)
fz.input(%vP:vP)
fz.input(%a1:alfa1)
fz.input(%a2:alfa2)

fz.if(%vF:male .and. %a1:male) then (%moment1:m1)
fz.if(%vF:duze .and. %a1:duze) then (%moment1:m2)
fz.if(%vP:male .and. %a2:duze .or. %vF:duze .and. %a1:male) then (%moment2:m1)
fz.if(%vP:duze .and. %a1:duze .or. %vF:male .and. %a2:male) then (%moment2:m2)

M1:=fz.output(%moment1)
M2:=fz.output(%moment2)
endproc