examen

Document Sample
examen Powered By Docstoc
					Inhaltsverzeichnis




  Schriftliche Hausarbeit zur Ersten Staatsprüfung für die
  Lehrämter der Sekundarstufe II und der Sekundarstufe I




Eine www-basierte Lernsoftware für den Bereich
         „Fuzzy-Arithmetik und Fuzzy-Logik“




     Institut für Informatik der Westfälischen Wilhelms-
                     Universität Münster


                       vorgelegt von


                       Peter Wimber


                          - 2000 -




Themensteller: Prof. Dr. W.-M. Lippe
Inhaltsverzeichnis


1.     Einleitung _________________________________________________ 1

     1.1       Möglichkeiten und Gefahren von Lernsoftware im World Wide Web 1

     1.2       Fuzzy-Systeme _____________________________________________ 6

     1.3       Eignung von Lehrmaterial zu Fuzzy-Systemen im WWW _________ 8

2.     Allgemeine Anforderungen an HTML-Dokumente _______________ 10

     2.1       Strukturierung der Seiten durch Frames ______________________ 10

     2.2       Aufbau der einzelnen Frames ________________________________ 11
       2.2.1     Farbliche Gestaltung ____________________________________________ 11
       2.2.2     Gebrauch von Graphiken, Animationen und Programmen _______________ 12
       2.2.3     Textdesign ____________________________________________________ 13

3.     Gestaltung der Seiten zum Thema „Fuzzy-Systeme“ ______________ 15

     3.1       Layout der Seiten __________________________________________ 15

     3.2       Die Navigation ____________________________________________ 17

     3.3       Das Layout der einzelnen Frames_____________________________ 19
       3.3.1     Die Farbwahl __________________________________________________ 20
       3.3.2     Graphiken, Animationen und Programme ____________________________ 21
       3.3.3     Formatierung des Textes _________________________________________ 22

4.     Gedanken zum inhaltlichen Aufbau der WWW-Seiten ____________ 24

     4.1       Die Einleitung _____________________________________________ 25

     4.2       Das Kapitel „Klassische Mengen vs Fuzzy-Mengen“ _____________ 26

     4.3       Das Kapitel „Operationen auf Fuzzy-Mengen“__________________ 29

5.     Erläuterungen zu den Interaktionsmöglichkeiten ________________ 33

     5.1       Applet „menge.java“ _______________________________________ 33
       5.1.1     Quellcode „menge.java“ _________________________________________ 35

     5.2       Applet „fuzzymenge.java“ ___________________________________ 38
       5.2.1     Quellcode „fuzzymenge.java“ _____________________________________ 39

     5.3       Applet „sportarten.java“ ____________________________________ 42
       5.3.1     Quellcode „sportarten.java“ ______________________________________ 43

     5.4       Applet „menschen.java“ ____________________________________ 46
       5.4.1     Quellcode „menschen.java“ ______________________________________ 48

     5.5       Applets „sugeno.java“ und „yager.java“ _______________________ 51
Inhaltsverzeichnis

       5.5.1     Quellcode „sugeno.java“ _________________________________________ 52
       5.5.2     Quellcode „yager.class“ _________________________________________ 54

     5.6       Applet „komplement.java“ __________________________________ 55
       5.6.1     Quellcode „komplement.java“ ____________________________________ 56

     5.7       Applet „operationen.java“___________________________________ 61
       5.7.1     Quellcode „operationen.java“ _____________________________________ 62

     5.8       Die Applets zum Zeichnen von Funktionsgraphen _______________ 72
       5.8.1     Quellcode „voegel.java“ _________________________________________ 72
       5.8.2     Quellcode „badewasser.java“ _____________________________________ 73
       5.8.3     Quellcode „cazwei.java“ _________________________________________ 74
       5.8.4     Quellcode „komplement1.java“ ___________________________________ 75
       5.8.5     Quellcode „komplement2.java“ ___________________________________ 76
       5.8.6     Quellcode „komplement3.java“ ___________________________________ 77

     5.9       Quellcode „bilderkoordsystem.java“ __________________________ 78

6.     Verwendete Hilfsmittel ______________________________________ 81

     6.1       Das HTML-Format ________________________________________ 81

     6.2       Die Programmiersprache Java _______________________________ 82

7.     Testphase _________________________________________________ 84

8.     Ausdruck der erstellten Webseiten _____________________________ 86

9.     Literaturverzeichnis ________________________________________ 87
Einleitung                                                                 1



1. Einleitung

Im Rahmen des Projekts „Neuronale Netze und Fuzzy-Systeme“ im
Fachbereich Informatik der Westfälischen Wilhelms-Universität kam die Idee
auf, eine Lernsoftware zur Bereitstellung für das Internet zu entwickeln.
Nachdem dieser Gedanke in der Disziplin der „Neuronalen Netze“ umgesetzt
wurde, galt es nun, Internetseiten (Pages) zum Thema „Einführung in Fuzzy-
Systeme“ anzufertigen. Insgesamt besteht die Einführung aus den zwei
Abschnitten „Fuzzy-Arithmetik und Fuzzy-Logik“ bzw. „Fuzzy-Control“. Die
Aufstellung des Gesamtkonzepts musste aufgrund der Abhängigkeit dieser
beiden Teilgebiete in Teamarbeit erfolgen. Nur so konnten eine einheitliche
Struktur und stimmige Verbindung zwischen den aufeinander aufbauenden
Teilen erreicht werden. Ein Ausdruck der entstandenen Pages zur Fuzzy-
Arithmetik sowie zur Fuzzy-Logik und die angestellten didaktischen
Überlegungen bilden den Inhalt dieser schriftlichen Ausarbeitung.
In   dieser   Einleitung   werden   zunächst   grundsätzliche   Gedanken       zu
Lernsoftware im Allgemeinen und zur Nutzung im World Wide Web gemacht.
Nach einer kurzen Beschreibung von Fuzzy-Systemen wird das vorher
erwähnte Potential des WWW bezüglich des Themas „Einführung in Fuzzy-
Systeme“ überprüft.


1.1 Möglichkeiten und Gefahren von Lernsoftware im World
      Wide Web

Was vor gut 30 Jahren noch niemand bei der Entwicklung des Internet ahnen
konnte, ist für uns heute absolute Gewissheit: Die Nutzung des World Wide
Web (WWW) wird in Zukunft für Unternehmen wie Privatleute unumgänglich
sein. Für viele Menschen wird dies ein erhebliches Umdenken erfordern und
beinhaltet, infolge der Umgewöhnung von den konventionellen Medien auf die
multimediale Welt der Computer, durchaus auch Probleme. Doch wird die
Nutzung des Computers nicht als Ersatz, sondern als Erweiterung zu den schon
vorher existierenden Medien angesehen, so bieten sich hier weitreichende
Möglichkeiten.
Einleitung                                                                               2

Zunächst einmal bietet der Gebrauch des Computers für sich bereits große
Vorteile in vielen Bereichen des alltäglichen Lebens. Inzwischen weiß fast
jeder      Besitzer     eines       Computers,     die   Vorteile   einer    elektronischen
Textverarbeitung oder die Wartung größerer Datenmengen ohne großen
Verwaltungsaufwand zu schätzen. Mit der Entwicklung des Internet wurden
diese Vorzüge noch einmal perfektioniert. Durch die Nutzung des World Wide
Web        scheinen     Entfernungen       keine     Rolle   mehr    zu     spielen.   Daten
unterschiedlichster Art werden in Sekundenschnelle von einem beliebigen Ort
auf der Erde zu einem anderen übertragen. Insbesondere die Eignung zum
schnellen Informationsaustausch stellt einen hohen Nutzungsgrad des Internet
dar. Aktuelle Neuigkeiten, egal auf welchem Gebiet, können von überall und
jederzeit individuell vom Nutzer des World Wide Web in Erfahrung gebracht
werden. „Die Welt wird zu einem Dorf!“
Die Medienwelt wurde damit um ein sehr mächtiges Werkzeug ergänzt, das im
Vergleich zu den konventionellen Informationsträgern große Vorteile bietet.
Im Unterschied zu Zeitung und Fernsehen können alle Informationen zu jedem
Zeitpunkt auf dem aktuellsten Stand dem Internet-Surfer zugänglich gemacht
werden. Dabei kann der Benutzer dank der ständigen Interaktion mit dem
Computer selbst bestimmen, wann er welche Informationen abfragen möchte.
Gerade die Fähigkeit der Interaktivität kann kein anderes Medium außer dem
Computer bieten. Hier liegt die große Herausforderung für Lernsoftware.
„Interaktivität fördert eine aktive Auseinandersetzung mit multimedialen
Angeboten. Je stärker Lernende sich in Lernanwendungen ‚einbringen‘
können, desto attraktiver wird die Anwendung und motiviert auch zum
Lernen.“1 Auf diese Weise kann somit erstmals Lehrmaterial entwickelt
werden, das auf die Aktionen des Lernenden, der in der Folge auch als
Anwender oder Benutzer bezeichnet wird, reagiert. Dadurch, dass ein
Computerprogramm kein statisches Gebilde wie z.B. ein Buch ist, ergeben sich
viele weitere Vorteile, die ein Buch zu liefern nicht im Stande ist. Die Abfrage
von Stichwörtern geht mittels der Verwendung von Hyperlinks2 nun zügig und
ohne Suchaufwand vonstatten, so dass lästiges Nachschlagen und Blättern den

1
    siehe Aufenanger 1999 (S. 17)
2
    links, dt.: Verbindungen, ein Mausklick auf ein Hyperlink veranlasst einen Sprung zu einer
durch diesen Hyperlink spezifizierten Quelle
Einleitung                                                                             3

Anwender nicht aus der Konzentration bringen können. Der Einsatz von
Multimedia3 erspart darüber hinaus umständliche Medienwechsel und birgt
angesichts der vielfältigen Darstellungsformen weitere Stärken bei der
Präsentation des Materials in sich. Das Erscheinungsbild der zumeist sehr
trockenen      Theorie     kann     durch    bewegte         Bilder   und     Animationen
abwechslungsreicher und lebendiger gestaltet werden. Im Bereich der
Motivation stehen Lernsoftware auf Rechenanlagen dadurch beträchtliche
Mittel zur Verfügung. Programme innerhalb der Lernsoftware fordern den
Benutzer zur Aktivität auf und wecken das Interesse an der Behandlung des
Stoffes. Die Bearbeitung von Aufgaben kann so in einer angenehmen,
aufgelockerten Form erledigt werden. Spielerische Elemente, die in die
Lernsoftware eingeflochten werden, können den Spaß bei der Bearbeitung des
Lernstoffes bewahren. Eine abwechslungsreiche Darstellung sowie die
Möglichkeit zur Interaktion mit der Lernsoftware halten die Aufmerksamkeit
und Konzentration aufrecht.
Aber nicht nur im Gebiet der Motivation können Computerprogramme als
Lernhilfe      ihre   Vorteile     ausspielen.     Es   ergeben       sich    völlig   neue
Darstellungsformen        zur     besseren       Erklärung     einzelner      Sachverhalte.
Dementsprechend können heute beispielsweise dreidimensionale Gebilde ohne
größere Probleme aus sämtlichen Perspektiven auf dem Bildschirm angezeigt
oder sogar bewegt werden. Dabei kann dem Anwender immer die Option
gegeben werden, interaktiv auf diese Gebilde Einfluss zu nehmen, damit er
eine für ihn geeignete Darstellung finden kann. Ferner kann kraft auditiver
Komponenten das Erleben des Stoffes noch verstärkt werden. Dadurch sind
viele umständliche beschreibende Erklärungen überflüssig geworden, da der
Lernende Lerninhalte in einer vom Programmierer erschaffenen Erlebniswelt
selbst erfahren kann. Simulationen lassen den Anwender selber einige
Konstruktionen bilden oder Veränderungen an bestehenden Objekten
vornehmen, um bereits Gelerntes in einem praktischen Beispiel anzuwenden
oder zu überprüfen. Zudem lassen sich auch Aufgaben stellen, die dem
Lernenden ein Feedback auf die gegebene Antwort geben können. Benutzer
von      Lernsoftware     können     nun     autodidaktisch      lernen      und   dennoch

3
    Als Multimedia wird die Zusammenfassung verschiedener Darstellungsformen von Audio,
Video, Grafik, Animation und Text auf einem Medium bezeichnet.
Einleitung                                                                               4

kontinuierlich in Interaktion mit dem lehrenden Programm stehen, daneben
bietet die e-mail4-Technik die Möglichkeit, einen schnellen Kontakt mit
Experten herzustellen. Die Vermittlung der Lerninhalte über den Computer
kann folglich gegenüber den konventionellen Medien völlig neu gestaltet und
perfektioniert werden.
Der Einsatz des Computers vereinfacht zwar die Erstellung von Lehrmaterial
und liefert dazu ein gewaltiges Werkzeug, aber um das gegebene Potential
ausschöpfen zu können, ist ein hohes Maß an Kreativität gefordert. Götz 5 legt
dazu in seinem Artikel „Interaktives Lernen mit dem Computer“ allgemeine
Qualitätsmaßstäbe fest, die er in „sprachliche, optische, inhaltliche, didaktische
und technische“ Kriterien unterteilt, die während der Erstellung der
Lernsoftware „Einführung in Fuzzy-Systeme“ immer wieder Berücksichtigung
gefunden haben.
Wie es Koring6 in seinem Buch „Lernen und Wissenschaft im Internet“
formuliert, liegt der Erfolg informationstechnologischer Lehrmaterialien in der
auditiven, visuellen und animierten Präsentation sowie in der Interaktivität
zwischen dem Lernenden und dem lehrenden Programm. Mittlerweile sind zur
Bedienung derartiger Software auch keine Befehle mehr auswendig zu lernen.
Mit Hilfe graphischer Benutzeroberflächen und einfacher Mausklicks wird die
Benutzung von Computerprogrammen auch für den Laien völlig transparent.
Den Prognosen der Experten zufolge wird bald ein Großteil der
Erdbevölkerung den Zugang zum Internet haben. Darin enthalten ist die
notwendige Software an Browsern7, die benötigt wird, um die Ansicht von
HTML8-Dokumenten zu gewährleisten. Daher bietet sich die Bereitstellung
von Lehrmaterial im World Wide Web an. Das Internet schränkt dabei die
Leistungsfähigkeit von Softwareentwicklungen im Lehrbereich kaum ein und
stellt somit dem „Internetschüler“ eine Vielzahl von Lehrprogrammen orts-

4
    Mit e-mail wird die elektronische Post bezeichnet, die es erlaubt, vornehmlich Texte, aber
auch Daten anderer Art (Graphik, Ton, Video) über das Netz zu verschicken
5
    siehe Götz 1994
6
    siehe Koring 1997
7
    browse, dt.: abgrasen, schmökern, Browser sind Software-Komponenten, die die Ansicht von
HTML-Dokumenten ermöglichen
8
    HTML (HyperText Markup Language): Dateiformat zur Darstellung von Dokumenten im
World Wide Web, siehe auch Kapitel 6.1 „Das HTML-Format“
Einleitung                                                                     5

und zeitunabhängig zur Verfügung. In dieser Form sind sogar internationale
Lerngruppen, die mit einer bestimmten Lernsoftware arbeiten, über regionale
Grenzen hinaus in Zukunft vorstellbar.
Trotz aller Vorteile in Präsentation, seitens Audio, Video, Grafik und
Animation, und der Interaktivität ist der durch eine Lehrperson unmittelbar
angeleitete Unterricht nicht zu ersetzen.
Während ein Lehrer die Lerninhalte und die Organisation des Curriculums klar
vorgibt, hat der Benutzer von Lernprogrammen selbst sein Lernpensum zu
strukturieren. Hierbei ergibt sich, wegen der großen Vielfalt an Lernsoftware
im Internet, ein Selektionsproblem bei der Auswahl der richtigen, für das
Problem geeigneten, Programme. Es besteht die Gefahr, dass Lernsoftware
nach falschen Aspekten, wie z.B. deren Unterhaltungswert, ausgewählt wird.
Der „spielerische, unterhaltungsorientierte Gebrauch des Internet – das
‚Surfen‘ – ist vom Grundmuster her Zerstreuung, vielleicht noch Entspannung
und Rekreation; es hat aber keinesfalls etwas mit Lernen oder systematischer
Problembearbeitung gemeinsam...“.9 Eine pädagogische Strukturierung, die
den Nutzer zur Auswahl der richtigen Lernsoftware in einem bestimmten
Bereich anleitet, ist bis heute im World Wide Web nicht vorhanden. Eine
professionelle Steuerung von Lernprozessen, wie sie von einer Lehrperson
arrangiert wird, ist im autodidaktischen Bereich aber kaum zu realisieren, da
dies eine individuelle Rückfrage an die Schüler erfordert, wodurch der Lehrer
entscheiden kann, auf welchem Wissensstand sich der einzelne Schüler
befindet.
Eine weitere Schwierigkeit ergibt sich durch den Aspekt der Entfremdung.
Bereits heute leben viele Kinder und Jugendliche in einer virtuellen Welt der
Computer. Der Bezug zur Realität fällt vielen jungen Menschen, die stark
durch       den    intensiven     Gebrauch   des   Computers,   insbesondere   von
Computerspielen, beeinflusst sind, schwer. Das Lernen in der Wirklichkeit und
an realen Gegenständen, und das in einer sozialen Umgebung, ist nicht durch
den Einsatz von Computern zu ersetzen.
Nichtsdestotrotz ist der Unterricht am Bildschirm gerade für Gruppierungen,
die gezwungen sind, autodidaktisch zu arbeiten, eine optimale Ergänzung im

9
    siehe Bernhard Koring 1997 (S. 25)
Einleitung                                                                             6

Lehrplan. Dies betrifft insbesondere auch die Zielgruppe der in den folgenden
Kapiteln beschriebenen Lernsoftware.




1.2 Fuzzy-Systeme

Die Entwicklung von Fuzzy-Systemen stellt einen Zweig der Informatik dar,
der es ermöglichen soll, komplexe funktionale Zusammenhänge durch einfache
sprachliche         Formulierungen         zu        ersetzen.      Zur       Beschreibung
naturwissenschaftlicher Systeme werden gewöhnlich mathematische Modelle
zu Grunde gelegt. Dahingehend werden z.B. die meisten physikalischen
Gesetze mittels mathematischer Formeln beschrieben. Dies setzt aber zumeist
eine erhebliche Idealisierung der angenommenen Situation voraus, um ein
mathematisches        Modell     aufstellen     zu    können.      Dank     leistungsfähiger
Rechenanlagen sind heutzutage zwar immer komplexere Systeme zu
bewältigen, doch diese Handhabbarkeit erfordert häufig riesige, schwer zu
verwaltende Datenmengen und die Bedienung derartiger Systeme wird immer
unüberschaubarer.
Ein Modell, das keine idealisierten, exakten Daten erfordert, würde hier eine
erhebliche Vereinfachung bedeuten. Es wurden also Methoden entwickelt, die
in der Lage sind, mit nicht exakten (imperfekten) Informationen in Form von
Impräzision, Vagheit und Unsicherheit10 umgehen zu können. Diese Systeme
liefern dann auf den etwas ungenauen, nicht idealisierten Daten keine absolut
einwandfreien Ergebnisse, sind jedoch vielfach im Stande, geeignete und
brauchbare Modelle zu liefern. In Expertensystemen11 hat sich dieses Verfahren
unter Berücksichtigung der Unvollkommenheit der Modellbildung bereits
bewährt.
Fuzzy-Systeme versuchen, die Komplexität von anderen Systemen dadurch zu
reduzieren,      indem     sie   fragmentarische       und       ungenaue    Informationen
verwenden. Die Bewertung des entstandenen Modells hängt dabei nicht von
der Vollständigkeit und Präzision der verwendeten Informationen ab, sondern
wird anhand von Gütekriterien, die an das Modell gestellt werden,

10
     vgl. Kruse/Gebhardt/Klawonn 1993
11
     Expertensystem: Ein System, das nicht Daten, Texte usw. verarbeitet, sondern Aussagen
kombiniert und daraus Schlüsse ziehen kann.
Einleitung                                                                        7

charakterisiert. Hier kann ein komplexitätsreduziertes System in Bezug auf
manche der Gütekriterien wie „Korrektheit, Vollständigkeit, Adäquatheit,
Effizienz oder Benutzerfreundlichkeit“12 durchaus besser bewertet werden als
ein mit idealisierten Informationen modelliertes System.
Was ist nun mit vagen, impräzisen und unsicheren Informationen gemeint?
Diese Begriffe verkörpern die drei Arten des imperfekten Wissens und spiegeln
immer eine Abweichung von den exakten, idealisierten Informationen wider.
Im täglichen Leben begegnen wir nur allzu häufig vagen Informationen, die
sich in Aussagen wie „Das Auto kommt schnell auf uns zu!“ ausdrücken. In so
einem Moment ist die exakte Bestimmung der Geschwindigkeit gar nicht von
Bedeutung. Die oben erwähnte Aussage soll beispielsweise nur ein
Ausweichmanöver           veranlassen,     wozu    die   „vage“   Beschreibung    der
Geschwindigkeit völlig ausreichend ist. Das Adjektiv „schnell“ ist indes immer
abhängig von der jeweiligen Situation zu interpretieren. Aber selbst unter
eindeutigen Bedingungen wird die Auffassung von Geschwindigkeiten als
„schnell“ oder „nicht schnell“ individuell von Person zu Person differieren, da
es keine klar definierte Grenze für diese beiden Begriffe gibt. Vielmehr erfolgt
im       menschlichen      Denken      eine    feinere   Abstufung   zwischen     den
Geschwindigkeiten.         Mittels    so   genannter     Fuzzy-Mengen   (fuzzy,   dt.:
verschwommen, unscharf) können diese intuitiven Abstufungen ebenso formal
ausgedrückt werden. Der vage Begriff „schnell“ kann daher anhand von Fuzzy-
Mengen (unscharfe Mengen) spezifiziert werden. Die dieser Arbeit zu Grunde
liegende Lernsoftware beschäftigt sich intensiv mit Fuzzy-Mengen.
Unterliegen Informationen einer gewissen Fehlertoleranz, so wird von
Impräzision gesprochen. Die Aussage „Das Auto fährt schnell“ kann in eine
Angabe des Wertes der Geschwindigkeit umgewandelt werden, aber eine
daraus resultierende Aussage wie „Das Auto fährt zwischen 120 und 140
Stundenkilometern“ ist in Bezug auf die exakte Geschwindigkeit recht ungenau
(impräzise). Die sich ergebenen Fehlerintervalle können ebenfalls mit Fuzzy-
Mengen beschrieben werden.
Unsicherheit tritt meist in Verbindung mit stochastischen Prozessen auf. Der
Ausgang eines Würfelexperiments oder Münzwurfs kann nicht vorausgesagt
werden und wird daher mittels stochastischer Modelle charakterisiert.

12
     siehe Kruse/Gebhardt/Klawonn 1993, S. 2
Einleitung                                                                8

Subjektive Einschätzungen unterliegen ebenfalls einer gewissen Unsicherheit.
Das oben angegebene Geschwindigkeitsintervall ist nicht nur impräzise,
sondern auch unsicher, da eine Fehleinschätzung des Beobachters bezüglich
des Geschwindigkeitsintervalls nicht auszuschließen ist.
Es kann auch vorkommen, dass Vagheit, Impräzision und Unsicherheit
gleichzeitig in einem Modell auftreten. Die Bewertung, ob ein Auto „schnell“
an einem Beobachter vorbeifährt, beinhaltet die drei Arten des imperfekten
Wissens. Zunächst wird die Geschwindigkeit nicht genau bestimmt werden
können     (Impräzision)    und   auch   die   Richtigkeit   des   angegebenen
Geschwindigkeitsintervalls unterliegt der subjektiven Einschätzung des
Betrachters (Unsicherheit). Hinzu kommt noch die Vagheit der Definition eines
„schnellen“ Autos.
Ein System, dass alle drei Erscheinungen berücksichtigt, vereinfacht somit eine
Modellierung. Und genau diese Erleichterung liefern gerade die Fuzzy-
Systeme.




1.3 Eignung von Lehrmaterial zu Fuzzy-Systemen im WWW

Da gerade Studenten die Hauptinteressengemeinschaft zum Thema „Fuzzy-
Systeme“ bilden, eignet sich das World Wide Web ausgezeichnet zur
Bereitstellung von Lehrmaterial in diesem Bereich. Es ist davon auszugehen,
dass Studierende im Bereich der Informatik einen Internetzugang und die
entsprechende Software besitzen, um die Vorteile des Mediums Internet nutzen
zu können. In diesem Punkt ist während der Erstellung des Projekts darauf
geachtet worden, dass ausschließlich gängige Standards der benutzten Software
verwendet wurden, wobei diesbezüglich Versionen angewandt worden sind,
die auch auf älteren Systemen lauffähig sind, so dass das Material für nahezu
alle Studenten zugänglich ist. Außerdem dürfte Hochschülern die Art des
autodidaktischen Lernens nicht fremd sein. Damit sind die Voraussetzungen,
die an die Nutzung des World Wide Web zur Bereitstellung von Lehrmaterial
geknüpft sind, bereits erfüllt.
Bislang existiert Lehrmaterial zu Fuzzy-Systemen hauptsächlich nur in Form
von Skripten oder Buchmaterial. Es bietet sich daher geradezu an, die Trümpfe
des Internet auf diesem Gebiet auszuspielen. Die in Kapitel 1.1 beschriebene
Einleitung                                                               9

