clear;

function F = fregler(x,v)
    F = -x-v;
endfunction

function f = rechteSeite(t,y)
    x = y(1,1);
    v = y(2,1);

    F = fregler(x,v);

    f(1,1) =  v;
    f(2,1) = -x + F;
endfunction

t = 0:0.01:10;
y0 = [2,0]';
t0 = 0;
y  = ode(y0,t0,t,rechteSeite);

plot(t,y(1,:)',t,y(2,:)');

Code 0-1: Rahmensystem, in dem der Zustandsregler durch die Implementierung eines Fuzzy-Reglers ersetzt werden soll.

clear;

function nzp = fuzzysetX(x)

endfunction
function nzp = fuzzysetV(v)

endfunction

function F = fregler(x,v)
   // 1. Fuzzifizieren der Eingangsgrößen x und v, heißt: zu jeder Fuzzygröße
   //    jedes der beiden Eingangsfuzzysets wird der Erfülltheitsgrad berechnet.
   nzp_x = fuzzysetX(x);
   nzp_v = fuzzysetX(v);
   // 2. Erfülltheitsgrade jeder Regel berechnen
   erfuelltheit = zeros(9);
   erfuelltheit(1) = min(nzp_x(1),nzp_v(1));
//...
   // 3. Defuzzifizierung der Ausgangsgröße (Kraft F), heißt Schwerpunktberechnung.


endfunction

function f = rechteSeite(t,y)
    x = y(1,1);
    v = y(2,1);

    F = fregler(x,v);

    f(1,1) =  v;
    f(2,1) = -x + F;
endfunction

t = 0:0.01:10;
y0 = [2,0]';
t0 = 0;
y  = ode(y0,t0,t,rechteSeite);

plot(t,y(1,:)',t,y(2,:)');

Code 0-2: Noch unfertige Umsetzung, jedoch mit kompletter Programmstruktur.

clear;

function A=flaecheTrapez(h)
    q = 2.0;
    p = 2.0*(1.0-h);
    A = h*(p+q)/2.0;
end

function nzp = fuzzysetX(x)
   nzp = zeros(3);
   if x<-1 then
      nzp(1)=1.0;
      nzp(2)=0.0;
      nzp(3)=0.0;
   elseif x<0 then
      nzp(1)=-x;
      nzp(2)=1-nzp(1);
      nzp(3)=0.0;
   elseif x<1 then
      nzp(3)=x;
      nzp(2)=1-nzp(3);
      nzp(1)=0;
   else
      nzp(1)=0.0;
      nzp(2)=0.0;
      nzp(3)=1.0;
   end
endfunction

function nzp = fuzzysetV(v)
   nzp = zeros(3);
   if v<-1 then
      nzp(1)=1.0;
      nzp(2)=0.0;
      nzp(3)=0.0;
   elseif v<0 then
      nzp(1)=-v;
      nzp(2)=1-nzp(1);
      nzp(3)=0.0;
   elseif v<1 then
      nzp(1)=0.0;
      nzp(3)=v;
      nzp(2)=1-nzp(3);
   else
      nzp(1)=0.0;
      nzp(2)=0.0;
      nzp(3)=1.0;
   end
endfunction

function erg=mini(x,y)
   if x<y then
      erg=x;
   else
      erg=y;
   end
end

function F = fregler(x,v)
   // 1. Fuzzifizieren der Eingangsgrößen x und v, heißt: zu jeder Fuzzygröße
   //    jedes der beiden Eingangsfuzzysets wird der Erfülltheitsgrad berechnet.
   nzp_x = fuzzysetX(x);
   nzp_v = fuzzysetV(v);
   // 2. Erfülltheitsgrade jeder Regel berechnen
   ef = zeros(9); //erfuelltheit
   ef(1) = mini(nzp_x(1),nzp_v(1)); //Regel 1
   ef(2) = mini(nzp_x(2),nzp_v(1)); //Regel 2
   ef(3) = mini(nzp_x(3),nzp_v(1)); //...
   ef(4) = mini(nzp_x(1),nzp_v(2));
   ef(5) = mini(nzp_x(2),nzp_v(2));
   ef(6) = mini(nzp_x(3),nzp_v(2));
   ef(7) = mini(nzp_x(1),nzp_v(3));
   ef(8) = mini(nzp_x(2),nzp_v(3));
   ef(9) = mini(nzp_x(3),nzp_v(3));


