6. Graphik

Gewaltige Datenmengen - wiewohl genauestens einen Vorgang beschreibend oder Resultat

peinlichst genauer Messungen - sind Ergebnis einer detaillierten Analyse (zumindest hofft man

das), haben aber den Nachteil, sehr schnell unübersichtlich zu sein. Die eigentliche (gesuchte)

Aussage der Analyse geht sehr schnell verloren - oder man findet sie gar nicht erst1. Um

Datenmengen verständlich darzustellen, müssen sie in eine Form gebracht werden, mittels derer

man vergleichsweise einen Überblick erhält und so relevante von irrelevanten Daten unterscheiden

kann. Ein Mittel ist die graphische Darstellung (nicht umsonst heißt es ja auch Datenverarbeitung!).

Schon aus der Schule kennt man das leidige Problem, über eine gegebene Funktion eine Aussage

treffen zu müssen, um sie zu charakterisieren: Existenz und Angabe von Nullstellen, Extrema,

Wendepunkte, Asymptoten, Polstellen, hebbare Lücken, Symmetrie oder auch nur ganz einfach der

Verlauf der Kurve in einem bestimmten Intervall. Liegt die Funktion im Falle einer Unabhängigen

und einer Abhängigen in gezeichneter Form vor, genügt schon ein einziger Blick auf den Graphen,

um signifikante Aussagen machen zu können.

Mit MATLAB lassen sich nicht nur komplexe Rechnungen mit Vektoren und Matrizen bewältigen,

sondern auch Daten graphisch darstellen.

Die wichtigste Anweisung heißt

plot(x,y).

Sie erzeugt ein Graphikfenster - wie im nachfolgenden Beispiel zu sehen.

1 Berümte Redewendung in wissenschaftlichen Arbeiten: „Unter den mannigfaltigen Datenmengen wurden die

folgenden ausgewählt“ bedeutet in Wahrheit: „Der Rest ergab erst recht keinen Sinn.“

1

Man muß allerdings mitunter danach suchen - es ist möglicherweise von anderen Fenstern verdeckt.

Dieses Fenster enthält die Graphen der Funktionen y1(x) = cos(50⋅x) und y2(x) = 12⋅x+1 im

Intervall [-0.01; +0.01] - es diente in einem anderen Zusammenhang für die Ermittlung eines

Startwertes für das Newton-Verfahren der Funktion y(x) = cos(50⋅x) + 12⋅x + 1; der Schnittpunkt er

Graphen von y1 und y2 (bei x = 0.085) wurde dann als solcher gewählt.

Bei der Erstellung eines Graphen greift MATLAB auf eine Wertetabelle zurück, die mühselig von

Hand erstellt ja auch schon in manchen trüben Schultagen Ausgangspunkt für das Zeichnen eines

Graphen war.

Um eine Wertetabelle für eine Funktion der Gleichung y = f(x) zu erstellen, braucht man also eine

Anzahl Argumentwerte für xi und die dazugehöigen errechneten yi = f(xi). Mit anderen Worten: es

muß ein Vektor =(xxr 1, x2, .... xn) mit einer bestimmten Anzahl von n Elementen erstellt werden,

und von jedem Element xi der dazugehöige Funktionswert yi = f(xi) bestimmt werden. Dies ergibt