Leistungsfähigkeit des WWW kann somit in diesem Bereich weitgehend
ausgeschöpft werden.
Da viele Forscher und Gelehrte einen Zugriff auf ihre Ausarbeitungen im
Internet erlauben, liegt hier ein großer Vorteil, seitens Hyperlinks auf diese
Veröffentlichungen einen direkten Bezug zu neusten Forschungsergebnissen
und Expertenwissen herzustellen. Damit ist auch die Gelegenheit gegeben,
einen direkten Kontakt zu den Experten aufzubauen.
Während der Abhandlung der Anwendungen von Fuzzy-Systemen erscheint es
überdies sinnvoll, Simulationen zur Überprüfung des erlangten Wissens und als
anschauliches Beispiel bereitzustellen. Demgemäß können viele Vorzüge des
Computereinsatzes auch zur Einführung von Fuzzy-Systemen ausgenutzt
werden.
Der Nachteil des unangeleiteten und unüberwachten Lernens bleibt dagegen
bestehen. Dieses Defizit könnte allerdings dadurch ausgeglichen werden,
indem die Lernsoftware lediglich als Begleitwerk zu einer Vorlesung gebraucht
wird und der Lernprozess damit unter der Kontrolle eines Dozenten steht. Die
Software kann dagegen (noch) nicht auf den individuellen Wissensstand eines
Lernenden reagieren.
Allgemeine Anforderungen an HTML-Dokumente                                      10



2. Allgemeine Anforderungen an HTML-Dokumente

Da die erstellte Lernsoftware an das HTML-Dateiformat gebunden ist, sollen
zunächst allgemeine Prinzipien, die mit der Benutzung von HTML-
Dokumenten verbunden sind, erläutert und später auf unser spezielles Problem
der Fuzzy-Systeme spezifiziert werden.


2.1 Strukturierung der Seiten durch Frames

Frames (dt.: Rahmen) unterteilen Internet-Dokumente in verschiedene
Teilbereiche (Fenster). Üblicherweise wird mit Frames eine Unterteilung
zwischen Hauptfenster und Navigationsleisten bewirkt. Diese Art der
Aufteilung empfiehlt sich auch bei der Strukturierung von WWW-Seiten zur
Präsentation von Lehrmaterial. Das Hauptfenster sollte eine dominante
Stellung auf dem Bildschirm einnehmen, da sich hier der zu vermittelnde Inhalt
befindet. D.h. unter anderem, dass der Hauptrahmen eine zentrale Lage im
Gesamtbild besitzen und die Größe ausreichend bemessen sein sollte. Die
Navigationsleisten möglichst klein an den Rändern der Pages zu halten, ist ein
übliches Vorgehen, da diese Fenster nur zu Navigationszwecken genutzt
werden und weder eine intensive Betrachtung erfordern noch zur Vermittlung
des Lernstoffes dienen. Somit kann eine größere Darstellung des Hauptfensters
gewährleistet werden. Ein anderer Weg, die für den Hauptrahmen nutzbare
Fläche zu erweitern, ohne dabei die Navigationsmöglichkeiten zu verlieren,
kann mit Frames leicht dadurch erreicht werden, indem Inhaltsverzeichnisse
vom Benutzer wahlweise ein- und ausgeschaltet werden können.
Prinzipiell ist   es   denkbar, viele      Inhaltsverzeichnisse in       Form    von
Navigationsleisten in eine Internet-Seite einzufügen, um eine sehr feine
Untergliederung des Stoffes zu erhalten und den Benutzer somit schnell zu
anderen Kapiteln oder Textpassagen springen zu lassen. Aber nicht nur, weil
dieses Vorgehen die Maße des Hauptfensters einschränken würde, ist von
dieser Möglichkeit abzusehen. Auch die Übersichtlichkeit des Gesamtfensters
würde an einer Vielzahl von überflüssigen Frames verloren gehen. Zudem ist
es nicht besonders empfehlenswert, dem Anwender ein Übermaß an
Sprungmöglichkeiten     anzubieten,   so    dass   der   Stoff   evtl.    in    einer
Allgemeine Anforderungen an HTML-Dokumente                                               11

unsachgemäßen Reihenfolge abgearbeitet wird und der Benutzer den Überblick
verliert. Der Verlust der Orientierung auf Webseiten wird mit dem Begriff
„Lost       in   Hyperspace“        bezeichnet       und     sollte      mit     geeigneten
Navigationselementen          verhindert   werden.      Dem       Artikel      „Lernen    mit
Multimedia im Internet“ von Lüssem/Sünderkamp13 zufolge kann einer
Desorientierung seitens vordefinierter Pfade („Guided Tours“) und einer
Vorstrukturierung der Informationen vorgebeugt werden.
Ein klar strukturierter und auf allen Pages einheitlicher Bildschirmaufbau wirkt
zwar langweilig, ist aber im Sinne der einfachen Orientierung und Gewöhnung
dringend erforderlich. Ein mehrfach wechselnder Aufbau der Frames würde ein
ständiges Umgewöhnen verlangen und den eigentlichen Lernprozess stören.
Jegliche Ablenkung von der Behandlung des Stoffes ist nach Möglichkeit zu
vermeiden.       Dies    bedingt      auch       eine      hohe       Funktionalität      der
Bildschirmaufteilung. Aber auch das optisch ästhetische Design der Frames
spielt eine entscheidende Rolle. Eine ausdruckslos und eintönig gestaltete Seite
würde die motivierenden Fähigkeiten eines HTML-Dokumentes vollkommen
vernachlässigen. Oft steht allerdings die Funktionalität in Widerspruch zur
Ästhetik, so dass in diesem Fall ein annehmbarer Mittelweg gefunden werden
muss.
Insgesamt ist darauf zu achten, übersichtliche, leicht zu bedienende und optisch
angenehme Frames zu erstellen.


2.2 Aufbau der einzelnen Frames

Im vorigen Kapitel wurde beschrieben, wie die Gestaltung und die
Strukturierung der Gesamtseite unter Verwendung von Frames aussehen soll.
Hier wird nun auf die Prinzipien eingegangen, die bei der Erstellung der
einzelnen Frames beachtet werden müssen.

2.2.1     Farbliche Gestaltung
Die farbliche Ausschmückung von Internet-Dokumenten kann sowohl einen
ästhetischen als auch funktionalen Hintergrund haben. Zunächst einmal
gestaltet eine farbliche Aufmachung das Erscheinungsbild von WWW-Seiten
viel freundlicher und lebendiger und erhält leichter die Freude an der

13
     Lüssem/Sünderkamp 1997
Allgemeine Anforderungen an HTML-Dokumente                                 12

Bearbeitung des zu vermittelnden Stoffes. Andererseits kann der Gebrauch von
Farben eine gewisse Funktionalität bewirken. So können Begriffe, die eine
bestimmte Bedeutung haben, durch eine genau festgelegte Einfärbung
kenntlich gemacht werden. Dies sind z.B. Wörter, die ein Stichwort oder einen
Hyperlink repräsentieren. Die farbliche Betonung lässt diese Begriffe im Text
leichter wiederfinden und deutet auf deren hervorgehobene Stellung hin. Bei
Inhaltsverzeichnissen ist das gewöhnlich eine farbliche Hervorhebung des
aktuell angewählten Kapitels. Insgesamt sind dezente, matte Farben
vorzuziehen, da grelle Farben die Aufmerksamkeit zu sehr auf sich ziehen und
damit vom eigentlichen Text ablenken. Wichtig ist auch die Beziehung
zwischen Hintergrund- und Textfarbe. Unter diesem Gesichtspunkt sollte ein
angenehmer Kontrast gewählt werden, der den Text vor dem Hintergrund klar
abhebt und leicht lesbar macht. Mit Hintergründen können auch gewisse
Bereiche kenntlich gemacht werden. Inhaltsverzeichnisse werden gewöhnlich
mit einer anderen Hintergrundfarbe hinterlegt als das Hauptfenster, in dem
wiederum Tabellen, wichtige Textabschnitte usw. mit unterschiedlichen
Eintönungen herausgestellt werden können.
Zu beachten ist, dass die Farben in allen verwendeten Seiten die gleiche
Bedeutung haben und dass die Dokumente nicht mit Farben überfrachtet
werden, wodurch die Übersichtlichkeit und Funktionalität verloren gehen
würde.     Eine   kunterbunte   Lernsoftware    wäre    allenfalls   für    ein
Kinderlernprogramm annehmbar, würde aber in dem behandelten Bereich der
Fuzzy-Systeme seinen wissenschaftlichen Anspruch verlieren.



2.2.2    Gebrauch von Graphiken, Animationen und Programmen
Während das Lesen eines Buches im Allgemeinen als angenehm empfunden
wird und von vielen sogar zur Entspannung dient, gelten am Bildschirm ganz
andere Gesetze. Längere Textabschnitte am Monitor lassen den Lesenden
schnell ermüden und verführen zum Überfliegen des Textes. Diesem Problem
kann mittels einer klaren, optisch angenehmen Gliederung und der
Verwendung von Graphiken und Animationen begegnet werden.
Der Vorteil eines Computers gegenüber einem Buch liegt gerade in der
Fähigkeit, Animationen ablaufen zu lassen und komplexe Graphiken zur
Anschauung heranzuziehen. Der begleitende Text kann dadurch meist kurz und
Allgemeine Anforderungen an HTML-Dokumente                                  13

prägnant gehalten werden. Bevor eine umständliche Erklärung erforderlich
wird, kann oft eine Animation oder Graphik Abhilfe schaffen. Laut dem
Artikel „Interaktives Lernen mit dem Computer“ von Götz sollten die Objekte
dabei entsprechend gekennzeichnet und sinnvoll im Text platziert werden, um
die behandelten Sachverhalte zu veranschaulichen und zu vertiefen. Zusätzlich
können noch kleinere Programme, die zur (Inter)aktivität auffordern, den Stoff
freundlicher gestalten und helfen, das Gelernte zu vertiefen. Auch hier gilt der
Grundsatz, „zu viele Köche verderben den Brei“. Zu zahlreiche Graphiken und
Spielereien lenken wiederum vom Wesentlichen ab. Auch Aufenanger schreibt
in seinem Artikel „Lernen mit neuen Medien“14, dass die positive Wirkung von
Illustrationen nur dann gewährleistet werden kann, wenn sie nicht überladen
und nicht zu komplex sind. Es muss ein ausgewogenes Verhältnis zwischen
Text und den anderen Elementen erreicht werden. Nach Möglichkeit sollten die
Graphiken, Animationen und Programme in ihrer Größe so beschränkt werden,
dass sie stets in vollem Umfang auf dem Monitor angezeigt werden können,
damit der Benutzer zu jeder Zeit einen Überblick über das gesamte Objekt hat.



2.2.3     Textdesign
Die Auswahl der Schriftart wird wieder durch funktionale wie ästhetische
Aspekte bestimmt. In erster Linie sollte die Schrift gut lesbar sein und auf allen
Seiten      eine       einheitliche   Form   besitzen.   Die   Verwendung     von
Standardzeichensätzen bietet sich dadurch an, dass sie ein gewohntes Bild
liefern und auf den meisten Rechner verfügbar sind. Der Nachteil jedoch liegt
in dem recht ausdruckslosen Erscheinungsbild, das aufgrund der häufigen
Verwendung der üblichen Fonts entsteht. Es ist allerdings schwierig,
Schrifttypen zu finden, die auf dem Großteil der Rechner implementiert sind
und überdies auch noch ein gut lesbares, attraktives Textmaterial bieten.
Letztendlich kann auch dem Anwender die Wahl der gewünschten Schriftart
überlassen werden, so dass der Zeichensatz (Font) auf jeden Fall den
persönlichen Vorlieben entspricht und auch auf dem Rechner verfügbar ist.
Für die Vorgabe der Schriftgröße ergibt sich eine ähnliche Problematik. Eine
kleinere Schrift erlaubt zwar einen besseren Überblick über Textpassagen, ist

14
     Aufenanger 1999
Allgemeine Anforderungen an HTML-Dokumente                              14

aber nicht so gut lesbar und kann daher eine zusätzliche Anstrengung bedeuten.
Es empfiehlt sich, in diesem Punkt den Benutzer gleichermaßen nach seinen
subjektiven Neigungen entscheiden zu lassen.
Längere Textpassagen sind zu vermeiden und es soll eine angemessene Menge
an Informationen bereitgestellt werden, die ausreicht, um die behandelte
Theorie dem Benutzer näherzubringen. Eine nicht mehr zu überblickende
Informationsflut wirkt indessen eher irritierend.
Die Inhalte sind in kurze, voneinander getrennte Abschnitte zu halten. Die
Bildung von Spalten lässt dabei längere Absätze ein wenig angenehmer
wirken. Überdies ist darauf zu achten, dass zusammenhängende Abschnitte
komplett auf einem Blick am Bildschirm sichtbar sind, um den lästigen und
ablenkenden Gebrauch der Laufleiste zu verhindern. Auch das Einfügen von
Überschriften und besonders markierte Begriffe, z.B. mit Hilfe von
Unterstreichungen, Kursiv- oder Fettdruck, gestalten das Schriftbild ein wenig
interessanter und können die Aufmerksamkeit des Benutzers steigern.
Gestaltung der Seiten zum Thema „Fuzzy-Systeme“                         15



3. Gestaltung der Seiten zum Thema „Fuzzy-Systeme“

Der Aufbau der einzelnen Pages, die als Lehrmaterial zu Fuzzy-Systemen
dienen sollen, richtet sich nach den bereits erläuterten allgemeinen
Anforderungen an WWW-Seiten. Der Inhalt dieses Kapitels ist die Umsetzung
der Prinzipien an der im Rahmen dieser Arbeit entwickelten Lernsoftware.


3.1 Layout der Seiten

Da es sich bei dem Projekt zur „Einführung in Fuzzy-Systeme“ um eine
Erweiterung der bereits erstellten Lernsoftware zum Bereich „Neuronale
Netze“ handelt, lieferten die im Vorfeld errichteten Pages schon ein Layout,
das auch für die zu planende Lernsoftware einen möglichen Aufbau der
HTML-Dokumente darstellte. Weil die Einheitlichkeit eine große Rolle spielt
und der bestehende Entwurf den oben beschriebenen Anforderungen entsprach,
empfahl es sich, das Konzept auch in der Fortsetzung beizubehalten.




 Abb. 1: Layout der Seiten mit den vier verwendeten Frames

Insgesamt bilden vier Frames das Grundgerüst der erstellten Seiten. Auf der
linken Seite befindet sich das Inhaltsverzeichnis zum Komplex „Einführung in
Fuzzy-Systeme“. Eine weitere Leiste im rechten oberen Teil des Dokuments
bietet eine Untergliederung des aktuell gewählten Kapitels, verweist zudem auf
Gestaltung der Seiten zum Thema „Fuzzy-Systeme“                         16

das vorherige wie nachfolgende Kapitel und beinhaltet einen Knopf (Button)
zur Aktivierung bzw. Deaktivierung des Inhaltsverzeichnisses auf der linken
Seite. Die beiden genannten Fenster dienen zur Navigation und sollen dem
Benutzer einen detaillierten Überblick über das Thema verleihen. Es ist dabei
gelungen, die Inhaltsverzeichnisse stets vollständig sichtbar in den Frames zu
platzieren. Den rechten unteren Teil bildet das Hauptfenster mit den zu
behandelnden Inhalten. Die entstandene linke obere Ecke zeigt einen Verweis
auf die Homepage der Arbeitsgemeinschaft des Projekts.




 Abb. 2: Ansicht der Seiten bei ausgeschaltetem Inhaltsverzeichnis



Um die Größe des Hauptfensters zu optimieren, sind die Höhe und die Breite
der Verzeichnisse möglichst gering gehalten worden. Durch die Umrandung
der Leisten wurde eine klare Abtrennung zwischen den Fenstern zur
Unterscheidung ihrer verschiedenartigen Bedeutungen erreicht. Die Texte in
den Frames sind allesamt in Tabellen gefasst, wodurch noch der Abstand zu
den Rändern erweitert wird, um eine deutliche Abgrenzung der diversen
Frames voneinander zu erwirken.
Gestaltung der Seiten zum Thema „Fuzzy-Systeme“                                        17


3.2 Die Navigation

Die       Navigation      durch    den     Lernstoff     geschieht     einmal   über    die
Navigationsleisten und zum anderen mittels Sprunggelegenheiten innerhalb des
Hauptfensters.        Nach      Koring   gleichen       die   Navigationsleisten    einem
„differenzierten,        zumeist    auch     farblich     und      graphisch    animierten
Inhaltsverzeichnis, dem man mit dem Browser nachgehen kann, bis man die
gewünschten Daten gefunden hat.“15 Die dazu verwendete Hyperlinkvariante
stellt nach Koring die fortgeschrittenste Form dar. Diese Voraussetzungen sind
in den Navigationsleisten, die im Folgenden näher beschrieben werden,
umgesetzt worden.
Die Leiste, die das Inhaltsverzeichnis enthält, ermöglicht das Springen in die
einzelnen Themengebiete des Projekts und liefert eine Übersicht über die
gesamte Materie. Die abzuarbeitende Reihenfolge der Kapitel wird dabei
anhand eingefügter Pfeile angedeutet. Da es sich bei diesem Inhaltsverzeichnis
nur um die Themenübersicht zu Fuzzy-Systemen handelt, besteht zusätzlich die
Option, auf die Startseite des Gesamtprojekts „Neuronale Netze und Fuzzy-
Systeme“ zurückzuspringen. Zudem wird noch ein Stichwortverzeichnis zur
Auswahl angeboten. Damit kann der Benutzer bei der Suche nach einem
Begriff mit einem simplen Mausklick zu einer entsprechenden Textpassage
gelangen und die Bedeutung des gesuchten Stichwortes auf schnellstem Wege
abrufen, ohne vom Lernprozess abgelenkt zu werden.
Mittels der Untergliederung des ausgewählten Kapitels in der oberen Leiste
werden Sprunggelegenheiten zu den einzelnen Abschnitten bereitgestellt und
somit auch eine Übersicht über dieses Kapitel geliefert. Außerdem besteht die
Möglichkeit in das vorige oder auch nachfolgende Kapitel zu springen. Dies
erlaubt       eine    Navigation    durch     den      Lernstoff     ohne   eingeblendetes
Inhaltsverzeichnis, das zusätzlich in dem oberen Frame ein- und ausgeschaltet
werden kann.
Mit der Auswahl eines Kapitels aus dem Inhaltsverzeichnis auf der linken Seite
und der nachfolgenden Bestimmung eines Unterpunktes aus der oberen Leiste
ist der Benutzer befähigt, einfach und schnell zu jedem Abschnitt zu gelangen.



15
     siehe Koring 1997, S. 37
Gestaltung der Seiten zum Thema „Fuzzy-Systeme“                        18

Die Nutzung des Inhaltsverzeichnisses und der Untergliederungsleiste
ermöglicht zwar eine unsachgemäße Reihenfolge der Bearbeitung des
Lernstoffes, bedeutet aber eine erkennbare Strukturierung der Informationen
und ist zur gezielten Auswahl eines bestimmten Themenbereichs unerlässlich.
Demgemäß ist ein schneller Wiedereinstieg nach einer Lernpause oder eine
sinnvolle Wiederholung des Stoffes gewährleistet. Auch der Gebrauch des
Stichwortverzeichnisses kann zu einer Desorientierung, dem „Lost in
Hyperspace“, führen, doch die Praktikabilität einer solchen Hilfe macht das
Angebot eines Stichwortverzeichnisses äußerst zweckmäßig. Darüber hinaus
verführen Navigationsframes weniger dazu, unkontrolliert in den Dokumenten
herumzuspringen, da sie schon aufgrund ihrer Existenz eine klare Struktur
vorgeben und die von Lüssem/Sünderkamp geschilderten vordefinierten Pfade
darstellen.
Anders verhält es sich dabei mit Verweisen innerhalb des Hauptfensters, denn
innerhalb des eigentlichen Lehrmaterials lassen sich auch immer wieder
Verweise auf wichtige Begriffe, Definitionen, Bemerkungen und Sätze finden.
Die Neugierde oder der Wissensdrang verleitet beim Auffinden eines solchen
Links zum Verlassen der aktuellen Seite. Infolge weiterer Verweise kann das
dazu führen, dass der Lernende nicht mehr chronologisch korrekt vorgeht und
es so zum unerwünschten „Lost in Hyperspace“ kommt. Diesem Problem ist
derart begegnet worden, dass nur Rückwärtssprünge zu bereits behandelten
Themen erlaubt werden. In dieser Gestalt haben die Verweise eine ähnliche
Funktion wie ein Stichwortverzeichnis. In Vergessenheit geratene Sachverhalte
können auf diese Weise an den Stellen, an denen sie gebraucht werden,
unverzüglich in Erinnerung gerufen werden. Der Benutzer unterliegt nicht
mehr so sehr der Verführung, dem Link zu folgen, da hier keine neuen
Erkenntnisse geliefert werden können. Die Gefahr, den Stoff in einer nicht
chronologischen und unangemessenen Reihenfolge abzuarbeiten, ist damit
weitestgehend gebannt.
Eine weitere Art von Verweisen verkörpern die Links auf andere Homepages
zu diesem Thema. Zur genaueren Betrachtung eines Sachverhalts bieten
derartige Verweise, an der entsprechenden Stelle platziert, eine schnelle
Verbindung zu den wissenschaftlichen Ausführungen der Fachgrößen. Auf
diesem Weg wird die „Sekundärliteratur“ quasi schon mitgeliefert.
Gestaltung der Seiten zum Thema „Fuzzy-Systeme“                                      19

Ein Sprung zu externen Pages birgt jedoch wiederum die Gefahr des „Lost in
Hyperspace“. Um diesem Problem Rechnung zu tragen, bleibt die Aufteilung
der Frames weiterhin bestehen. Die angewählte Seite wird nur im Hauptfenster
angezeigt und die Inhaltsverzeichnisse sind nach wie vor sichtbar und liefern
die Verbindung zurück zum Lernprogramm. Aktuellste Forschungsergebnisse
und Erkenntnisse auf dem Gebiet der Fuzzy-Systeme können somit auf die
Schnelle abgefragt werden, ohne den Bezug zur eigentlichen Lernsoftware zu
verlieren.
Nach Aktivierung eines Buttons auf den HTML-Seiten wird ebenfalls ein
neues Fenster zur Darstellung umfangreicherer Inhalte geöffnet. Dies geschieht
aus den oben genannten Gründen nur innerhalb des Hauptrahmens und
gleichzeitig wird immer eine Rücksprunggelegenheit zur Verfügung gestellt.
Eine ganz andere Form von Verweisen sind Sprunggelegenheiten zur
Justierung der Fensterinhalte. Per Mausklick können so Applets16, Graphiken
und Textabschnitte am oberen Bildschirmrand ausgerichtet werden. Dieses
Vorgehen dient zwar nicht zur direkten Navigation, verhindert aber in einigen
Fällen die recht umständliche Benutzung der Laufleisten. Auf diese Weise
können alle größeren Objekte, wie sie insbesondere in Form von Applets
auftreten, in eine optimale Stellung am Monitor gebracht werden. So werden
zwar Vorwärtssprünge erlaubt, doch sind diese Sprünge minimal und
unterbrechen nicht die chronologische Abarbeitung des Lehrmaterials. Der
Vorwärtssprung zum nächsten Kapitel am Ende jeder Seite stellt hinsichtlich
dieser Überlegungen selbstverständlich keine Ausnahme dar.
Die verschiedenen Arten der Sprungmöglichkeiten bilden die von Lüssem und
Sünderkamp erwähnten Informationsknoten, die dem Anwender eine, im oben
angeführten Sinne, eingeschränkte Navigationsfreiheit bieten.


3.3 Das Layout der einzelnen Frames

Die Gestaltung der Inhalte des Hauptfensters ist strikt nach den oben
besprochenen Anforderungen erfolgt. Zu diesem Zweck ist auf eine




16
     Mit Applets werden in der Programmiersprache Java erstellte Anwendungen bezeichnet, die
in HTML-Dokumenten aufgerufen werden und auf Internetseiten ablaufen können.
Gestaltung der Seiten zum Thema „Fuzzy-Systeme“                               20

harmonische Komposition von Text, Farben, Graphiken und Animationen
großer Wert gelegt worden.
Die Vorgaben in Farbwahl, Schriftart und Formatierung wurden gegenüber den
Vorgängerseiten nicht geändert. Hier gelten ebenso wie bei der Entwicklung
des Gesamtlayouts Gründe der Einheitlichkeit aller Pages dieser Lernsoftware.
Seitens einer geeigneten Mischung aus Ästhetik und Funktionalität bedeuten
die schon vorher existierenden Layouts eine akzeptable Vorgabe zur
Gestaltung der einzelnen Frames.

3.3.1   Die Farbwahl
In den beiden Navigationsleisten ist der Hintergrund durchgängig in einer
matten türkisen Farbe gehalten, von der sich der blaue Text gut lesbar abhebt.
Ein rot markierter Begriff deutet im Inhaltsverzeichnis auf das aktuell
aufgerufene Kapitel hin. Die Bezeichnungen der Untergliederung ändern ihre
Farbe auf ein sattes Grün, wenn ein jeweiliger Unterpunkt schon einmal
angewählt worden ist. Diese Farbpalette reicht aus, um die verschiedenen
Sinngehalte der einzelnen Begriffe innerhalb der Leisten deutlich zu machen
und liefert stets ein wohlgestaltetes und klares Schriftbild.
Die Farbkollektion des Hauptfensters zeigt sich dagegen vielfältiger. Die
auffällige rote Färbung von Stichwörtern soll auch hier auf deren grundlegende
Bedeutung hindeuten. Um den Text in einer bunten Farbenpracht nicht
unübersichtlich werden zu lassen, sind sie Schlagwörter nur bei ihrem ersten
Vorkommen rot akzentuiert. Angesichts der blauen Färbung von Hyperlinks
wird auch später im Dokument auf die Wichtigkeit einzelner Begriffe
hingewiesen. Verweise mit einer blauen Farbe zu versehen, ist an dieser Stelle
äußerst zweckmäßig, da dies die gängige Art ist, Links zu markieren. Die
Hyperlinks sollten daher sofort als solche erkannt werden.
Als Standardhintergrundfarbe des Hauptfensters ist weiß gewählt worden, so
dass der normale schwarze Text und die eingefärbten Begriffe ohne
Schwierigkeiten lesbar sind. Um eine kunstvollere Umgebung zu kreieren,
würden sich helle Backgroundbilder anbieten, worauf aber wegen der
Einheitlichkeit   und    der   gegebenen     Funktionalität     verzichtet   wurde.
Definitionen, Sätze, Bemerkungen und Formeln werden durch einen türkisen
Hintergrund, der schon in den Inhaltsverzeichnissen Verwendung gefunden
hat, signalisiert. Während nicht selten wichtige Textstellen in einem Buch mit
Gestaltung der Seiten zum Thema „Fuzzy-Systeme“                       21




 Abb. 3: Beispiel der für Text und Hintergrund verwendeten Farben

