kramann.info
© Guido Kramann

Login: Passwort:










COACH2
1 Planung
2 Architektur
3 Anzeige
4 EEPROM
5 I2C
..5.1 MasterSendByte
..5.2 MasterSend2Bytes
..5.3 MasterReceiveByte
..5.4 MasterReceive2Bytes
6 UART
7 DFT
8 FFT
9 Planung2
10 Klassen
..10.1 AnzeigeTaster
..10.2 RS232
..10.3 MotorServo
..10.4 Drehgeber
..10.5 Sensor
..10.6 Funk
11 Adaption
..11.1 Programmiertechnik
..11.2 Evoopt
12 Fuzzy
..12.1 Uebungsaufgabe
..12.2 Fuzzygroesse
..12.3 Fuzzyset
..12.4 Lookuptable
13 Skript
..13.1 Funkkorrektur
..13.2 Skriptsprachen
..13.3 Anforderungen
..13.4 Agentensysteme
..13.5 Implementierung
..13.6 Experimente
14 Gesamtkonzept
..14.1 Skripterweiterung
..14.2 Makroverhalten
67 Echtzeitsysteme
..67.1 Einfuehrung
....67.1.1 Echtzeit
....67.1.2 Korrektheit
....67.1.3 Hardware
....67.1.4 Ziele
....67.1.5 Synchronprogramm
..67.2 Threads
....67.2.1 Java
....67.2.2 Synchronisierung
..67.3 COACH
....67.3.1 Kaskadenregler
....67.3.2 Zeitebene1
....67.3.3 Zeitebene2
....67.3.4 Zeitebene3
....67.3.5 Puck
....67.3.6 Puckschwarm
..67.4 RTAIlab
....67.4.1 Slax
....67.4.1 USB_Stick
....67.4.2 Sinus
..67.5 Semaphor
....67.5.1 Laufkatze
....67.5.2 Java
....67.5.3 Semaphor
..67.6 Audio
....67.6.1 wav
....67.6.2 Linux
..67.7 Lookup
....67.7.1 Fuzzy
....67.7.2 PWM
..67.8 NeuronaleNetze
....67.8.1 Neuron
....67.8.2 Backpropagation
....67.8.3 Umsetzung
....67.8.4 Winkelerkennung
..67.9 Internetprogrammierung
....67.9.1 Codegenerierung
....67.9.2 PHP_Programmierung
....67.9.3 PHP_OOP
....67.9.4 Java
....67.9.5 UDP
..67.10 DFT
..67.11 FFT
..67.12 Zustandsmaschine
..67.13 Fuzzy
....67.13.1 Fuzzylogik
....67.13.2 FuzzyRegler
....67.13.3 Uebung9
....67.13.5 Softwareentwicklung
......67.13.5.1 AgileSoftwareentwicklung
......67.13.5.2 FuzzyRegler
......67.13.5.3 Uebung
....67.13.6 Umsetzung
......67.13.6.1 FuzzyRegler
......67.13.6.2 Simulation
......67.13.6.3 Optimierung
......67.13.6.4 Uebung
....67.13.7 Haengependel
......67.13.7.1 Haengependel
......67.13.7.2 Simulation
......67.13.7.3 FuzzyRegler
......67.13.7.4 Optimierer
......67.13.7.5 Genetisch
....67.13.8 Information
....67.13.9 Energie

12.2 Objektorientierte Implementierung einer Fuzzygröße

fuzzy_cpp.zip - Klassen Fuzzygroesse, Eingangsfuzzyset, Ausgangsfuzzyset.
  • Im Hauptkapitel wurden top-down einige Implementierungstechniken beschrieben.
  • Nun folgen bottom-up einige Teilimplementierungen.
  • Zunächst soll eine Fuzzygröße durch eine C++-Klasse repräsentiert werden.
  • Dies geschieht im wesentlichen durch die analythische Repräsentation der Zugehörigkeitsfunktion.
  • Dabei ist zu unterscheiden, ob die Ränder begrenzt sind oder nicht:
Varianten bei einer Fuzzy-Größe