dann den Ergebnisvektor )(xfy rr= .

2

Daher noch eine kurze Wiederholung über die Erstellung eines Vektors:

explizite Vorbesetzung

die Elemente werden in eckigen Klammern notiert und zeilenweise geschrieben; die Elemente

sind dabei durch Leerzeichen voneinander zu trennen

Beispiel x = [-0.1 –0.05 0 0.05 0.1]

Vorbesetzung mit Schleife variable = Anfangswert : Schrittweite : Endewert

Mit dem Anfangswert beginnend wird auf diesen die Schrittweite hochgezählt, so lange die

Summe kleiner oder gleich dem Endewert ist. Dies setzt natürlich voraus, daß der Anfangswert

kleiner als der Endewert ist.

Beispiel: x = -0.1 : 0.05 : 0.1

(die Leerzeichen vor und hinter dem Doppelpunkt sind nicht notwendig, aber können die

Lesbarkeit erhöhen).

Einfache Beispiele mit Befehl plot

Wir wollen nun einmal die Sinus-Funktion in eben diesem Intervall zeichnen.

Die Funktion sin operiert elementweise auf einem Vektor; daher sind hier die Anweisungen recht

einfach: x = -0.1 : 0.05 : 0.1; y = sin(x); plot(x, y)

3

plot(x, y) verbindet benachbarte Punkte durch eine Gerade. Dies sind

xi yi

-0.10 -0.0998

-0.05 -0.0500

0.00 0.0000

0.05 0.0500

0.10 0.0998

4

Sehr beeindruckend (überzeugend?) sieht das Resultat nun wirklich nicht aus. Dies liegt allerdings

nicht an MATLAB, sondern an den etwas unglücklich gewählten Parametern: insgesamt lagen nur

fünf Stützwerte vor (siehe obige Tabelle), die mittels Geraden verbunden wurden; das Intervall, in

dem gezeichnet wurde, umfaßt auch nur den kleinen Ausschnitt um den Koordinatenursprung, wo

der Sinus in der Tat annähernd die Steigung 1 hat. Daher ist eine Modifikation der Parameter sicher

sinnvoll.

Erweitern wir daher das Intervall auf [-2π, 2π] und verfeinern die Schrittweite auf 0.01.

x = -2*pi : 0.01 : 2*pi; y = sin(x); plot(x, y)

5

Das Ergebnis sieht in der Tat überzeugender aus.

Deutlich ist jetzt die bekannte Sinuskurve zu erkennen.

Bevor wir Verfeinerungen und weitere Funktionalitäten betrachten, zunächst Warnung vor einer

Falle.

6

Wir wollen den Graphen einer Parabel ausgeben: y = ½⋅x².

Wir geben ein: x = -4 : 0.1 : 4 y = x*2;

und an dieser Stelle erscheint eine Fehlermeldung über nicht zusammenpassende Matrizen!

Dasselbe Resultat hätten wir erhalten bei y = x^2;

Der Grund ist einfach:

das Argument x ist ein Vektor, also keine einfache Variable! Die Operation „^“ bzw. „*“ wird als

Verknüpfung auf Vektoren interpretiert - in diesem Fall als Matrizenmultiplikation.

Stattdessen soll aber die Verknüpfung wie bei der Sinus-Funktion komponentenweise erfolgen.

Bereits im Kapitel über Vektoren lernten wir kennen, daß dies mit einem vorangestellten Punkt

erreicht wird.

Also x = -4 : 0.1 : 4 y = x.^2; (oder y = x.*x;) plot(x, y)

7

MATLAB beschwert sich nicht und bringt folgende formschöne Graphik auf den Bildschirm:

Also:

bei Verknüpfungen der Grundrechenarten *, /, ^ immer darauf achten, daß diese komponentenweise

ausgeführt werden!2

2Die Rechenarten + und - sind komponentenweise definiert; ebenso ist die skalare Multiplikation (also z.B. 2*x)

komponentenweise definiert. Hingegen * und / nicht!

8

Der allgemeine plot-Befehl ist sehr vielseitig. help plot

bringt folgende Erklärungen auf den Bildschirm:

PLOT Linear plot. PLOT(X,Y) plots vector Y versus vector X. If X or Y is a matrix, then the vector is plotted versus the rows or columns of the matrix, whichever line up. If X is a scalar and Y is a vector, length(Y) disconnected points are plotted. PLOT(Y) plots the columns of Y versus their index. If Y is complex, PLOT(Y) is equivalent to PLOT(real(Y),imag(Y)). In all other uses of PLOT, the imaginary part is ignored. Various line types, plot symbols and colors may be obtained with PLOT(X,Y,S) where S is a character string made from one element from any or all the following 3 columns: b blue . point - solid g green o circle : dotted r red x x-mark -. dashdot c cyan + plus -- dashed m magenta * star y yellow s square k black d diamond v triangle (down) ^ triangle (up) < triangle (left) > triangle (right) p pentagram h hexagram For example, PLOT(X,Y,'c+:') plots a cyan dotted line with a plus at each data point; PLOT(X,Y,'bd') plots blue diamond at each data point but does not draw any line. PLOT(X1,Y1,S1,X2,Y2,S2,X3,Y3,S3,...) combines the plots defined by the (X,Y,S) triples, where the X's and Y's are vectors or matrices and the S's are strings. For example, PLOT(X,Y,'y-',X,Y,'go') plots the data twice, with a solid yellow line interpolating green circles at the data points. The PLOT command, if no color is specified, makes automatic use of the colors specified by the axes ColorOrder property. The default ColorOrder is listed in the table above for color systems where the default is blue for one line, and for multiple lines, to cycle through the first six colors in the table. For monochrome systems, PLOT cycles over the axes LineStyleOrder property. PLOT returns a column vector of handles to LINE objects, one handle per line. The X,Y pairs, or X,Y,S triples, can be followed by parameter/value pairs to specify additional properties of the lines.

So kann also die Form der Linienführung und deren Farbe geändert werden!

9

plot(x, y, '*r')

zeichnet also die Kurve statt mit Linienzug und Standardfarbe blau mit dem Sternchen in rot!

ACHTUNG!

Es darf nur das einfache Hochkomma ' zum Einschließen der Zeichenkette verwendet werden!

Benutzt man " oder ` oder ´, so erhält man eine Fehlermeldung.

Nachfolgend die Darstellung einer Funktion in Parameterdarstellung also in der Form

x = x(t)

y = y(t)

Als Beispiel dient eine sogenannte Lissajous-Figur3:

x = sin (2t)

y = cos (t) für 0 ≤ t ≤ 2π.

Es werden nur x und y graphisch dargestellt; t als Parameter hat (mitunter) eine geometrische

3 die allgemeine Form der nach J.A. Lissajous benannten Figuren lautet x(t) = A1⋅sin(ω1⋅t), y(t) = A2⋅cos(ω2⋅t+ϕ), t≥0.

Die Gestalt der Bahnkurven hängt vom Verhältnis ω1:ω2 der Kreisfrequenzen sowie von der Phasendifferenz α ab. Ist ω1:ω2 rational, so ist die Bahnkurve eine sogenannte algebraische Kurve und geschlossen; die Schwingung ist periodisch. Ist ω1:ω2 irrational, so ist die Bahnkurve nicht geschlossen und kommt jedem Punkt des Rechtecks |x|≤ A1, |y|≤A2 beliebig nahe; die Schwingung ist nicht periodisch.

10

Bedeutung wie Winkel zwischen x-Achse und Verbindungsgeraden zwischen Ursprung und

Bahnpunkt; also werden zwar drei Vektoren berechnet, aber nur zwei zum Zeichnen benötigt.

Nachfolgend die Befehlsfolge in MATLAB

Die ausgegebene Bahnkurve hat das Aussehen:

Einfügen eines Rastergitters in die Graphik

Zur genaueren Bestimmung von Bahnpunkten kann ein Rastergitter in die Graphik eingefügt

11

werden. Der dazugehörige Befehl lautet ganz einfach:

grid;

Beispiel für eine weitere Lissajous-Figur:

x(t) = 4⋅cos (3⋅t)

⎟⎠⎞

⎜⎝⎛ +⋅⋅=

82cos5)( πtty

Kommandofolge: t = 0 : 0.1 : 2*pi; x = 4 * cos(3*t); y = 5 cos( 2*t + pi/8); plot(x, y); grid; bzw. im Kommandofenster:

dazu wird dann im Graphikfenster folgende Lissajous-Figur ausgegeben (wie zu ersehen, war die

Schrittweite 0.1 bei Zeichnungen der Kurve in den Ecken des Rechtecks offensichtlich noch zu

grob - man erkennt deutlich die Verbindung mittels einer Linie von einem berechneten

Kurvenpunkt zum nächsten):

12

Beschriftung einer Graphik

Die Koordinatenachsen werden mit xlabel und ylabel beschriftet. Der Text der Beschriftung

folgt in Klammern und einfache Hochkomma eingeschlossen.

Also xlabel('Text1') ylabel('Text2')

Die Überschrift im Graphikfenster wird mit titel gesetzt. Der Text der Überschrift folgt wie bei

xlabel und ylabel in Klammern und einfaches Hochkommata eingeschlossen.

Also title('Überschrift')

Text innerhalb der Graphik wird mit text eingegeben: text(Position x, Position y, 'Text')

Die ersten beiden Parameter sind Positionen bzgl. der x- bzw. y-Achse, geben also an, wo innerhalb

der Graphik (durch das Koordinatensystem bestimmt) der Text beginnt. Der eigentliche Text ist in

einfaches Hochkommata eingeschlossen als dritter Parameter anzugeben.

Als Beispiel lassen wir die Funktion y(t) = t⋅sin²(t) ausgeben.

13

Kommandofolge: x = -2*pi : 0.1 : 2*pi; y = x.*sin(x).^2; plot(x, y, 'r'); grid; xlabel('Zeit'); ylabel('Spannung'); title('Abbildung 1'); text(-3, 1.5, 'y = t*sin(t)^2');

im Kommandofenster:

Man achte bitte insbesondere auf die Punkte vor dem Multiplikationszeichen * bei der Berechnung

des Vektors(!) y, die anzeigen, daß keine Matrizenmultiplikation durchgeführt werden soll (was

ohnehin nicht möglich ist), sondern eine komponentenweise Multiplikation auf dem Vektor y.

Die Positionierung des Textes kann ein Gefummel darstellen, da er möglicherweise mit der Kurve -

oder in diesem Fall mit dem Rastergitter - kollidiert. Daher ist durchaus überlegenswert, entweder

auf das Rastergitter zuverzichten oder eben auf Text innerhalb der Graphik.

ACHTUNG!

Es ist wichtig, zuerst die Anweisung plot zu geben und anschließend die Kommandos zur

Beschriftung der Graphik! Die Beschriftung wird nämlich immer in die bereits bestehende Graphik

eingefügt. Ein plot-Kommando hingegen leert zuerst das Graphikfenster (mithin auch die eventuell

bereits vorgenommene Beschriftung) und zeichnet die Kurve.

Die aktuelle MATLAB-Version 6.1 stellt übrigens Nachbearbeitungs-Tools für die Graphik zur

Verfügung. Diese sind als Menüleiste oberhalb des Graphikfensters eingeblendet. Mittels des nach

14

rechts weisenden Pfeils können Pfeile eingefügt werden, mittels der Linie durchgezogene Linien

(für die x-Achse durchaus sinnvoll anstelle des Rastergitters).

Dies ist erst einmal die Standardausgabe:

Komplexere Bearbeitungen sind über Menüauswahl „Edit“ möglich.

Beispielsweise erlaubt Edit -> Axes Properties

Änderungen an den Achsen.

Es öffnet sich ein Fenster „Edit properties for axes“

Der Reiter „Style“ erlaubt beispielsweise die Änderung der Größe und des Schrifttyps der

Achsenbeschriftung. Standard ist der Typ „Helvetica“ - es kann aber eine - wie in der Auswahlliste

zu ersehen - andere aus einer gewaltigen Anzahl von Schrifttypen ausgewählt werden. Ist das

Kästchen „Immediate apply“ gesetzt (ganz unten im Fenster - ist eigentlich standardmäßig

gesetzt), werden die gemachten Änderungen sofort im Gaphikfenster umgesetzt.

Der Reiter „Scale“ erlaubt unter anderem das Ein- bzw. Ausblenden des Rastergitters

15

(Kontrollkästchen „Grid Show“ ist gesetzt bzw. nicht gesetzt).

Klickt man einen eingegebenen Text im Graphikfenster an und geht dann

„Edit“ -> „Current Object Properties“ (oder direkt rechte Maustaste in die

Auswahlzeile „Properties“), kann auch dieser Text nachträglich bearbeitet werden:

es öffnet sich das Fenster „Edit properties for text“.

der Reiter „Text“ läßt Änderungen am Texttyp zu. Standard ist (immer noch „Helvetica“) - hier

wurde aus Jux und Dollerei (damit man mal ein paar Änderungen sieht) „Bookman Old Style“

gewählt.

Diese Änderung wird auch sofort in der aktuellen Graphik am ausgewählten Text umgesetzt, wenn

das Kontrollkästchen „Immediate apply“ gesetzt ist - die anderen Texte bleiben von dieser

Änderung unberührt.

16

Unter dem Reiter „Alignment“ kann die Positionierung des Textes modifiziert werden:

17

In diesem Beispiel wurde sie - damit man etwas sieht - weit nach links gerückt.

Nach den Änderungen sieht dann der Inhalt des Graphikfensters so aus:

Man probiere die unterschiedlichen Möglichkeiten am besten selbst aus.

der Befehl linspace - Vorgabe der Anzahl der Datenpunkte

Bei Besetzen des Komponenten des Argumentvektors mit einer Schleifenanweisung der Form x = Anfangswert : Schrittweite : Endewert

ist der mittlere Parameter die Angabe der Schrittweite. Mittels

eDatenpunktderAnzahlteSchrittwei

tAnfangswerEndewert=

−

läßt sich ausrechnen, wieviele Komponenten der Vektor enthält bzw. mittels Linie graphisch

verbunden werden.

Es gibt ein Kommando zum Besetzen eines Vektors, das Anfangs- und Endewert entgegennimmt

und zusätzlich anstatt der Schrittweite die Anzahl der Bahnpunkte. Dies ist das Kommando

18

linspace.

Syntax: x = linspace(Anfangswert, Endewert, Anzahl der Bahnpunkte)

Der dritte Parameter kann weggelassen werden. MATLAB setzt dann automatisch Anzahl=100.

Nachfolgend ein Beispiel - wieder einmal eine Lissajous-Figur: t = linspace(0, 2*pi, 250); x = 4*cos(3*t); y = 5*cos(2*t); plot(x, y, 'r'); grid; xlabel('x(t)'); ylabel('y(t)'); title('Lissajous-Figur'); text(-1.5,-2.5, 'x(t)=4*cos(3t)'); text(-1.5,-3.5, 'y(t)=5*cos(2t);

19

Ausgabe:

Mehrere Funktionen gleichzeitig zeichnen

Dies ist sogar recht einfach durch Erweiterung des plot-Kommandos:

plot(x, y, x, z) zeichnet die Funktion y(x) und z(x) in das gleiche Koordinantensystem.

Beispiel:

Sinus- und Cosinusfunktion in einem gemeinsamen Graphikfenster.

Befehlsfolge: x = linspace(-pi, pi, 50); y = sin(x); z = cos(x); plot(x, y, 'r', x, z, 'b'); title('Sinus- und Cosinus-Funktion'); xlabel('x'); ylable('y');

Im Kommandofenster hat dies dann das Aussehen:

20

Und die Ausgabe im Graphikfenster:

Bei der Ausgabe in das Graphikfenster wurde noch nachträglich das Achsenkreuz und die

Beschriftung innerhalb des Fensters hinzugefügt.

Der Befehl hold

Es gibt noch eine zweite Möglichkeit, mehrere Funktionen in ein und dasselbe Graphikfenster

zeichnen zu lassen - den Befehl hold.

Er bewirkt, daß die aktuelle Graphik im Fenster festgehalten wird, so daß bei allen nachfolgenden

21

plot-Kommandos jeweils eine die neue Graphik zur alten in dasselbe Achsenkreuz hinzugefügt

wird. Der Befehl hold off beendet diese Funktion.

Sinnvoll wird diese Funktion bei stückweisem Zeichnen einer Funktion.

Betrachten wir das Beispiel y = tan(x).

Bekanntlich hat der Tangens bei ½⋅π + k⋅π Polstellen (k∈⎫). Lassen wir MATLAB ohne

Berücksichtung dieses Sachverhalts die Kurve des Tangens zeichnen, kommt ein etwas

merkwürdiges Resultat bei heraus:

Das Graphikfenster sieht dann so aus:

22

Dies ist nicht allzu verwunderlich, da bei bei einem Argumentwert um die jeweilige Polstelle herum

einmal der Funktionswert sehr groß und dann sehr klein ist - und diese beiden werden mit einer

Linie verbunden. Dies führt zu obiger Darstellung.

Wir lassen die Funktion daher stückweise zeichnen, nämlich in den Intervallen

[-π, -½⋅π[,

]- ½⋅π, ½⋅π[ und

] ½⋅π, π].

Die Befehlsfolge sieht so aus: >> %Ausgabe Tangens - in drei Plotaufrufen >> %erster Abschnitt [-pi, -pi/2] >> x = -pi : 0.1 : -pi/2-1e-01; >> y = tan(x); >> plot(x,y); >> hold; Current plot held >> %zweiter Abschnitt [-pi/2, pi/2] >> x = -pi/2+1e-01 : 0.1 : pi/2 - 1e-01; >> y = tan(x); >> plot(x, y);

23

>> %dritter Abschnitt [pi/2, pi] >> x = pi/2 + 1e-01 : 0.1 : pi; >> y = tan(x); >> plot(x, y); >> title('Graph des Tangens mit Berücksichtigung der Polstellen'); >> xlabel('x'); >> ylabel('y');

bzw. im Kommandofenster:

Nachträglich wurden noch die Koordinatenachsen und Polstellen hinzugefügt und die Skalierung

der Achsen manuell gesetzt („Edit“ -> „Axes Properties“):

(später werden wir noch die Kommandos für das Kommandofenster kennenlernen, mit deren Hilfe

eine Skalierung der Achsen möglich ist).

24

Und dann ist das stolze Resultat der Mühen ein fast formschöner Tangens:

25

Darstellung in zwei unterschiedlichen Graphikfenstern

Es ist also möglich, zwei und mehr Kurven in ein und demselben Fenster graphisch darzustellen.

Ebenso ist es möglich, das Fenster in zwei (und mehr) zu unterteilen und in jedes Unterfenster eine

(oder mehrere) Graphen zu zeichnen.

Der Befehl zur Unterteilung lautet subplot(m, n, aktuelles Unterfenster)

Die Parameter sind natürliche Zahlen, wobei festgelegt ist

m: Anzahl Unterfenster in vertikaler Richtung

n: Anzahl Unterfenster in horizontaler Richtung

aktuelles Unterfenster: in welches der m⋅n Unterfenster gezeichnet werden soll. Gezählt wird

zeilenweise von links oben bis rechts unten (analog der Numerierung der Indizes einer Matrix).

Als harmloses Beispiel für zwei übereinander befindliche Unterfenster:

Der Sinus wird im oberen, der Cosinus im unteren Fenster gezeichnet.

Also ist m = 2, n = 1.

Die Befehlsfolge lautet: >> %Ausgabe zweier Graphen in zwei getrennte Unterfenster >> x = linspace(-pi, pi, 50); >> y = sin(x); z = cos(x); >> %erstes Unterfenster >> subplot(2, 1, 1); plot(x, y); >> xlabel('x'); ylabel('y'); title('Sinus-Funktion'); >> %zweites Unterfenster >> subplot(2, 1, 2); plot(x, z); >> xlabel('x'); ylabel('y'); title('Cosinus-Funktion');

bzw. im Kommandofenster:

Alle auf subplot(2,1,2) nachfolgenden Befehle bis ausschließlich subplot(2,1,2) sind dem

26

ersten Unterfenster zugeordnet. Entsprechend werden alle auf subplot(2,1,2) nachfolgenden

Befehle dem zweiten Unterfenster zugeordnet. Auf diese Weise „weiß“ das Programm, welche

Fenster es womit beschriften soll.

Wie zu ersehen, kommen sich Beschriftung des ersten mit dem zweiten Teilfenster ins Gehege. Ein

mitunter ärgerlicher Nebeneffekt.

Ein völlig neues Graphikfenster zusätzlich zu einem bereits bestehenden öffnet man mit dem Befehl

figure.

Darstellung in Polarkoordinaten

Ganz beliebt sind Funktionen, deren Gleichung nicht wie bisher in den bekannten kartesischen,

sondern in Polarkoordinaten gegeben sind, d.h. Funktionen mit der Gleichung

r(ϕ) = f(ϕ)

z.B.

r(ϕ) = sin(ϕ)⋅cos(ϕ)

Glücklicherweise zeigt sich MATLAB davon vergleichsweise wenig beeindruckt und zeichnet auch

die Graphen solcher Funktionen (und Kurven). Der Befehl dazu lautet:

polar(phi, r),

27

wobei phi das Argument - also i.a. der Winkel im Bogenmaß - ist und r der dazugehöige Radius.

Ansonsten ändert sich nicht viel.

phi = 0 : 0.1 : 2*pi; r = sin(phi) .* cos(phi); polar(phi, r); title('Darstellung in Polarkoordinaten');

Im Kommandofenster:

Und dann die Ausgabe:

Skalierung der Achsen

Nicht immer ist die automatische Wahl der Größenodnung, die MATLAB zur Dastellung einer

28

Kurve trifft, die Beste. Wir hatten ein solches Problem schon einmal bei Darstellung der Tangens-

Funktion erlebt und uns mit nachträglicher Bearbeitung der Achsengößen über „Edit“ -> „Axes

Properties“ beholfen. Es gibt jedoch Befehle, die die Skalierung der Achsen direkt aus dem

Kommanofenster heraus vornehmen.

Ein solcher Befehl lautet:

axis([xmin, xmax, ymin, ymax]).

Die Funktion wird dann im Bereich xmin ≤ x ≤ xmax und ymin ≤ y ≤ ymax dargestellt.

Greifen wir wieder auf das Beispiel des Tangens zurück.

Die Befehlsfolge x = 0 : 0.01 : pi/2; y = tan(x); plot(x, y);

hat wegen der Polstelle bei ½π sehr große Werte und daher einen großen Bereich für die

Bemaßung der y-Achse gewählt.

Eine andere Bemaßung ist daher sinnvoll: x = 0 : 0.01 : pi/2; y = tan(x); plot(x, y);

29

axis([0, pi/2, 0, 15]);

Und das ergibt dann

Gleiche Skalierung erreicht man mit axis equal

Die ursprüngliche Skalierung wird mit axis normal

wiederhergestellt.

Logarithmische Skalierung der Achse

30

Bei gewissen Funktionen ist es von Vorteil, im kartesischen Koordinantensystem statt der

äquidistanten Unterteilung eine logarithmische Skalierung zu verwenden. Bekanntlich ist die

Darstellung der Funktion y(x) = ea·x+b bei logarithmisch unterteilter y-Achse eine Gerade;

umgekehrt kann man bei einer Geraden als Graphen bei logarithmisch unterteilter y-Achse darauf

schließen, daß die dazugehörige Funktion eine Exponentialfunktion sein muß.

Das Kommando für Darstellung der Funktion bei logarithmisch skalierter y-Achse ist

semilogy.

Es wird wie plot verwendet.

Betrachten wir das Beispiel y(x) = 3·e-0.5·x.

Einmal stellen wir die Funktion in normalen, das zweite Mal in logarithmisch skalierter y-Achse

dar.

Befehlsfolge: >> %Verwendung logarithmischer Skalierung >> x = linspace(0, 10, 50); >> y = 3*exp(-0.5*x); >> %Darstellung in normalen kartesichen Koordinaten >> subplot(2, 1, 1); plot(x, y); >> grid; >> title('normale kartesische Koordinaten'); >> %Darstellung mit logarithmisch skalierter y-Achse >> subplot(2, 1, 2); semilogy(x, y); >> grid; >> title('logarithmisch unterteilte y-Achse');

im Kommandofenster

(das Zeichnen des Rastergitters für die erste Darstellung fehlt hier - es wurde im Unterfenster

nachträglich hinzugefügt).

Als Ausgabe erhält man:

31

Der Vollständigkeit wegen sei noch erwähnt, daß der Befehl semilogx

analog zu einer logarithmisch unterteilten x-Achse führt.

Und daß loglog

eine logarithmische Skalierung beider Achsen zur Folge hat.

Darstellung komplexer Bahnkurven

Auch wenn sie sich nicht großer Beliebtheit erfreuen, sei auch ihnen noch eine kurze

Randbemerkung gewidmet: den komplexen Zahlen C.

Wir erwähnten zwar die Grundrechenarten und auch einige höhere Rechenarten wie die Bildung

des Logarithmus, nicht jedoch den Funktionenbegriff einer komplexen Funktion

f: C → C, z = a + b⋅i → f(z) = u + i⋅v

Da sowohl Argument- als auch Funktionswert über Real- und Imaginärteil verfügen, ist eine

graphische Darstellung nur im vierdimensionalen Achsenkreuz möglich, also schlechthin

unmöglich.

Man hat sich daher auf folgende Darstellungsform geeinigt:

Man stellt im gleichen ebenen Achsensystem, das die Gaußsche Zahlenebene repräsentiert

32

(immerhin wissen wir ja mittlerweile, daß C ≅ R² ist) ausgewählte Punkte (a, b) des Argumentwerts

z = a + b⋅i dar und im gleichen System die Punkte (u, v) der dazugehörigen Funktionswerte

f(a + b⋅i) = u + i⋅v.

Und studiert dann dabei die Veränderungen, die die Bahnkurven der Argumentwerte unter der

Funktion f durchlaufen (im Falle einer linearen Funktion f(z) = c⋅z + d, c, d ∈ R spricht man auch

von linearer Transformation).

Beispiel: Das Joukovoski-Profil

Beispielsweise beschreibt die Funktion f(t) = r⋅eit + xM + yM⋅i für t ∈ ⎭, konstante r, xM, yM ∈ R

einen Kreis mit Radius r und Mittelpunkt (xM, yM). Man betrachtet also für ein vorgegebenes r ∈ R

und einen vorgegebenen Punkt (xM, yM) die Menge von komplexen Zahlen

X = {a + b⋅i ∈ C | ∃t∈⎭: a + b⋅i = r ⋅eit } und wählt als komplexe Funktion aus:

zzf 1)( = oder

zzzf 1)( += . Geometrisch lassen sich die Bildpunkte f(z) für z∈C konstuieren -

diese Konstruktion nennt sich Inversion am Einheitskreis (es spielt dabei der Kathetensatz von

Euklid eine Rolle). Transformiert man die obige Menge X mit der zuletzt genannten Funktion,

entsteht eine Figur, die an den Querschnitt einer Tragfläche eines Flugzeugs erinnert, das sog.

„Joukovski-Profil“. Man kann in der Tat die Strömungsverhältnisse an einem solchen Profil

studieren mit Hilfe verhältnismäßig einfacher mathematischer Werkzeuge wie der Inversion eines

Kreises am Einheitskreis.

Wir werden diesen Prozeß mit MATLAB graphisch darstellen.

Dazu läßt sich der bereits bekannte Befehl plot verwenden. Er kann auch komplexe Werte

entgegennehmen. Besteht die Argumentliste lediglich aus einer (komplexen) Variable z (einzelner

Wert oder Vektor), wird diese aufgespalten in Real- und Imaginärteil und analog gezeichnet wie

plot(real(z), imag(z)).

So zeichnet beispielsweise die Befehlsfolge t = 0 : pi/50 : 2*pi; plot(exp(i*t)); den Einheitskreis.

Für die Inversion am Einheitskreis werden wir drei Bahnkurven zeichnen lassen:

1. den Einheitskreis

33

2. den zu invertierenden Kreis mit Radius 1.2 und Mittelpunkt (0.2; 0.2)

3. der invertierte Kreis (das Joukovski-Profil).

Nachfolgend die Befehlsfolge:

bzw. einmal mitprotokolliert: >> %Darstellung komplexe Bahnkurven >> %hier Inversion am Einheitskreis >> %Argumentwerte >> t = 0 : pi/100 : 2*pi; >> %Erstellen Einheitskreis >> einheit = exp(i*t); >> plot(einheit, 'r'); >> axis equal; >> hold; Current plot held >> %Erstellen Kreis mit Mittelpunkt (0.2; 0.2) und Radius 1.2 >> u = 1.2*exp(i*t)+0.2+0.2*i; >> plot(u, 'b'); >> %Erstellen der Inversionskurve >> v = u + 1./u; >> plot(v, 'g');

34

>> %x-Achse ziehen >> xachse = [-2.8 2.6]; >> yachse = [0 0]; >> plot(xachse, yachse, 'k'); >> %y-Achse ziehen >> xachse = [0 0]; >> yachse = [-2 2]; >> plot(xachse, yachse, 'k'); >> %Beschriftung >> text(-2.35, 1.1, 'rot: Einheitskreis'); >> text(-2.35, 1.3, 'blau: zu invertierender Kreis'); >> text(-2.35, 1.5, 'grün: Joukovski-Profil'); >> title('Inversion am Einheitskreis'); >> xlabel('Realteil'); >> ylabel('Imaginärteil');

Das Ergebnis ist dann folgendes Graphikfenster:

die Textverteilung innerhalb entspricht nicht der Befehlfolge (und die Farbgebung schon gar nicht);

sie wurde manuell nachbearbeitet.

Dreidimensionale Darstellungen

Visualisierung räumlicher Zusammenhänge ist mit MATLAB möglich. Es enthebt einem der

mühseligen Arbeit, sich selbst durch den Dschungel von Überschneidungen und Verdeckungen

eines räumlichen Objekts schlagen zu müssen, das nur als Datensalat vorgegeben ist. Es hilft dem

Prozeß des „Begreifens“ (im wörtlichen Sinne) ungemein.

Wir zeichnen

35

Kurven im Raum (Befehl plot3)

Flächen im Raum (Befehl meshgrid, surf)

Der Befehl plot3

plot3 nimmt drei Argumente entgegen (und möglicherweise ein viertes für den Stil und Farbe), die

diedrei Koordinaten eines Punktes im Raum repräsentieren:

Sind x, y, z reelle Vektoren, so zeichnet also plot3(x, y, z)

die räumliche Verbindungslinie vom Punkt (x(i-1), y(i-1), z(i-1)) zum Punkt (x(i), y(i), z(i).

Oder, wie es die Hilfe-Funktion help plot3 ausgibt: PLOT3 Plot lines and points in 3-D space. PLOT3() is a three-dimensional analogue of PLOT(). PLOT3(x,y,z), where x, y and z are three vectors of the same length, plots a line in 3-space through the points whose coordinates are the elements of x, y and z. PLOT3(X,Y,Z), where X, Y and Z are three matrices of the same size, plots several lines obtained from the columns of X, Y and Z. Various line types, plot symbols and colors may be obtained with PLOT3(X,Y,Z,s) where s is a 1, 2 or 3 character string made from the characters listed under the PLOT command. PLOT3(x1,y1,z1,s1,x2,y2,z2,s2,x3,y3,z3,s3,...) combines the plots defined by the (x,y,z,s) fourtuples, where the x's, y's and z's are vectors or matrices and the s's are strings. Example: A helix: t = 0:pi/50:10*pi; plot3(sin(t),cos(t),t); PLOT3 returns a column vector of handles to LINE objects, one handle per line. The X,Y,Z triples, or X,Y,Z,S quads, can be followed by parameter/value pairs to specify additional properties of the lines.

Das vorgeschlagene Beispiel wollen wir realisieren:

es handelt sich dabei um eine Parameterfunktion mit drei Argumenten, eine sogenannte

Raumkurve:

f:R → R³, t → (sin(t), cos(t), t)

oder kurz f(t) = (sin(t), cos(t), t)

und ergibt eine Spirale oder Helix.

Die Befehlsfolge:

36

und das stolze Resultat:

Pro Durchlauf einer Periode 2π steigt sie um die Höhe 2π.

Der Befehl meshgrid

37

Für Darstellung von Flächen im Raum, deren Gleichung vorgegeben ist - also für die graphische

Darstellung von Funktionen der Art

f: ² → , (x, y) → z = f(x, y)

muß eine Wertetabelle erstellt werden, auf die die Zeichenfunktion von MATLAB zurückgreift.

Bestünde die Aufgabe darin, selber zeichnerisch tätig zu werden, muß man also Paare (xi, yi)

zusammenstellen und damit jeweils den Funktionswert zi = f(xi, yi) berechnen. Hat man also a

Werte xi vorgegeben und b Werte yi, gibt es also a⋅b Paare (xi, yi), von denen der Funktionswert zu

ermitteln ist.

Man erzeugt ein sogenanntes Gitter (xi, yi) von Argumentwerten.

Glücklicherweise ist dieser Prozeß in MATLAB etwas automatisiert. Auf dem Weg dahin hilft der

dazugehörige Befehle meshgrid.

[Matrix A, Matrix B] = meshgrid(Vektor x, Vektor y)

Dieser Befehl transformiert den Vektor x in eine Matrix A, deren Zeilen Kopien von x sind, und

transformiert den Vektor y in eine Matrix B, deren Spalten Kopien von y sind. Die Anzahl der

Zeilen von A ist dabei gleich der Anzahl der Elemente von y; die Anzahl der Spalten von B ist

gleich der Anzahl von Zeilen von x.

MESHGRID X and Y arrays for 3-D plots. [X,Y] = MESHGRID(x,y) transforms the domain specified by vectors x and y into arrays X and Y that can be used for the evaluation of functions of two variables and 3-D surface plots. The rows of the output array X are copies of the vector x and the columns of the output array Y are copies of the vector y. [X,Y] = MESHGRID(x) is an abbreviation for [X,Y] = MESHGRID(x,x). [X,Y,Z] = MESHGRID(x,y,z) produces 3-D arrays that can be used to evaluate functions of three variables and 3-D volumetric plots. For example, to evaluate the function x*exp(-x^2-y^2) over the range -2 < x < 2, -2 < y < 2, [X,Y] = meshgrid(-2:.2:2, -2:.2:2); Z = X .* exp(-X.^2 - Y.^2); mesh(Z) MESHGRID is like NDGRID except that the order of the first two input and output arguments are switched (i.e., [X,Y,Z] = MESHGRID(x,y,z) produces the same result as [Y,X,Z] = NDGRID(y,x,z)). Because of this, MESHGRID is better suited to problems in cartesian space, while NDGRID is better suited to N-D problems that aren't spatially based. MESHGRID is also limited to 2-D or 3-D.

Ist also x = (x(1), x(2), x(3)) = (0; 1; 2) und

38

y = (y(1), y(2)) = (-1; 0),

so wird die Matrix A das Aussehen haben:

A: x(1) x(2) x(3) 0 1 2

x(1) x(2) x(3) 0 1 2

(also zwei Zeilen (= Anzahl der Elemente von y), die jeweils Kopien von x sind)

und

B: y(1) y(1) y(1) -1 -1 -1

y(2) y(2) y(2) 0 0 0

(also drei Spalten (= Anzahl der Elemente von x), die jeweils Kopien von y sind)

Wie zu ersehen, haben beide Matrizen gleiche Dimensionen. Damit können beide elementweise

verknüpft werden. Die Ergebnismatrix C = A°B enthält dann die Verknüpfung aller Punktepaare

(also z(i, k) = c(i,k ) = a(i, k)°b(i, k) = x(k)°y(i), die dann die eigentlichen Daten für die

Zeichenfunktionen bilden. Sie bilden ein sogenanntes Datengitter („mesh“ = Masche, „grid“ =

Gitter).

C: z(1, 1) z(1, 2) z(1,3) x(1)°y(1) x(2)°y(1) x(3)°y(1)

z(2, 1) z(2, 2) z(2, 3) x(1)°y(2) x(2)°y(2) x(3)°y(2)

Aus der Wertetabelle

39

x: x(1) x(2) x(3) x(1) x(2) .....

y: y(1) y(1) y(1) y(2) y(2) .....

z: z(1, 1) z(1,2) z(1,3) z(2,3) z(2,2) .....

erfolgt dann die graphische Darstellung.

Es ist also z(i, k) = f(x(i), y(k)).

Man kann unter vier Darstellungsmöglichkeiten wählen:

mesh Netz

meshc Netz und Höhenlinien

surf Fläche

surfc Fläche und Höhenliniene

3D-Graphik-Kommandos

• Der Befehl mesh

erstellt eine 3D-Wiedergabe einer Funktion der Gleichung z = f(x, y) durch sogenannten

Maschenplot oder Drahtmodell - benachbarte Punkte sind durch eine Linie miteinander

verbunden. Ausgewählte Verbindungslinien werden ausgegeben, um den Verlauf der Fläche

zu kennzeichnen.

• Der Befehl meshc

erstellt eine 3D-Wiedergabe einer Funktion der Gleichung z = f(x, y) analog zum Befehl

mesh. Zusätzlich werden auf Höhe der x, y-Ebene die Höhenlinien ausgegeben.

• Der Befehl surf

erstellt eine 3D-Wiedergabe einer Funktion der Gleichung z = f(x, y) durch sogenanntes

Kachelmodell - statt benachbarte Punkte zu verbinden, wurden zwischen diese kleine

Flächenstücke gesetzt. Die graphische Wiedergabe erhält damit den Eindruck einer soliden

Fläche im Raum (surf von „surface“ - Oberfläche) .

• Der Befehl surfc

erstellt eine 3D-Wiedergabe einer Funktion der Gleichung z = f(x, y) analog zum Befehl

surf. Zusätzlich werden auf Höhe der x, y-Ebene die Höhenlinien ausgegeben.

Entsprechend die Erklärungen aus der MATLAB-Dokumentation: MESH 3-D mesh surface.

40

MESH(X,Y,Z,C) plots the colored parametric mesh defined by four matrix arguments. The view point is specified by VIEW. The axis labels are determined by the range of X, Y and Z, or by the current setting of AXIS. The color scaling is determined by the range of C, or by the current setting of CAXIS. The scaled color values are used as indices into the current COLORMAP. MESH(X,Y,Z) uses C = Z, so color is proportional to mesh height. MESH(x,y,Z) and MESH(x,y,Z,C), with two vector arguments replacing the first two matrix arguments, must have length(x) = n and length(y) = m where [m,n] = size(Z). In this case, the vertices of the mesh lines are the triples (x(j), y(i), Z(i,j)). Note that x corresponds to the columns of Z and y corresponds to the rows. MESH(Z) and MESH(Z,C) use x = 1:n and y = 1:m. In this case, the height, Z, is a single-valued function, defined over a geometrically rectangular grid. MESH(...,'PropertyName',PropertyValue,...) sets the value of the specified surface property. Multiple property values can be set with a single statement. MESH returns a handle to a SURFACE object. MESHC Combination mesh/contour plot. MESHC(...) is the same as MESH(...) except that a contour plot is drawn beneath the mesh. Because CONTOUR does not handle irregularly spaced data, this routine only works for surfaces defined on a rectangular grid. The matrices or vectors X and Y define the axis limits only. SURF 3-D colored surface. SURF(X,Y,Z,C) plots the colored parametric surface defined by four matrix arguments. The view point is specified by VIEW. The axis labels are determined by the range of X, Y and Z, or by the current setting of AXIS. The color scaling is determined by the range of C, or by the current setting of CAXIS. The scaled color values are used as indices into the current COLORMAP. The shading model is set by SHADING. SURF(X,Y,Z) uses C = Z, so color is proportional to surface height. SURF(x,y,Z) and SURF(x,y,Z,C), with two vector arguments replacing the first two matrix arguments, must have length(x) = n and length(y) = m where [m,n] = size(Z). In this case, the vertices of the surface patches are the triples (x(j), y(i), Z(i,j)). Note that x corresponds to the columns of Z and y corresponds to the rows. SURF(Z) and SURF(Z,C) use x = 1:n and y = 1:m. In this case, the height, Z, is a single-valued function, defined over a geometrically rectangular grid. SURF(...,'PropertyName',PropertyValue,...) sets the value of the specified surface property. Multiple property values can be set with a single statement. SURF returns a handle to a SURFACE object. SURFC Combination surf/contour plot. SURFC(...) is the same as SURF(...) except that a contour plot is drawn beneath the surface. Das nachfolgende Beispiel verwendet die vier Graphikbefehle in je einem Unterfenster zur

41

Darstellung der (äußerst dekorativen) Funktion

( )

100011000

1sin),(

22

22

++

++==

yx

yxyxfz

(der Summand 1000

1 im Nenner soll verhindern, daß durch Null dividiert wird. Dann muß aber für

gleiche Abmessungen auch der Zähler entsprechend angepaßt werden).

Die Befehlsfolge: %Darstellung einer Funktion z=f(x,y) als Fläche im Raum %Erstellung der Datengitter x = -10 : 0.5 : 10; y = x; [xi, yi] = meshgrid(x, y); zi = sin(sqrt(xi.^2+yi.^2) + 0.001)./(sqrt(xi.^2+yi.^2)+0.001); %Darstellung mit Netz subplot(2, 2, 1); mesh(xi, yi, zi); title('Fall 1: Netz (mesh)'); %Darstellung mit Netz und Höhenlinien subplot(2,2,2); meshc(xi, yi, zi); title('Fall 2: Netz und Höhenlinien (meshc)'); %Darstellung der Oberfläche subplot(2, 2, 3); surf(xi, yi, zi); title('Fall 3: Fläche (surf)'); %Darstellung mit Fläche und Höhenlinien subplot(2, 2, 4); surfc(xi, yi, zi); title('Fall 4: Fläche mit Höhenlinien');

Dann ergibt sich folgendes Bild:

42

Wahl der Blickrichtung auf den Graphen mit view

Mit view(az, el) kann die Blickrichtung auf die 3D-Zeichnung geändert werden.

az gibt den sogenannten Azimutwinkel an,d.h. der Winkel in der x,y-Ebene zur x-Achse, und

el gibt den Höhenwinkel an, d.h. den Winkel über der x,y-Ebene.

Standardwert (wenn also nichts gesetzt): az = -37.5° und el = 30°.

view(3) setzt alles wieder auf den Standard zurück.

Dokumentation aus MATLAB: VIEW 3-D graph viewpoint specification. VIEW(AZ,EL) and VIEW([AZ,EL]) set the angle of the view from which an observer sees the current 3-D plot. AZ is the azimuth or horizontal rotation and EL is the vertical elevation (both in degrees). Azimuth revolves about the z-axis, with positive values indicating counter- clockwise rotation of the viewpoint. Positive values of elevation correspond to moving above the object; negative values move below. VIEW([X Y Z]) sets the view angle in Cartesian coordinates. The magnitude of vector X,Y,Z is ignored. Here are some examples: AZ = -37.5, EL = 30 is the default 3-D view. AZ = 0, EL = 90 is directly overhead and the default 2-D view. AZ = EL = 0 looks directly up the first column of the matrix. AZ = 180 is behind the matrix. VIEW(2) sets the default 2-D view, AZ = 0, EL = 90. VIEW(3) sets the default 3-D view, AZ = -37.5, EL = 30.

43

[AZ,EL] = VIEW returns the current azimuth and elevation. VIEW(T) accepts a 4-by-4 transformation matrix, such as the perspective transformations generated by VIEWMTX. T = VIEW returns the current general 4-by-4 transformation matrix. VIEW(AX,...) uses axes AX instead of the current axes.

Betrachten wir ein Beispiel:

Der Graph von f(x, y) = x² - y² beschreibt eine Sattelfläche.

Wir lassen sie einmal mit Standard ausgegen, danach mit az = 90° und el = 0° und zu guter Letzt

mit az = 0° und el = 90°.

Befehlsfolge: %Drehung einer Fläche im Raum - der Befehl view %Beispiel Funktion z=x²-y² %Bereitstellung der Daten x = -5:0.1:5; y = x; [xi, yi] = meshgrid(x, y); zi = xi.^2 - yi.^2; %Standardwiedergabe (az = -37.5°, el= 30°) mesh(xi, yi, zi); xlabel('x'); ylabel('y'); zlabel('z'); title('Standardwiedergabe (az = -37.5° el = 30°'); %Blick direkt auf x-Achse figure; mesh(xi, yi, zi); view(90, 0); ylabel('y'); zlabel('z'); title('Blick direkt auf x-Achse (az = 90°, el = 0°)'); %Blick von oben (az = 0°, el = 90°) figure; mesh(xi, yi, zi); view(0, 90); xlabel('x'); ylabel('y'); title('Blick von oben (az = 90°, el = 0°)'); bzw. direkt im Kommandofenster:

44

Die Standardausgabe (az = -37.5°, el = 30°) hat dann folgendes Aussehen:

die x,y-Ebene erscheint für den Betrachter hochgekippt zu sein, so daß er auf diese sieht (das sind

45

die 30° = el); sowohl x- als auch y-Achse laufen nicht parallel zur Bildkante, sondern schräg dazu

(da machen sich die az = -37.5° bemerkbar).

Es erscheint eine wunderschöne Sattelfläche, die zu y,z-Ebene hin offen ist.

Ändert man dagegeben Azimut- und Höhenwinkel, so erhält man für az = 90° und el = 0° folgendes

Bild:

Der Blick fällt direkt auf die y,z-Ebene; die x-Achse ist nur noch als Nullpunkt wahrzunehmen, die

x,y-Ebene nur noch in der y-Achse. Der Betrachter sieht also frontal in die Sattelfläche (längs der

x-Achse) hinein.

Und ändert man erneut az = 0° und el = 90°, so betrachtet man die Welt von oben.

46

Der Betrachter steht jetzt senkrecht über der x,y-Ebene; die z-Achse ist nur noch als Nullpunkt des

Koordinantenschnittpunktes der x- und y-Achse zu sehen. Damit fällt die Blickrichtung direkt von

oben auf dden Sattel. Zur erahnen sind die Höhenlinien x²-y²=const, die Hyperbeln bilden.

Am besten, man probiert die verschiedenen Blickwinkel selber aus.

Zurücksetzen aller Figuren in einem Graphikfenster mit clf reset

Wenn eine graphische Darstellung bereits in einem Fenster gezeichnet worden ist und dieses

Fenster für eine völlig neue Figur benutzt werden soll, setzt clear all

zwar die Inhalte der verwendeten Variablen zurück; neue Zeichenbefehle setzen die Beschriftung

der Überschrift und der Achsen zurück. Jedoch sind nicht automatisch alle Eigenschaften wie

Hintergrundfarbe oder Schriftgröße wieder auf Standard zurückgesetzt worden.

Abhilfe schafft folgendes Kommando:

Das Kommando clf mit der reset Option in der Form clf reset

setzt alle Eigenschaften wieder auf den Standard zurück.

Es gibt noch sehr viele weitere Befehle in Verbind mit einer geeigneten 3D-Darstellung; doch ist man dann gut beraten, die Dokumentation oder andere Kundige zu konsultieren....

47