Textmarker gekennzeichnet werden, kann sich der Benutzer diese Aufgabe bei
der interaktiven Einführung in Fuzzy-Systeme sparen. Eine ebenfalls matte
beige Farbe wurde für die Unterlage von Tabellen gewählt, so dass sich mit
dieser Farbgebung ein stimmiges Bild mit allen Frames ergibt.
Die verwendeten Farben helfen dem Benutzer, sich in dem Dokument zu
orientieren, ohne gleichzeitig aufdringlich zu wirken und vom übrigen Text
abzulenken.



3.3.2   Graphiken, Animationen und Programme
Insbesondere bei der Behandlung einer recht trockenen Theorie, wie der von
Fuzzy-Systemen, ist es wichtig, viele auflockernde und motivierende Elemente
in die Pages einzuflechten. Es hat sich letztlich eine Sammlung von Bildern,
Animationen und Applets ergeben mit denen die verschiedenen Seiten
ausstaffiert worden sind. Nach jedem Theorieteil wird hierbei dem Benutzer
die Gelegenheit gegeben, aktiv zu werden und entspricht somit einem
Vorgehen, wie es Götz in seinen Ausführungen propagiert. Verschiedene
Aufgaben oder Graphiken, auf die interaktiv Einfluss genommen werden kann,
sollen die Aufmerksamkeit und den Spaß an der Bearbeitung aufrechterhalten.
Die Ausmaße der Objekte sind dabei jedesmal so begrenzt worden, dass alle
Gestaltung der Seiten zum Thema „Fuzzy-Systeme“                            22

Gebilde unter den Standardeinstellungen der herkömmlichen Browser komplett
in das Hauptfenster passen. Welche Aufgabe die Graphiken und Applets im
Einzelnen haben und wie sie im Text angeordnet sind, wird im Kapitel
„Gedanken zum inhaltlichen Aufbau der WWW-Seiten“ näher erläutert.




 Abb. 4: Der Gebrauch von Graphiken



3.3.3   Formatierung des Textes
Im Hauptfenster sind zur Grundschriftart keinerlei Vorgaben gemacht worden,
da jeder Benutzer individuelle Vorlieben besitzt und in diesem Punkt nicht
eingeschränkt werden soll. Damit ist gleichzeitig die Verfügbarkeit des
gewählten Zeichensatzes garantiert. Eine zu beachtende Alternative wäre ein
Vorschlag der Schriftart gewesen, die vom Benutzer nach Belieben
nachträglich   verändert    werden    könnte.   Unter   Berücksichtigung    der
verwendeten HTML-Version17 ist diese Variante allerdings nicht realisierbar
gewesen. Im Hinblick auf die Schriftgröße gelten die gleichen Argumente.
Lediglich in den Navigationsframes sind die Schriftart und –größe festgelegt
worden, um sicherzustellen, dass alle Begriffe vollständig in den Fenstern zu
erkennen sind. Wegen der geringen Höhe des oberen Fensters ist die
Schriftgröße der Kapiteluntergliederung um zwei Punkte im Verhältnis zum
übrigen Text zurückgesetzt worden. Damit soll gewährleistet werden, dass
möglichst die gesamte Untergliederung sichtbar ist. Bei Inhaltsverzeichnissen
Gestaltung der Seiten zum Thema „Fuzzy-Systeme“                                      23

steht die bessere Übersicht gegenüber der Lesbarkeit im Vordergrund, da es
sich hier nicht um den eigentlichen Bildungsinhalt, sondern um eine
Orientierungshilfe handelt, der nicht die ständige Aufmerksamkeit gewidmet
wird.
Die Texte sind für eine saubere Gliederung in äußerlich nicht sichtbare
Tabellen gefasst. Dadurch ergibt sich eine deutliche Struktur und die Bildung
von Spalten zu einem angenehmeren Schriftbild wird auf diese Weise erreicht.
Mit der Erstellung einer Tabelle innerhalb einer äußeren Tabelle sind
Einrückungen          zur    Hervorhebung        von     wichtigen    Textpassagen     wie
Definitionen, Sätze, Bemerkungen und Formeln realisiert worden. Wie es
schon bei konventionellen Medien praktiziert wird, werden zusätzlich Fett- und
Kursivdruck         sowie    Unterstreichungen         zur   Strukturierung   und    einem
abwechslungsreicheren Design des Textes eingesetzt. Die gängigen Browser
liefern sogar eine automatische Unterstreichung der Hyperlinks.




17
     siehe auch Kapitel 6 „Verwendete Hilfsmittel“
Gedanken zum inhaltlichen Aufbau der WWW-Seiten                            24




4. Gedanken zum inhaltlichen Aufbau der WWW-
       Seiten

Als Grundlage zu der „www-basierten Lernsoftware für den Bereich Fuzzy-
Arithmetik und Fuzzy-Logik“ diente das Skript „Fuzzy-Systeme“ von Thomas
Feuring18. Ergänzendes Material lieferten das Buch „Fuzzy-Systeme“ von
Kruse, Gebhardt und Klawonn19 sowie das Skript „Einführung in die Fuzzy-
Logik“ von H. Thiele20.
In den folgenden Abschnitten wird beschrieben, wie die allgemeinen
Überlegungen in den einzelnen Kapiteln der Lernsoftware umgesetzt wurden
und inwiefern das vorliegende Skript zu einem interaktiven Lernprogramm
umgeschrieben worden ist. Die essenziellen inhaltlichen Unterschiede zum
Vorlageskript von Feuring liegen insbesondere darin, dass nach kurzen
Theorieabhandlungen stets Graphiken und Interaktionsmöglichkeiten zur
Auflockerung, Anschauung und Vertiefung bereitgestellt wurden.
Um die Erklärungen der einzelnen Kapitel nachvollziehen zu können,
empfiehlt es sich, gleichzeitig einen Blick auf die Lernsoftware im Internet
unter der Adresse
„http://wwwmath.uni-muenster.de/SoftComputing/scag/fuzzyscript/fseinl.html“
zu werfen oder sich den Ausdruck der Seiten im 8. Kapitel „Ausdruck der
erstellten Webseiten“ anzuschauen. Ebenso findet man eine Erklärung der
erwähnten           Applets   in   Kapitel   5   „Erläuterungen       zu    den
Interaktionsmöglichkeiten“.
In dieser Arbeit finden sich nur die Kapitel zum ersten Teil der Teamarbeit in
Form der Ausarbeitungen zum Thema „Fuzzy-Arithmetik und Fuzzy-Logik“.
Weitere Ideen wurden im Bereich „Fuzzy-Control“ in Abhängigkeit des hier
erläuterten ersten Teils umgesetzt. Zum Abschluss der gesamten Lernsoftware
kann schließlich anhand einer, hier nicht vorgestellten, Simulation das Gelernte
in die Praxis umgesetzt und ausgetestet werden. Diese Interaktionsgelegenheit

18
     Feuring 1996
19
     Kruse/Gebhardt/Klawonn 1993
20
     Thiele, 1995
Gedanken zum inhaltlichen Aufbau der WWW-Seiten                          25

liefert einerseits ein praktisches Beispiel zur Anschauung und andererseits die
Möglichkeit, sein Wissen individuell zu überprüfen und schöpft damit die
Leistungsfähigkeit eines rechnergestützten Lehrprogramms aus. Gerade mit
dieser Simulation werden viele Vorzüge von Multimedia ausgenutzt, die in den
ersten Abschnitten nicht so sehr zur Geltung kommen konnten.


4.1 Die Einleitung




 Abb. 5: Der Rahmen zum Kapitel „Einleitung“

In der Einleitung wird ein historischer Rückblick auf die Entwicklung der
Fuzzy-Logik gegeben. Hierbei handelt es sich lediglich um einen einleitenden
Text, in dem vorab schon auf einige grundlegende Begriffe der Fuzzy-Logik
hingedeutet wird und der Verweise zu den Personen bietet, die die Geschichte
der Fuzzy-Logik geprägt haben. Dank der Verweise entsteht demgemäß auf der
Einleitungsseite bereits eine umfangreiche Materialsammlung, auf die jederzeit
nach Belieben zurückgegriffen werden kann.
Der Inhalt wurde vollständig aus dem zu Grunde liegenden Skript von Th.
Feuring übernommen und mit illustrierenden Portraitbildern der zitierten
Philosophen und Wissenschaftler aufgefrischt. Gegenüber dem Skript ist auf
der Anfangsseite, wenn auch im geringen Maße, von einigen Vorteilen des
Internet Gebrauch gemacht worden. Die Seite hat infolge der Bebilderung ein
Gedanken zum inhaltlichen Aufbau der WWW-Seiten                       26

attraktiveres Aussehen erhalten und wegen der bereitgestellten Links ist aus
dieser kurzen Einführung ein kleiner Almanach geworden.




4.2 Das Kapitel „Klassische Mengen vs Fuzzy-Mengen“




  Abb. 6: Der Rahmen zum Kapitel „Klassische Mengen vs Fuzzy-Mengen

Die eigentliche Lernsoftware beginnt genau genommen erst mit dem Kapitel
„Klassische Mengen vs Fuzzy-Mengen“.
Nach Abhandlung des ersten theoretischen Teils kann der Benutzer zum ersten
Mal interaktiv tätig werden. Bevor lange Textpassagen gelesen werden
müssen, soll zunächst die bereits erlernte Theorie mit Hilfe eines
Übungsprogramms konkretisiert und vertieft werden. Das vorliegende Applet
„menge.java“ verfolgt dabei zwei Ziele: Zum einen soll die vorgestellte
„charakteristische Funktion“ (auch Indikatorfunktion) in einem praktischen
Beispiel veranschaulicht werden und zum anderen soll der Benutzer die
Schwierigkeit erkennen, die mit klassischen (scharfen) Mengen behaftet ist.
Auf diese Weise wird ein fließender Übergang zu den Fuzzy-Mengen
eingeleitet.
Zu diesem Zeitpunkt wird schon früher als im Vorlageskript auf Fuzzy-
Mengen eingegangen. Erstens, weil seitens des Programms bereits eine
Gedanken zum inhaltlichen Aufbau der WWW-Seiten                                      27

Motivation zum Gebrauch von unscharfen Mengen gegeben worden ist und
zweitens, weil dem Lernenden, der eventuell schon mit klassischen Mengen
vertraut ist, etwas Neues präsentiert werden soll. Ein weiterer Vorteil liegt in
der parallelen Betrachtung der zueinander analogen charakteristischen
Funktion bei klassischen Mengen und der „Zugehörigkeitsfunktion“ bei Fuzzy-
Mengen. Wegen der einfachen Charakterisierung scharfer Mengen mittels
Indikatorfunktionen wird durch die unmittelbare Nebeneinanderstellung mit
den          Zugehörigkeitsfunktionen             das       Verständnis     für       die
Zugehörigkeitsabbildungen gefördert, die zur Beschreibung von Fuzzy-
Mengen erforderlich sind.
Daher wird in dem anschließenden Abschnitt bereits der Begriff der
Zugehörigkeitsfunktion behandelt und stets der Bezug zur Indikatorfunktion
mittels Hyperlinks aufrechterhalten. Auch hier wird zum Abschluss dieses
Theorieteils ein Übungsprogramm („fuzzymenge.java“) angeboten. In dieser
Übung soll einerseits der Vorteil der unscharfen gegenüber den scharfen
Mengen deutlich und andererseits der Umgang mit der Zugehörigkeitsfunktion
einstudiert werden. Des Weiteren zeigt das Applet einen Weg zur
Visualisierung von Fuzzy-Mengen anhand von Graufärbungen. Aufgrund
dessen wurde auf die im Skript angedeutete graphische Beschreibung von B.
Kosko21 in Form eines Hyperwürfels bewusst verzichtet. Denn schon bei
Grundmengen mit mehr als drei Elementen wird der dreidimensionale Raum
verlassen, so dass eine anschauliche Darstellung kaum noch realisierbar ist. Die
in den Applets verwendete Graufärbung bedeutet dagegen eine einfache und
ausdrucksvolle optische Charakterisierung.
Im Anschluss an die Formalisierung von Fuzzy-Mengen werden in einigen
Beispielen die Indikator- und die Zugehörigkeitsfunktion im direkten Vergleich
gegenübergestellt. Dadurch wird das Erscheinungsbild der Seite wiederum ein
wenig aufgelockert und der Sinn und die Interpretation der beiden
Abbildungsformen werden eidetisch dargelegt.
Nachdem          die   charakteristische      und    die    Zugehörigkeitsfunktion    zur
Beschreibung der unterschiedlichen Mengen erläutert worden sind, werden im
folgenden Abschnitt die Operationen auf klassischen Mengen erörtert. Da zur

21
     siehe auch Feuring 1996, „Sets as Points Ansatz von B. Kosko“
Gedanken zum inhaltlichen Aufbau der WWW-Seiten                                         28

eindeutigen Beschreibung von unscharfen Mengen die Zugehörigkeitsfunktion
unentbehrlich ist, erfolgt          im     weiteren Verlauf dieses           Kapitels    die
Charakterisierung der klassischen Mengen immer in Verbindung mit der
Indikatorfunktion. Dahingehend sind auch Begriffe wie Teilmengigkeit und die
Operationen auf scharfen Mengen anhand der Indikatorfunktion erklärt
worden. Die bekannten Gesetze über den Operationen Komplement,
Durchschnitt        und    Vereinigung       sind    wie    im      Skript     tabellarisch
zusammengefasst, wobei die Tabelle gegenüber dem Feuring-Skript durch die
vorgestellten Beweise ergänzt wurde, so dass auch hier ein Bezug zur
Indikatorfunktion hergestellt wurde. Demgemäß wird der praktische Nutzen
der charakteristischen Funktion in der Einfachheit der Beweise demonstriert
und zudem eine Vorgehensweise vorgestellt, wie sie auch bei Fuzzy-Mengen
eine Anwendung findet. Zur Anschauung und Vertiefung steht wieder ein
Applet („sportarten.java“) zur Verfügung, das zusätzlich für den Lernenden
nach dem Studieren der Beweise eine Verschnaufpause bedeuten kann.
In Analogie zu den klassischen Mengenoperationen werden Komplement,
Durchschnitt und Vereinigung von unscharfen Mengen über die gleichen
Abbildungen in Form von Zugehörigkeitsfunktionen erklärt. Die Operationen
auf Fuzzy-Mengen sind zwar nicht eindeutig, doch diese spezielle Variante
nach L. Zadeh liefert einen konkreten Vergleich zu den klassischen
Mengenoperationen, der durch Rücksprungmöglichkeiten unterstützt wird und
erleichtert den Übergang zu den Fuzzy-Mengen-Operationen. Auch hier ist
eine Tabelle mit den geltenden Gesetzen angelegt worden. Wie es vorher schon
mit den Indikatorfunktionen praktiziert wurde, werden wiederum die Beweise
der Gesetzmäßigkeiten bereitgestellt. Dieses Angebot schult abermals das
Arbeiten mit den Zugehörigkeitsfunktionen und erübrigt das zu vermeidende,
ermüdende Durcharbeiten von langen Textpassagen. Dem Lernenden mag die
Kontradiktion        im    Gesetz    des    Widerspruchs      und     im     Gesetz      des
ausgeschlossenen Dritten zunächst nachteilig erscheinen. Der tatsächliche
Vorteil dieser Widersprüche wird aber sofort mit der Auflösung der Paradoxie
des spanischen Barbiers22 deutlich gemacht. Das anschließende Applet



22
     Ein Widerspruch der klassischen Mengenlehre, den schon die alten Griechen aufgeworfen
hatten
Gedanken zum inhaltlichen Aufbau der WWW-Seiten                                29

„menschen.java“ lässt den Benutzer im Umgang mit den Fuzzy-Mengen-
Operationen tätig werden.
Mit einer Überleitung und dem Verweis auf das folgende Kapitel wird das
Kapitel „Klassische Mengen vs Fuzzy-Mengen“ letztendlich abgeschlossen.




4.3 Das Kapitel „Operationen auf Fuzzy-Mengen“




  Abb. 7: Der Rahmen zum Kapitel „Operationen auf Fuzzy-Mengen“

Wie der Name schon vermuten lässt, werden in diesem Kapitel die Operationen
auf    Fuzzy-Mengen       diskutiert.   Um     bereits    Gelerntes   wieder        zu
vergegenwärtigen, wird mit der Darstellung der Operatoren nach Zadeh der
Bezug zum vorigen Kapitel hergestellt. Im Folgenden werden dann die
speziellen Operatoren auf eine allgemeine Form gebracht.
Das Fuzzy-Komplement bildet dabei den Anfang. Als Erweiterung der
klassischen Mengenoperationen wird die erste Bedingung für das Fuzzy-
Komplement aus den Gesetzmäßigkeiten motiviert, die für die klassische
Komplementabbildung gelten. Im Gegensatz zum Skript wird für die zweite
Bedingung eine andere, anschauliche Motivation geliefert, da sich diese
Prämisse nicht von den Gegebenheiten bei charakteristischen Funktionen
ableiten lässt.
Gedanken zum inhaltlichen Aufbau der WWW-Seiten                                     30

Gebührend der allgemeinen Anforderungen an HTML-Seiten folgen den
theoretischen Betrachtungen wieder illustrative Beispiele mittels graphischer
Darstellungen      von      verschiedenen           Komplementfunktionen,            die
Komplementoperatoren mit den zuvor besprochenen unterschiedlichen
Eigenschaften repräsentieren. Eine erste Gelegenheit zur Interaktivität wird
während der Einführung der Sugeno- und Yager-Klasse durch die Applets
„sugeno.java“     und     „yager.java“     geboten,        die     den   Verlauf     der
Komplementfunktionen                nach            R.              Yager            und
M.    Sugeno     zeigen   und      somit   den      Einfluss      der    Parameterwahl
veranschaulichen. Im anschließenden Applet „komplement.java“ wird wieder
der Bezug zur Zugehörigkeitsfunktion hergestellt, denn es werden die
Auswirkungen des Zadeh-, Sugeno- und Yager-Komplements auf die im
Kapitel    „Klassische       Mengen        vs       Fuzzy-Mengen“            vorgestellte
Zugehörigkeitsfunktion des idealen Badewassers demonstriert. Es wird also
nicht nur der Graph einer Komplementabbildung dargestellt, sondern die
Zugehörigkeitsfunktion des resultierenden Komplements einer speziellen
Fuzzy-Menge. Diese Anschauung liefert eine sehr gute Vorstellung, welche
Formen das Komplement einer Fuzzy-Mengen annehmen kann.
Analog zum Inhalt des Feuring-Skripts wird zum Abschluss des Fuzzy-
Komplements noch der Begriff des Gleichgewichts diskutiert und anhand des
Komplements vom idealen Badewasser konkretisiert. Der darauf folgende Satz
zum Gleichgewicht wird durch eine erläuternde Bemerkung ergänzt, so dass
die Aussage des Satzes anschaulich verständlich wird. Damit kann der
Abschnitt über Fuzzy-Komplemente abgeschlossen und auf die weiteren
Operationen eingegangen werden.
Zunächst wird der Fuzzy-Durchschnitt behandelt. Unter Beachtung der Gesetze
der klassischen Mengenlehre, die sich hier in Form von Hyperlinks zur
Wiederholung anbieten, werden die vier Prämissen der Randbedingung,
Monotonie, Assoziativität und Kommutativität zur Charakterisierung der
Fuzzy-Durchschnittsoperatoren        vorgestellt.     Im         Anschluss     an    die
Formalisierung der Bedingungen im Begriff der t-Norm werden noch zwei
weitere nicht notwendige Zusatzbedingungen, die an Durchschnittsoperatoren
gestellt werden können, in Form von Stetigkeit und Idempotenz betrachtet. Auf
die   zunächst    unverständlich     erscheinende        Nichtberücksichtigung       der
Gedanken zum inhaltlichen Aufbau der WWW-Seiten                          31

Idempotenz in der Definition der t-Norm wird an dieser Stelle explizit
eingegangen. Mit dem parametrisierten Durchschnittsoperator nach R. Yager
wird nun ein spezielles Beispiel zu den t-Normen untersucht. Durch die
Parametrisierung entsteht eine ganze Schar von t-Normen, die insbesondere
den wichtigen Minimumoperator enthält. Damit bietet dieses Beispiel eine
Vorbereitung auf die anschließende Bemerkung, deren Inhalt der min-Operator
und die Klasse aller t-Normen bilden. Ein Hyperlink stellt sogar einen formalen
Beweis der geschilderten Beobachtung zur Verfügung, ohne dabei den
Textfluss zu unterbrechen. Eine Tabelle mit verschiedenen parametrisierten t-
Normen liefert zu guter Letzt Beispiele für weitere Durchschnittsoperatoren.
Gegenüber dem Skript ist die Aufstellung um die t-Norm nach Schweizer und
Sklar, ergänzt worden, die zur Anwendung der vorstehenden Bemerkung
auffordert. Angesichts der Option zur graphischen Darstellung der diversen
Durchschnittsoperatoren     wurde     die   Tabelle    durch     das    Applet
„operationen.java“ um eine Interaktionsmöglichkeit bereichert. Das Applet
soll die Aussage der Bemerkung auch anschaulich darlegen und die diversen
Durchschnittsoperatoren vorstellen.
Da sich Fuzzy-Vereinigung und –Durchschnitt in der Struktur sehr ähnlich
sind, ist der folgende Abschnitt über die Fuzzy-Vereinigung analog zum
vorherigen Abschnitt aufgebaut, so dass sich in diesem Absatz keine
wesentlichen Neuerungen ergeben. Nach Definition der s-Norm (t-Conorm)
zur Beschreibung der Vereinigungsabbildungen folgt ein erläuterndes Beispiel
des Yager-Vereinigungsoperators, bevor sich auch hier der entsprechende Satz
über die s-Norm nach Yager anfügt und die Bemerkung über alle Klassen der
s-Normen behandelt wird. Im Verlauf des Studiums der Fuzzy-Vereinigung
wird mittels Hyperlinks regelmäßig der Vergleich zu den analogen und
ausführlicheren Überlegungen zum Fuzzy-Schnitt hergestellt. Die Bestimmung
der t-Conorm aus der t-Norm bei gegebener Komplementfunktion stellt dann
die erste Neuerung gegenüber dem vorherigen Absatz dar. Anders als bei
Feuring kann in diesem Punkt bereits Gelerntes in die Praxis umgesetzt
werden, indem die Richtigkeit der vorgestellten Formel aus dem im vorigen
Kapitel erörterten DeMorganschen Gesetz abgeleitet wird. Mit Hilfe des
Komplements nach Zadeh, das somit wieder in Erinnerung gerufen werden
kann, wird dem Benutzer dazu ein konkretes Beispiel geboten. Im Anschluss
Gedanken zum inhaltlichen Aufbau der WWW-Seiten                        32

daran werden die t-Conormen zu den im vorigen Abschnitt vorgestellten t-
Normen zur Anschauung bereitgehalten. Nach dem längeren Theorieteil sollen
die anwählbaren Graphen auch wieder für ein wenig Rekreation sorgen.
Gegen Ende des Kapitels wird noch ein wichtiger Satz erwähnt, der die
besondere Stellung des min- und des max-Operators in der Fuzzy-Logik
unterstreichen soll. Im Vergleich zum Vorlageskript wurde dieser Satz etwas
detaillierter ausgeführt, um die Verbindung zu den t- und s-Normen auch unter
Verwendung von Hyperlinks deutlich werden zu lassen. Ergänzend zu dieser
Aussage wurde eine Beobachtung von Bellmann und Giertz hinzugefügt, die
nochmals das Auslassen der Forderung nach Idempotenz begründet. Die
Paradoxie des spanischen Barbiers liefert an dieser Stelle wiederum eine
Reflexion zu den zuvor behandelten speziellen Fuzzy-Operationen nach Zadeh.
Den Abschluss bildet eine Bemerkung aus dem Skript von Thiele, die den
Zusammenhang der klassischen Mengenoperationen als spezielle Fuzzy-
Operationen verdeutlichen soll. Damit schließt sich der Kreis in der
Betrachtung von klassischen und Fuzzy-Mengen.
Erläuterungen zu den Interaktionsmöglichkeiten                        33



5. Erläuterungen zu den Interaktionsmöglichkeiten

Die folgenden Abschnitte erläutern die Intention der verwendeten Applets.
Dabei bedeutet jedes Programm eine Auflockerung des Lehrmaterials und
beinhaltet auch den motivierenden Aspekt, der in Aufenangers Ausführungen
erwähnt wird. Die meisten Applets arbeiten mit Symbolen und bildhaften
Darstellungen, um die Sachverhalte greifbarer zu machen. In diesem Punkt
wird die von Aufenanger geschilderte „hypermediale Struktur“, insbesondere
in der multicodalen Form, angewandt.
Zu jeder Beschreibung eines Applets ist zusätzlich der Java-Quellcode
hinzugefügt, der im Besonderen beim Programm „menge.java“ ausführlich
dokumentiert ist. In den weiteren Applets fällt die Dokumentation nicht mehr
so umfassend aus, da sich viele Beschreibungen wiederholen würden, die
bereits im Code von „menge.java“ enthalten sind.


5.1 Applet „menge.java“

Mit dem Applet „menge.java“ wird dem Anwender eine zunächst einfach
erscheinende Aufgabe gestellt. Er soll lediglich eine Klassifizierung
verschiedener Fahrzeuge in schnelle und langsame Verkehrsmittel treffen.
Dabei entstehen zwei Mengen, die mit „Schnell“ und „Langsam“ bezeichnet
und mittels einer Schwarz- und Weißfärbung symbolisiert werden. Eine
besondere Betrachtung erfährt die Menge der schnellen Fahrzeuge, die
zusätzlich zur Schwarzfärbung durch eine Auflistung ihrer Elemente und
anhand der zugehörigen charakteristischen Funktion dargestellt wird. Damit
werden auch gleichzeitig die verschiedenen Repräsentationsformen von
Mengen vorgestellt.
Die Darstellung der Komponenten aus der Grundmenge, in Form von
Symbolen der verschiedenen Fahrzeuge, wirkt dabei optisch sehr ansprechend
und die Elemente verkörpern Objekte aus dem alltäglichen Leben, so dass die
Behandlung des recht theoretischen Hintergrunds seine abschreckende
Wirkung verliert und somit der Lernende zur Bearbeitung der Aufgabe
animiert wird.
Erläuterungen zu den Interaktionsmöglichkeiten                                   34