//...
   //F = F/Ages;
   // 3. Defuzzifizierung der Ausgangsgröße (Kraft F), heißt Schwerpunktberechnung.
   F=0.0;
   Ages=0.0;   

   sp=[2,1,0,1,0,-1,0,-1,-2];

   //Regel 1..9:
   for i=1:9
     A=flaecheTrapez(ef(i));
     s=sp(i);   
     Ages=Ages+A;
     F=F+s*A;
   end


   F=F/Ages;
endfunction

function f = rechteSeite(t,y)
    x = y(1,1);
    v = y(2,1);
    F = fregler(x,v);
    f(1,1) =  v;
    f(2,1) = -x + F;
endfunction

t = 0:0.01:10;
y0 = [2,0]';
t0 = 0;
y  = ode(y0,t0,t,rechteSeite);

plot(t,y(1,:)',t,y(2,:)');

Code 0-3: Komplettes System.

r1: WENN xgross UND ygross DANN Fklein
r2: WENN xgross UND yklein DANN Fklein
r3: WENN xklein UND ygross DANN Fgross
r4: WENN xklein UND yklein DANN Fgross

Code 0-4: Fuzzy-Regeln

r1=...
r2=...
r3=...
r4=...

Code 0-5: Erfülltheitsgrad zu jeder Regel.

clear;
mode(0);
clc;

A=3.5;
B=2.5;

function a = SystemA(A)
    if A<=2 then
        a(1)=1;
        a(2)=0;
        a(3)=0;
    end
    if A>2 && A<=3 then
        a(1)=-A+3;
        a(2)=A-2;
        a(3)=0;
    end
    if A>3 && A<=4 then
        a(1)=0;
        a(2)=-A+4;
        a(3)=A-3;
    end
    if A>4 then
        a(1)=0;
        a(2)=0;
        a(3)=1;
    end
endfunction

function b = SystemB(B)
    if B<=2 then
        b(1)=1;
        b(2)=0;
        b(3)=0;
    end
    if B>2 && B<=3 then
        b(1)=-B+3;
        b(2)=B-2;
        b(3)=0;
    end
    if B>3 && B<=4 then
        b(1)=0;
        b(2)=-B+4;
        b(3)=B-3;
    end
    if B>4 then
        b(1)=0;
        b(2)=0;
        b(3)=1;
    end
endfunction

function A=flaecheTrapez(h)
    q = 2.0;
    p = 2.0*(1.0-h);
    A = h*(p+q)/2.0;
end

function C = berechneC (A,B)
    a=SystemA(A);
    b=SystemB(B);
    
    Reg1=min(a(1),b(3));
    Reg2=min(a(2),b(2));
       
    A1=flaecheTrapez(Reg1);
    A2=flaecheTrapez(Reg2);
    
    s1=4;
    s2=5;
    
    C=(s1*A1+s2*A2)/(A1+A2);
    pause;
endfunction

C=berechneC(A,B);

Code 0-6: Studentische Lösung zu Aufgabe 2.

public class Vektor
{
     double x,y;
     
     public double berechneLaenge()
     {
         return Math.sqrt(x*x+y*y);
     }
}


public void setup()
{
    Vektor v1,v2;
    v1 = new Vektor();
    v2 = new Vektor();
    
    v1.x = 3.0;
    v1.y = 4.0;
    
    v2.x = 1.0;
    v2.y = 0.0;
    
    println("Länge v1: "+v1.berechneLaenge());
    println("Länge v2: "+v2.berechneLaenge());
}

public void draw()
{
}

Code 0-7: Konzept der Objektorientierung am Beispiel des mathematischen R2-Vektors

public interface iOptimierer
{
     public abstract void configure(iFehlerfunktion fehlerfunktion, double[] startparameter);
     
     public abstract void iteration();
     
     public abstract double[] getBestParametersatz();
}

