Funktionsdarstellung - Cinderella Dokumentation
Description: The user's guide to the Interactive Geometry Software Cinderella

Zum Inhalt

# Funktionsdarstellung

Cinderella bietet mehrere Operatoren, mit denen Informationen über mathematische Funktionen dargestellt werden können. Neben einfacher Funktionsdarstellung können auch Informationen über Extrema, Nullstellen und Wendepunkte angezeigt werden.

### Funktionen

Die folgenden Funktionen ermöglichen das Zeichnen des Graphen einer Funktion, die eine reelle Zahl auf eine reelle Zahl abbildet.

#### Zeichnen einer Funktion: `plot(<expr>)`

Beschreibung: Der `plot`-Operator kann verwendet werden, um eine Funktion zu zeichnen. Die Funktion muss als Ausdruck `<expr>` angegeben werden. Dieser Ausdruck muss die Laufvariable `#` enthalten und entweder einen Realwert für eine reelle Eingabe von `#` oder einen zweidimensionalen Vektor berechnen. Im ersten Fall zeichnet der `plot`-Operator einfach die Funktion. Im zweiten Fall zeichnet er einen parametrischen Graph einer Funktion. Das Koordinatensystem ist an das Koordinatensystem der geometrischen Ansichten gebunden. Statt `#` werden auch andere Laufvariablen automatisch erkannt. Wenn es nur eine freie Variable gibt, wird diese Variable als Laufvariable verwendet. Wenn es mehrere freie Variablen gibt, durchsucht die `plot(...)`-Funktion typische Namen in der Reihenfolge `x`, `y`, `t`, `z`.

Beispiele: In seiner einfachsten Form kann der `plot`-Operator direkt zum Zeichnen einer Funktion verwendet werden. Die Zeile `plot(sin(#))` zeichnet sofort die Funktion sin(x). Der gleiche Graph wird durch `plot(sin(x))` erzeugt.

Ebenso kann man zunächst eine Funktion definieren, deren Graph dann durch den `plot`-Operator angezeigt wird. Die folgenden Codezeilen erzeugen das folgende Bild:

    f(x):=1/(x^2+1)*sin(4*x);
    plot(f(x));

Wenn dieser mit einem Ausdruck `<expr>` aufgerufen wird, der einen zweidimensionalen Vektor als Ausgabe erzeugt, generiert der `plot`-Operator automatisch einen parametrischen Graph einer Kurve. Der Wertebereich für die Eingabevariable wird standardmäßig von 0 bis 100 angenommen. Diese Vorgaben können jedoch leicht durch Modifizierer geändert werden. Die Zeile `plot([sin(t),cos(t)]*t)` erzeugt die folgende Ausgabe:

Modifizierer: Der `plot`-Operator unterstützt viele verschiedene Modifizierer. Einige von ihnen müssen ausführlich erklärt werden. Sie können verwendet werden, um das Aussehen der Kurve zu ändern, den Plotbereich zu ändern, die Position auf dem Bildschirm zu ändern und sogar Maxima, Minima, Nullstellen und Wendepunkte der Funktion anzuzeigen. Ein Überblick über verfügbare Modifizierer wird in der folgenden Tabelle gegeben. Beachten Sie, dass einige der Modifizierer sogar mit verschiedenen Arten von Argumenten aufgerufen werden können, was zu etwas unterschiedlichen Effekten führt.