Das Programm verfolgt den von Aufenanger geschilderten konstruktivistischen
Ansatz zur Bildung von Wissen. „Letzteres wird aus dieser Sicht nicht einfach
vermittelt, sondern in den Köpfen der Lernenden hergestellt.“23 Der Benutzer
soll bei Bearbeitung der ihm gestellten Aufgabe selbst erkennen, dass es
schwierig ist, eine scharfe Grenze zwischen den schnellen und langsamen
Fahrzeugen         zu    ziehen.     Er   soll   sich   mit   diesem   Problem   aktiv




     Abb. 8: Ansicht des Applets „menge.java“

auseinandersetzen, um den Lösungsansatz der Fuzzy-Mengen logisch
nachvollziehen und verinnerlichen zu können.
Außerdem wird mit der Schwarz-Weiß-Färbung der Mengen eine typische
optische Darstellungsform vorgestellt, wie sie sich später auch in Form von
Graufärbungen bei Fuzzy-Mengen verwirklichen lässt. Eine weitere wichtige
Eigenschaft des Applets ist das Einblenden der zugehörigen charakteristischen
Funktion, die im Verlaufe der Lernsoftware zur Beschreibung klassischer
Mengen kontinuierlich verwendet wird. Der charakteristischen Funktion
kommt eine bedeutende Rolle zu, da zur Beschreibung von Fuzzy-Mengen
derartige Abbildungen absolut notwendig sind. Damit ist die Analogie zu den


23
     siehe Aufenanger 1999 (S. 18)
Erläuterungen zu den Interaktionsmöglichkeiten                             35

unscharfen Mengen hergestellt und ein kongruentes Applet zur Erstellung der
Fuzzy-Menge „Schnell“ kann später im Dokument folgen.

5.1.1   Quellcode „menge.java“
import ksys.*;
import java.awt.*;

// einfache Klasse, die übergebene Bilder hintereinander in ein Oval zeichnet
// und je nach Mausklick, die eine Hälfte schwarz und die andere weiß färbt zur
// Symbolisierung einer klassischen Menge
public class menge extends java.applet.Applet {
       final int anzahl=7; //legt die Anzahl der anzuzeigenden Bilder fest
       final int xgroesse=557; //horizontale Groesse des Ovals
       final int ygroesse=300; //vertikale Groesse des Ovals
       final int xfaktor=80; //Abstand zwischen x-Koordinaten zweier Bilder
       final int laenge=55; //Laenge der Bilder
       final int hoehe=laenge; // Hoehe der Bilder
       final int mitte=(xfaktor-laenge)/2; //Halber Abstand zwischen Bildern
       final int verschiebung=13; //Verschiebung aller Bilder nach rechts
       final int ypos=120; //vertikale Position der Bilder
       final int yhoehe=100; //Hoehe fuer Koordinatenkreuz
       final int ynull=ygroesse+30; //Anfangskoord. fuer Koord.kreuz
       int xpos=xgroesse; //Position fuer Grenze zwischen Schwarz und
                         //Weißfaerbung
       int grenze=anzahl; //Bestimmt wieviele Bilder links von der
                         //Schwarz-Weiß-Grenze liegen
       Image[] img = new Image[anzahl]; //Array fuer die Namen der Bilder
       String[] bild = new String[anzahl]; //Array fuer die Texte unter
                                           //den Bildern
        String[] bezeichner = new String[anzahl]; //Array fuer Bezeichner unter
                                                  //dem Koordinatensystem
       int[] schriftpos = new int[anzahl]; //Positionen fuer Schrift
       int[] wert = new int[2]; //Array fuer Werte der char. Fkt.
       int[] trennlinie = new int[2]; //Array fuer die Positionen der
                                      //Spruenge der char. Fkt

        Font f = new Font("TimesNewRoman",Font.PLAIN,12);
        FontMetrics fm = getFontMetrics(f);

        public void init() {
               int i;
        //Namen der zu ladenden Bilder
               String[] bilder={"dreirad.gif", "trecker.gif", "trabbi.gif",
                              "golf.gif", "porsche.gif", "formel1.gif",
                              "flugzeug.gif"};
        //Text unter den Bildern
               String[] text={"Dreirad", "Trecker",
                              "Trabbi", "Golf",
                              "Porsche", "Formel1",
                              "Flugzeug"};

               String[] text1={"        Dreirad", "        Trecker",
                             "       Trabbi", "     Golf",
                             "        Porsche", "        Formel1",
                             "         Flugzeug"};

               //Der Fkt.wert der char. Fkt. ist bis zum Sprung gleich 0
               wert[0]=0;
               wert[1]=1;

               setBackground(Color.white);

               for (i=0; i<anzahl; i++) {
                      img[i]=getImage(getDocumentBase(), "images/"+bilder[i]);
                      bild[i]=text[i];
                      bezeichner[i]=text1[i];
               }
        }




        public boolean mouseDown(Event evt, int x, int y) {
Erläuterungen zu den Interaktionsmöglichkeiten                             36

       //falls Mausklick innerhalb der horizontalen Ovalgrenzen, wird
       //die Menge neu gezeichnet
              if (x<=xgroesse)
                      neuzeichnen(x);

              return true;
       }




       // Zeichnet die gewaehlte Menge, als schwarz-weiß gefaerbtes Oval
       // mit den Bildern im Oval
       // x ist die horizontale Position des Mausclicks
       void neuzeichnen(int x) {
              int i=anzahl-1;
              boolean weiter=true;

              //Initialisierung fuer Faerbung des ganzen Ovals
              xpos=xgroesse;
              grenze=anzahl;

              do {

              //falls Mausklick links von der Haelfte eines Bildes statt-
              //findet, wird die Position fuer die Schwarz-Weiß-Grenze
              //genau zwischen das betrachtete Bild und dem Vorgaengerbild
              //gesetzt.
              //grenze wird auf die Anzahl der Vorgaengerbilder gesetzt.
                     if (x<i*xfaktor+verschiebung+laenge/2) {
                             xpos=(i-1)*xfaktor+laenge+mitte+verschiebung;
                             grenze=i;
                     }
                     else {
              //sonst kann die Berechnung der Grenze abgebrochen werden
                             weiter=false;
                     }

                     i--;
              }
              while (weiter);

              //falls Mausklick hinter der Haelfte es 1. Bildes liegt,
              //muss das ganze Oval eingefaerbt werden
              if (grenze==0) {
                     xpos=0;
              }

              repaint();
       }



       public void paint(Graphics g) {
              final int nachunten=14;
              int i;
              bilderkoordsystem b = new bilderkoordsystem(g);

              //Hier entsteht das Oval, das bis zur berechneten x-Koordinate
              //schwarz eingefaerbt ist.
              g.setColor(Color.black);
              g.fillOval(0,0,xgroesse,ygroesse);
              g.setColor(Color.white);
              g.fillRect(0,0,xpos,ygroesse);
              g.setColor(Color.black);
              g.drawOval(0,0,xgroesse,ygroesse);

              //Es werden die Bilder gezeichnet
              for (i=0; i<anzahl; i++) {
                     g.drawImage(img[i], i*xfaktor+verschiebung, ypos,
                             laenge, hoehe, this);

              //Wenn man in den Bereich der Schwarzfaerbung kommt, muss die
              //Schriftfarbe auf Weiß gesetzt werden.
                     if (i==grenze) {
                             g.setColor(Color.white);
                     }
Erläuterungen zu den Interaktionsmöglichkeiten                              37

              //Beschriftung der gezeichneten Bilder
                     g.drawString(bild[i], i*xfaktor+verschiebung,
                             ypos+hoehe+10);
              }

              //In die Weißfaerbung wird der Mengenbezeichner geschrieben
              if (grenze>0) {
                     g.setColor(Color.black);
                     g.drawString("langsam",xpos/2-13,ygroesse*2/3);
              }

              g.setColor(Color.white);
              //In die Schwarzfaerbung wird der andere Bezeichner geschrieben
              if (grenze<anzahl) {
                     g.drawString("schnell",
                                 (xgroesse+xpos)/2-25,ygroesse*2/3);
              }

              //Beschreibung der Menge "schnell"
              g.setColor(Color.black);
              g.drawString("Die Menge A der schnellen Fahrzeuge: A = ",
                           verschiebung, ygroesse+nachunten);
              g.setColor(Color.red);
              g.drawString("{",verschiebung,ygroesse+2*nachunten);


              //In Abhaengigkeit der ausgewaehlten Elemente, werden die
              //Positionen berechnet, an denen die Bezeichner in die Menge
              //geschrieben werden.
              if (grenze<anzahl) {
                     schriftpos[grenze]=verschiebung+5;

                       for (i=grenze+1; i<anzahl; i++) {
                              schriftpos[i]=schriftpos[i-1]
                                            +fm.stringWidth(bild[i-1])+7;
                       }

                       //Schreiben der Elemente der Menge "schnell"
                       if (grenze<anzahl)
                              i=grenze;

                       while (i<anzahl-1) {
                              g.drawString(bild[i]+",", schriftpos[i],
                                           ygroesse+2*nachunten);
                              i++;
                       }

                       if (i>=anzahl-1) {
                              g.drawString(bild[i], schriftpos[i],
                                          ygroesse+2*nachunten);
                       }

                       g.drawString("}", schriftpos[i]
                                      +fm.stringWidth(bild[i])+5,
                                        ygroesse+2*nachunten);
              }

              else {
                     g.drawString("}", verschiebung+10,
                                      ygroesse+2*nachunten);
              } //end if

              // zugehoerige charakteristische Funktion wird angezeigt
              // zunaechst wird das Koordinatensystem gezeichnet
              b.koordSystemZeichnen(g,verschiebung,ynull,xgroesse,yhoehe,
                                   xfaktor,anzahl,bezeichner);
              g.drawImage(getImage(getDocumentBase(),
                                  "formeln/chischnell.gif"),
                         (anzahl-1)*xfaktor,ynull-10,this);
              //Anfang der Funktion und Sprung der Funktionswerte wird in
              //trennlinie gespeichert
              trennlinie[0]=verschiebung;
              if (xpos==0) {
                trennlinie[1]=verschiebung;
              }
              else {
              trennlinie[1]=xpos;
              }
Erläuterungen zu den Interaktionsmöglichkeiten                            38


                  g.setColor(Color.red);
                  b.charFkt(g, trennlinie, 1, ynull+b.tiefer, xgroesse,
                           yhoehe-b.tiefer,wert);
          }
}




5.2 Applet „fuzzymenge.java“

Das Programm „fuzzymenge.java“ liefert die Fortsetzung des Applets
„menge.java“ von klassischen auf unscharfe Mengen. Es ist noch einmal die
gleiche Aufgabe wie zuvor gestellt worden, allerdings mit der Modifikation,
dass die Fahrzeuge dieses Mal einer Fuzzy-Menge zugeordnet werden sollen.
Nun muss zu jedem Fahrzeug der Zugehörigkeitsgrad angegeben werden, der
beschreibt, in welchem Maß das Fahrzeug ein schnelles Verkehrsmittel ist. Die
Zuordnung erfolgt über Schiebeleisten (Scrollbars), um eine falsche Eingabe
bzgl. des Wertebereichs und den hinderlichen Wechsel zwischen Maus und
Tastatur zu vermeiden. Überdies kann eine Scrollbar den Zugehörigkeitsgrad
sehr gut wiedergeben, da in der relativen Stellung des Schiebers schon der
Grad der Abbildung erkennbar ist. Nach Aktivierung des OK-Knopfes wird die
erstellte Menge in einer analogen Form dargestellt, wie es bei den klassischen
Mengen im Applet „menge.java“ erfolgt ist.




    Abb. 9: Ansicht des Applets „fuzzymenge.java“
Erläuterungen zu den Interaktionsmöglichkeiten                           39

Hiermit wird die Absicht verfolgt, den Benutzer erkennen zu lassen, dass es
sich bei Fuzzy-Mengen um eine Erweiterung und Präzisierung der klassischen
Mengen handelt. Der gewünschte Verlust der scharfen Grenzen soll seitens der
leichteren Einteilung der Fahrzeuge in die Fuzzy-Menge „Schnell“ als Vorteil
empfunden werden. Die Graufärbung und die feineren Abstufungen in der
Zugehörigkeitsfunktion spiegeln die Präzisierung wider. Die Abbildung der
Funktionswerte direkt unter dem Mengenbild verdeutlicht das Verhältnis
zwischen der Visualisierung durch Graustufen und der Beschreibung mittels
Zugehörigkeitsfunktionen. Damit soll betont werden, dass zur genauen
Beschreibung die Zugehörigkeitsfunktionen unerlässlich sind, es aber auf der
anderen Seite eine ähnliche Darstellungsform von Fuzzy-Mengen gibt, wie sie
bei klassischen Mengen längst bekannt ist.

5.2.1    Quellcode „fuzzymenge.java“
import   java.awt.event.*;
import   java.awt.*;
import   java.lang.*;
import   ksys.*;

//Mit diesem Applet kann man eine Fuzzy-Menge erstellen, die graphisch
//dargestellt wird und deren Zugehoerigkeitsfunktion angezeigt wird
public class fuzzymenge extends java.applet.Applet
  implements AdjustmentListener, ActionListener
{

  //Anzahl der Elemente der Menge
  final int anzahl=7;
  //Konstanten fuer Maße des Applets
  final int rechteckhoehe=100;
  final int bildlaenge=55;
  final int bildhoehe=bildlaenge;
  final int abstand=75;
  final int xnull=13;
  final int hoehe=100;
  final int breite=550;
  final int y1=100;
  final int ynull=y1+30+rechteckhoehe;

  double[] fktwert = new double[anzahl];

  //Knoepfe, Schieber und deren Beschriftung
  Button OK = new Button("OK");
  Scrollbar wert1 = new Scrollbar(Scrollbar.HORIZONTAL,0,0,0,101);
  Scrollbar wert2 = new Scrollbar(Scrollbar.HORIZONTAL,0,0,0,101);
  Scrollbar wert3 = new Scrollbar(Scrollbar.HORIZONTAL,0,0,0,101);
  Scrollbar wert4 = new Scrollbar(Scrollbar.HORIZONTAL,0,0,0,101);
  Scrollbar wert5 = new Scrollbar(Scrollbar.HORIZONTAL,0,0,0,101);
  Scrollbar wert6 = new Scrollbar(Scrollbar.HORIZONTAL,0,0,0,101);
  Scrollbar wert7 = new Scrollbar(Scrollbar.HORIZONTAL,0,0,0,101);
  Label beschriftung1 = new Label("Dreirad",Label.CENTER);
  Label beschriftung2 = new Label("Trecker",Label.CENTER);
  Label beschriftung3 = new Label("Trabant",Label.CENTER);
  Label beschriftung4 = new Label("VW Golf",Label.CENTER);
  Label beschriftung5 = new Label("Porsche",Label.CENTER);
  Label beschriftung6 = new Label("Formel 1",Label.CENTER);
  Label beschriftung7 = new Label("Flugzeug",Label.CENTER);
  Label lb1 = new Label("0%",Label.CENTER);
  Label lb2 = new Label("0%",Label.CENTER);
  Label lb3 = new Label("0%",Label.CENTER);
  Label lb4 = new Label("0%",Label.CENTER);
  Label lb5 = new Label("0%",Label.CENTER);
Erläuterungen zu den Interaktionsmöglichkeiten                              40

 Label   lb6 = new Label("0%",Label.CENTER);
 Label   lb7 = new Label("0%",Label.CENTER);
 Label   fahrzeug = new Label("Typ:");
 Label   prozent = new Label("Schnell?");

 String[] bezeichner = new String[anzahl];
 String[] koordbezeichner = new String[anzahl];
 Image[] bild = new Image[anzahl];

 Font f = new Font("TimesNewRoman",Font.PLAIN,12);
 FontMetrics fm = getFontMetrics(f);




 public void init() {
   int i;

   //Bezeichner
   String[] text={"Dreirad", "Trecker", "Trabbi", "Golf",
                 "Porsche", "Formel1", "Flugzeug"};
   String[] text1={"        Dreirad", "        Trecker", "       Trabbi",
                 "     Golf", "        Porsche", "        Formel1",
                 "         Flugzeug"};

   //Namen der zu ladenden Bilder
   String[] bilder={"dreirad.gif", "trecker.gif", "trabbi.gif",
                   "golf.gif", "porsche.gif", "formel1.gif",
                   "flugzeug.gif"};

   //Es werden Panels fuer die Knoepfe und Schieber eingefuegt
   setLayout(new FlowLayout(FlowLayout.LEFT));
   Panel alle = new Panel();
   alle.setLayout(new FlowLayout(FlowLayout.LEFT));
   Panel teil8 = new Panel();
   teil8.setLayout(new GridLayout(3,1));
   OK.setBackground(Color.lightGray);
   OK.setForeground(Color.black);
   teil8.add(OK);
   teil8.add(fahrzeug);
   teil8.add(prozent);
   alle.add(teil8);
   Panel teil1 = new Panel();
   teil1.setLayout(new GridLayout(3,1));
   teil1.add(wert1);
   teil1.add(beschriftung1);
   teil1.add(lb1);
   alle.add(teil1);
   Panel teil2 = new Panel();
   teil2.setLayout(new GridLayout(3,1));
   teil2.add(wert2);
   teil2.add(beschriftung2);
   teil2.add(lb2);
   alle.add(teil2);
   Panel teil3 = new Panel();
   teil3.setLayout(new GridLayout(3,1));
   teil3.add(wert3);
   teil3.add(beschriftung3);
   teil3.add(lb3);
   alle.add(teil3);
   Panel teil4 = new Panel();
   teil4.setLayout(new GridLayout(3,1));
   teil4.add(wert4);
   teil4.add(beschriftung4);
   teil4.add(lb4);
   alle.add(teil4);
   Panel teil5 = new Panel();
   teil5.setLayout(new GridLayout(3,1));
   teil5.add(wert5);
   teil5.add(beschriftung5);
   teil5.add(lb5);
   alle.add(teil5);
   Panel teil6 = new Panel();
   teil6.setLayout(new GridLayout(3,1));
   teil6.add(wert6);
   teil6.add(beschriftung6);
   teil6.add(lb6);
   alle.add(teil6);
Erläuterungen zu den Interaktionsmöglichkeiten                             41

     Panel teil7 = new Panel();
     teil7.setLayout(new GridLayout(3,1));
     teil7.add(wert7);
     teil7.add(beschriftung7);
     teil7.add(lb7);
     alle.add(teil7);
     add(alle);

     setBackground(Color.white);

     OK.addActionListener(this);
     wert1.addAdjustmentListener(this);
     wert2.addAdjustmentListener(this);
     wert3.addAdjustmentListener(this);
     wert4.addAdjustmentListener(this);
     wert5.addAdjustmentListener(this);
     wert6.addAdjustmentListener(this);
     wert7.addAdjustmentListener(this);

     //Initialisieren der Bezeichner und Bilder der Menge
     for (i=0;i<anzahl;i++) {
       bezeichner[i]=text[i];
       koordbezeichner[i]=text1[i];
       bild[i]=getImage(getDocumentBase(),"images/"+bilder[i]);
     }

 }




 public void adjustmentValueChanged(AdjustmentEvent e) {
   //Wird ein Schieber betaetigt, muss der entsprechende Wert gesetzt werden
   //und der Wert im Textfeld wird angepasst
   if (e.getAdjustable()==wert1) {
     fktwert[0]=(int)wert1.getValue();
     lb1.setText(String.valueOf(fktwert[0])+"%");
     }
   if (e.getAdjustable()==wert2) {
     fktwert[1]=(int)wert2.getValue();
     lb2.setText(String.valueOf(fktwert[1]+"%"));
     }
   if (e.getAdjustable()==wert3) {
     fktwert[2]=(int)wert3.getValue();
     lb3.setText(String.valueOf(fktwert[2]+"%"));
     }
   if (e.getAdjustable()==wert4) {
     fktwert[3]=(int)wert4.getValue();
     lb4.setText(String.valueOf(fktwert[3]+"%"));
     }
   if (e.getAdjustable()==wert5) {
     fktwert[4]=(int)wert5.getValue();
     lb5.setText(String.valueOf(fktwert[4]+"%"));
     }
   if (e.getAdjustable()==wert6) {
     fktwert[5]=(int)wert6.getValue();
     lb6.setText(String.valueOf(fktwert[5]+"%"));
     }
   if (e.getAdjustable()==wert7) {
     fktwert[6]=(int)wert7.getValue();
     lb7.setText(String.valueOf(fktwert[6]+"%"));
     }
 }



 public void actionPerformed(ActionEvent e) {
   int i;
   //Wird der Knopf gedrueckt muss die neue Darstellung angezeigt werden
   if (e.getSource()==OK) {
     repaint();
   }

 }



 public void paint(Graphics g) {
Erläuterungen zu den Interaktionsmöglichkeiten                                 42

        int i;
        int farbe,fktwert1,fktwert2;

        bilderkoordsystem b = new bilderkoordsystem(g);

        for (i=0;i<anzahl;i++) {
          //Mit Hilfe der gesetzten Werte wird die Intensitaet der Graustufe
          //eingestellt
          farbe=(int)((100-fktwert[i])*2.55);
          g.setColor(new Color(farbe,farbe,farbe));
          //Die Graustufen werden gezeichnet
          g.fillRect(xnull+i*abstand,y1,abstand,rechteckhoehe);
          g.drawImage(bild[i],i*abstand+xnull+(abstand-bildlaenge)/2,
                     y1+rechteckhoehe/2-bildhoehe/2,
                     bildlaenge,bildhoehe,this);
        }

      //Auflistung der Mengenelemente
      g.setColor(Color.black);
    g.drawString("Darstellung der Fuzzy-Menge und deren Zugehörigkeitsfunktion:",
                  xnull,y1-7);
      g.drawRect(xnull,y1,anzahl*abstand,rechteckhoehe);
      g.drawString("Fuzzy-Menge 'Schnell'=",xnull,y1+rechteckhoehe+15);
      g.setColor(Color.red);
      g.drawString("{",xnull+150,y1+rechteckhoehe+15);
      for(i=0;i<4;i++) {
        g.drawString("("+bezeichner[i]+", "+(double)fktwert[i]/100+"),",
                    xnull+155+i*(abstand+21),y1+rechteckhoehe+15);
      }
      for(i=4;i<anzahl-1;i++) {
        g.drawString("("+bezeichner[i]+", "+(double)fktwert[i]/100+"),",
                    xnull+155+(i-4)*(abstand+22),y1+rechteckhoehe+30);
      }
      g.drawString("("+bezeichner[anzahl-1]+", "+(double)fktwert[anzahl-1]/100
                 +") }",xnull+155+(anzahl-5)*(abstand+23),y1+rechteckhoehe+30);

        //Eine Treppenfunktion mit den gesetzten Werten wird erstellt
        b.koordSystemZeichnen(g,xnull,ynull,breite,hoehe,
                             abstand,anzahl,koordbezeichner);
        g.drawImage(getImage(getDocumentBase(),"formeln/muea.gif"),
                   xnull+b.tiefer,ynull,this);
        g.setColor(Color.red);
        fktwert1=(int)(ynull+hoehe-fktwert[0]/100*(hoehe-b.tiefer));
        for (i=1;i<anzahl;i++) {
          fktwert2=(int)(ynull+hoehe-fktwert[i]/100*(hoehe-b.tiefer));
          g.drawLine(xnull+(i-1)*abstand,fktwert1,xnull+i*abstand,fktwert1);
          g.drawLine(xnull+i*abstand,fktwert1,xnull+i*abstand,fktwert2);
          fktwert1=fktwert2;
        }
        g.drawLine(xnull+(anzahl-1)*abstand,fktwert1,xnull+breite,fktwert1);
    }
}




5.3 Applet „sportarten.java“

Nach Betrachtung der Operationen auf klassischen Mengen, und insbesondere
der damit verbundenen charakteristischen Funktionen, wird mit dem Programm
„sportarten.java“ ein typisches Beispiel für scharfe Mengen untersucht. Es
handelt sich um eine Grundmenge, welche die Teilmengen „Ballsportarten“
und „Mannschaftssportarten“ enthält, über neun verschiedene Sportarten. Auf
diese Mengen können nun die Operationen Komplement, Durchschnitt und
Vereinigung angewandt werden. Wie es schon in der Schule eine gängige
Methode ist, sind dabei die Mengen als Ovale dargestellt, in denen die
Erläuterungen zu den Interaktionsmöglichkeiten                            43

zugehörigen Piktogramme der Sportarten eingefügt sind. Nach Wahl einer
bestimmten Operation wird die entsprechende Menge durch die übliche




 Abb. 10: Ansicht des Applets „sportarten.java“

Schwarzfärbung ausgedrückt. Zur funktionalen Kennzeichnung sind auch
wieder die Graphen der charakteristischen Funktionen zu den Ball- und
Mannschaftssportarten sowie zu der gewählten Operation abgebildet.
So kann zum einen das Ergebnis der resultierenden Indikatorfunktion
funktional über die verwendeten Abbildungen für Komplement, Schnitt und
Vereinigung verifiziert werden und zum anderen über die Anschauung anhand
des entstandenen Mengenbilds mit den entsprechenden Schwarzfärbungen. Der
Lernende soll erkennen, dass die angezeigte Indikatorfunktion in jedem Fall
das richtige Resultat liefert und es somit prinzipiell möglich ist, auch
Mengenoperationen mit Hilfe charakteristischer Funktionen vollständig in
funktionaler Weise zu beschreiben.

5.3.1   Quellcode „sportarten.java“
import ksys.*;
import java.awt.event.*;
import java.awt.*;

//Darstellung von Operationen auf klassischen Mengen
public class sportarten extends java.applet.Applet implements ActionListener
{