Code 0-8: Interface für einen Optimierer

public void setup() 
{
}

public interface iEingangsFuzzySet
{
    /**
         breite ist der Abstand zwischen der am weitesten links liegenden Fuzzy-Größe und
         der am weitesten rechts liegenden.
         Alle Fuzzy-Größen werden äquidistant angeordnet.
    */
    public abstract void setzeStuetzpunkte(double breite); 
    /** Liefert Erfülltheitsgrad einer bestimmten Fuzzy-Größe */
    public abstract double berechneErfuelltheitsgrad(int index, double x);    
}

public interface iAusgangsFuzzySet
{
    /** breite reicht hier bis an die Berührpunkte der äußeren Dreiecke mit der x-Achse */ 
    public abstract void setzeStuetzpunkte(double breite); 
    /**
        int[][] regeln: jede Eingangsgröße der beiden E.-Fuzzysets mit jeder kombiniert beeinflusst 
        eine Fuzzy-Größe des Ausgangsfuzzysets. Letztere ist im Array eingetragen als Index.
        double[][] aktivierungen: aktuell aus der Eingangssituation resultierende Aktivierungen jeder
        Regel korrespondierend mit int[][] regeln.
    */
    public abstract double berechneSchwerpunkt(int[][] regeln, double[][] aktivierungen); 
     
}

public interface iFuzzySystem
{
     public abstract double berechneAusgang(double[] y);
     /** obere neue Breiten für Eingangsfuzzysets, unterste ist die Breite für das Ausgangsfuzzyset */
     public abstract void setzeBreiten(double[] breiten);
}

Code 0-9: Definition der Schnittstellen für ein Fuzzy-System, das in Processing umgesetzt werden soll.

function F = fehlerfunktion(u)
   x = u(1);
   y = u(2);
   F = x^3-4*x+y^3-16*y
endfunction

ustart = [1,1];
uopt   = [2/sqrt(3),4/sqrt(3) ]

Fstart = fehlerfunktion(ustart)
Fopt = fehlerfunktion(uopt)

