Euler Math Toolbox ist ein Programm, das aus dem numerischen Programm Euler und dem symbolischen Algebraprogramm Maxima besteht, und beide Welten zu einem gemeinsamen, integrierten System zusammen führt. Der numerische Teil, die Oberfläche, und die Kommunikation mit Maxima wurde von R. Grothmann an der Universität Eichstätt entwickelt. Das ausgereifte Computer-Algebra-System Maxima ist ein Open-Source-Programm, das von einer Community betreut wird. Die Hauptsprache für Euler ist Englisch. Mit Euler wird aber ein deutsches Skript über numerische Mathematik installiert, dessen erstes Kapitel eine Einführung in die Euler enthält. In den weiteren, mathematischen Kapiteln gibt es viele Beispiele für numerische Algorithmen in Euler. Die aktuelle Version öffnet sich durch Doppelklick auf den folgenden Link. http://euler.rene-grothmann.de/german/Numerik-Skript.pdf Geben Sie bitte die folgenden Kommandos ein, indem Sie die Eingabetaste an einer beliebigen Stelle der Kommandozeile drücken. Sie können jederzeit mit den Pfeiltasten zu vorherigen Kommandos zurückkehren.
>sqrt(sin(10°)/cos(20°))
0.429875017772
Euler beherrscht die üblichen mathematischen Funktionen. Wie Sie sehen, rechnet Euler bei trigonometrischen Funktionen im Bogenmaß. Deswegen muss mit dem Gradsymbol (oder alternativ mit der Funktion "deg") auf Grad umgerechnet werden. Die Quadratwurzel heißt sqrt. Es kann aber auch x^(1/2) verwendet werden. Variablen werden mit "=" oder ":=" gesetzt. Wir verwenden hier der Deutlichkeit halber ":=". Mehrere Kommandos in einer Zeile werden mit Kommas "," oder Semikolons ";" getrennt. Das Semikolon unterdrückt die Ausgabe des Kommandos. Das Komma am Ende einer Zeile kann fehlen.
>g:=9.81; t:=2.5; 1/2*g*t^2
30.65625
Euler kann auch mit Einheiten umgehen. Einheiten werden aber nicht auf Korrektheit überprüft. Die gespeicherten Werte sollten im Internationalen Standard (IS, also Meter, Sekunden etc.) sein. Im folgenden Kommando rechnen wir Lichtjahre in km um. Dazu gibt es die spezielle Syntax ->.
>0.45ly->km
4.25732871266e+012
Brüche kann der numerische Teil von Euler nur zur Ausgabe verwenden. (Maxima kann mit Brüchen rechnen.) Die interne Rechengenauigkeit ist unabhängig von der Ausgabe der IEEE-Standard von 15-16 dezimalen Stellen.
>1/3+1/7, frac(%)
0.47619047619 10/21
Der numerische Teil von Euler Math Toolbox plottet Funktionen in einen separaten Fenster. Das Fenster wird nur während des Plots angezeigt. Es kann aber jederzeit mit der TAB-Taste nach oben geholt werden. Die einfachste Art zu plotten, verwendet Ausdrücke. Das sind Zeichenketten mit mathematischen Funktionen der Variablen "x".
>plot2d("sin(x)/x",-2pi,2pi);
Drücken Sie die TAB-Taste, um den Plot zu sehen, falls das Fenster auf Ihrem Bildschirm verdeckt ist. Mehrere Plots kann man in dasselbe Fenster plotten, indem man dem Parameter "add=true" (oder ">add") setzt. Die Farbe bestimmt man mit "color=...". Es gibt einige vordefinierte Farben mit den Zahlenwerten 0 bis 15, sowie die Funktion "rgb(red,green,blue)". ../../reference/plot Wir fügen die Taylorreihe von sin(x)/x dazu.
Übrigens lassen sich solche Formeln im Kommentarfenster eingeben, wenn Latex installiert ist. Der Plot lässt sich auch in das Textfenster einfügen. Dazu gibt es das Kommando "insimg", oder man endet die Kommandozeile einfach mit einem Doppelpunkt ":". Die Grafiken im Textfenster werden mit dem Notebook als PNG abgespeichert und auch für den HTML-Export verwendet.
>plot2d("1-x^2/3!+x^4/5!",color=cyan,>add):
Eine weitere Möglichkeit ist, den Plot interaktiv zu machen. Der Benutzer kann dann mit den Pfeiltasten und +/- den Plot verschieben. Dies geht mit user=true (oder einfach >user). Das folgende Kommando ist zu lang für eine leicht lesbare Zeile. Deswegen teilen wir es in zwei Zeilen auf, die mit "..." verbunden sind.
>plot2d("sin(x)*exp(-x)",a=-2,b=2,grid=3, ... title="+/-, Pfeiltaste, Leertaste oder Return!",>user):
Die Funktion plot2d hat noch weit mehr Möglichkeiten. Für alle Details kann man "help plot2d" eingeben, oder die Deokumentation und die Referenz im Hilfemenü zu Rate ziehen. Es gibt auch ein einführendes Notebook über plot2d. Euler kann auch dreidimensionale Plots darstellen. Dazu verwenden wir Ausdrücke in "x" und "y".
>plot3d("x*y",r=2,>contour):
Die Möglichkeiten reichen bis zu impliziten Plots, bei denen die Nullstellenfläche einer Funktion in drei Variablen gezeichnet wird. Wir zeichnen die Menge
Der folgende Plot ist ein Anaglyph. Um den eindrucksvollen 3D-Effekt zu sehen, benötigt man eine Rot/Cyan-Brille.
>plot3d("x^2+y^2+4*x*z+z^3",implicit=1,r=2,>anaglyph):
Euler hat weit mehr numerische Verfahren, als wir in dieser Einleitung erwähnen können. Darunter sind auch Verfahren mit unendlicher Genauigkeit, sowie Intervall-Verfahren, die garantierte Einschließungen liefern. Das einfache "integrate" berechnet ein Integral adaptiv.
>integrate("exp(-x)*sin(x)/log(x)",2,3)
0.0659785778609
Die wesentliche schnellere Gauß-Quadratur ist genauso erfolgreich. Sie verwendet nur 10 Funktionsauswertungen. Für mehr Genauigkeit kann das Intervall in Teilintervalle unterteilt werden.
>gauss("exp(-x)*sin(x)/log(x)",2,3)
0.0659785778609
Eine weitere häufig verwendete Funktion ist das numerische Lösen von Gleichungen. Es wird das Sekantenverfahren mit einem einfachen Startwert verwendet.
>solve("cos(x)-x",1)
0.739085133215
Beispiel: Um eine Rendite zu berechnen, finden wir die Nullstelle des Polynoms
zwischen 0 und 1, und geben das Ergebnis in % aus.
>p:=[1000,-400,-400,-400]; q:=bisect("polyval(p,x)",0,1); ... print((1/q-1)*100,unit="%")
9.70%
Natürlich kann man auch alle reellen und komplexen Nullstellen von p berechnen. Die erste Nullstelle ist in diesem Fall unsere gesuchte Nullstelle in [0,1].
>polysolve(p), q=real(%[1]); "Zins: "|print((1/q-1)*100,unit="%")
[ 0.911568504717+0i -0.955784252358+1.35240604348i -0.955784252358-1.35240604348i ] Zins: 9.70%
Maxima läuft völlig separat von Euler. Die beiden Systeme können aber Variablen, Werte und Funktionen mit Hilfe symbolischer Ausdrücke und Funktionen austauschen. Solche Ausdrücke beginnen mit &... Wie alle symbolischen Algebraprogramme rechnet Maxima mit symbolischen Variablen und einer "unendlichen" Ganzahlarithmetik. Im folgenden Beispiel ist x eine Variable, der kein Wert zugewiesen sein darf.
>&expand((1+x)^5), &factor(%)
5 4 3 2 x + 5 x + 10 x + 10 x + 5 x + 1 5 (x + 1)
Maxima kann auch direkt aufgerufen werden. Dazu beginnt die Zeile mit :: (oder mit :, wenn die Originalsyntax von Maxima verwendet werden soll). Hier eine Demonstration der unendlichen Ganzzahl-Arithmetik. Diese Demo würde mit &... nicht funktionieren, da die Ausgabe von symbolischen Ausdrücken stets vereinfacht wird. Insbesondere werden Zahlen ausmultipliziert.
>:: factor(50!)
47 22 12 8 4 3 2 2 2 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47
Natürlich kann Maxima auch Differenzieren und Integrieren. Man kann an Ausdrücke mit "|" Flags anhängen, um zusätzliche Einstellungen zu erreichen. Im folgenden Fall verwenden wir "factor" als Flag, nicht als Funktion.
>&integrate(log(x)*x,x) | factor
2 x (2 log(x) - 1) ----------------- 4
Gleichungen kann man mit "solve" lösen.
>&solve(x^2-4*x+1=0,x)
[x = 2 - sqrt(3), x = sqrt(3) + 2]
Maxima gibt einen Vektor mit Lösungen zurück. Um auf eine bestimmte Lösung zuzugreifen, kann man indizieren, und die rechte Seite der Gleichung mit "rhs" isolieren. Wir bestätigen durch numerische Auswertung dieses Ergebnisses unsere numerische Rechnung von oben. Damit können wir die Aufgabe exakt lösen, die Euler nur numerisch lösen konnte. Allerdings ist die exakte Lösung in der Praxis oft nicht möglich, und wenn sie möglich ist, sind die Ausdrücke sehr unübersichtlich.
>&solve(1000-400*x-400*x^2-400*x^3,x); &rhs(%[3]), 100*(1/%()-1)
sqrt(827) 149 1/3 2 1 (--------- + ---) - ---------------------- - - 3/2 108 sqrt(827) 149 1/3 3 4 3 9 (--------- + ---) 3/2 108 4 3 9.70102574033
Für Gleichungssysteme muss man einen Vektor von Gleichungen angeben. Es wird ein Vektor von Vektoren zurückgegeben, für jede Lösung einen Vektor mit Variablenzuweisungen.
>&solve([x+y=4,x^2+y^2=12],[x,y])
[[x = 2 - sqrt(2), y = sqrt(2) + 2], [x = sqrt(2) + 2, y = 2 - sqrt(2)]]
Symbolische Ausdrücke und Funktionen erleichtern die Verwendung von Maxima in Euler, weil sie automatisch in beiden Welten zur Verfügungs stehen. Es ist deswegen nur selten nötig, Maxima direkt aufzurufen. Ausdrücke der Form &ausdruck werden in Maxima ausgewertet, und ergeben dann einen symbolischen Ausdruck für Euler und Maxima.
>&factor(diff(x/(x+1),x))
1 -------- 2 (x + 1)
Sie können auch einer Variablen zugeordnet werden.
>expr &= integrate(x/(x+1),x)
x - log(x + 1)
Und sie können in anderen Ausdrücken verwendet werden.
>&factor(diff(expr,x))
x ----- x + 1
Die Ausdrücke können auch in Euler verwendet werden. Im folgenden Beispiel wird das Integral einer Funktion geplottet.
>plot2d(&integrate(x^2*sin(x),x),0,2*pi):
Da man Ausdrücke in Euler auch direkt mit einen Wert für die Variable "x" und mit Werten für die anderen Variablen auswerten kann, kann man auf diese Art auch Maxima-Ausdrücke numerisch in Euler berechnen.
>&diff(x^2*sin(a*x),x)(1,a=2)
0.986301180557
Manche Funktionen können Maxima zu Hilfe nehmen. Ein Beispiel ist das Newton-Verfahren, das die Ableitung mit Hilfe von Maxima berechnet. Wir berechnen die Lösung von x^x=2.
>x0:=mxmnewton("x^x",1,y=2), x0^x0
1.55961046946 2
Matrizen und Vektoren können in Euler für Berechnungen in der Linearer Algebra verwendet werden. Meist werden sie jedoch für Tabellen von Werten verwendet. Eine Matrix wird zeilenweise definiert. Wir definieren Sie hier mit "&:=", damit sie auch für symbolische Ausdrücke und in Maxima zur Verfügung steht.
>A &:= [2,1,3; 1,2,1; 3,1,2]
2 1 3 1 2 1 3 1 2
Die Determinante in Euler wird numerisch berechnet. Das geht auch bei sehr großen Matrizen schnell.
>det(A)
-8
Mit Matrix ist es möglich auch, symbolische Determinanten zu berechnen. Neben der in Maxima üblichen Eingabe von Matrizen mit der Funktion "matrix", kann in Euler auch die normale Darstellung mit Strichpunkten verwendet werden.
>&[a,1,1;1,b,a;1,1,1], &factor(determinant(%))
[ a 1 1 ] [ ] [ 1 b a ] [ ] [ 1 1 1 ] (a - 1) (b - a)
Die Eigenwerte von A werden in Euler komplex berechnet.
>eigenvalues(A)
[ -1+0i 1.43844718719+0i 5.56155281281+0i ]
In Maxima ist das Resultat symbolisch und wird einschließlich der Vielfachheiten ausgegeben.
>&eigenvalues([2,1,3;1,2,1;3,1,2])
7 - sqrt(17) sqrt(17) + 7 [[------------, ------------, - 1], [1, 1, 1]] 2 2
Wir berechnen die Inverse der Matrix A aus Euler, wobei die Determinante ausgeklammert werden soll. Wir verwenden wieder die direkte Eingabe von Maxima-Kommandos, damit das Ergebnis nicht vereinfacht wird.
>:: inv(A)|detout
[ 3 1 - 5 ] [ ] [ 1 - 5 1 ] [ ] [ - 5 1 3 ] - ----------------- 8
Ansonsten wird zur Ausgabe ausmultipliziert.
>&inv(A)|detout
[ 3 1 5 ] [ - - - - - ] [ 8 8 8 ] [ ] [ 1 5 1 ] [ - - - - - ] [ 8 8 8 ] [ ] [ 5 1 3 ] [ - - - - - ] [ 8 8 8 ]
Das Ausmultiplizieren dieses Ergebnisses geschieht erst bei der Ausgabe. In der Variablen IA ist noch das Ergebnis gespeichert.
>IA &= inv(A)|detout; "Euler String IA = "|IA
Euler String IA = -matrix([3,1,-5],[1,-5,1],[-5,1,3])/8
Ein Vektor ist einfach eine Matrix mit einer Zeile oder Spalte.
>b:=[1;1;1]
1 1 1
Das Gleichungssystem Ax=b wird mit "A\b" gelöst.
>x:=A\b; fracprint(x)
1/8 3/8 1/8
Machen wir die Probe! Das Matrixprodukt wird mit dem Punkt "." berechnet.
>A.x
1 1 1
Das funktioniert auch in symbolischen Ausdrücke, wobei hier sogar auf die Unterscheidung zwischen Spalten- und Zeilenvektoren verzichtet werden kann. Maxima ist da toleranter als Euler.
>&A.[x,y,z]
[ 3 z + y + 2 x ] [ ] [ z + 2 y + x ] [ ] [ 2 z + y + 3 x ]
Prinzipiell werden Operatoren oder Funktionen elementweise ausgeführt. Das ist das Prinzip der Matrixsprache von Euler.
>sin([0,pi,2pi]), cos([0,pi,2pi])
[ 0 0 0 ] [ 1 -1 1 ]
Wir können daher mit Vektoren rechnen, solange sie die gleiche Länge haben.
>2*b+4*x
2.5 3.5 2.5
Die Matrixsprache wird verwendet, um Tabellen von Funktionen zu erstellen. Im Beispiel erzeugen wir einen Vektor der die Zahlen 0, 0.01 usw. bis 1 enthält. Danach quadrieren wir alle Elemente des Vektors und summieren das Ergebnis. Multipliziert man diese Summe mit der Schrittweite 0.01, so erhält man eine Näherung für die Riemann-Summe des Integrals von x^2.
>t:=0:0.01:1; sum(t^2)*0.01
0.33835
Tabellen von Funktionen können auch geplottet werden.
>plot2d(t,t^3-t):
Das Funktioniert dann auch umgekehrt.
>plot2d(t^3-t,t):
Werden Vektoren mit Matrizen verknüpft, so wird der Vektor auf sinnvolle Weise zu einer Matrix erweitert. Im folgenden Beispiel wird der Vektor 1:10 mit sich selbst multipliziert, und zwar einmal als Spaltenvektor und einmal als Zeilenvektor. Das Ergebnis ist die Matrix i*j. Wir stellen das Format für die Ausgabe auf ein engeres Format um.
>format(6,0); (1:10)'*(1:10), longformat;
1 2 3 4 5 6 7 8 9 10 2 4 6 8 10 12 14 16 18 20 3 6 9 12 15 18 21 24 27 30 4 8 12 16 20 24 28 32 36 40 5 10 15 20 25 30 35 40 45 50 6 12 18 24 30 36 42 48 54 60 7 14 21 28 35 42 49 56 63 70 8 16 24 32 40 48 56 64 72 80 9 18 27 36 45 54 63 72 81 90 10 20 30 40 50 60 70 80 90 100
Auf diese Weise kann man Funktionsscharen plotten. Ist eine Variable im Ausdruck ein Spaltenvektor, so gibt der Ausdruck eine Matrix mit Zeilen zurück, die die Funktionswerte für jeden Parameter enthalten.
>n=(1:10)'; plot2d("x^n",0,1):
In Euler und Maxima kann der Benutzer eigene Funktionen schreiben. In der Tat sind große Teile von Euler mit Funktionen realisiert. Die einfachste Form ist die Einzeilenfunktion von Euler.
>function f(x) := x^x
Man beachte, dass die Funktion automatisch auch für Vektoren funktioniert.
>f(0:5)
[ 1 1 4 27 256 3125 ]
Euler kann auch symbolische Funktionen definieren, die dann in symbolischen oder numerischen Ausdrücken zur Verfügung stehen.
>function f(x) &= x^3-x
3 x - x
Funktionen kann man einfach per Namen plotten. grid==1 zeigt nur die Koordinatenachsen.
>plot2d("f",0,2,grid=1):
Wie gesagt, kann f auch in symbolischen Ausdrücken verwendet werden.
>&f(1-t)
3 t + (1 - t) - 1
Komplexere Funktionen müssen in mehreren Zeilen eingegeben werden. Dazu gibt es einen internen Editor, der mit F9 aufgerufen wird. Alternativ kann die Funktion in einer externen Datei enthalten sein, und mit "load" geladen werden. Das folgende Beispiel ist eine abgebrochene Potenz.
Die Programmiersprache entspricht einem erweiterten BASIC. Parameter lassen sich in Euler im Typ eingrenzen, so dass Missbrauch vorgebeugt wird. Außerdem gibt es Default-Werte für Parameter. Im Beispiel ist n=2 vorgegeben. Eine solche Funktion funktioniert nicht mehr automatisch für Vektoren. Man kann Euler allerdings mit "map" zwingen, die Regeln der Matrixsprache auf die Funktion anzuwenden.
>function map f (x:number,a:number,n:integer=2) ...
if x<a then return 0; else return (x-a)^n endif; endfunction
>plot2d("f(x,1)",r=2); plot2d(1,0,points=true,add=true):
Auch Funktionen mit Vektoren als Parametern sind möglich, sogar in der folgenden Form, und sogar als symbolische Funktionen.
>function f([x,y]) &= [x+y-1,x^2+y^2-0.8]
2 2 [y + x - 1, y + x - 0.8]
Das Bild des Vektors ist wieder ein Vektor.
>f([0.1,0.9])
[ 0 0.02 ]
Zur Bestimmung von Nullstellen solcher Funktionen kennt Euler mehrere Verfahren. Eines ist das Broyden-Verfahren.
>x:=broyden("f",[1,2]), "Fehler: "|norm(f(x))
[ 0.112701665379 0.887298334621 ] Fehler: 0
Da die Funktion symbolisch definiert wurde, ist es möglich, symbolisch die Jacobi-Matrix von f zu berechnen.
>&jacobian(f(x,y),[x,y])
[ 1 1 ] [ ] [ 2 x 2 y ]
Euler ist wie ein Schweizer Taschenmesser. Es deckt eine große Breite von mathematischen Anwendungen ab mit weit mehr Möglichkeiten, als wir in dieser Einleitung erwähnen können. Natürlich kann Euler (oder auch Maxima) mit komplexen Zahlen rechnen.
>(1+I)^2, &expand((1+I)^2)
0+2i 2 I
Auch Plots von komplexen Funktionen sind möglich. Im Beispiel plotten wir das Bild des Einheitskreises unter der komplexen Funktion E^z. grid==4 stellt das Gitter ab, zeigt aber den Plotbereich an.
>t:=linspace(0,2pi,100); r:=linspace(0,1,25); z:=r*exp(I*t'); ... plot2d(exp(z),grid=4):
Euler beherrscht auch Intervall-Rechnung. Damit ist eine Abschätzung des maximalen Fehlers einer Rechnung möglich. Ein Turm in 25.1km Abstand erscheine unter einem Winkel von 5.2°. Wie hoch ist der Turm? Die Eingaben werden als Intervalle vorgenommen, wobei das Zeichen Plus-Minus mit F8 eingegeben werden kann. Die Ausgabe ist ein Intervall von möglichen Höhen.
>d:=(25.1±0.05)km$; a:=5.2°±0.05°; d*tan(a)
~2257,2311~
Es gibt Intervall-Algorithmen, mit denen sich Ergebnisse verifiziert berechnen lassen. Das heißt, die Rechnung garantiert ein eindeutiges Ergebnis im ausgegebenen Intervall. Ein Beispiel ist das Intervall-Newton-Verfahren. Wir lösen wieder x^x=2.
>mxminewton("x^x",~1,2~,y=2)
~1.559610469462368,1.559610469462371~
Euler hat ein exaktes Skalerprodukt. Damit kann man schlecht konditionierte, aber exakt gegebene Gleichungssysteme genauer lösen. Mit dem einfachen Gauß-Algorithmus von "\" erhält man wesentlich schlechtere Lösungen.
>A:=hilb(10); x:=ones(10,1); b:=A.x; xlgs(A,b)
1 1 1 1 1 1 1 1 1 1
Mit Hilfe von Ausdrücken kann Euler viele Funktionen in einfacher Weise zur Verfügung stellen. Ein Beispiel ist die Funktion "sequence", die eine rekursiv definierte Folge (auch von Vektoren) erzeugen kann. Wir erzeugen die Fibonacci-Folge.
>sequence("x[n-2]+x[n-1]",[1,1],10)
[ 1 1 2 3 5 8 13 21 34 55 ]
Eine etwas unübersichtlichere Alternative dazu ist ein Schleife.
>v=[1,1]; for i=1 to 8; v=v|(v[-2]+v[-1]); end; v,
[ 1 1 2 3 5 8 13 21 34 55 ]
Differentialgleichungen oder Systeme von Differentialgleichungen lassen sich in Euler numerisch, und in Maxima exakt lösen. Gegeben sei die Differentialgleichung
Diese Differentialgleichung kann mit Maxima gelöst werden. Die Lösung wird allerdings in diesem Fall nur implizit gegeben.
>sol &= ode2('diff(y,x)=-x*exp(y),y,x)
2 - y x E = -- + %c 2
Wir können nun die Anfangsbedingung in die Lösung einsetzen. Dadurch wird die Konstante %c eleminiert.
>solic &= ic1(sol,x=0,y=1)
- 1 2 - y E (E x + 2) E = --------------- 2
Nun können wir eine Funktion definieren, die die Lösung enthält.
>function g(x) &= at(y,solve(solic,y))
2 E log(--------) 2 E x + 2
Die Funktion sieht folgendermaßen aus, wenn man sie in Euler plottet.
>plot2d("g",0,10):
Euler kann dasselbe Ergebnis mit Hilfe des Runge-Verfahrens numerisch ermitteln.
>t:=0:0.01:10; s:=runge("-x*exp(y)",t,1); >plot2d(t,s):
Euler wird mit einer vollständigen Referenz, einer Dikomentation in PDF-Form und vielen Beispielen installiert. Markieren Sie etwa im folgenden Kommando das Wort "cos" durch einen Doppelklick, und drücken Sie F1. Es öffnet sich der Browser mit der Referenz an der Stelle "cos". Unter Windows XP müssen Sie den Browser zunächst mit dem Menüeintrag konfigurieren. Im Programm selbst gibt es die Funktion "help", die auch Beispiele ausgibt.
>help cos
cos is a builtin function. The usual trigonometric mathematical functions, for real, complex and intervals. sin(x) : sine function cos(x) : cosine function tan(x) : tangent function asin(x) : inverse sine, maps [-1,1] to [-pi/2,pi/2] acos(x) : inverse cosine, maps [-1,1] to [0,pi] atan(x) : inverse tangent, maps R to [-pi/2,pi/2] arcsin(x) : inverse sine, maps [-1,1] to [-pi/2,pi/2] arccos(x) : inverse cosine, maps [-1,1] to [0,pi] arctan(x) : inverse tangent, maps R to [-pi/2,pi/2] arctan2(x,y) : Angle of the polar coordinates of [x,y] in ]-pi,pi]. atan2(x,y) : Angle of the polar coordinates of [x,y] in ]-pi,pi]. The functions work for radians. To convert from degree to radians use x° or rad(x). Use shift-F7 to enter the degree symbol in an Euler notebook. To convert back, use rad(x). The degree symbol ° works in Maxima too. >sin(90°) >cos(pi) >deg(atan(1)) >deg(atan2(1,1)) >degprint(rad(10,30,20)) See: polar, rect, matrixlanguage, deg, rad, degprint Search Maxima for help: cos (<x>) For more information try: mxmhelp cos
Viele Beispiele und Kommandos können über das Menü eingefügt werden. Die Kommandos enthalten Stellen, die durch ein Fragezeichen gekennzeichnet sind. An diesen Stellen ist eine Eingabe des Benutzers notwendig. Beachten Sie auch die Statuszeile, die Hilfe für das aktuelle Kommando anzeigt. Die Funktion "mxmhelp" liest die interne Hilfe von Maxima, und gibt die relevanten Informationen aus.
>mxmhelp makelist
-- Function: makelist () -- Function: makelist (<expr>, <n>) -- Function: makelist (<expr>, <i>, <i_max>) -- Function: makelist (<expr>, <i>, <i_0>, <i_max>) -- Function: makelist (<expr>, <i>, <i_0>, <i_max>, <step>) -- Function: makelist (<expr>, <x>, <list>) The first form, `makelist ()', creates an empty list. The second form, `makelist (<expr>)', creates a list with <expr> as its single element. `makelist (<expr>, <n>)' creates a list of <n> elements generated from <expr>. The most general form, `makelist (<expr>, <i>, <i_0>, <i_max>, <step>)', returns the list of elements obtained when `ev (<expr>, <i>=<j>)' is applied to the elements <j> of the sequence: <i_0>, <i_0> + <step>, <i_0> + 2*<step>, ..., with <|j|> less than or equal to <|i_max|>. The increment <step> can be a number (positive or negative) or an expression. If it is omitted, the default value 1 will be used. If both <i_0> and <step> are omitted, they will both have a default value of 1. `makelist (<expr>, <x>, <list>)' returns a list, the `j''th element of which is equal to `ev (<expr>, <x>=<list>[j])' for `j' equal to 1 through `length (<list>)'. Examples: (%i1) makelist (concat (x,i), i, 6); (%o1) [x1, x2, x3, x4, x5, x6] (%i2) makelist (x=y, y, [a, b, c]); (%o2) [x = a, x = b, x = c] (%i3) makelist (x^2, x, 3, 2*%pi, 2); (%o3) [9, 25] (%i4) makelist (random(6), 4); (%o4) [2, 0, 2, 5] (%i5) flatten (makelist (makelist (i^2, 3), i, 4)); (%o5) [1, 1, 1, 4, 4, 4, 9, 9, 9, 16, 16, 16] (%i6) flatten (makelist (makelist (i^2, i, 3), 4)); (%o6) [1, 4, 9, 1, 4, 9, 1, 4, 9, 1, 4, 9]
Es bleibt mir, Ihnen viel Erfolg mit Euler zu wünschen. Wenn Sie Kontakt mit anderen Benutzern aufnahmen wollen, so bietet sich das Forum auf Sourceforge, oder das Wiki zu Euler an. Die Homepage von Euler ist http://euler.rene-grothmann.de/ R. Grothmann