Modifizierer | Parameter | Effekt
--- | --- | ---
Aussehen |  |
`color` | `[<real1>,<real2>,<real3>]` | Farbe auf bestimmten Wert setzen
`size` | `<real>` | Liniengröße auf bestimmten Wert setzen
`alpha` | `<real>` | Deckkraft setzen
`connect` | `<true>` | Sprünge in Funktionen verbinden
Iterations-Kontrolle |  |
`start` | `<real>` | Startwert für das Funktionszeichnen setzen
`stop` | `<real>` | Endwert für das Funktionszeichnen setzen
`steps` | `<real>` | Anzahl der gesetzten Plotpunkte (nur für parametrische Funktionen)
`pxlres` | `<real>` | Pixelauflösung der Kurvendarstellung (nur für reelle Funktionen)
Signifikante Punkte |  |
`extrema` | `<bool>` | alle Extrema markieren
`extrema` | `[<real1>,<real2>,<real3>]` | alle Extrema in angegebener Farbe markieren
`minima` | `<bool>` | alle Minima markieren
`minima` | `[<real1>,<real2>,<real3>]` | alle Minima in angegebener Farbe markieren
`maxima` | `<bool>` | alle Maxima markieren
`maxima` | `[<real1>,<real2>,<real3>]` | alle Maxima in angegebener Farbe markieren
`zeros` | `<bool>` | alle Nullstellen markieren
`zeros` | `[<real1>,<real2>,<real3>]` | alle Nullstellen in angegebener Farbe markieren
`inflections` | `<bool>` | alle Wendepunkte markieren
`inflections` | `[<real1>,<real2>,<real3>]` | alle Wendepunkte in angegebener Farbe markieren
Linienstil |  |
`dashing` | `<real>` | Breite der Strichmuster (Standard 5)
`dashtype` | `<int>` | ein bestimmter Strichtyp (Werte 0...4 sind zulässig)
`dashpattern` | `<list>` | ein individuelles Strichmuster angeben

Beispiele: Hier sind einige Beispiele, die die Verwendung der Modifizierer demonstrieren:

Man kann den Plotbereich leicht variieren, indem man die Start- und Stoppwerte setzt. Zum Beispiel hilft `plot(f(#),start->A.x,stop->B.x)` dabei, das Plotten mit den x-Koordinaten zweier freier Konstruktionspunkte zu steuern.

##### Plotaussehen

Die Auflösung des Plots wird automatisch und adaptiv gesteuert. Die `plot(...)`-Funktion erhöht ihre Auflösung automatisch in der Nähe von Singularitäten. Der folgende Plot zeigt die Ausgabe des Aufrufs `plot(sin(1/#)*#)`. Beachten Sie die Qualität des Plots in der Nähe des Ursprungs.

Normalerweise werden Sprünge in Funktionen erkannt und standardmäßig nicht verbunden. Man kann sie gezielt verbinden, indem man `connect->true` setzt.

`plot(x-floor(x))` | `plot(x-floor(x),connect->true)` |

##### Spezielle Punkte

Mit den Modifizierern für die signifikanten Punkte einer Kurve können Nullstellen, Minima, Maxima und Wendepunkte angezeigt werden. Die folgenden drei Bilder demonstrieren die Verwendung dieser Operatoren.

`zeros->true`
`extrema->true`
`inflections->true`

##### Strichmuster

Die Strichmuster-Optionen für eine Plot-Anweisung sind identisch mit denen für Linien und Kreise. Sie können durch die Modifizierer `dashing`, `dashtype` und `dashpattern` gesteuert werden.

- `dashtype` kann eine ganze Zahl zwischen 0 und 4 sein und wählt eines von vier vordefinierten Strichmustern aus. Der Wert 0 erstellt eine durchgehende Linie.
- `dashing` ist eine Realzahl, die die Einheitsgröße der Striche angibt. Einfaches Setzen von `dashing->5` erzeugt bereits ein Standard-Strichmuster.
- `dashpattern` kann auf eine Liste gesetzt werden, die die Länge der aufeinanderfolgenden Striche und Leerzeichen angibt.

Das folgende Bild wurde mit `plot(sin(x),dashpattern->[0,3,7,3],size->2,dashing->5)` erstellt

### Dynamische Farbe und Deckkraft

Die `color` und die `alpha` können wiederum Funktionen sein, die von der Laufvariablen abhängen. Auf diese Weise können die Deckkraft und die Farbe des Funktionsgraphen entlang der Funktion variiert werden. Der folgende Plot wurde mit der Anweisung erzeugt

    ![](../assets/wiki_up/DashPlot.png)

    plot(sin(x),color->hue(x/(2*pi)),size->3)