Bild 12.2-1: Varianten bei einer Fuzzy-Größe

  • Eine begrenzte Fuzzygröße ist eindeutig durch Angabe der Stellen p0, p1 und p2 bestimmt (s. Bild oben), mit p0<p1<p2.
  • Sie kann als Alternative noch rechts oder links unbegrenzt sein. In diesen Fällen spielen die Stellen p0, bzw. p2 dann keine Rolle.
  • Für die Berechnung des Zugehörigkeitswertes für eine Eingangsgröße x, müssen die entsprechenden Fallunterscheidungen vorgenommen werden.
  • Dies ist in der entsprechenden Funktion folgender Implementierung bereits umgesetzt worden:
class Fuzzygroesse
{
    public:
        double p[3];
        bool links_unbegrenzt, rechts_unbegrenzt;
        Fuzzygroesse(double p0, double p1, double p2, 
                     bool links_unbegrenzt=false, bool rechts_unbegrenzt=false)
        {
            this->p[0] = p0;
            this->p[1] = p1;
            this->p[2] = p2;
            this->links_unbegrenzt  = links_unbegrenzt;
            this->rechts_unbegrenzt = rechts_unbegrenzt;
            //Sinnvolle Festlegung von p0 und p2 bei teilweise unbegrenzten Funktionen,
            //damit die Fallunterscheidung unten richtig funktioniert:
            if(links_unbegrenzt == true)
                p[0]=p[1]-1.0;
            if(rechts_unbegrenzt == true)
                p[2]=p[1]+1.0;
        }
        double berechneZugehoerigkeitswert(double x)
        {
            //Behandlung der trivialen Fälle:
            if(links_unbegrenzt==true && x<=p[1])
                return 1.0;
            if(rechts_unbegrenzt==true && x>=p[1])
                return 1.0;
            if(x<=p[0])
                return 0.0;
            if(x>=p[2])
                return 0.0;
            if(x<p[1]) //steigende Gerade
                return (x-p[0])/(p[1]-p[0]);
            else       //fallende Gerade
                return (x-p[2])/(p[1]-p[2]);
        }
        double berechneSchwerpunkt(double aktivierung)
        {
            if(aktivierung==0.0)  //Division durch Null vermeiden.
                return 0.0;
            //Schnittpunkte mit y=aktivierung bestimmen:
            double x1 = p[0] + aktivierung*(p[1]-p[0]);
            double x2 = p[2] + aktivierung*(p[1]-p[2]);
            //Flächen von erstem Dreieck, Rechteck und zweitem Dreieck bestimmen:
            double A0 = 0.5*(x1-p[0])*aktivierung;
            double A1 = (x2-x1)*aktivierung;
            double A2 = 0.5*(p[2]-x2)*aktivierung;
            //Schwerpunkte von erstem Dreieck, Rechteck und zweitem Dreieck bestimmen:
            double s0 = p[0]+(2.0/3.0)*(x1-p[0]);
            double s1 = 0.5*(x1+x2);
            double s2 = p[2]-(2.0/3.0)*(p[2]-x2);
            return (s0*A0+s1*A1+s2*A2)/(A0+A1+A2);
        }
        double berechneFlaeche(double aktivierung)
        {
            //Schnittpunkte mit y=aktivierung bestimmen:
            double x1 = p[0] + aktivierung*(p[1]-p[0]);
            double x2 = p[2] + aktivierung*(p[1]-p[2]);
            //Flächen von erstem Dreieck, Rechteck und zweitem Dreieck bestimmen:
            double A0 = 0.5*(x1-p[0])*aktivierung;
            double A1 = (x2-x1)*aktivierung;
            double A2 = 0.5*(p[2]-x2)*aktivierung;
            return A0+A1+A2;
        }
};

Code 12.2-1: Quellcode der Klasse Fuzzygroesse in der Datei Fuzzygroesse.h

Übungsaufgabe a): Schreiben Sie ein Testprogramm "TestFuzzygroesse.cpp" für obige Klasse, das alle Fuzzygrößen der Übung9 erzeugt und die Zugehörigkeitswerte zu den Eingangsgrößen berechnet.
R=7 und T=12.5, =>
Rkalt   = 0.6
Rmittel = 0.4
Rwarm   = 0
Tkalt   = 0.5
Twarm   = 0.5
R=5 und T=7, =>
Rkalt   = 1
Rmittel = 0
Rwarm   = 0
Tkalt   = 0.866667
Twarm   = 0.133333

Code 12.2-2: Ihr Programm sollte obige Ausgabe liefern.