alfa = 0.01;
schritte = 1000
u=ustart;
Fakt=fehlerfunktion(u)
for i=1:schritte
   r = floor(grand(2, 1, "unf", 0, 2.999999999))-1;
   uneu = u + alfa*(r');
   Fneu = fehlerfunktion(uneu);
   if Fneu<Fakt
      Fakt = Fneu;
      u=uneu;
   end
end

disp("Endergebnis der Optimierung:")
disp(u)
disp("Fehler am Ende:")
disp(fehlerfunktion(u))

Code 0-10: Modifiziertes Gradientenverfahren mit Scilab.

//Alfa steuern
function F = fehlerfunktion(u)
   x = u(1);
   y = u(2);
   F = x^3-4*x+y^3-16*y
endfunction

ustart = [1,1];
uopt   = [2/sqrt(3),4/sqrt(3) ]

Fstart = fehlerfunktion(ustart)
Fopt = fehlerfunktion(uopt)

alfa = 0.1;
alfaunterschwelle=0.003;
schritte = 100
u=ustart;
Fakt=fehlerfunktion(u)
//for i=1:schritte
while alfa>alfaunterschwelle
   r = floor(grand(2, 1, "unf", 0, 2.999999999))-1;
   uneu = u + alfa*(r');
   Fneu = fehlerfunktion(uneu);
   if Fneu<=Fakt //wenn sich nichts ändert, trotzdem wandern!!!
      Fakt = Fneu;
      u=uneu;
      alfa=alfa*1.1;
   else
      alfa=alfa*0.9;
   end
end

disp("Endergebnis der Optimierung:")
disp(u)
disp("Fehler am Ende:")
disp(fehlerfunktion(u))
disp("Alfa am Ende:")
disp(alfa);

Code 0-11: Modifiziertes Gradientenverfahren mit Schrittweitensteuerung.

VoltCm = [ 2.5 20
           2.0 30
           1.5 40
           1.05 60
           0.75 90
           0.5  130
           0.45 150
         ];

// Aufgabe:
// a) Messwerte möglichst gut durch quadratische Funktion annähern
// b) Messwerte möglichst gut durch kubische Funktion annähern
// Verläufe aus a) , b) und den Messwerten übereinander als Plot darstellen

// a) und b) sind mit Scilab mittels kleinster Quadrate-Methode zu lösen.

Code 0-12: Näherung der Meßwerte zu einem Entfernungssensor über Funktionen

import java.util.Random;

Random zufall = new Random(System.currentTimeMillis());

public int[][] erzeugeZufallsmatrix(int zeilen, int spalten)
{
    int[][] arr = new int[zeilen][spalten];
    
    for(int i=0;i<arr.length;i++)
       for(int k=0;k<arr[i].length;k++)
          arr[i][k] = zufall.nextInt(2);
    return arr;      
}

public void showArray(int[][] arr)
{
    println();
    for(int i=0;i<arr.length;i++)
    {
       for(int k=0;k<arr[i].length;k++)
       {
          print(arr[i][k]+" ");
       }   
       println();
    }      
}

public void drawArray(int[][] arr, float x, float y, float w)
{
    float d = w/(float)arr.length;
    noStroke();
    for(int i=0;i<arr.length;i++)
    {
       for(int k=0;k<arr[i].length;k++)
       {
           if(arr[i][k]>0)
              fill(0);
           else
              fill(255);
           rect(x+(float)k*d,y+(float)i*d,w,w);   
       }   
    }      
}

public void setup()
{
    size(600,600);
    frameRate(5);
    
    int[][] x = erzeugeZufallsmatrix(8, 8);
    showArray(x);
}

public void draw()
{
    background(255);
    int[][] x = erzeugeZufallsmatrix(16, 16);
    drawArray(x, 0, 0, width);
}

Code 0-13: Hilfsprogramm.

1. Eingangsfuzzyset:
3 Fuzzygrößen
Breite: 2.0

2. Eingangsfuzzyset:
3 Fuzzygrößen
Breite: 2.0

Ausgangsfuzzyset:
3 Fuzzygrößen
Breite: 4.0

Regelmatrix:
0 1 2 
1 2 0
2 0 1

Code 0-14: Zu erzeugendes Fuzzy-System

in1=1 in2=0 
in1=1 in2=1 
in1=0.5 in2=0.5 
in1=0.75 in2=1.0 

Code 0-15: Stichproben.

    p= 0.5 
    q= 0.0
    r= 4.0
    s= 0.0
    t= 0.5
    u= 5.0
    v= 0.5
    w= 0.5
    x= 4.5

Code 0-16: Musterlösung für die geforderten Werte.

public void setup() 
{
   double[] OFFSETS = {3.0,3.0,4.5};
   double[] breiten = {2.0,2.0,3.0};
   int[] anzahlFuzzyGroessen = {3,3,2};     
   int[][] regeln = {
                        {-1,-1, 0}, //  -1 => fehlende Regel!
                        {-1, 1,-1},
                        {-1,-1,-1}
                    };
   //FuzzySystem(double[] OFFSETS, double[] breiten, int[] anzahlFuzzyGroessen, int[][] regeln)
   FuzzySystem fs = new FuzzySystem(OFFSETS,breiten,anzahlFuzzyGroessen,regeln);
   
   println("p="+fs.berechneAktivierung(new double[] {2.5,4.0}, 0, 2));
   println("q="+fs.berechneAktivierung(new double[] {2.5,4.0}, 1, 1));
   println("r="+fs.berechneAusgang(new double[] {2.5,4.0}));
   
   println("s="+fs.berechneAktivierung(new double[] {3.5,2.5}, 0, 2));
   println("t="+fs.berechneAktivierung(new double[] {3.5,2.5}, 1, 1));
   println("u="+fs.berechneAusgang(new double[] {3.5,2.5}));
   
   println("v="+fs.berechneAktivierung(new double[] {2.5,3.5}, 0, 2));
   println("w="+fs.berechneAktivierung(new double[] {2.5,3.5}, 1, 1));
   println("x="+fs.berechneAusgang(new double[] {2.5,3.5}));
}  

Code 0-17: setup-Methode der Musterlösung.