Hier wurde die `hue`-Funktion verwendet, die zyklisch Regenbogenfarben erzeugt.

#### Zeichnen einer Funktion: `plot(<expr>,<var>)`

Beschreibung: Identisch mit `plot(<expr>)` aber mit einer angegebenen Laufvariablen.

#### Zeichnen von integralartigen Effekten: `fillplot(<expr>)`

Beschreibung: Oft ist es wünschenswert, die Fläche zwischen einem Funktionsgraphen und der x-Achse des Koordinatensystems hervorzuheben (zum Beispiel beim Erstellen eines Applets zur Erklärung von Integralen). Dies kann mit der Funktion `fillplot` erreicht werden. Ähnlich wie `plot` verwendet dieser Operator eine Funktion als Argument (die Laufvariable wird durch denselben Prozess wie in `plot(...)` bestimmt). In seiner einfachsten Form hebt dieser Operator einfach die von der Funktion durchlaufene Fläche hervor. Die Funktion selbst wird nicht gezeichnet. Dies könnte durch explizites Aufrufen des `plot(...)`-Operators erfolgen. Der folgende Code

    f(x):=1/(x^2+1)*sin(4*x);
    fillplot(f(x));
    plot(f(x));

erzeugt das folgende Bild:

Warnung: Die Singularitätsbehandlung der `fillplot(...)`-Anweisung ist bei weitem weniger subtil als die der `plot(...)`-Anweisung. Obwohl die Modifizierer das Zeichnen von Funktionen auch mit `fillplot` ermöglichen, sollte man `plot` zum Funktionszeichnen verwenden.

Modifizierer:

Modifizierer | Parameter | Effekt
--- | --- | ---
Aussehen |  |
`color` | `[<real1>,<real2>,<real3>]` | Farbe auf bestimmten Wert setzen
`pluscolor` | `[<real1>,<real2>,<real3>]` | Farbe für positive Funktionswerte setzen
`minuscolor` | `[<real1>,<real2>,<real3>]` | Farbe für negative Funktionswerte setzen
`alpha` | `<real>` | Deckkraft setzen

| Iterations-Kontrolle | | | | `start` | `<real>` | Startwert für das Funktionszeichnen setzen | | `stop` | `<real>` | Endwert für das Funktionszeichnen setzen |

| Funktionsgraph | | | | `graph` | `<bool>` | auch den Funktionsgraphen zeichnen | | `graph` | `[<real1>,<real2>,<real3>]` | auch den Funktionsgraphen in angegebener Farbe zeichnen | | `size` | `<real>` | Liniengröße für den Funktionsgraphen setzen |

Der `color`- und der `alpha`-Modifizierer unterstützen wiederum die Verwendung von Funktionen, die Farbe und Deckkraft steuern (ähnlich wie `plot`). Der folgende Sampler illustriert verschiedene Verwendungen der `fillplot`-Anweisung:

`fillplot(sin(x))`
`fillplot(sin(x),graph->true)`
`fillplot(sin(x),graph->true,color->(sin(x),-sin(x),0))`

#### Zeichnen von integralartigen Effekten: `fillplot(<expr1>,<expr2>)`

Beschreibung: Diese Funktion ist der `fillplot(...)`-Anweisung sehr ähnlich. Statt jedoch die Fläche zwischen einer Funktion und der x-Achse hervorzuheben, hebt sie die Fläche zwischen zwei Funktionen hervor.

Das folgende Bild

wurde mit der Anweisung erstellt

    fillplot(sin(x),cos(x),graph->true,pluscolor->(.5,1,.5),minuscolor->(1,.5,.5))

Modifizierer: Diese Anweisung unterstützt genau die gleichen Modifizierer wie `fillplot(...)`.

### Farbdiagramme

Farbdiagramme sind nützlich, um visuelle Informationen über Funktionen zu erstellen, die in der gesamten Ebene definiert sind. Sie können jedem Punkt in einem Rechteck einen Farbwert zuordnen.