  final int anzahlmengen=8;
  final int anzahlbilder=9;
Erläuterungen zu den Interaktionsmöglichkeiten                              44

 //Konstanten fuer die Appletmaße
 final int xnull=20;
 final int breite=550;
 final int hoehe=100;
 final int abstand=60;
 final int zurueck=5;
 final int bildy=60;
 final int bildlaenge=500;
 final int ynull=bildy+230;

 //Knoepfe zum anzeigen der Mengen
 Button A = new Button("Menge A");
 Button B = new Button("Menge B");
 Button AuB = new Button("Vereinigung");
 Button AnB = new Button("Schnitt");
 Button nA = new Button("Nicht A");
 Button nB = new Button("Nicht B");
 Button leer = new Button("Leere Menge");
 Button grund = new Button("Grundmenge");
 Image[] mengen = new Image[anzahlmengen];
 Image[] funktionen = new Image[anzahlmengen];
 //Werte zum Zeichnen der char. Fkten.
   //Anzahl der Spruenge der charakteristischen Funktion zur Beschreibung
   //einer bestimmten klassischen Menge
 int[] spruenge = new int[anzahlmengen];
 //Positionen der Spruenge der char. Funktion
 int[][] trennlinie={{xnull,xnull+4*abstand-zurueck},
              {xnull,xnull+2*abstand-zurueck,xnull+6*abstand-zurueck},
              {xnull,xnull+6*abstand-zurueck},
              {xnull,xnull+2*abstand-zurueck,xnull+4*abstand-zurueck},
              {xnull,xnull+4*abstand-zurueck},
              {xnull,xnull+2*abstand-zurueck,xnull+6*abstand-zurueck},
              {xnull},{xnull}};
   int[][] wert={{1,0},{0,1,0},{1,0},{0,1,0},{0,1},{1,0,1},{0},{1}};
 String[] bezeichner = new String[anzahlbilder];

 //Variable zur Kennzeichnung der betrachteten Menge
 int aktuell=-1;

 int i;



 public void init() {
   int i,j;

   String[] mengenbilder={"mengea.gif","mengeb.gif","vereinigung.gif",
                        "schnitt.gif","nichta.gif","nichtb.gif",
                        "leeremenge.gif","grundmenge.gif"};
   String[] funktionenbilder={"chia.gif","chib.gif","defvereinigung.gif",
                            "defschnitt.gif","defkomplement.gif",
                            "komplementb.gif","defleer.gif","defgrund.gif"};

   String[] elementbezeichner={"      Tennis","     Golf","         Fußball",
                             "       Basketb.", "        Eishock.",
                             "      Rudern","    Ski",
                             "   Rad","         Turmspr."};


   spruenge[0]=1;
   spruenge[1]=2;
   spruenge[2]=1;
   spruenge[3]=2;
   spruenge[4]=1;
   spruenge[5]=2;
   spruenge[6]=0;
   spruenge[7]=0;

   for (i=0;i<anzahlmengen;i++) {
     mengen[i]=getImage(getDocumentBase(),"images/"+ mengenbilder[i]);
     funktionen[i]=getImage(getDocumentBase(),"formeln/"+funktionenbilder[i]);
   }

   for (i=0;i<anzahlbilder;i++) {
     bezeichner[i]=elementbezeichner[i];
   }

   setBackground(Color.white);
Erläuterungen zu den Interaktionsmöglichkeiten                               45


     //Knoepfe einsetzen
     Panel knoepfe = new Panel();
     knoepfe.setForeground(Color.black);
     knoepfe.setBackground(Color.lightGray);
     knoepfe.setLayout(new GridLayout(2,anzahlmengen/2));
     knoepfe.add(A);
     knoepfe.add(B);
     knoepfe.add(AuB);
     knoepfe.add(AnB);
     knoepfe.add(nA);
     knoepfe.add(nB);
     knoepfe.add(leer);
     knoepfe.add(grund);
     add(knoepfe);
     A.addActionListener(this);
     B.addActionListener(this);
     AuB.addActionListener(this);
     AnB.addActionListener(this);
     nA.addActionListener(this);
     nB.addActionListener(this);
     leer.addActionListener(this);
     grund.addActionListener(this);
 }




 public void actionPerformed(ActionEvent e) {
   //Setzt den Zaehler auf die Nummer der anzuzeigenden Menge
   if (e.getSource()==A)
     aktuell=0;

     if (e.getSource()==B)
       aktuell=1;

     if (e.getSource()==AuB)
       aktuell=2;

     if (e.getSource()==AnB)
       aktuell=3;

     if (e.getSource()==nA)
       aktuell=4;

     if (e.getSource()==nB)
       aktuell=5;

     if (e.getSource()==leer)
       aktuell=6;

     if (e.getSource()==grund)
       aktuell=7;

     repaint();
 }




 public void paint(Graphics g) {
   int[] trennung = new int[3];

     bilderkoordsystem b = new bilderkoordsystem(g);
     g.setColor(Color.black);

     //Koordinatensystem mit den Mengen A und B leicht versetzt, damit die
     //Kurven nicht ueberzeichnet werden
     b.koordSystemZeichnen(g, xnull, ynull, breite, hoehe, abstand,
                         anzahlbilder, bezeichner);
     g.setColor(Color.blue);
     g.drawString("Ballsportarten (A)",xnull+6,ynull+hoehe/2);
     trennung[0]=xnull;
     trennung[1]=trennlinie[0][1]-2;
     b.charFkt(g, trennung,spruenge[0],ynull+b.tiefer+1,breite,
              hoehe-b.tiefer, wert[0]);
Erläuterungen zu den Interaktionsmöglichkeiten                                46

    g.setColor(Color.gray);
    g.drawString("Mannschaftssportarten
(B)",trennlinie[1][1]+10,ynull+hoehe/2);
    trennung[1]=trennlinie[1][1]+2;
    trennung[2]=trennlinie[1][2]-2;
    b.charFkt(g, trennung,spruenge[1],ynull+b.tiefer-1,breite,
             hoehe-b.tiefer, wert[1]);

        //Wenn eine Menge ausgewaehlt wurde, wird die zugeh. char. Fkt. gezeichnet
        if (aktuell!=-1) {
          //Zeichnet die gewuenschte Menge
          g.drawImage(mengen[aktuell], breite/2-bildlaenge/2,bildy,this);
          //Funktionenbezeichner an die Achse schreiben
          g.drawImage(funktionen[aktuell],xnull-10,ynull-20,this);
          //Blinkeffekt der Funktion
          for (i=0;i<1000;i++) {
            g.setColor(Color.white);
            b.charFkt(g, trennlinie[aktuell],spruenge[aktuell], ynull+b.tiefer-3,
                  breite, hoehe-b.tiefer, wert[aktuell]);
            b.charFkt(g, trennlinie[aktuell],spruenge[aktuell], ynull+b.tiefer-4,
                  breite, hoehe-b.tiefer, wert[aktuell]);
            g.setColor(Color.red);
            b.charFkt(g, trennlinie[aktuell],spruenge[aktuell], ynull+b.tiefer-3,
                     breite, hoehe-b.tiefer, wert[aktuell]);
            b.charFkt(g, trennlinie[aktuell],spruenge[aktuell], ynull+b.tiefer-4,
                  breite, hoehe-b.tiefer, wert[aktuell]);
          }
        }
    }

}




5.4 Applet „menschen.java“

Während im Programm „sportarten.java“ die klassischen Mengenoperationen
anhand eines typischen Beispiels scharfer Mengen vorgestellt wurden,
demonstriert das Applet „menschen.java“ die Operationen auf unscharfen
Mengen. Dazu sind Fuzzy-Mengen der großen und der mittelgroßen Menschen
erstellt worden auf denen das Zadeh-Komplement, der Zadeh-Durchschnitt und
die Zadeh-Vereinigung ausgeführt werden können. Des Weiteren kann die
Fuzzy-Menge der großen Menschen mit ihrem Komplement vereinigt und
geschnitten werden. Die Darstellung der zu Grunde liegenden Fuzzy-Mengen
und der resultierenden Fuzzy-Menge erfolgt wieder über die (stetigen)
Zugehörigkeitsfunktionen sowie durch Graufärbungen. Der Unterschied zu den
klassischen Mengenoperationen liegt gerade in der Stetigkeit der berechneten
Zugehörigkeitsfunktionen und soll vom Benutzer im Vergleich zum
korrespondieren Applet „sportarten.java“ erkannt werden.
Das Applet dient dazu, die Operationen auf Fuzzy-Mengen dem Lernenden
näher zu bringen. Die Wahl stetiger Zugehörigkeitsfunktionen bewirkt, dass
zwischen den Elementen keinerlei scharfe Grenzen mehr zu erkennen sind, die
Erläuterungen zu den Interaktionsmöglichkeiten                               47

auch nicht nach Anwendung der Zadeh-Operatoren entstehen, obwohl diese
Operatoren    den     klassischen      Mengenoperatoren    entsprechen.     Dieser
Sachverhalt zeigt sich ebenso ausdrucksvoll in den fließenden Übergängen der
Graufärbungen, die es bei klassischen Mengen nicht gibt. Auch in diesem Fall
gehen die berechneten Zugehörigkeitsfunktionen konform mit den bildhaften




 Abb. 11: Ansicht des Applets „menschen.java“

Darstellungen. Das Austesten der einzelnen Operationen soll den Lernenden an
das Arbeiten mit den Zugehörigkeitsfunktionen und den entsprechenden
Illustrationen gewöhnen.
Das Applet liefert darüber hinaus ein offenkundiges Beispiel für die
Ungültigkeit des Gesetzes des ausgeschlossenen Dritten und des Gesetzes vom
Widerspruch. Mit der Darstellung der Vereinigung bzw. des Durchschnitts der
Fuzzy-Menge „Groß“ mit ihrem Komplement wird die Ungültigkeit der
Gesetze sowohl anhand der Zugehörigkeitsfunktionen als auch durch die
Graufärbungen ausgedrückt.
Nicht   zuletzt     durch     dieses     Applet   sollte   das   Arbeiten     mit
Zugehörigkeitsfunktionen und der entsprechenden Anschauung dem Benutzer
verständlich geworden sein, so dass dieses Applet einen sinnvollen Abschluss
des Kapitels „Klassische Mengen vs Fuzzy-Mengen“ bildet.
Erläuterungen zu den Interaktionsmöglichkeiten                               48

5.4.1   Quellcode „menschen.java“
import ksys.*;
import java.awt.event.*;
import java.awt.*;

//Darstellung von Operationen auf Fuzzy-Mengen
public class menschen extends java.applet.Applet implements ActionListener
{

  final int anzahlmengen=10;
  final int anzahlgroessen=7;
  //Konstanten fuer die Appletmaße
  final int xnull=20;
  final int breite=550;
  final int hoehe=80;
  final int abstand=70;
  final int bildlaenge=breite-xnull;
  final int bildhoehe=50;
  final int anfanga=2*abstand;
  //Werte fuer die Funktionen der Fuzzy-Mengen
  final int endea=5*abstand;
  final int anfangb=0*abstand;
  final int mittelb=4*abstand;
  final int endeb=6*abstand;

  int[] y = new int[4];
  double[][] wert = new double[anzahlmengen][bildlaenge];

  //Knoepfe zum anzeigen der Mengen
  Button A = new Button("groß (A)");
  Button B = new Button("mittel (B)");
  Button AuB = new Button("A vereinigt B");
  Button AnB = new Button("A Schnitt B");
  Button nA = new Button("nicht groß");
  Button nB = new Button("nicht mittel");
  Button wid = new Button("A Schnitt NotA");
  Button dritten = new Button("A und NotA");
  Button leer = new Button("Leermenge");
  Button grund = new Button("Grundmenge");
  Image[] funktionen = new Image[anzahlmengen];
  String[] bezeichner = new String[anzahlgroessen];
  String[] mengen = new String[anzahlmengen];

  //Variable zur Kennzeichnung der betrachteten Menge
  int aktuell=-1;



  public void init() {
    int i;

    String[] funktionenbilder={"muea.gif","mueb.gif","muevereinigung.gif",
                             "mueschnitt.gif","muekomplement.gif",
                             "muekomplementb.gif",
                             "defanna.gif","defauna.gif","defleer1.gif",
                             "defgrund1.gif"};

    String[] elementbezeichner={"1,00","1,20","1,40","1,60","1,80","2,00",
                              "2,20"};
    String[] mengenbezeichner={"Menge groß","Menge mittelgroß","Vereinigung",
                             "Schnitt","nicht groß","nicht mittel",
                             "groß geschnitten nicht groß",
                             "groß vereinigt nicht groß","leere Menge",
                             "Grundmenge"};

    for (i=0;i<anzahlmengen;i++) {
      funktionen[i]=getImage(getDocumentBase(),"formeln/"+funktionenbilder[i]);
      mengen[i]=mengenbezeichner[i];
    }

    for (i=0;i<anzahlgroessen;i++) {
      bezeichner[i]=elementbezeichner[i];
    }

    //Vertikale Positionen fuer die Visualisierung der Mengen setzen
    y[0]=70;
    for (i=1;i<4;i++)
Erläuterungen zu den Interaktionsmöglichkeiten                       49

     y[i]=y[i-1]+bildhoehe+30;

   //Werte fuer A
   for (i=0;i<anfanga;i++)
     wert[0][i]=0;
   for (i=anfanga;i<endea;i++)
     wert[0][i]=(1/(double)(endea-anfanga))*(double)(i-anfanga);
   for (i=endea;i<bildlaenge;i++)
     wert[0][i]=1;

   //Werte fuer B
   for (i=0;i<abstand;i++)
     wert[1][i]=0;
   for (i=anfangb;i<mittelb;i++)
     wert[1][i]=(1/(double)(mittelb-anfangb))*(double)(i-anfangb);
   for (i=mittelb;i<endeb;i++)
     wert[1][i]=1-(1/(double)(endeb-mittelb)*(double)(i-mittelb));
   for (i=endeb;i<bildlaenge;i++)
     wert[1][i]=0;

   //Vereinigung
   for (i=0;i<bildlaenge;i++)
     wert[2][i]=Math.max(wert[0][i],wert[1][i]);

   //Schnitt
   for (i=0;i<bildlaenge;i++)
     wert[3][i]=Math.min(wert[0][i],wert[1][i]);

   //nichtA
   for (i=0;i<bildlaenge;i++)
     wert[4][i]=1-wert[0][i];

   //nichtB
   for (i=0;i<bildlaenge;i++)
     wert[5][i]=1-wert[1][i];

   //A Schnitt nichtA
   for (i=0;i<bildlaenge;i++)
     wert[6][i]=Math.min(wert[0][i],wert[4][i]);

   //A vereinigt nichtA
   for (i=0;i<bildlaenge;i++)
     wert[7][i]=Math.max(wert[0][i],wert[4][i]);

   //Leermenge
   for (i=0;i<bildlaenge;i++)
     wert[8][i]=0;

   //Grundmenge
   for (i=0;i<bildlaenge;i++)
     wert[9][i]=1;

   setBackground(Color.white);
   setLayout(new FlowLayout(FlowLayout.CENTER));
   //Knoepfe einsetzen
   Panel knoepfe = new Panel();
   knoepfe.setForeground(Color.black);
   knoepfe.setBackground(Color.lightGray);
   knoepfe.setLayout(new GridLayout(2,anzahlmengen/2));
   knoepfe.add(A);
   knoepfe.add(B);
   knoepfe.add(AuB);
   knoepfe.add(AnB);
   knoepfe.add(nA);
   knoepfe.add(nB);
   knoepfe.add(wid);
   knoepfe.add(dritten);
   knoepfe.add(leer);
   knoepfe.add(grund);
   add(knoepfe);
   A.addActionListener(this);
   B.addActionListener(this);
   AuB.addActionListener(this);
   AnB.addActionListener(this);
   nA.addActionListener(this);
   nB.addActionListener(this);
   wid.addActionListener(this);
   dritten.addActionListener(this);
Erläuterungen zu den Interaktionsmöglichkeiten                        50

     leer.addActionListener(this);
     grund.addActionListener(this);
 }




 public void actionPerformed(ActionEvent e) {
   //Setzt den Zaehler auf die Nummer der anzuzeigenden Menge
   if (e.getSource()==A)
     aktuell=0;

     if (e.getSource()==B)
       aktuell=1;

     if (e.getSource()==AuB)
       aktuell=2;

     if (e.getSource()==AnB)
       aktuell=3;

     if (e.getSource()==nA)
       aktuell=4;

     if (e.getSource()==nB)
       aktuell=5;

     if (e.getSource()==wid)
       aktuell=6;

     if (e.getSource()==dritten)
       aktuell=7;

     if (e.getSource()==leer)
       aktuell=8;

     if (e.getSource()==grund)
       aktuell=9;

     repaint();
 }




 public void paint(Graphics g) {
   int i,j,k;
   int farbe;
   int fktwert1,fktwert2;

     bilderkoordsystem b = new bilderkoordsystem(g);

     //Zeichnet die Mengen A und B in den entsprechenden Graustufen
     for (j=0;j<2;j++) {
       // Darstellung von NichtA bei Gesetz vom Widerspruch und
       //ausgeschl. Dritten
       if((j==0)||((aktuell<6)||(aktuell>7)))
         k=j;
       else
         k=4;
       if (j==0) g.setColor(Color.blue);
       else g.setColor(Color.black);
       g.drawString(mengen[k]+":",xnull,y[j]-5);
       for (i=0;i<bildlaenge;i++) {
         farbe=(int)((1-wert[k][i])*255);
         g.setColor(new Color(farbe,farbe,farbe));
         g.drawLine(xnull+i,y[j]+bildhoehe,xnull+i,y[j]);
       }
     }

     if (aktuell!=-1){
       //Zeichnet die gewuenschte Menge in den Graustufen
       for (i=0;i<bildlaenge;i++) {
         farbe=(int)((1-wert[aktuell][i])*255);
         g.setColor(new Color(farbe,farbe,farbe));
         g.drawLine(xnull+i,y[2]+bildhoehe,xnull+i,y[2]);
       }
Erläuterungen zu den Interaktionsmöglichkeiten                                   51

            g.setColor(Color.red);
            g.drawString(mengen[aktuell]+":",xnull,y[2]-5);
        }

        //Bezeichnung der Mengenbilder
        g.setColor(Color.black);
        for(j=0;j<3;j++) {
          g.drawRect(xnull,y[j],bildlaenge,bildhoehe);
          for(i=0;i<anzahlgroessen;i++) {
            g.drawString(bezeichner[i]+" m",xnull+i*abstand,y[j+1]-17);
          }
        }

        //Zeichnen der Zugehoerigkeitsfunktionen
        b.koordSystemZeichnen(g, xnull, y[3], breite, hoehe, abstand,
                            anzahlgroessen, bezeichner);

        //Zug.fkt. zur Menge A wird immer angezeigt
        g.drawString("Größen in m",xnull+(anzahlgroessen-1)*abstand+abstand/2,
                    y[3]+hoehe+b.tiefer);
        g.setColor(Color.blue);
        g.drawString("groß",breite-50,y[3]+hoehe/2);
        fktwert1=(int)(y[3]+hoehe-wert[0][0]*(hoehe-b.tiefer)-1);
        for(i=1;i<bildlaenge;i++) {
          fktwert2=(int)(y[3]+hoehe-wert[0][i]*(hoehe-b.tiefer)-1);
          g.drawLine(xnull+i-1,fktwert1,xnull+i,fktwert2);
          fktwert1=fktwert2;
        }

        //Menge B wird immer angezeigt, außer bei Darstellung des Gesetzes
        //vom Widerspruch und es ausgeschl. Dritten
        g.setColor(Color.black);
        if ((aktuell<6)||(aktuell>7)) {
          g.drawString("mittelgroß",xnull+20,y[3]+hoehe/2);
          j=1;
        }
        else {
          //dann wird Menge NichtA angezeigt
          j=4;
          g.drawString("nicht groß",xnull+20,y[3]+hoehe/2);
        }
        fktwert1=(int)(y[3]+hoehe-wert[j][0]*(hoehe-b.tiefer)+1);
        for(i=1;i<bildlaenge;i++) {
          fktwert2=(int)(y[3]+hoehe-wert[j][i]*(hoehe-b.tiefer)+1);
          g.drawLine(xnull+i-1,fktwert1,xnull+i,fktwert2);
          fktwert1=fktwert2;
        }

        //Ist eine Menge ausgewaehlt worden wird die zugehoerige Funktion gez.
        if(aktuell!=-1) {
          g.drawImage(funktionen[aktuell],xnull+10,y[3]-10,this);
          g.setColor(Color.red);
          fktwert1=(int)(y[3]+hoehe-wert[aktuell][0]*(hoehe-b.tiefer));
          for(i=1;i<bildlaenge;i++) {
            fktwert2=(int)(y[3]+hoehe-wert[aktuell][i]*(hoehe-b.tiefer));
            g.drawLine(xnull+i-1,fktwert1,xnull+i,fktwert2);
            fktwert1=fktwert2;
          }
        }

    }

}




5.5 Applets „sugeno.java“ und „yager.java“

Mittels der Applets „sugeno.java“ und „yager.java“ kann sich der Benutzer den
Verlauf der Funktionsgraphen der Sugeno- und Yager-Klasse zu selbst
Erläuterungen zu den Interaktionsmöglichkeiten                               52

bestimmten Parameterwerten anschauen. Damit wird wieder ein entscheidender
Vorteil in puncto Interaktivität ausgenutzt. Während im Vorlageskript nur eine
beschränkte Anzahl an Beispielen der Sugeno- bzw. Yager-Klasse, seitens der
Vorgabe verschiedener Parameterwerte, vorgestellt werden können, obliegt es
in diesem Programm dem Anwender, individuell die Parameter zu bestimmen
und sich die resultierende Komplementfunktion anzuschauen. Auf diese Weise




 Abb. 12: Ansicht des Applets „sugeno.java“
werden     die   Auswirkungen        der      Parameterwahl   am   Graphen    der
Komplementfunktion sichtbar. Die Erfüllung der an das Fuzzy-Komplement
gestellten Bedingungen soll vom Benutzer am entstandenen Bild der
Zugehörigkeitsfunktion erkannt werden.
In diesen Applets erfolgt die Eingabe der Parameterwerte nicht über Scrollbars,
sondern durch die Nutzung von Textfeldern. Die Verwendung von Scrollbars
ist an dieser Stelle nicht möglich, da der unendliche Wertebereich einen
Gebrauch von Schiebeleisten nicht zulässt. Außerdem handelt es sich bei den
Eingabegrößen um absolute und keine relativen Zahlenwerte, bei denen
Scrollbars keine Vorteile in der Anschauung liefern. Eine fehlerhafte Eingabe
der Parameterwerte ist durch entsprechende Sicherheitsabfragen dennoch nicht
möglich.

5.5.1    Quellcode „sugeno.java“
import java.awt.*;
import java.awt.event.*;
import ksys.*;
Erläuterungen zu den Interaktionsmöglichkeiten                               53

//Zeichnet die Sugeno-Komplementfunktion
public class sugeno extends java.applet.Applet implements ActionListener {

 final int anzahl=6;
 //Konstanten fuer verschiedene Maße
 final int xnull=35;
 final int ynull=30;
 final int breite=250;
 final int hoehe=250;
 final int abstand=(breite-bilderkoordsystem.tieferst)/(anzahl-1);

 double lambda;

 String[] skala = new String[anzahl];
 //Felder zur Parameterabfrage
 TextField abfrage = new TextField("0",3);
 Label lb1 = new Label("lambda:");
 Label lb2 = new Label("Bitte Wert fuer lambda eingeben!");

 public void init() {
   int i;

     String[] werte={"0","0.2","0.4","0.6","0.8","1"};

     for (i=0;i<anzahl;i++) {
       skala[i]=werte[i];
     }

     abfrage.setBackground(Color.white);
     abfrage.setForeground(Color.blue);
     add(lb1);
     add(abfrage);
     abfrage.addActionListener(this);
     add(lb2);
     setBackground(Color.white);
 }



 public void actionPerformed(ActionEvent evt) {
   double i;

     //Wird der Wert im Textfeld geaendert...
     if (evt.getSource()==abfrage) {
       //...wird geprueft, ob er numerisch ist...
       try {
         Double j = new Double(abfrage.getText());
         i=j.doubleValue();
         //...und im erlaubten Bereich liegt
         if(i<=-1) {
           lb2.setText("Wert muss groesser als -1 sein");
         }
         else {
           //falls alles korrekt, wird neuer Wert gesetzt und Fkt. gezeichnet
           lb2.setText("OK");
           lambda=i;
           repaint();
         }
       }
       catch (NumberFormatException e) {
         lb2.setText("Keine Zahl angegeben");
       }
     }
 }



 public int c(int a) {
   //Berechnet die Funktionswerte der Sugenoklasse
   double fktwert,x;
   int ergebnis;

     x=(a/(double)((anzahl-1)*abstand));
     fktwert=(double)(1-x)/(double)(1+lambda*x);
     ergebnis=(int)(ynull+hoehe-fktwert*(hoehe-bilderkoordsystem.tieferst));
     return ergebnis;
 }
Erläuterungen zu den Interaktionsmöglichkeiten                                54



    public void paint(Graphics g) {
      int i;
      int f1, f2;
      double j;

        bilderkoordsystem b = new bilderkoordsystem(g);

        //Zeichnen des Koord.systems
        b.koordSystemZeichnen(g,xnull,ynull,breite,hoehe,abstand,anzahl,skala);
        b.vertikalBeschriftung(g,xnull,ynull+hoehe,abstand,anzahl-1,skala);
        b.einteilung(g,xnull,ynull+hoehe,abstand,anzahl);
        g.drawString("a",xnull+breite+2,ynull+hoehe+5);
        //Zeichnen der Sugeno-Komplementfunktion
        g.setColor(Color.red);
        g.drawString("c(a)",xnull-5,ynull-2);
        f1=c(0);
        for(i=xnull;i<xnull+(anzahl-1)*abstand;i++) {
          f2=c(i+1-xnull);
          g.drawLine(i,f1,i+1,f2);
          f1=f2;
        }
    }
}



5.5.2      Quellcode „yager.class“
import java.lang.*;
import java.awt.*;
import ksys.*;

//Zeichnet die Yager-Komplementfunktion
public class yager extends java.applet.Applet {

