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.

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.

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.

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:

| 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:

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.

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.

| 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.

| 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