#### Erstellen eines Farbdiagramms: `colorplot(<expr>,<vec>,<vec>)`

Beschreibung: Der `colorplot`-Operator ermöglicht die Visualisierung einer ebenen Funktion. Zu jedem Punkt eines Rechtecks kann ein Farbwert durch eine Funktion zugeordnet werden. In der Funktion `<expr>` kann die Laufvariable als `#` gewählt werden (für weitere Informationen über Laufvariablen siehe unten). Es ist jedoch wichtig zu beachten, dass diese Variable jetzt einen Punkt in der Ebene beschreibt (dies ist eine Variable mit zweidimensionalen Koordinaten). Der Rückgabewert von `<expr>` sollte entweder eine reelle Zahl sein (in welchem Fall ein Grauwert zugeordnet wird) oder ein Vektor von drei reellen Zahlen (in welchem Fall ein RGB-Farbwert zugeordnet wird). In jedem Fall sollten die Werte der reellen Zahlen zwischen 0 und 1 liegen. Das zweite und dritte Argument bestimmen die untere linke und obere rechte Ecke des Zeichenbereichs.

Beispiel: Der folgende Code und zwei Punkte A und B erzeugen das folgende Bild. In der ersten Zeile wird eine reellwertige Funktion definiert, die zwei Punkten den Sinus des Abstands zwischen ihnen zuordnet (verschoben und skaliert, um in das Intervall [0, 1] zu passen). Das erste Argument des `colorplot`-Operators ist jetzt ein Vektor von drei Zahlen, die von der Laufvariablen `#` abhängen (der rote Teil ist eine zirkuläre Welle um A, der grüne Teil ist null und der blaue Teil ist eine zirkuläre Welle um B). Schließlich markieren C und D die Ecken des Rechtecks.

    f(A,B):=((1+sin(2*dist(A,B)))/2);
    colorplot(
       (f(A,#),0,f(B,#)),
       C,D
    )

Laufvariablen: Normalerweise ist `#` eine gute Wahl für die Laufvariable in der `colorplot`-Funktion. Es sind jedoch auch andere Wahlen möglich. Die Möglichkeiten für Laufvariablen werden in der folgenden Reihenfolge überprüft:

- Wenn es nur eine freie Variable in `<expr>` gibt, wird diese Variable als Laufvariable verwendet und als zweidimensionaler Vektor interpretiert.
- Wenn `<expr>` `#` enthält, wird `#` als Laufvariable verwendet (wiederum als zweidimensionaler Vektor)
- Wenn `<expr>` sowohl `x` als auch `y` als freie Variablen enthält, können diese beiden Variablen als Laufvariablen verwendet werden, die zusammen den Vektor `(x,y)` darstellen.
- Wenn genau eine freie Variable noch nicht zugewiesen ist, wird diese Variable verwendet (als Vektor)
- Falls keines der obigen Punkte zutrifft, werden auch `p` (für Punkt) und `z` (für komplexe Zahl) als Laufvariablen überprüft.

Zum Beispiel die folgende Zeile

    ![](../assets/wiki_up/ColPlot2X.png)

    colorplot((sin(2*x),sin(2*y),0),A,B)

erzeugt das folgende Bild:

Modifizierer: Der `colorplot`-Operator unterstützt drei Modifizierer. Der Modifizierer `pxlres` kann auf eine ganze Zahl gesetzt werden, die die Größe in Pixeln der elementaren Quadrate des Farbdiagramms bestimmt. Das obige Bild wurde mit `pxlres->2` aufgenommen, was der Standardwert ist. Das Setzen des `pxlres`-Modifizierers auf 1 oder 2 erzeugt atemberaubende Bilder. Jedoch sollte man sich bewusst sein, dass für jedes elementare Quadrat der `colorplot`-Ausgabe die Funktion einmal ausgewertet werden muss. Der Rechenaufwand wächst quadratisch, wenn `pxlres` linear reduziert wird. Also ist es manchmal auch eine gute Praxis, den pxlres-Modifizierer zu reduzieren, um mehr Leistung zu gewinnen. Das folgende Bild wurde mit `pxlres->8` gerendert.

Man kann auch die Auflösung dynamisch ändern. Hierfür gibt es einen anderen Modifizierer `startres`, der für allmählich bessernde Plots verwendet werden kann und somit das Beste aus zwei Welten kombiniert. Wenn Sie beispielsweise sowohl `startres->16` als auch `pxlres->1` verwenden, erhalten Sie während interaktiver Bewegungen ein grobes Plot, das automatisch mit einer feineren Auflösung neu berechnet wird, wenn genügend Zeit vorhanden ist.

Außerdem unterstützt der `colorplot`-Operator einen Modifizierer `alpha`, der verwendet wird, um die Deckkraft zu steuern. Dieser Modifizierer kann sogar auf Werte gesetzt werden, die parametrisch von der Laufvariablen abhängen.

Das folgende Bild wurde durch den folgenden Code erzeugt, der nur eine leichte Änderung des Codes eines der vorherigen Beispiele ist:

    f(A,B):=((1+sin(2*dist(A,B)))/2);
    colorplot(
       (f(A,#),0,f(B,#)),
       C,D,
       pxlres->2,
       alpha->-abs(#)+5
    )

### Vektorfelder

Vektorfelder können verwendet werden, um Strömungen und Kräfte zu visualisieren. Sie haben viele Anwendungen bei der Visualisierung von Systemen von Differentialgleichungen.

#### Zeichnen eines Vektorfeldes: `drawfield(<expr>)`

Beschreibung: Der `drawfield`-Operator kann verwendet werden, um ein Vektorfeld zu zeichnen. Die Funktion muss als Ausdruck `<expr>` angegeben werden. Dieser Ausdruck muss eine Laufvariable enthalten (normalerweise `#`), die diesmal einen zweidimensionalen Vektor darstellen sollte (wie bei Farbdiagrammen). Das Ergebnis sollte auch ein zweidimensionaler Vektor sein. Das Anwenden des Operators `drawfield` auf diesen Ausdruck führt zur Darstellung des entsprechenden Vektorfeldes. Das Feld wird animiert. Dies bedeutet, dass es sich bei jedem Bild leicht ändert. Daher ist es oft sinnvoll, den `drawfield`-Operator in den „Timer Tick"-Evaluierungsslot zu setzen. Dies erstellt ein Animationssteuerelement in der geometrischen Ansicht. Das Ausführen der Animation wird das Vektorfeld automatisch animieren. Die Laufvariablenpolicy ist identisch mit der in der `colorplot(...)`-Anweisung. Insbesondere ist es möglich, freie Variablen `x` und `y` zu verwenden, um die zweidimensionale Position `(x,y)` darzustellen

Beispiele: Wir betrachten ein Vektorfeld, das durch die Funktion `f(x,y)=(y,sin(x))` definiert wird. Der entsprechende Code mit der Funktionsdefinition und dem Aufruf des `drawfield`-Operators lautet wie folgt:

    f(v):=[v.y,sin(v.x)];
    drawfield(f(#));

Alternativ könnte das gleiche Bild durch generiert werden

    drawfield([y,sin(x)]);

Um das Bild zu erzeugen, wird eine Sammlung von nadelartigen Objekten auf die Zeichenfläche geworfen. Diese Nadeln werden gemäß dem Vektorfeld ausgerichtet. Während der Animation bewegen sich die Nadeln gemäß dem Vektorfeld. Es ist auch möglich, die Nadeln durch kleine schlangenähnliche Objekte zu ersetzen, die einen genaueren Eindruck des Vektorfeldes vermitteln, aber länger zur Berechnung benötigen. Dies kann mit einem geeigneten Modifizierer erfolgen.

    f(v):=[v.y,sin(v.x)];
    drawfield(f(#),stream->true,color->(0,0,0));

Modifizierer: Der `drawfield`-Operator unterstützt viele Modifizierer, die den Generierungsprozess des Vektorfeldes steuern. Um zu helfen, sie zu verstehen, beschreiben wir zunächst etwas ausführlicher, wie die Bilder erzeugt werden.

Die Bilder werden durch die Anzeige der Bewegung einiger Testobjekte unter dem Einfluss des Feldes erzeugt. Standardmäßig sind die Testobjekte nadelartig. Sie sind zunächst auf einem regulären Gitter angeordnet. Da dies normalerweise viele visuelle Artefakte erzeugt, werden sie zufällig innerhalb eines bestimmten Radius um die Gitterpunkte verzerrt. Während einer Animation werden die Nadeln in der Richtung des Kraftfeldes bewegt. Die Länge der Nadeln stellt die Stärke des Feldes dar.

Modifizierer | Parameter | Effekt
--- | --- | ---
Testobjekte |  |
`resolution` | `integer` | ursprüngliche Gitterzellensgröße in Pixeln
`jitter` | `integer` | Verzerrung der Testobjekte
`needlesize` | `<real>` | maximale Größe der Nadeln
`factor` | `<real>` | Skalierungsfaktor der Feldstärke
`stream` | `<bool>` | Nadeln oder Streamlets verwenden
`move` | `<real>` | Geschwindigkeit der bewegten Objekte
Aussehen |  |
`color` | `[<real1>,<real2>,<real3>]` | Streamlet-Farbe oder erste Nadelfarbe setzen
`color2` | `[<real1>,<real2>,<real3>]` | zweite Nadelfarbe setzen

Das folgende Bild zeigt das ursprüngliche Gitter. Es wurde mit `move->0` und `jitter->0` gerendert. Es zeigt deutliche Artefakte, die aus unnatürlicher Ausrichtung in horizontaler oder vertikaler Richtung resultieren.

Das folgende Bild wurde mit `resolution->5` und `stream->true` gerendert.

#### Zeichnen eines komplexen Vektorfeldes: `drawfieldcomplex(<expr>)`

Beschreibung: Dieser Operator ist dem `drawfield`-Operator sehr ähnlich. Es nimmt jedoch eine eindimensionale komplexe Funktion als Eingabe. Die Real- und Imaginärteile werden als x- und y-Komponenten für das Vektorfeld behandelt. Ansonsten ist der Operator vollständig analog zum vorherigen.

Beispiel: Das folgende Beispiel zeigt die Verwendung des Operators mit einem komplexen Polynom, dessen Nullstellen durch vier Punkte in der Zeichnung bestimmt werden:

    f(x):=(x-complex(A))*(x-complex(B))*(x-complex(C))*(x-complex(D));
    drawfieldcomplex(f(#),stream->true,resolution->5,color->(0,0,0))

Die Modifizierer sind analog zu denen für die `drawfield`-Operatoren.

#### Zeichnen eines Kraftfeldes: `drawforces()`

Beschreibung: Dieser Operator ist wiederum dem `drawfield`-Operator sehr ähnlich. Dieses Mal ist er jedoch mit einer Physik-Simulation in CindyLab verbunden. Es sind keine Argumente erforderlich, und er zeigt die Kräfte auf eine hypothetische Testladung, die an verschiedenen Stellen auf dem Bildschirm platziert wird. Die Testladung hat Masse = 1, Ladung = 1 und Radius = 1. Allerdings wird kein anderes Teilchen mit ihr wechselwirken. Manchmal ist es notwendig, den `factor`-Modifizierer zu verwenden, um das Kraftfeld zu verstärken. Das folgende Beispiel zeigt die Wechselwirkung unter vier geladenen Partikeln.

#### Zeichnen des Kraftfeldes eines Punktes: `drawforces(<mass>)`

Beschreibung: Es gibt einen weiteren Operator, der das Kraftfeld bezüglich eines fest definierten Massenpartikels zeichnet. Das Teilchen selbst nimmt nicht an der Berechnung der Kräfte teil. Auf diese Weise kann man die Kräfte visualisieren, die auf ein bestimmtes Teilchen wirken.

### Gitter

Gitter können verwendet werden, um Transformationen zu visualisieren, die die Ebene auf sich selbst abbilden. Mit Gittern kann die durch eine solche Abbildung induzierte Verformung visualisiert werden.

#### Abbilden eines rechteckigen Gitters: `mapgrid(<expr>)`

Beschreibung: Dieser Operator nimmt ein rechteckiges Gitter und verformt es durch eine in `<expr>` angegebene Funktion. Standardmäßig wird der Bereich des ursprünglichen Gitters als das Einheitsquadrat in der Ebene angenommen. Die Grenzen dieses Rechtecks können mithilfe von Modifizierern geändert werden. Es ist auch möglich, komplexe Abbildungen zu visualisieren, indem der Modifizierer `complex->true` verwendet wird.

Modifizierer: Es gibt mehrere Modifizierer, die das Verhalten dieser Funktion steuern.

Modifizierer | Parameter | Effekt
--- | --- | ---
Aussehen |  |
`color` | `[<real1>,<real2>,<real3>]` | Farbe auf bestimmten Wert setzen

| `alpha` | `<real>` | Deckkraft setzen | | `size` | `<real>` | Größe der Gitterlinien setzen | | Iterations-Kontrolle | | | | `xrange` | `[<real>,<real>]` | x-Bereich des Quellrechtecks | | `yrange` | `[<real>,<real>]` | y-Bereich des Quellrechtecks | | `resolution` | `<int>` | Anzahl der Gitterlinien in beide Richtungen | | `resolutionx` | `<int>` | Anzahl der Gitterlinien in x-Richtung | | `resolutiony` | `<int>` | Anzahl der Gitterlinien in y-Richtung | | `step` | `<int>` | Verfeinerung in beide Richtungen | | `stepx` | `<int>` | Verfeinerung in x-Richtung | | `stepy` | `<int>` | Verfeinerung in y-Richtung | | Typ | | | | `complex` | `<boolean>` | komplexe Funktionen verwenden |

Beispiele: Das folgende Stück Code exemplifiziert die Verwendung des `mapgrid`-Operators. Es illustriert auch die Auswirkung der Modifizierer `xrange` und `yrange`. Es zeigt die Auswirkung einer zweidimensionalen Funktion, die die x- und die y-Koordinate separat quadriert.

    f(v):=(v_1^2,v_2^2);
    linesize(1.5);
    mapgrid(f(v),color->(0,0,0));
    mapgrid(f(v),xrange->[1,2],color->(.6,0,0));
    mapgrid(f(v),yrange->[1,2],color->(.6,0,0));
    mapgrid(f(v),xrange->[1,2],yrange->[1,2],color->(0,.6,0));

Im folgenden Beispiel sehen wir, dass die Gitterlinien im Allgemeinen nicht gerade oder parallel bleiben müssen.

    f(v):=(v_1*sin(v_2),v_2*sin(v_1));
    linesize(1.5);
    mapgrid(f(v),xrange->[1,2],yrange->[1,2]);

Das folgende einfache Beispiel illustriert die Verwendung von `mapgrid` für komplexe Funktionen.

    mapgrid(z^2,complex->true);

Mit dem Modifizierer `resolution` können Sie die Anzahl der erzeugten Gitterlinien angeben.

    mapgrid(z^2,complex->true,resolution->4);

Standardmäßig verbindet der Befehl `mapgrid` die Gitterpunkte direkt. Dies kann zu Bildern führen, die die mathematische Wahrheit nicht wirklich widerspiegeln. Mit dem Modifizierer `step` können Sie zusätzliche Schritte zwischen den Gitterpunkten einführen.

    mapgrid(z^2,complex->true,resolution->4,step->5);

Die Ergebnisse der letzten drei Codestücke sind unten dargestellt.

Gitter tragen sehr charakteristische Informationen über komplexe Funktionen. Die folgenden drei Bilder zeigen Gitter für die Funktionen `z*z`, `sin(z)`, `1/z` und `tan(z)` beziehungsweise.

### Oszillographen

Oszillographen ermöglichen die Visualisierung dynamischer Änderungen von Werten in physikalischen Simulationen und Animationen.

#### Kurvendarstellung von physikalischen Größen: `drawcurves(<vec>,<list>)`

Beschreibung: In realen und simulierten physikalischen Situationen ist man oft daran interessiert, Kurven zu zeichnen, die zeigen, wie sich Größen im Laufe der Zeit entwickeln. Zu diesem Zweck wurde der `drawcurves`-Operator erstellt. Hier ist `<vec>` ein zweidimensionaler Vektor, der auf die untere linke Ecke des Zeichenbereichs verweist, und `<list>` ist eine Liste von Werten, die beobachtet werden sollen. Wenn die Animation ausgeführt wird, werden die Werte aktualisiert und die entsprechenden Kurven werden gezeichnet.

Beispiel: Das folgende Bild zeigt eine sehr einfache Anwendung des `drawcurves`-Operators. In CindyLab wurde ein physikalisches Pendel konstruiert. Der folgende Code erzeugt eine Kurvendarstellung der x-Koordinate des bewegten Punktes und seiner x-Geschwindigkeit:

    drawcurves([0,0],[D.x,D.vx])

Modifizierer: Der `drawcurves`-Operator unterstützt viele Modifizierer. Sie können verwendet werden, um das Aussehen der Kurven zu ändern und zusätzliche Informationen anzuzeigen.

Modifizierer | Parameter | Effekt
--- | --- | ---
Dimension |  |

| `width` | `<real>` | Pixelbreite des Plotbereichs | | `height` | `<real>` | Pixelhöhe für jede Kurve | | Aussehen | | | | `border` | `<bool>` | Grenzen der Tabelle anzeigen | | `back` | `<bool>` | Hintergrund anzeigen | | `back` | `[<real1>,<real2>,<real3>]` | Hintergrund in angegebener Farbe anzeigen | | `backalpha` | `<real>` | Deckkraft des Hintergrunds | | `colors` | `[<col1>,<col2>,<col3>,...]` | Farbe für jede Kurve bereitstellen | | Information | | | | `texts` | `[<text1>,<text2>,...]` | Beschriftung für jede Kurve bereitstellen | | `showrange` | `<bool>` | maximale und minimale Werte für jede Kurve anzeigen | | Rendering | | | | `range` | `<string>` | „peek" skaliert auf das absolut gemessene Maximum, „auto" skaliert auf den aktuell angezeigten Teil der Kurve | | `range` | `[<string1>,<string2>,...]` | individuelles „peek"/„auto" für jede Kurve |

Das folgende Stück Code demonstriert die Verwendung der Modifizierer. Es zeigt ein schwach gekoppeltes Pendel und sein Energieverhalten.

    linecolor((1,1,1));
    textcolor((0,0.8,0));
    drawcurves([-7,-3],
      [A.x,B.x,A.ke,B.ke,a.pe+b.pe+c.pe],
      height->50,
      color->(1,1,1),
      back->(0,0,0),
      backalpha->1,
      range->"peek",width->400,
      colors->[

    ![](../assets/wiki_up/Drawcurves1X.png)
        [1,0.5,0.5],
        [0.5,1,0.5],
        [1,0.5,0.5],
        [0.5,1,0.5],
        [0.5,0.5,1]],
      texts->[
        "PosA = "+ A.x,
        "PosB = "+B.x,
        "EnergyA = "+A.ke,
        "EnergyB = "+B.ke,
        "PotentialEnergy = "+(a.pe+b.pe+c.pe)
    ]
    );

Die entsprechende Zeichnung sieht wie folgt aus:

Diese Seite wurde automatisch mit KI (Claude) übersetzt und wartet noch auf Überprüfung. → Alle KI-übersetzten Seiten