    final int anzahl=6;
    //Konstanten fuer verschiedene Maße
    final int xnull=35;
    final int ynull=30;
    final int breite=250;
    final int hoehe=250;
    final int abstand=(breite-bilderkoordsystem.tieferst)/(anzahl-1);

    double omega=1;

    String[] skala = new String[anzahl];
    //Felder zur Parameterabfrage
    TextField abfrage = new TextField("1",3);
    Label lb1 = new Label("omega:");
    Label lb2 = new Label("Bitte Wert fuer omega eingeben!");

    public void init() {
      int i;

        //Werte fuer char. Fkt. werden gesetzt
        String[] werte={"0","0.2","0.4","0.6","0.8","1"};

        for (i=0;i<anzahl;i++) {
          skala[i]=werte[i];
        }

        abfrage.setBackground(Color.white);
        abfrage.setForeground(Color.blue);
        add(lb1);
        add(abfrage);
        add(lb2);
        setBackground(Color.white);
    }



    public boolean action(Event evt, Object arg) {
      double i;

        //Wird der Wert im Textfeld geaendert...
        if (evt.target instanceof TextField) {
Erläuterungen zu den Interaktionsmöglichkeiten                                 55

         //...wird geprueft, ob er numerisch ist...
         try {
           Double j = new Double(abfrage.getText());
           i=j.doubleValue();
           //...und im erlaubten Bereich liegt
           if(i<=0) {
             lb2.setText("Wert muss groesser als 0 sein");
           }
           else {
             //falls alles korrekt, wird neuer Wert gesetzt und Fkt. gezeichnet
             lb2.setText("OK");
             omega=i;
             repaint();
           }
         }
         catch ( NumberFormatException e) {
           lb2.setText("Keine Zahl angegeben");
         }
        }
        return true;
    }



    public int c(int a) {
      //Berechnen der Funktionswerte des Yagerkomplements
      double fktwert,x;
      int ergebnis;

        x=(a/(double)((anzahl-1)*abstand));
        fktwert=Math.pow(1-Math.pow(x,omega),(1/omega));
        ergebnis=(int)(ynull+hoehe-fktwert*(hoehe-bilderkoordsystem.tieferst));
        return ergebnis;
    }



    public void paint(Graphics g) {
      int i;
      int f1, f2;

        bilderkoordsystem b = new bilderkoordsystem(g);

        //Zeichnen des Koord.systems
        b.koordSystemZeichnen(g,xnull,ynull,breite,hoehe,abstand,anzahl,skala);
        b.vertikalBeschriftung(g,xnull,ynull+hoehe,abstand,anzahl-1,skala);
        b.einteilung(g,xnull,ynull+hoehe,abstand,anzahl);
        g.drawString("a",xnull+breite+2,ynull+hoehe+5);
        //Zeichnen der Yager-Komplementfunktion
        g.setColor(Color.red);
        g.drawString("c(a)",xnull-5,ynull-2);
        f1=c(0);
        for(i=xnull;i<xnull+(anzahl-1)*abstand;i++) {
          f2=c(i+1-xnull);
          g.drawLine(i,f1,i+1,f2);
          f1=f2;
        }
    }
}




5.6 Applet „komplement.java“

Die       Applets      „sugeno.java“   und    „yager.java“    bilden    zwar      die
Komplementfunktionen der Sugeno- bzw. der Yager-Klasse zu gewählten
Parametern ab, aber ein wirklich aussagekräftiges Bild stellt erst die
Zugehörigkeitsfunktion des resultierenden Komplements einer Fuzzy-Menge
Erläuterungen zu den Interaktionsmöglichkeiten                            56

dar. Das Applet „komplement.java“ bildet zur bekannten Fuzzy-Menge des
idealen Badewassers je nach Wunsch das Komplement nach Zadeh, Sugeno
oder Yager. Hier zeigt sich die Zugehörigkeitsfunktion des erstellten
Komplements in Abhängigkeit des gewählten Parameters.




 Abb. 13: Ansicht des Applets „komplement.java“

An diesem Beispiel können die Auswirkungen nach Wahl einer der
Komplementfunktionen mit den verschiedenen Parametern ausgetestet werden
und der Lernende bekommt eine Vorstellung von den vielfältigen
Möglichkeiten, Komplemente von Fuzzy-Mengen zu bilden. Aus den gleichen
Gründen wie bei den Applets „sugeno.java“ und „yager.java“ bilden wieder
Textfelder die Eingabemöglichkeit der Parameter.

5.6.1   Quellcode „komplement.java“
import java.awt.*;
import java.awt.event.*;
import ksys.*;

//Zeichnet eine Komplementfunktion ueber der Funktion des idealen Badewassers
public class komplement extends java.applet.Applet implements ActionListener {

  final int anzahl=6;
  //Konstanten fuer verschiedene Masse
  final int xnull=20;
  final int ynull=140;
  final int breite=500;
  final int hoehe=150;
  final int abstand=80;

  double parameter;
  int aktuell=-1;

  //Werte fuer Textfelder und Knoepfe setzen
  String[] skala = new String[anzahl];
  TextField abfrage1 = new TextField("0",3);
Erläuterungen zu den Interaktionsmöglichkeiten                               57

 TextField abfrage2 = new TextField("0",3);
 Label lbs1 = new Label("lambda:");
 Label lby1 = new Label("omega:");
 Label lbs2 = new Label("Bitte Wert für lambda eingeben!");
 Label lby2 = new Label("Bitte Wert für omega eingeben!");
 Button zadeh = new Button("Zadehkomplement");
 Button sugeno = new Button("Sugenokomplement");
 Button yager = new Button("Yagerkomplement");
 Panel einstellung1 = new Panel();
 Panel einstellung2 = new Panel();


 public void init() {
   int i;

     String[] werte={"25","30","35","40","45","50"};

     for (i=0;i<anzahl;i++) {
       skala[i]=werte[i];
     }

     //Einfuegen aller benoetigten Panel
     Panel kompl = new Panel();
     kompl.add(zadeh);
     kompl.add(sugeno);
     kompl.add(yager);
     add(kompl);

     abfrage1.setBackground(Color.white);
     abfrage1.setForeground(Color.blue);
     abfrage2.setBackground(Color.white);
     abfrage2.setForeground(Color.blue);
     einstellung1.add(lbs1);
     einstellung1.add(abfrage1);
     einstellung1.add(lbs2);
     einstellung2.add(lby1);
     einstellung2.add(abfrage2);
     einstellung2.add(lby2);
     add(einstellung1);
     add(einstellung2);
     zadeh.addActionListener(this);
     sugeno.addActionListener(this);
     yager.addActionListener(this);
     abfrage1.addActionListener(this);
     abfrage2.addActionListener(this);
     setBackground(Color.white);

 }



 public void actionPerformed(ActionEvent evt) {
   double i;

     //Je nach gedruecktem Knopf werden die zu bedienenden Elemente zu der
     //gewuenschten Funktion angezeigt und die vorherigen geloescht
     if (evt.getSource()==zadeh) {
       if (aktuell==2) remove(einstellung1);
       if (aktuell==3) remove(einstellung2);
       aktuell=1;
       repaint();
     }

     if (evt.getSource()==sugeno) {
       if (aktuell==3) remove(einstellung2);
       aktuell=2;
       add(einstellung1);
       parameter=0;
       abfrage1.setText("0");
       lbs2.setText("Bitte Wert fuer lambda eingeben!");
       repaint();
     }

     if (evt.getSource()==yager) {
       if (aktuell==2) remove(einstellung1);
       aktuell=3;
       add(einstellung2);
       parameter=1;
Erläuterungen zu den Interaktionsmöglichkeiten                             58

         abfrage2.setText("1");
         lby2.setText("Bitte Wert fuer omega eingeben!");
         repaint();
     }

     //Wird der Wert im Textfeld geaendert...
     if (evt.getSource()==abfrage1) {
       //...wird geprueft, ob er numerisch ist...
       try {
         Double j = new Double(abfrage1.getText());
         i=j.doubleValue();
         //...und im erlaubten Bereich liegt
         if(i<=-1) {
           lbs2.setText("Wert muss groesser als -1 sein");
         }
         else {
           //falls alles korrekt, wird neuer Wert gesetzt und Fkt. gezeichnet
           lbs2.setText("OK");
           parameter=i;
           repaint();
         }
       }
       catch (NumberFormatException e) {
         lbs2.setText("Keine Zahl angegeben");
       }
     }

     //Wird der Wert im Textfeld geaendert...
     if (evt.getSource()==abfrage2) {
       //...wird geprueft, ob er numerisch ist...
       try {
         Double j = new Double(abfrage2.getText());
         i=j.doubleValue();
         //...und im erlaubten Bereich liegt
         if(i<=0) {
           lby2.setText("Wert muss groesser als 0 sein");
         }
         else {
           //falls alles korrekt, wird neuer Wert gesetzt und Fkt. gezeichnet
           lby2.setText("OK");
           parameter=i;
           repaint();
         }
       }
       catch (NumberFormatException e) {
         lby2.setText("Keine Zahl angegeben");
       }
     }
 }




 public int f(int x) {
   //Berechnet die Gausssche Glockenkurve als Zugehoerigkeitsfkt.
   final double mue=2.5*abstand;
   final double sigma=50;
   double fktwert;
   int ergebnis;

     fktwert=Math.exp(-(Math.pow(x-mue,2)/(2*Math.pow(sigma,2))));
     ergebnis=(int)(fktwert*(hoehe-bilderkoordsystem.tieferst));

     return ergebnis;
 }



 public int csugeno(int a) {
   //Berechnet die Funktionswerte der Sugeno-Klasse
   double fktwert;
   int ergebnis;

     fktwert=(double)(hoehe-bilderkoordsystem.tieferst-a)/
       (double)(hoehe-bilderkoordsystem.tieferst+parameter*a);
     ergebnis=(int)(fktwert*(hoehe-bilderkoordsystem.tieferst));
     return ergebnis;
 }
Erläuterungen zu den Interaktionsmöglichkeiten                             59



 public int cyager(int a) {
   //Berechnen der Funktionswerte der Yager-Klasse
   double fktwert;
   int ergebnis;

     fktwert=Math.pow(1-Math.pow((double)a/(hoehe-bilderkoordsystem.tieferst),
                               parameter),(1/parameter));
     ergebnis=(int)(fktwert*(hoehe-bilderkoordsystem.tieferst));
     return ergebnis;
 }



 public int czadeh(int a) {
   //Berechnen der Funktionswerte des Zadehkomplements
   double fktwert;
   int ergebnis;

     fktwert=hoehe-bilderkoordsystem.tieferst-a;
     ergebnis=(int)(fktwert);
     return ergebnis;
 }



 public void paint(Graphics g) {
   int i;
   int f1, f2;
   int j;

     bilderkoordsystem b = new bilderkoordsystem(g);

     //Zeichnen des Koord.systems
     b.koordSystemZeichnen(g,xnull,ynull,breite,hoehe,abstand,anzahl,skala);
     g.drawString("a",xnull+breite+2,ynull+hoehe+5);
     g.drawString("Temperatur in Grad Celsius",breite-170,ynull+hoehe+25);
     //Zeichnen der Badewasserfunktion
     g.setColor(Color.blue);
     g.drawString("ideales Badewasser",xnull+2*abstand,ynull-2);
     f1=ynull+hoehe-f(0);
     for(i=xnull;i<xnull+(anzahl-1)*abstand;i++) {
       f2=ynull+hoehe-f(i+1-xnull);
       g.drawLine(i,f1,i+1,f2);
       f1=f2;
     }

     //Zeichnen der Zugeh.fkt.
     g.setColor(Color.red);
     switch (aktuell) {
       //Beim ersten Aufruf von paint muessen noch die ueberfluessigen
       //Panels entfernt werden
     case -1:
       remove(einstellung2);
       remove(einstellung1);
       break;

     case 1:
      g.drawString("Zadehkomplement",xnull-5,ynull-2);
      f1=ynull+hoehe-czadeh(f(0));
      for(i=xnull;i<xnull+(anzahl-1)*abstand;i++) {
        f2=ynull+hoehe-czadeh(f(i+1-xnull));
        g.drawLine(i,f1,i+1,f2);
        f1=f2;
      }
      break;

      //Bleibt ein Eingabewert unveraendert, wird erst eine Linie zwischen
      //den Funktionswerten gezeichnet bei denen sich der Eingabewert geaendert
      //hat, damit an den Raendern keine "Treppen" entstehen
     case 2:
      g.drawString("Sugenokomplement",xnull-5,ynull-2);
      f1=ynull+b.tiefer;
      j=i=xnull;
      //waagerechte Linie bis zum ersten Wert ungleich 1
      while(ynull+hoehe-csugeno(f(i-xnull))==ynull+b.tiefer) {
        i++;}
Erläuterungen zu den Interaktionsmöglichkeiten                                  60

        g.drawLine(j,f1,i-1,f1);
        j=i-1;

        //Linien bei fallender Funktion
        do {
          f2=ynull+hoehe-csugeno(f(i-xnull));
          if ((csugeno(f(i-xnull))!=csugeno(f(i+1-xnull)))
              || (csugeno(f(i-xnull))==0)){
            g.drawLine(j,f1,i,f2);
            j=i;
            f1=f2;
          }
          i++;
        } while(csugeno(f(i-1-xnull))>=csugeno(f(i-xnull)));

        //Linien bei steigender Funktion
        do {
          f2=ynull+hoehe-csugeno(f(i-xnull));
          if (csugeno(f(i-1-xnull))!=csugeno(f(i-xnull))) {
            g.drawLine(j,f1,i,f2);
            j=i;
            f1=f2;
          }
          i++;
        } while(ynull+hoehe-csugeno(f(i-1-xnull))!=ynull+b.tiefer);

        g.drawLine(j,ynull+b.tiefer,xnull+(anzahl-1)*abstand,ynull+b.tiefer);

        break;

        case 3:
          //Zeichnen der Yagerkomplements wie bei Sugeno
         g.drawString("Yagerkomplement",xnull-5,ynull-2);
         f1=ynull+b.tiefer;
         j=i=xnull;
         while(ynull+hoehe-cyager(f(i-xnull))==ynull+b.tiefer) {
           i++;}
         g.drawLine(j,f1,i-1,f1);
         j=i-1;

        do {
          f2=ynull+hoehe-cyager(f(i-xnull));
          if ((cyager(f(i-xnull))!=cyager(f(i+1-xnull)))
              || (cyager(f(i-xnull))==0)){
            g.drawLine(j,f1,i,f2);
            j=i;
            f1=f2;
          }
          i++;
        } while(cyager(f(i-1-xnull))>=cyager(f(i-xnull)));

        do {
          f2=ynull+hoehe-cyager(f(i-xnull));
          if (cyager(f(i-1-xnull))!=cyager(f(i-xnull))) {
            g.drawLine(j,f1,i,f2);
            j=i;
            f1=f2;
          }
          i++;
        } while(ynull+hoehe-csugeno(f(i-1-xnull))!=ynull+b.tiefer);

        g.drawLine(j,ynull+b.tiefer,xnull+(anzahl-1)*abstand,ynull+b.tiefer);

        break;

        default:
         g.drawString("Ein Fehler ist aufgetreten!!!",xnull-5,ynull-2);
        }


    }
}
Erläuterungen zu den Interaktionsmöglichkeiten                            61


5.7 Applet „operationen.java“

Was schon beim Fuzzy-Komplement mit den Programmen „sugeno.java“,
„yager.java“ und „komplement.java“ praktiziert wurde, soll mit dem Applet
„operationen.java“ für die Vereinigung und den Durchschnitt von Fuzzy-
Mengen fortgesetzt werden. An dieser Stelle wird, je nach Wahl, eine der
vorgestellten Zugehörigkeitsfunktionen zum Fuzzy-Durchschnitt oder zur
Fuzzy-Vereinigung angezeigt. Die Visualisierung der Durchschnitts- und
Vereinigungsfunktionen gestaltet sich allerdings etwas schwieriger als dies bei
den    Komplementabbildungen       der    Fall   war.    Durchschnitts-    und
Vereinigungsabbildungen hängen von zwei Variablen ab und das Bild der
Funktionen liegt somit im 3. Analog zur Darstellung von Fuzzy-Mengen
wurden daher die Funktionswerte mittels Graufärbungen symbolisiert.
Dementsprechend sind höhere Funktionswerte dunkler dargestellt. Auf diese
Weise soll eine bildhafte Vorstellung von den Durchschnitts- und
Vereinigungsoperatoren entstehen. Dazu wird auch wieder der Graph der
resultierenden Zugehörigkeitsfunktion, nach Anwendung einer Operation auf
die zwei bekannten Fuzzy-Mengen der großen und der mittelgroßen Menschen,
abgebildet. In diesem Beispiel sollen die herausgearbeiteten Gesetzmäßigkeiten
der t- und s-Normen verdeutlicht werden. Der Anwender hat die Möglichkeit,
das Verhalten der vorgestellten Durchschnitts- bzw. Vereinigungsoperatoren
mit verschiedenen Parameterwerten auszutesten und die Effekte dieser
Operationen auf Fuzzy-Mengen eingehend zu studieren. Dabei kann
anschaulich nachvollzogen werden, dass insbesondere die Operatoren nach
Yager bei geeigneten Parametern dem min- bzw. max-Operator entsprechen,
der schon bei den klassischen Mengenoperationen Anwendung gefunden hat
und von großer Bedeutung ist.
Erläuterungen zu den Interaktionsmöglichkeiten                              62




 Abb. 14: Ansicht des Applets „operationen.java“ nach Wahl des Durchschnitts nach
 Schweizer und Sklar


5.7.1    Quellcode „operationen.java“
import   ksys.*;
import   java.awt.event.*;
import   java.awt.*;
import   java.lang.*;

//Darstellung verschiedener t- und s-Normen
public class operationen extends java.applet.Applet implements ActionListener
{

  //Anzahl an Bezeichnern und verschiedener Funktionen
  final int anzahl=14;
  final int anzahlgroessen=7;
  final int anzahlwerte=5;
  //Konstanten fuer die Appletmaße
  final int xnull=30;
  final int breite=150;
  final int xnull2=80+breite+20;
  final int breite2=300;
  final int hoehe1=breite;
  final int hoehe2=hoehe1-30;
  final int ynull1=65;
  final int ynull2=ynull1+30;
  final int abstand=(breite-bilderkoordsystem.tieferst)/(anzahlwerte-1);
  final int abstand2=(breite2-bilderkoordsystem.tieferst)/(anzahlgroessen-1);
  final int anfanga=2*abstand;
  //Werte fuer die Funktionen der Fuzzy-Mengen "mittelgroß" und "groß"
  final int endea=5*abstand2;
  final int anfangb=0*abstand2;
  final int mittelb=4*abstand2;
  final int endeb=6*abstand2;
  final int minusunendlich=-100;
  final int unendlich=0;
  String untenstring, obenstring, paramstring;

  //verschiedene Parametergrenzen fuer die vers. Funktionen
  int unten, mitte, oben, funktion;
  boolean ausnahme=false;
  double parameter=1;

  double[][] wert = new double[2][breite2];

  Button OK = new Button("OK");
  TextField tf = new TextField("1",3);
  Label lb1 = new Label();
  Label lb = new Label();

  Image[] funktionen = new Image[anzahl];
  String[] bezeichner = new String[anzahlgroessen];
  String[] bezeichnung = new String[anzahlwerte];

  Font f = new Font("TimesNewRoman",Font.PLAIN,12);
  FontMetrics fm = getFontMetrics(f);



  public void init() {
    int i;

    //Bildernamen und Strings zur Bezeichnung der Achsen
    String[] funktionenbilder={"hamacherschnitt.gif","frankschnitt.gif",
Erläuterungen zu den Interaktionsmöglichkeiten                              63

                            "yagerschnitt.gif","duboisschnitt.gif",
                            "dombischnitt.gif","schweizerschnitt.gif",
                            "hamachervereinigung.gif",
                            "frankvereinigung.gif","yagervereinigung.gif",
                            "duboisvereinigung.gif","dombivereinigung.gif",
                            "schweizervereinigung.gif","muea.gif",
                            "mueb.gif"};

   String[] elementbezeichner={"1,00","1,20","1,40","1,60","1,80","2,00",
                             "2,20"};
   String[] achsenbezeichner={"0","0,25","0,5","0,75","1"};

   for (i=0;i<anzahl;i++) {
    funktionen[i]=getImage(getDocumentBase(),"formeln/"+funktionenbilder[i]);
   }

   for (i=0;i<anzahlgroessen;i++) {
     bezeichner[i]=elementbezeichner[i];
   }
   for (i=0;i<anzahlwerte;i++) {
     bezeichnung[i]=achsenbezeichner[i];
   }

   //Werte fuer A
   for (i=0;i<anfanga;i++)
     wert[0][i]=0;
   for (i=anfanga;i<endea;i++)
     wert[0][i]=(1/(double)(endea-anfanga))*(double)(i-anfanga);
   for (i=endea;i<breite2;i++)
     wert[0][i]=1;

   //Werte fuer B
   for (i=0;i<abstand2;i++)
     wert[1][i]=0;
   for (i=anfangb;i<mittelb;i++)
     wert[1][i]=(1/(double)(mittelb-anfangb))*(double)(i-anfangb);
   for (i=mittelb;i<endeb;i++)
     wert[1][i]=1-(1/(double)(endeb-mittelb)*(double)(i-mittelb));
   for (i=endeb;i<breite2;i++)
     wert[1][i]=0;

   //Parameter und Grenzen fuer den Parameter und die entsprechenden
   //Texte fuer die Textfelder werden fuer die uebergebene Funktion
   //gesetzt, die durch den Wert von "funktion" repraesentiert wird
   String funktionstring = getParameter("funktion");
   funktion=Integer.parseInt(funktionstring);
   switch (funktion) {
   case 0:
     unten=0;
     oben=unendlich;
     paramstring="gamma";
     untenstring="0";
     break;

   case 1:
     unten=0;
     oben=unendlich;
     paramstring="s";
     //Der Wert 1 darf als Parameterwert nicht zugelassen werden
     mitte=1;
     ausnahme=true;
     untenstring="0";
     parameter=.5;
     tf.setText("0.5");
     break;

   case 2:
     unten=0;
     oben=unendlich;
     paramstring="omega";
     untenstring="0";
     break;

   case 3:
     unten=0;
     oben=1;
     paramstring="alpha";
     untenstring="0";
Erläuterungen zu den Interaktionsmöglichkeiten               64

     obenstring="1";
     parameter=.5;
     tf.setText("0.5");
     break;

   case 4:
     unten=0;
     oben=unendlich;
     paramstring="lambda";
     untenstring="0";
     break;

   case 5:
     unten=minusunendlich;
     oben=0;
     mitte=0;
     ausnahme=true;
     paramstring="p";
     break;

   case 6:
     unten=0;
     oben=unendlich;
     paramstring="gamma";
     untenstring="0";
     break;

   case 7:
     unten=0;
     oben=unendlich;
     paramstring="s";
     untenstring="0";
     mitte=1;
     ausnahme=true;
     parameter=.5;
     tf.setText("0.5");
     break;

   case 8:
     unten=0;
     oben=unendlich;
     paramstring="omega";
     untenstring="0";
     break;

   case 9:
     unten=0;
     oben=1;
     paramstring="alpha";
     untenstring="0";
     obenstring="1";
     parameter=.5;
     tf.setText("0.5");
     break;

   case 10:
     unten=0;
     oben=unendlich;
     paramstring="lambda";
     untenstring="0";
     break;

   case 11:
     unten=minusunendlich;
     oben=0;
     paramstring="p";
     mitte=0;
     ausnahme=true;
     break;
   }

   setBackground(Color.white);
   setLayout(new FlowLayout(FlowLayout.LEFT));
   lb1.setText("Bitte Wert für "+paramstring+" angeben!");
   lb.setText(paramstring+":");
   add(lb);
   add(tf);
   add(lb1);
Erläuterungen zu den Interaktionsmöglichkeiten                               65

     tf.addActionListener(this);
 }




 public void actionPerformed(ActionEvent evt) {
   double i;

     //Wird der Wert im Textfeld geaendert...
     if (evt.getSource()==tf) {
       //...wird geprueft, ob er numerisch ist...
       try {
         Double j = new Double(tf.getText());
         i=j.doubleValue();
         //...und im erlaubten Bereich liegt
         if (((i<=unten) && (unten!=minusunendlich))
            || ((i>=oben) && (oben!=unendlich))
            || ((i==mitte) && (ausnahme==true))) {
           if((i<=unten) && (unten!=minusunendlich)) {
             lb1.setText("Wert muss größer als "+untenstring+" sein");
           }
           else {
             if ((i>=oben) && (oben!=unendlich)) {
               lb1.setText("Wert muss kleiner als "+obenstring+" sein");
             }
             else {
               lb1.setText("Wert muss ungleich "+mitte+" sein");
             }
           }
         }
         else {
           //falls alles korrekt, wird neuer Wert gesetzt und Fkt. gezeichnet
           lb1.setText("OK");
           parameter=i;
           repaint();
         }
       }
       catch (NumberFormatException e) {
         lb1.setText("Keine Zahl angegeben");
       }
     }
 }


 //Berechnungen der vers. moeglichen Funktionen
 public double hamacher(double a,double b) {
   double ergebnis;

     ergebnis=a*b/(parameter+(1-parameter)*(a+b-a*b));

     return ergebnis;
 }



 public double frank(double a, double b) {
   double ergebnis;

     ergebnis=Math.log((Math.pow(parameter,a)-1)*(Math.pow(parameter,b)-1)
                      /(parameter-1)+1)/Math.log(parameter);

     return ergebnis;
 }




 public double yager(double a, double b) {
   double ergebnis;
   double faktor=1;

     //Transformation der Eingabedaten auf einen anderen Bereich zur Vermeidung
     //von Rundungsfehlern (die Werte werden groeßer, damit bei der Poten-
     //zierung mit hohen Parameterwerten keine Null als Ergebnis berechnet wird
     if ((1-a!=0) || (1-b!=0)) {
       if (1-a>1-b) faktor=1/(1-a);
Erläuterungen zu den Interaktionsmöglichkeiten                              66

         else faktor=1/(1-b);
     }

     ergebnis=1*faktor-Math.min(1*faktor,
                              Math.pow(Math.pow((1-a)*faktor,parameter)+
                                        Math.pow((1-b)*faktor,parameter),
                                        1/parameter));

     return ergebnis/faktor;
 }



 public double dubois(double a, double b) {
   double ergebnis;

     ergebnis=a*b/Math.max(a,Math.max(b,parameter));

     return ergebnis;
 }



 public double dombi(double a, double b) {
   double ergebnis;
   double faktor=1;

     //Transformation der Eingabedaten auf einen anderen Bereich zur Vermeidung
     //von Rundungsfehlern
     if ((a!=0) && (b!=0)) {
       if (1/a-1>1/b-1) faktor=1/(1/a-1);
       else
        faktor=1/(1/b-1);
     }

     if ((a==0) || (b==0))
       ergebnis=0;
     else
       ergebnis=1/(1+Math.pow(Math.pow(faktor*(1/a-1),parameter)
                +Math.pow(faktor*(1/b-1),parameter),1/parameter)/faktor);

     return ergebnis;
 }



 public double schweizer(double a, double b) {
   double ergebnis;

     if ((a==0) || (b==0)) {
       ergebnis=0;
     }
     else {
       ergebnis=Math.pow(Math.max(0,Math.pow(a,(-parameter))+
                                Math.pow(b,(-parameter))-1),
                       (-1)/parameter);
     }

     return ergebnis;
 }



 public double hamachervereinigung(double a,double b) {
   double ergebnis;

     ergebnis=(a+b-(2-parameter)*a*b)/(1-(1-parameter)*a*b);

     return ergebnis;
 }



 public double frankvereinigung(double a, double b) {
   double ergebnis;

     ergebnis=1-Math.log((Math.pow(parameter,1-a)-1)*(Math.pow(parameter,1-b)-1)
                      /(parameter-1)+1)/Math.log(parameter);
Erläuterungen zu den Interaktionsmöglichkeiten                                67


     return ergebnis;
 }




 public double yagervereinigung(double a, double b) {
   double ergebnis;
   double faktor=1;

     //Transformation der Eingabedaten auf einen anderen Bereich zur Vermeidung
     //von Rundungsfehlern
     if ((a!=0) || (b!=0)) {
       if (a>b) faktor=1/a;
       else
        faktor=1/b;
     }

     ergebnis=Math.min(1*faktor,Math.pow(Math.pow(a*faktor,parameter)+
                                Math.pow(b*faktor,parameter),1/parameter));

     return ergebnis/faktor;
 }



 public double duboisvereinigung(double a, double b) {
   double ergebnis;

     ergebnis=(a+b-a*b-Math.min(a,Math.min(b,1-parameter)))/
              Math.max(1-a,Math.max(1-b,parameter));

     return ergebnis;
 }



 public double dombivereinigung(double a, double b) {
   double ergebnis;

     if ((a==0) || (b==0)) {
       ergebnis=a+b;
     }
     else {
       if ((a==1) || (b==1)) {
         ergebnis=1;
       }
       else {
         ergebnis=1/(1+Math.pow(Math.pow(1/a-1,(-parameter))+
                               Math.pow(1/b-1,(-parameter)),
                               1/(-parameter)));
         if (parameter>=200) ergebnis=Math.max(a,b);
       }
     }

     return ergebnis;
 }



 public double schweizervereinigung(double a, double b) {
   double ergebnis;

     if ((a==1) || (b==1)) {
       ergebnis=1;
     }
     else {
       ergebnis=1-Math.pow(Math.max(0,Math.pow(1-a,(-parameter))+
                                  Math.pow(1-b,(-parameter))-1),
                         (-1)/parameter);
     }

     return ergebnis;
 }
Erläuterungen zu den Interaktionsmöglichkeiten                           68

 public void paint(Graphics g) {
   int i,j;
   //k ist Groeße fuer die Aufloesung
   final int k=1;
   int farbe;
   int fktwert1,fktwert2;

   bilderkoordsystem b = new bilderkoordsystem(g);

   b.koordSystemZeichnen(g, xnull, ynull1, breite, hoehe1, abstand,
                       anzahlwerte, bezeichnung);
   b.vertikalBeschriftung(g,xnull,ynull1+hoehe1,abstand,anzahlwerte-1,
                        bezeichnung);

   //Fuer alle Werte aus [0,1]x[0,1] werden die Werte der gewuenschten
   //Funktion berechnet und in einer Graufaerbung widergegeben
   switch (funktion) {
   case 0:
     for (j=k+1;j<=breite-b.tiefer;j=j+k) {
       for (i=1;i<=(anzahlwerte-1)*abstand;i=i+k) {
         farbe=(int)((1-hamacher((double)i/((anzahlwerte-1)*abstand),
                               (double)j/(breite-b.tiefer)))*255);
         g.setColor(new Color(farbe,farbe,farbe));
         g.fillRect(xnull+i,ynull1+hoehe1-j,k,k);
       }
     }
     break;

   case 1:
     for (j=k+1;j<=breite-b.tiefer;j=j+k) {
       for (i=1;i<=(anzahlwerte-1)*abstand;i=i+k) {
         farbe=(int)((1-frank((double)i/((anzahlwerte-1)*abstand),
                             (double)j/(breite-b.tiefer)))*255);
         g.setColor(new Color(farbe,farbe,farbe));
         g.fillRect(xnull+i,ynull1+hoehe1-j,k,k);
       }
     }
     break;

   case 2:
     for (j=k+1;j<=breite-b.tiefer;j=j+k) {
       for (i=1;i<=(anzahlwerte-1)*abstand;i=i+k) {
         farbe=(int)((1-yager((double)i/((anzahlwerte-1)*abstand),
                             (double)j/(breite-b.tiefer)))*255);
         g.setColor(new Color(farbe,farbe,farbe));
         g.fillRect(xnull+i,ynull1+hoehe1-j,k,k);
       }
     }
     break;

   case 3:
     for (j=k+1;j<=breite-b.tiefer;j=j+k) {
       for (i=1;i<=(anzahlwerte-1)*abstand;i=i+k) {
         farbe=(int)((1-dubois((double)i/((anzahlwerte-1)*abstand),
                             (double)j/(breite-b.tiefer)))*255);
         g.setColor(new Color(farbe,farbe,farbe));
         g.fillRect(xnull+i,ynull1+hoehe1-j,k,k);
       }
     }
     break;

   case 4:
     for (j=k+1;j<=breite-b.tiefer;j=j+k) {
       for (i=1;i<=(anzahlwerte-1)*abstand;i=i+k) {
         farbe=(int)((1-dombi((double)i/((anzahlwerte-1)*abstand),
                             (double)j/(breite-b.tiefer)))*255);
         g.setColor(new Color(farbe,farbe,farbe));
         g.fillRect(xnull+i,ynull1+hoehe1-j,k,k);
       }
     }
     break;

   case 5:
     for (j=k+1;j<=breite-b.tiefer;j=j+k) {
      for (i=1;i<=(anzahlwerte-1)*abstand;i=i+k) {
        farbe=(int)((1-schweizer((double)i/((anzahlwerte-1)*abstand),
                            (double)j/(breite-b.tiefer)))*255);
        g.setColor(new Color(farbe,farbe,farbe));
Erläuterungen zu den Interaktionsmöglichkeiten                69

           g.fillRect(xnull+i,ynull1+hoehe1-j,k,k);
       }
     }
     break;

   case 6:
     for (j=k+1;j<=breite-b.tiefer;j=j+k) {
       for (i=1;i<=(anzahlwerte-1)*abstand;i=i+k) {
         farbe=(int)((1-hamachervereinigung(
                       (double)i/((anzahlwerte-1)*abstand),
                     (double)j/(breite-b.tiefer)))*255);
         g.setColor(new Color(farbe,farbe,farbe));
         g.fillRect(xnull+i,ynull1+hoehe1-j,k,k);
       }
     }
     break;

   case 7:
     for (j=k+1;j<=breite-b.tiefer;j=j+k) {
       for (i=1;i<=(anzahlwerte-1)*abstand;i=i+k) {
         farbe=(int)((1-frankvereinigung(
                       (double)i/((anzahlwerte-1)*abstand),
                     (double)j/(breite-b.tiefer)))*255);
         g.setColor(new Color(farbe,farbe,farbe));
         g.fillRect(xnull+i,ynull1+hoehe1-j,k,k);
       }
     }
     break;

   case 8:
     for (j=k+1;j<=breite-b.tiefer;j=j+k) {
       for (i=1;i<=(anzahlwerte-1)*abstand;i=i+k) {
         farbe=(int)((1-yagervereinigung(
                       (double)i/((anzahlwerte-1)*abstand),
                     (double)j/(breite-b.tiefer)))*255);
         g.setColor(new Color(farbe,farbe,farbe));
         g.fillRect(xnull+i,ynull1+hoehe1-j,k,k);
       }
     }
     break;

   case 9:
     for (j=k+1;j<=breite-b.tiefer;j=j+k) {
       for (i=1;i<=(anzahlwerte-1)*abstand;i=i+k) {
         farbe=(int)((1-duboisvereinigung(
                       (double)i/((anzahlwerte-1)*abstand),
                     (double)j/(breite-b.tiefer)))*255);
         g.setColor(new Color(farbe,farbe,farbe));
         g.fillRect(xnull+i,ynull1+hoehe1-j,k,k);
       }
     }
     break;

   case 10:
     for (j=k+1;j<=breite-b.tiefer;j=j+k) {
       for (i=1;i<=(anzahlwerte-1)*abstand;i=i+k) {
         farbe=(int)((1-dombivereinigung(
                       (double)i/((anzahlwerte-1)*abstand),
                     (double)j/(breite-b.tiefer)))*255);
         g.setColor(new Color(farbe,farbe,farbe));
         g.fillRect(xnull+i,ynull1+hoehe1-j,k,k);
       }
     }
     break;

   case 11:
     for (j=k+1;j<=breite-b.tiefer;j=j+k) {
       for (i=1;i<=(anzahlwerte-1)*abstand;i=i+k) {
         farbe=(int)((1-schweizervereinigung(
                       (double)i/((anzahlwerte-1)*abstand),
                     (double)j/(breite-b.tiefer)))*255);
         g.setColor(new Color(farbe,farbe,farbe));
         g.fillRect(xnull+i,ynull1+hoehe1-j,k,k);
       }
     }
     break;

   default:
Erläuterungen zu den Interaktionsmöglichkeiten                              70

       g.drawString("Fehler",xnull+breite/2,ynull1+hoehe1/2);
   }

   //Bezeichnungen der Achsen und der Funktion
   g.drawImage(funktionen[anzahl-1],xnull-b.tiefer,ynull1-25,this);
   g.drawImage(funktionen[anzahl-2],xnull+breite,ynull1+hoehe1+5,this);
   g.drawImage(funktionen[funktion],xnull+breite/2,ynull1-20,this);



   //Zeichnen der Abbildung ueber den Mengen
   b.koordSystemZeichnen(g, xnull2, ynull2, breite2, hoehe2, abstand2,
                       anzahlgroessen, bezeichner);

   //Zug.fkt. zur Menge A wird immer angezeigt
   g.drawString("Größe in m",xnull2+(anzahlgroessen-1)*abstand2+abstand2/2,
               ynull2+hoehe2+b.tiefer);
   g.setColor(Color.blue);
   g.drawString("groß",xnull2+5*abstand2+5,ynull2+hoehe2/2);
   fktwert1=(int)(ynull2+hoehe2-wert[0][0]*(hoehe2-b.tiefer)-1);
   for(i=1;i<=abstand2*(anzahlgroessen-1);i++) {
     fktwert2=(int)(ynull2+hoehe2-wert[0][i]*(hoehe2-b.tiefer)-1);
     g.drawLine(xnull2+i-1,fktwert1,xnull2+i,fktwert2);
     fktwert1=fktwert2;
   }

   //Menge B wird immer angezeigt
   g.setColor(Color.gray);
   g.drawString("mittelgroß",xnull2+20,ynull2+hoehe2/2);
   fktwert1=(int)(ynull2+hoehe2-wert[1][0]*(hoehe2-b.tiefer)+1);
   for(i=1;i<=abstand2*(anzahlgroessen-1);i++) {
     fktwert2=(int)(ynull2+hoehe2-wert[1][i]*(hoehe2-b.tiefer)+1);
     g.drawLine(xnull2+i-1,fktwert1,xnull2+i,fktwert2);
     fktwert1=fktwert2;
   }

   //Zeichnen der uebergebenen Funktion ueber den Mengen "mittelgroß"
   //und "groß"
   g.setColor(Color.red);
   switch(funktion) {
   case 0:
     g.drawString("Hamacherdurchschnitt",xnull2+10,ynull2+b.tiefer);
     fktwert1=(int)(ynull2+hoehe2-hamacher(wert[0][0],wert[1][0])
                   *(hoehe2-b.tiefer));
     for(i=1;i<breite2;i++) {
       fktwert2=(int)(ynull2+hoehe2-hamacher(wert[0][i],wert[1][i])
                     *(hoehe2-b.tiefer));
       g.drawLine(xnull2+i-1,fktwert1,xnull2+i,fktwert2);
       fktwert1=fktwert2;
     }
     break;

   case 1:
     g.drawString("Frankdurchschnitt",xnull2+10,ynull2+b.tiefer);
     fktwert1=(int)(ynull2+hoehe2-frank(wert[0][0],wert[1][0])
                   *(hoehe2-b.tiefer));
     for(i=1;i<breite2;i++) {
       fktwert2=(int)(ynull2+hoehe2-frank(wert[0][i],wert[1][i])
                     *(hoehe2-b.tiefer));
       g.drawLine(xnull2+i-1,fktwert1,xnull2+i,fktwert2);
       fktwert1=fktwert2;
     }
     break;

   case 2:
     g.drawString("Yagerdurchschnitt",xnull2+10,ynull2+b.tiefer);
     fktwert1=(int)(ynull2+hoehe2-yager(wert[0][0],wert[1][0])
                   *(hoehe2-b.tiefer));
     for(i=1;i<breite2;i++) {
       fktwert2=(int)(ynull2+hoehe2-yager(wert[0][i],wert[1][i])
                     *(hoehe2-b.tiefer));
       g.drawLine(xnull2+i-1,fktwert1,xnull2+i,fktwert2);
       fktwert1=fktwert2;
     }
     break;

   case 3:
     g.drawString("Dubois-Prade-Durchschnitt",xnull2+10,ynull2+b.tiefer);
Erläuterungen zu den Interaktionsmöglichkeiten                           71

     fktwert1=(int)(ynull2+hoehe2-dubois(wert[0][0],wert[1][0])
                   *(hoehe2-b.tiefer));
     for(i=1;i<breite2;i++) {
       fktwert2=(int)(ynull2+hoehe2-dubois(wert[0][i],wert[1][i])
                     *(hoehe2-b.tiefer));
       g.drawLine(xnull2+i-1,fktwert1,xnull2+i,fktwert2);
       fktwert1=fktwert2;
     }
     break;

   case 4:
     g.drawString("Dombidurchschnitt",xnull2+10,ynull2+b.tiefer);
     fktwert1=(int)(ynull2+hoehe2-dombi(wert[0][0],wert[1][0])
                   *(hoehe2-b.tiefer));
     for(i=1;i<breite2;i++) {
       fktwert2=(int)(ynull2+hoehe2-dombi(wert[0][i],wert[1][i])
                     *(hoehe2-b.tiefer));
       g.drawLine(xnull2+i-1,fktwert1,xnull2+i,fktwert2);
       fktwert1=fktwert2;
     }
     break;

   case 5:
     g.drawString("Schweizer-Sklar-Durchschnitt",xnull2+10,ynull2+b.tiefer);
     fktwert1=(int)(ynull2+hoehe2-schweizer(wert[0][0],wert[1][0])
                   *(hoehe2-b.tiefer));
     for(i=1;i<breite2;i++) {
       fktwert2=(int)(ynull2+hoehe2-schweizer(wert[0][i],wert[1][i])
                     *(hoehe2-b.tiefer));
       g.drawLine(xnull2+i-1,fktwert1,xnull2+i,fktwert2);
       fktwert1=fktwert2;
     }
     break;

   case 6:
     g.drawString("Hamachervereinigung",xnull2+10,ynull2+b.tiefer);
     fktwert1=(int)(ynull2+hoehe2-hamachervereinigung(wert[0][0],wert[1][0])
                   *(hoehe2-b.tiefer));
     for(i=1;i<breite2;i++) {
       fktwert2=(int)(ynull2+hoehe2-hamachervereinigung(wert[0][i],wert[1][i])
                     *(hoehe2-b.tiefer));
       g.drawLine(xnull2+i-1,fktwert1,xnull2+i,fktwert2);
       fktwert1=fktwert2;
     }
     break;

   case 7:
     g.drawString("Frankvereinigung",xnull2+10,ynull2+b.tiefer);
     fktwert1=(int)(ynull2+hoehe2-frankvereinigung(wert[0][0],wert[1][0])
                   *(hoehe2-b.tiefer));
     for(i=1;i<breite2;i++) {
       fktwert2=(int)(ynull2+hoehe2-frankvereinigung(wert[0][i],wert[1][i])
                     *(hoehe2-b.tiefer));
       g.drawLine(xnull2+i-1,fktwert1,xnull2+i,fktwert2);
       fktwert1=fktwert2;
     }
     break;

   case 8:
     g.drawString("Yagervereinigung",xnull2+10,ynull2+b.tiefer);
     fktwert1=(int)(ynull2+hoehe2-yagervereinigung(wert[0][0],wert[1][0])
                   *(hoehe2-b.tiefer));
     for(i=1;i<breite2;i++) {
       fktwert2=(int)(ynull2+hoehe2-yagervereinigung(wert[0][i],wert[1][i])
                     *(hoehe2-b.tiefer));
       g.drawLine(xnull2+i-1,fktwert1,xnull2+i,fktwert2);
       fktwert1=fktwert2;
     }
     break;

   case 9:
     g.drawString("Dubois-Prade-Vereinigung",xnull2+10,ynull2+b.tiefer);
     fktwert1=(int)(ynull2+hoehe2-duboisvereinigung(wert[0][0],wert[1][0])
                   *(hoehe2-b.tiefer));
     for(i=1;i<breite2;i++) {
      fktwert2=(int)(ynull2+hoehe2-duboisvereinigung(wert[0][i],wert[1][i])
                     *(hoehe2-b.tiefer));
      g.drawLine(xnull2+i-1,fktwert1,xnull2+i,fktwert2);
Erläuterungen zu den Interaktionsmöglichkeiten                                72

            fktwert1=fktwert2;
          }
          break;

        case 10:
          g.drawString("Dombivereinigung",xnull2+10,ynull2+b.tiefer);
          fktwert1=(int)(ynull2+hoehe2-dombivereinigung(wert[0][0],wert[1][0])
                        *(hoehe2-b.tiefer));
          for(i=1;i<breite2;i++) {
            fktwert2=(int)(ynull2+hoehe2-dombivereinigung(wert[0][i],wert[1][i])
                          *(hoehe2-b.tiefer));
            g.drawLine(xnull2+i-1,fktwert1,xnull2+i,fktwert2);
            fktwert1=fktwert2;
          }
          break;

        case 11:
          g.drawString("Schweizer-Sklar-Vereinigung",xnull2+10,ynull2+b.tiefer);
          fktwert1=(int)(ynull2+hoehe2-schweizervereinigung(wert[0][0],wert[1][0])
                        *(hoehe2-b.tiefer));
          for(i=1;i<breite2;i++) {
            fktwert2=(int)(ynull2+hoehe2-schweizervereinigung(wert[0][i],
                          wert[1][i])*(hoehe2-b.tiefer));
            g.drawLine(xnull2+i-1,fktwert1,xnull2+i,fktwert2);
            fktwert1=fktwert2;
          }
          break;

        default:
          g.drawString("Fehler!",0,ynull2);
        }
    }
}




5.8 Die Applets zum Zeichnen von Funktionsgraphen

Im Gegensatz zu den übrigen Programmen fordern die Applets „voegel.java“,
„badewasser.java“, „cazwei.java“, „komplement1.java“, „komplement2.java“
und „komplement3.java“ nicht zur Interaktivität auf und verkörpern daher
keine Programme im ursprünglichen Sinne. In diesem Fall wurde die
Appletprogrammierung nur zur Erstellung einzelner Funktionsgraphen
verwendet.         Die    dazu    nötige      und   häufig    gebrauchte     Klasse
„bilderkoordsystem.java“ im Programmpaket (Package) „ksys“ dient ebenfalls
nicht direkt der Interaktion, ist aber Teil der meisten Applets.

5.8.1      Quellcode „voegel.java“
import java.awt.*;
import ksys.*;

//Zeichnet die char. Fkt. der klassischen Menge der Voegel
public class voegel extends java.applet.Applet {

    final int anzahl=8;
    //Konstanten fuer verschiedene Maße
    final int xnull=20;
    final int ynull=10;
    final int breite=500;
    final int hoehe=150;
Erläuterungen zu den Interaktionsmöglichkeiten                                73

    final int abstand=60;
    final int position=xnull-5;

    //Werte fuer die char. Fkt.
    int spruenge=5;
    int[] trennlinie = new int[spruenge+1];
    int[] wert = new int[spruenge+1];

    String[] tiere = new String[anzahl];

    public void init() {
      int i;

        //Setzen der Werte zum Zeichnen der char. Fkt.
        String[] tierbezeichner={"        Amsel","      Maus","         Papagei",
                               "      Fink","        Elefant",
                               "         Drossel","       Tiger","      Hund"};
        int[] trennlinien={xnull,position+abstand,position+2*abstand,
                          position+4*abstand,position+5*abstand,
                          position+6*abstand};
        int[] werte={1,0,1,0,1,0};

        for (i=0;i<anzahl;i++) {
          tiere[i]=tierbezeichner[i];
        }

        for (i=0;i<spruenge;i++) {
          trennlinie[i]=trennlinien[i];
          wert[i]=werte[i];
        }
        trennlinie[spruenge]=trennlinien[spruenge];

        setBackground(Color.white);
    }

    public void paint(Graphics g) {

        bilderkoordsystem b = new bilderkoordsystem(g);

        //Zeichnen der char. Fkt.
        b.koordSystemZeichnen(g,xnull,ynull,breite,hoehe,abstand,anzahl,tiere);
        g.setColor(Color.red);
        b.charFkt(g,trennlinie,spruenge,ynull+b.tiefer,breite-20,
                 hoehe-b.tiefer,wert);
    }
}




5.8.2      Quellcode „badewasser.java“
import java.lang.Math.*;
import java.awt.*;
import ksys.*;

//Stellt die char. und Zugehoerigkeitsfunktion von idealem Badewasser dar
public class badewasser extends java.applet.Applet {

    final int anzahl=6;
    //Konstanten fuer verschiedene Maße
    final int xnull=20;
    final int ynull=10;
    final int breite=500;
    final int hoehe=150;
    final int abstand=80;

    //Werte zum Zeichnen der char. Fkt.
    int spruenge=2;
    int[] trennlinie = new int[spruenge+1];
    int[] wert = new int[spruenge+1];

    String[] skala = new String[anzahl];


    public void init() {
      int i;
Erläuterungen zu den Interaktionsmöglichkeiten                                74


        //Werte fuer char. Fkt. werden gesetzt
        String[] temperatur={"25","30","35","40","45","50"};
        int[] trennlinien={xnull,xnull+(int)(1.5*abstand),
                          xnull+(int)(3.5*abstand)};
        int[] werte={0,1,0};

        for (i=0;i<anzahl;i++) {
          skala[i]=temperatur[i];
        }

        for (i=0;i<spruenge;i++) {
          trennlinie[i]=trennlinien[i];
          wert[i]=werte[i];
        }
        trennlinie[spruenge]=trennlinien[spruenge];

        setBackground(Color.white);
    }


    public int f(int x) {
      //Berechnet die gaußsche Glockenkurve als Zugehoerigkeitsfkt.
      final double mue=xnull+2.5*abstand;
      final double sigma=50;
      double fktwert;
      int ergebnis;


        fktwert=Math.exp(-(Math.pow(x-mue,2)/(2*Math.pow(sigma,2))));

        //Die Werte der Funktion werden auf die Hoehe des Koord.kreuzes gestreckt
        ergebnis=(int)(fktwert*(hoehe-bilderkoordsystem.tieferst));

        return ynull+hoehe-ergebnis;
    }



    public void paint(Graphics g) {
      int i;
      int f1,f2;

        bilderkoordsystem b = new bilderkoordsystem(g);

        //Zeichnen des Koord.systems
        b.koordSystemZeichnen(g,xnull,ynull,breite,hoehe,abstand,anzahl,skala);
        g.drawString("Temperatur in Grad Celsius",breite-170,ynull+hoehe+25);
        //char. Fkt. zeichnen
        g.setColor(Color.red);
        b.charFkt(g,trennlinie,spruenge,ynull+b.tiefer,breite-20,
                 hoehe-b.tiefer,wert);


        //Zeichnen der Zugeh.fkt. mit Hilfe der Funktion f
        //um ein Pixel gegenueber der char. Fkt. nach oben versetzt
        g.setColor(Color.blue);
        f1=f(xnull)-1;
        for (i=xnull;i<breite;i++) {
          f2=f(i+1)-1;
          g.drawLine(i,f1,i+1,f2);
          f1=f2;
        }
    }
}




5.8.3      Quellcode „cazwei.java“
import java.awt.*;
import ksys.*;

//Zeichnet Darstellung der Fuzzy-Menge "ungefaher 2"
Erläuterungen zu den Interaktionsmöglichkeiten                                75

public class cazwei extends java.applet.Applet {

    final int anzahl=4;
    //Konstanten fuer verschiedene Maße
    final int xnull=20;
    final int ynull=10;
    final int breite=200;
    final int hoehe=150;
    final int abstand=60;
    final int xnull2=xnull+breite+20;

    String[] zahlen = {"0","1","2","3"};

    public void init() {

            setBackground(Color.white);
    }

    public void paint(Graphics g) {

        bilderkoordsystem b = new bilderkoordsystem(g);

        b.koordSystemZeichnen(g,xnull,ynull,breite,hoehe,abstand,anzahl,zahlen);
        b.koordSystemZeichnen(g,xnull2,ynull,breite,hoehe,abstand,anzahl,zahlen);
        g.setColor(Color.red);

        //Zeichnen der crispen Menge "2"
        g.fillOval(xnull2+2*abstand-2,ynull-2+b.tiefer,4,4);

        //Zeichnen der Zugehoerigkeitsfkt. "ungefaehr 2"
        g.drawLine(xnull+abstand,ynull+hoehe,xnull+2*abstand,
                  ynull+b.tiefer);
        g.drawLine(xnull+2*abstand,ynull+b.tiefer,xnull+3*abstand,
                  ynull+hoehe);

    }
}




5.8.4      Quellcode „komplement1.java“
import java.awt.*;
import ksys.*;

//Zeichnet eine nicht stetige und nicht involutive Komplementfunktion
public class komplement1 extends java.applet.Applet {

    final int anzahl=5;
    //Konstanten fuer verschiedene Maße
    final int xnull=50;
    final int ynull=15;
    final int breite=200;
    final int hoehe=breite;
    final int abstand=(breite-bilderkoordsystem.tieferst)/(anzahl-1);

    String[] skala = new String[anzahl];

    public void init() {
      int i;

        //Werte fuer char. Fkt. werden gesetzt
        String[] werte={"0","0.25","0.5","0.75","1"};

        for (i=0;i<anzahl;i++) {
          skala[i]=werte[i];
        }

        setBackground(Color.white);
    }




    public void paint(Graphics g) {
Erläuterungen zu den Interaktionsmöglichkeiten                                76

        bilderkoordsystem b = new bilderkoordsystem(g);

        //Zeichnen des Koord.systems
        b.koordSystemZeichnen(g,xnull,ynull,breite,hoehe,abstand,anzahl,skala);
        b.vertikalBeschriftung(g,xnull,ynull+hoehe,abstand,anzahl-1,skala);
        b.einteilung(g,xnull,ynull+hoehe,abstand,anzahl);
        g.drawString("a",xnull+breite+2,ynull+hoehe+5);
        //Zeichnen der Zugeh.fkt.
        g.setColor(Color.red);
        g.drawString("c(a)",xnull-5,ynull-2);
        g.drawLine(xnull,ynull+b.tiefer,xnull+2*abstand,ynull+b.tiefer);
        g.drawLine(xnull+2*abstand,ynull+hoehe-1,
                  xnull+(anzahl-1)*abstand,ynull+hoehe-1);
        //Winkelhalbierende
        g.setColor(Color.lightGray);
        g.drawLine(xnull,ynull+hoehe,xnull+(anzahl-1)*abstand,ynull+b.tiefer);
    }
}




5.8.5      Quellcode „komplement2.java“
import java.awt.*;
import ksys.*;

//Zeichnet eine stetige und involutive Komplementfunktion
public class komplement2 extends java.applet.Applet {

    final int anzahl=4;
    //Konstanten fuer verschiedene Maße
    final int xnull=50;
    final int ynull=15;
    final int breite=200;
    final int hoehe=200;
    final int abstand=(breite-bilderkoordsystem.tieferst)/(anzahl-1);

    String[] skala = new String[anzahl];

    public void init() {
      int i;

        //Werte fuer char. Fkt. werden gesetzt
        String[] werte={"0","0.33","0.67","1"};

        for (i=0;i<anzahl;i++) {
          skala[i]=werte[i];
        }

        setBackground(Color.white);
    }




    public void paint(Graphics g) {

        bilderkoordsystem b = new bilderkoordsystem(g);

        //Zeichnen des Koord.systems
        b.koordSystemZeichnen(g,xnull,ynull,breite,hoehe,abstand,anzahl,skala);
        b.vertikalBeschriftung(g,xnull,ynull+hoehe,abstand,anzahl-1,skala);
        b.einteilung(g,xnull,ynull+hoehe,abstand,anzahl);
        g.drawString("c(a)",xnull-5,ynull-2);
        g.drawString("a",xnull+breite+2,ynull+hoehe+5);
        //Zeichnen der Zugeh.fkt.
        g.setColor(Color.red);
        g.drawLine(xnull,ynull+b.tiefer,xnull+abstand,
                  ynull+hoehe-(hoehe-b.tiefer)/3);
        g.drawLine(xnull+abstand,ynull+hoehe-(hoehe-b.tiefer)/3,
                  xnull+(anzahl-1)*abstand,ynull+hoehe-1);
        //Winkelhalbierende
        g.setColor(Color.lightGray);
        g.drawLine(xnull,ynull+hoehe,xnull+(anzahl-1)*abstand,ynull+b.tiefer);
    }
}
Erläuterungen zu den Interaktionsmöglichkeiten                                77




5.8.6      Quellcode „komplement3.java“
import java.lang.Math.*;
import java.awt.*;
import ksys.*;

//Zeichnet eine nicht involutive aber stetige Komplementfunktion
public class komplement3 extends java.applet.Applet {

    final int anzahl=5;
    //Konstanten fuer verschiedene Maße
    final int xnull=50;
    final int ynull=15;
    final int breite=200;
    final int hoehe=200;
    final int abstand=(breite-bilderkoordsystem.tieferst)/(anzahl-1);

    String[] skala = new String[anzahl];

    public void init() {
      int i;

        //Werte fuer char. Fkt. werden gesetzt
        String[] werte={"0","0.25","0.50","0.75","1"};

        for (i=0;i<anzahl;i++) {
          skala[i]=werte[i];
        }

        setBackground(Color.white);
    }


    public int c(int a) {
      double fktwert,x;
      int ergebnis;

        x=(a/(double)((anzahl-1)*abstand));
        fktwert=(double)1/2*(1+Math.cos(Math.PI*x));
        ergebnis=(int)(ynull+hoehe-fktwert*(hoehe-bilderkoordsystem.tieferst));
        return ergebnis;
    }



    public void paint(Graphics g) {
      int i;
      int f1, f2;

        bilderkoordsystem b = new bilderkoordsystem(g);

        //Zeichnen des Koord.systems
        b.koordSystemZeichnen(g,xnull,ynull,breite,hoehe,abstand,anzahl,skala);
        b.vertikalBeschriftung(g,xnull,ynull+hoehe,abstand,anzahl-1,skala);
        b.einteilung(g,xnull,ynull+hoehe,abstand,anzahl);
        g.drawString("c(a)",xnull-5,ynull-2);
        g.drawString("a",xnull+breite+2,ynull+hoehe+5);
        //Zeichnen der Zugeh.fkt.
        g.setColor(Color.red);
        f1=c(0);
        for(i=xnull;i<xnull+(anzahl-1)*abstand;i++) {
          f2=c(i+1-xnull);
          g.drawLine(i,f1,i+1,f2);
          f1=f2;
        }
        //Winkelhalbierende
        g.setColor(Color.lightGray);
        g.drawLine(xnull,ynull+hoehe,xnull+(anzahl-1)*abstand,ynull+b.tiefer);
    }
}
Erläuterungen zu den Interaktionsmöglichkeiten                              78


5.9 Quellcode „bilderkoordsystem.java“

package ksys;

import java.awt.*;

//Stellt Methoden zum Zeichnen von Koordinatensystemen und Funktionen zur
//Verfuegung
public class bilderkoordsystem extends java.applet.Applet {

 static public int pfeillaenge=10; //Laenge des Pfeils an den Achsen
 static public int tieferst=pfeillaenge+3; //Der maximale Fkt.wert liegt
 //um tiefer unterhalb der y-Pfeilspitze
 public final int tiefer=tieferst;

 Font f = new Font("TimesNewRoman",Font.PLAIN,12);
 FontMetrics fm = getFontMetrics(f);


 public bilderkoordsystem(Graphics g) {}


 //Zeichnet ein Koordinatensystem mit den uebergebenen Bezeichnern unterhalb
 //der x-Aschse
 public void koordSystemZeichnen(Graphics gr, int xnull, int ynull,
                               int breite, int hoehe, int xfaktor,
                               int anzahl,String[] bilder) {
   //xnull=Startpunkt x-Achse
   //ynull=Startpunkt y-Achse
   //breite=Breite der x-Achse
   //hoehe=Hoehe der y-Achse
   //xfaktor=Abstand der Bezeichnerkoordinaten
   //anzahl=Anzahl der Bezeichner
   //bilder=Array mit den Bezeichnern


     int i;

     gr.setColor(Color.black);

     //y-Achse
     gr.drawLine(xnull,ynull,xnull,ynull+hoehe);

     // x-Achse
     gr.drawLine(xnull,ynull+hoehe,xnull+breite,ynull+hoehe);

     // linker Teil des Pfeils an y-Achse
     gr.drawLine(xnull-pfeillaenge,
               ynull+pfeillaenge,xnull,ynull);

     // rechter Teil des Pfeils an y-Achse
     gr.drawLine(xnull+pfeillaenge,ynull+pfeillaenge,xnull,ynull);

     // oberer Teil des Pfeils an x-Achse
     gr.drawLine(xnull+breite-pfeillaenge,ynull+hoehe-pfeillaenge,
               xnull+breite, ynull+hoehe);

     // unterer Teil des Pfeils an x-Achse
     gr.drawLine(xnull+breite-pfeillaenge,ynull+hoehe+pfeillaenge,
               xnull+breite,ynull+hoehe);

     // Markierung der 1
     gr.drawLine(xnull-3,ynull+tiefer,
               xnull+3,ynull+tiefer);

     // Beschriftung der Koordinatenkreuzes
     gr.drawString("1",xnull-10,ynull+pfeillaenge+10);
     gr.drawString("0",xnull-10,ynull+hoehe);

     // die Bezeichner werden unter den Funktionsgraph geschrieben
     for (i=0; i<anzahl; i++) {
       gr.drawString(bilder[i], i*xfaktor+xnull-fm.stringWidth(bilder[i])/2,
                    ynull+hoehe+tiefer);
     }
 }
Erläuterungen zu den Interaktionsmöglichkeiten                           79


 //Erstellt die Beschriftung der y-Achse an einem Koord.kreuz
 public void vertikalBeschriftung(Graphics gr, int xnull, int ynull,
                                int yfaktor, int anzahl,String[] bilder) {
   //xnull=x-Position der y-Achse
   //ynull=y-Pos. des Nullpunktes
   //yfaktor=Abstand zwischen den Bezeichnern
   //anzahl=Anzahl der Bezeichner
   //bilder=Bezeichnerstrings der y-Achse
   int i;

     for (i=1;i<anzahl;i++) {
       gr.drawString(bilder[i],xnull-5-fm.stringWidth(bilder[i]),
                   ynull-yfaktor*i+6);
       gr.drawLine(xnull-2,ynull-yfaktor*i,xnull+2,
                 ynull-yfaktor*i);
     }
 }



 //Skaliert die x-Achse
 public void einteilung(Graphics gr, int xnull, int ynull,
                      int yfaktor, int anzahl) {
   //xnull=x-Position der y-Achse
   //ynull=y-Pos. des Nullpunktes
   //yfaktor=Abstand zwischen den Bezeichnern
   //anzahl=Anzahl der Unterteilungen

     int i;

     for (i=1;i<anzahl;i++) {
       gr.drawLine(xnull+i*yfaktor,ynull+2,xnull+i*yfaktor,ynull-2);
     }
 }




 //Zeichnet die Darstellung einer Fuzzyzahl
 public void fuzzyzahl(Graphics g,int xnull,int ynull,int hoehe,
                     int wert1,int wert2,int wert3,int wert4) {

     //xnull=x-Position der y-Achse
     //ynull=y-Pos. des Nullpunktes
     //hoehe=Hoehe des Koordinatenkreuzes
     //wert1-4=x-Positionen der Fuzzyzahl

     g.drawLine(xnull+wert1,ynull+hoehe,xnull+wert2,ynull+tiefer);
     g.drawLine(xnull+wert2,ynull+tiefer,xnull+wert3,ynull+tiefer);
     g.drawLine(xnull+wert3,ynull+tiefer,xnull+wert4,ynull+hoehe);
 }



 //Zeichnet eine charakteristische Funktion
 public void charFkt(Graphics g, int[] trennlinie, int spruenge,
                    int ynull, int breite, int hoehe, int[] wert) {
   //trennlinie=Array mit Positionen der Spruenge der Funktion
   //(trennlinie[0] ist dabei die Anfangsposition)
   //spruenge=Anzahl der Spruenge der Fkt.
   //ynull=y-Koordinate fuer den Wert 1 der Fkt.
   //breite=Breite der Funktion
   //hoehe=Hoehe der Funktion
   //wert=Array mit den Funktionswerten 0 oder 1

     final int xnull=trennlinie[0];

     int i;


     if (spruenge!=0) {
       for (i=0;i<spruenge;i++) {
        if (wert[i]==0) {
          // Funktionsgraph fuer den Wert Null
          g.drawLine(trennlinie[i], ynull+hoehe,trennlinie[i+1],
                     ynull+hoehe);
        }
Erläuterungen zu den Interaktionsmöglichkeiten                                 80

             else {
               // Funktionsgraph fuer den Wert Eins
               g.drawLine(trennlinie[i],ynull,trennlinie[i+1],ynull);
             }

             //vertikale Linie der char. Funktion
             g.drawLine(trennlinie[i+1],ynull,trennlinie[i+1], ynull+hoehe);
            } //end for
        }

        if (wert[spruenge]==0) {
          // Funktionsgraph fuer den Wert Null
          g.drawLine(trennlinie[spruenge], ynull+hoehe,breite+xnull,
                    ynull+hoehe);
        }
        else {
          // Funktionsgraph fuer den Wert Eins
          g.drawLine(trennlinie[spruenge],ynull,breite+xnull,ynull);
        }


    }

}
Verwendete Hilfsmittel                                                   81



6. Verwendete Hilfsmittel

Als Hilfsmittel, auf die in den unteren Abschnitten noch näher eingegangen
wird, dienten das HTML-Format und die Programmiersprache Java. Auf die
speziell für das Internet entwickelte Sprache JavaScript ist allerdings bewusst
verzichtet worden, denn im Gegensatz zu Java ist diese Sprache weder
softwareunabhängig noch mit den notwendigen Sicherheitsmechanismen
ausgestattet. Softwareunabhängigkeit und Sicherheit sind aber extrem wichtige
Merkmale, die auch für die angefertigte Lernsoftware gelten sollen. Gerade die
Softwareunabhängigkeit ist erforderlich, um die Lernsoftware auf möglichst
vielen Systemen lauffähig zu machen.
Zur Bearbeitung von Bildern wurden die Zeichenprogramme „Corel
PhotoPaint“ und „gimp“ verwendet. Die vorliegenden mathematischen
Formeln sind mit Hilfe des Formelgenerators „lyx“ in Bilddateien umgeformt
worden.


6.1 Das HTML-Format

Mit der so genannten Hypertext Markup Language (HTML) können
Internetseiten angelegt werden, wie es in Kapitel 2 „Allgemeine Anforderungen
an HTML-Dokumente“ beschrieben worden ist. Der Vorteil liegt darin, dass
eine vom eingesetzten Rechner, Monitor und Browser unabhängige
Darstellung erreicht wird. Damit auf allen gängigen Computersystemen das
gewünschte Bild der WWW-Seiten entsteht, wurde nur der Befehlssatz der
HTML-Version 3.2 verwendet. Mittlerweile gibt es zwar den erweiterten
Befehlssatz der Version 4.0, der aber noch nicht als Standard gilt und somit
derartige HTML-Anweisungen auf den meisten Rechnern keine Auswirkungen
hätten. Die Operationen bis zur Version 3.2 bilden dagegen den aktuellen
Standard, so dass die angewandten HTML-Befehle der Version 3.2 auch das
gewünschte Design der Pages auf den gebräuchlichen Systemen liefern.
Der HTML-Code wurde durch direktes Eintippen der Befehle in einen Editor
ohne Verwendung von Entwicklungsprogrammen generiert. Dadurch ist eine
einfache Struktur des Quelltextes garantiert und die Größe der zu ladenden
Verwendete Hilfsmittel                                                            82

Dateien sind somit minimal, so dass wenig Speicher verbraucht wird und
kürzeste Ladezeiten erreicht werden.
Probleme ergeben sich mit dem HTML-Format, wenn mathematische Formeln
erstellt und in den Text eingefügt werden müssen. Aufgrund der Vielzahl der
gebrauchten Formeln sind hinsichtlich dieser Problematik etliche Alternativen
überprüft worden, bevor die Methode angewandt wurde, über den
Formelgenerator „lyx“ die Formeln zu als Bilddatei zu erstellen und diese
Bilder als Graphiken in den Text einzubinden.




6.2 Die Programmiersprache Java

Die objektorientierte Programmiersprache Java bietet sich zum Gebrauch auf
Internetseiten       an.   Neben   der   einfachen     Entwicklung     von    Graphik,
Animationen, Audio, Video und Netzwerkzugriffen „besitzen Java-Programme
die bemerkenswerte Fähigkeit, nach dem Laden übers Netz automatisch
loszulaufen“24. Die scheinbar unbegrenzte Vielfalt an Animation und
Interaktion auf Webseiten ist erst mit der Entwicklung von Java realisierbar
geworden. Wegen der Plattformunabhängigkeit kann jedes Java-Programm
ohne Probleme auf dem Zielrechner ablaufen, was eine Nutzung von
Programmen über das Internet erst möglich macht.
Den Sicherheitsmängeln, die entstehen können, wenn fremde Programme von
außerhalb auf ein anderes Computersystem zugreifen können, ist in
gebührendem Maße Rechnung getragen worden.
Daher sind mittels der Applet-Programmierung in Java alle Animationen und
Interaktionen verwirklicht worden. Die Ladedauer der Applets spielt auch bei
der Menge der bereitgestellten Programme kaum eine Rolle, weil der einmalige
Start des Java-Interpreters25 im Verhältnis erheblich mehr Zeit in Anspruch
nimmt. Da aufgrund der Sicherheitsbestimmungen die Verwendung von Java-
Programmen auf den Zielrechnern deaktiviert werden kann, wird bei einem
Nichtstart eines Applets durch einen speziellen HTML-Befehl auf diesen


24
     siehe Weber 1997 (S. 10)
25
     Der Java-Interpreter übersetzt die erstellten Programme in eine für den Zielrechner
verständliche Sprache
Verwendete Hilfsmittel                                                    83

Umstand hingewiesen, damit der Anwender die Bereitstellung eines Applets
erkennen und somit diesem Problem begegnen kann.
Die entwickelten Applets sind allesamt ab der Java-Version 1.1 lauffähig, die
schon einen recht alten Standard darstellt und daher auf dem Großteil aller
Computer verfügbar ist. Entwicklungsumgebungen wie „Visual Cafe“ oder
„J-Builder“ sind nicht als Hilfsmittel herangezogen worden. Der Quellcode der
Applets wurde, wie dies schon bei der Anfertigung der HTML-Dokumente
geschehen ist, nur durch die Nutzung eines Editors erstellt. Auf diese Weise ist
sichergestellt, dass nur Java-Klassen verwendet wurden, die dem Standard der
Version 1.1 entsprechen.
Mit der Unterstützung von Java konnten die HTML-Dokumente um ein
mächtiges Werkzeug bereichert werden, auf das zur Erstellung von
Lernsoftware kaum verzichtet werden kann.
Testphase                                                                 84



7. Testphase

Zunächst war es sehr wichtig, die Richtigkeit der Programme ausführlich zu
testen. Aber nicht nur die Korrektheit war von entscheidender Bedeutung,
sondern auch das Erscheinungsbild der Applets, das je nach verwendetem
Browsers variieren kann. Auch das Design der HTML-Dokumente weist
diesbezüglich teilweise geringfügige Unterschiede auf. So wurden die
Webseiten, unter Verwendung des Netscape Navigators und des Microsoft
Internet Explorers in ihren verschiedenen Versionen, genau unter die Lupe
genommen. Innerhalb der Applets ergeben sich Probleme in der Darstellung
von Farben, die auf verschiedenen Computersystemen unterschiedlich
akzentuiert   werden.   Des    Weiteren   differiert   die   Gestalt   einzelner
Programmkomponenten, so dass z.B. Teile eines Applets bei einer anderen
Browserversion zunächst nicht mehr komplett auf der Webseite angezeigt oder
erst gar nicht geladen werden konnten. Die Justierung von Graphiken in den
Pages bedeutete ein weiteres Problem, da sich hier gleichermaßen Differenzen
ergeben. Infolge dieser Erschwernis konnten mathematische Formeln, die in
Form von Bilddateien vorlagen, nur schwer in den Textfluss integriert werden.
Diese und viele weitere kleinere Differenzen in der Darstellung der HTML-
Dokumente erforderten oftmals einen geeigneten Kompromiss zwischen den
verschiedenen Browsern und das in Abhängigkeit der benutzten Version.
Letztlich ist die entwickelte Lernsoftware für den Netscape-Navigator (ab
Version 4.5) und den Microsoft Internet-Explorer (ab Version 3.0) geeignet,
die auch zurzeit die gängigen Browser darstellen.
Da dem Anwender die Wahl der Schriftart und –größe im Hauptfenster
überlassen wird, ist das Erscheinungsbild auch auf unterschiedliche
Schriftarten und –größen überprüft worden. An dieser Stelle entsteht dadurch
ein Problem, dass die in den Text eingefügten Graphiken bei Änderung der
Schriftgröße nicht gleichsam ihre Ausmaße verändern. Anhand des
Zeichensatzes „Times New Roman“ wurden verschiedene Textgrößen
untersucht. Für alle sinnvollen Größen wurde bei einer entsprechenden
Bildschirmauflösung das Schriftbild als angenehm empfunden und auch die
Anpassung der Graphiken war unabhängig von der Wahl der jeweiligen
Testphase                                                            85

Schriftgröße. Ebenso ergaben sich keine Probleme bei den getesteten
Zeichensätzen, die insbesondere die Standardfonts beinhalten.
Unerlässlich war auch eine Kontrolle der Navigationselemente. Die Qualität
der Lernsoftware hängt speziell auch von einer funktionierenden Navigation
ab. Aus diesem Grunde ist jeder Hyperlink angewählt worden, um eine
fehlerfreie Navigation garantieren zu können.
Angesichts der umfangreichen Tests sollte die Lernsoftware den Ansprüchen
genügen, die in Sachen Attraktivität, Funktionalität und Korrektheit an das
Lehrmaterial gestellt worden sind.
Ausdruck der erstellten Webseiten                                        86



8. Ausdruck der erstellten Webseiten

Wer einen Blick auf die erstellte Lernsoftware werfen möchte, kann die Seiten
im Internet unter der Adresse
„http://wwwmath.uni-muenster.de/SoftComputing/scag/fuzzyscript/fseinl.html“
abrufen.
Der folgende Ausdruck dieser Seiten liefert ebenfalls ein Bild von den
entstandenen Pages, eignet sich allerdings nicht zur Bearbeitung des
behandelten Themas. Da die oben angegebene Internetadresse dagegen nicht
für alle Zeiten Bestand haben muss und die erstellte Lernsoftware Teil dieser
Arbeit ist, wurde auch ein Ausdruck der Seiten in diesem Kapitel beigefügt.
Zu beachten ist, dass die Darstellung auf Papier die Fähigkeiten und das
tatsächliche Erscheinungsbild am Bildschirm nicht optimal wiedergeben kann.
Zur Überprüfung der oben geschilderten Ausführungen ist der Ausdruck aber
ausreichend und kann beim Lesen dieser Arbeit zur Anschauung herangezogen
werden.
Literaturverzeichnis                                                 87




9. Literaturverzeichnis

Aufenanger, Stefan: Lernen mit neuen Medien. In: LOG IN, 19. Jg. (1999),
Heft 6, S. 16-19.
Bittel, Oliver: Skript „Fuzzy-Logik“, Version 1.2, Fachhochschule Konstanz
1999


Feuring, Thomas: Skript zur Vorlesung „Fuzzy-Systeme“ im Sommersemester
1996. Institut für Informatik, WWU Münster.


Götz, Klaus: Interaktives Lernen mit dem Computer. In: LOG IN, 14. Jg.
(1994), Heft 5/6, S. 41-47.


Koring, Bernhard: Lernen und Wissenschaft im Internet, 2. Auflage. Bad
Heilbrunn: Klinkhardt 1997.


Kruse, Rudolf / Gebhardt, Jörg / Klawonn, Frank: Fuzzy-Systeme. Stuttgart:
B. G. Teubner 1993.


Lemay, Laura / Perkins, Charles L.: Java 1.1 in 21 Tagen. München: SAMS
1997.


Lüssem, Jens / Sünderkamp, Steffen: Lernen mit Multimedia im Internet. In:
LOG IN, 17. Jg. (1997), Heft 1, S. 16-18.


Münz, Stefan: HTML-Dateien selbst erstellen. Das Kompendium für
Entwickler von WWW-Seiten.
URL: http://www.teamone.de/selfhtml/


Süselbeck, Benno: Programmieren in Java. Skript zum Sommersemester 1999.
Institut für Informatik, WWU Münster.
Literaturverzeichnis                                                88

Thiele, Helmut: Einfühurng in die Fuzzy-Logik. 1995.
URL: http://wwwjessen.informatik.tu-muenchen.de/skripten.html


Weber, Henning: Animation und Interaktion im Internet. In: LOG IN, 17. Jg.
(1997), Heft 5, S. 10-16.
Literaturverzeichnis                                                     89

Ich versichere, dass ich die schriftliche Hausarbeit selbstständig verfasst und
keine anderen als die angegebenen Quellen und Hilfsmittel benutzt habe. Alle
Stellen der Arbeit, die anderen Werken dem Wortlaut oder Sinn nach
entnommen wurden, habe ich in jedem Fall unter Angabe der Quelle als
Entlehnung kenntlich gemacht. Das Gleiche gilt auch für die beigegebenen
Zeichnungen, Kartenskizzen und Darstellungen.

				
DOCUMENT INFO