Formelsammlung Mathematik: Maxima

↑ Formelsammlung Mathematik

Grundlagen

Eingabe/Ausgabe

Eingaben werden mit einem Semikolon abgeschlossen, da sich Anweisungen in Maxima über mehrere Zeilen erstrecken können. Durch Verwendung eines Dollarzeichens anstelle eines Semikolons ist eine Unterdrückung der Ausgabe möglich. Das grafische Benutzerinterface benötigt zum Abschluss einer Eingabe stattdessen STRG+ENTER.

Das System versucht Ausgaben möglichst hübsch darzustellen. Ausschalten der booleschen Variable display2d führt zu einer Ausgabeform die wieder für Eingaben verwendet werden kann.

(Eingabe) 1/(a^2+b);
             1
(Ausgabe)  ------
                2
           b + a
(Eingabe) display2d: false$
(Eingabe) 1/(a^2+b);
(Ausgabe) 1/(a^2+b)

Die Funktion tex(A) wandelt einen Ausdruck $A$ in Quelltext für das Textsatzsystem TeX um.

Anweisungen an das CAS müssen nicht immer wieder neu eingegeben werden. Stehen die Anweisungen in Dateien, so können sie mit load("Dateiname") (ohne Ausgaben) oder batch("Dateiname") (mit Ausgaben) ausgeführt werden. Ausgaben lassen sich durch print(x) erzwingen. Die Datei muss sich im Arbeitsverzeichnis der aktuellen Sitzung befinden.

=== Datei m.mac ===
Werte(f,a) := makelist([x,f(x)],x,a);
g1(x) := 2*x+4;
g2(x) := 4*x-5;
=== Ende ==========

(Eingabe) load("m.mac");
(Eingabe) Werte(g1,[0,1,2,3]);
(Ausgabe) [[0, 4], [1, 6], [2, 8], [3, 10]]

Variablen

Eingabe	Bedeutung
`v: A;`	Der Variablen $v$ wird der Ausdruck $A$ zugewiesen.

Funktionen definieren

Eine Funktionsdefinition hat die Form f(x):=Ausdruck(x);.

Eine Funktion in zwei Variablen wird in der Form f(x,y):=Ausdruck(x,y) definiert. Ist alternativ $x=(x_{1},x_{2})$ ein Koordinatentupel, so kann eine Funktion in zwei Variablen in der Form f(x):=Term(x[1],x[2]) definiert werden. Der Aufruf erfolgt dann folglich nicht in der Form f(a,b), sondern in der Form f([a,b]).

Hilfsvariablen

Die Funktionsdefinition $f(x,y):={\frac {\sin({\sqrt {x^{2}+y^{2}}})}{\sqrt {x^{2}+y^{2}}}}$ lässt sich unter Verwendung einer Hilfsvariablen $r$ abkürzen zu $f(x,y):=\sin(r)/r$ . Eine solche Abkürzung ist auch in Maxima möglich:

f(x,y) := block([r], r: sqrt(x^2+y^2), sin(r)/r);

Solche Variablen sind nur lokal, d. h. sie sind nur innerhalb des Blocks definiert. Die allgemeine Form ist:

block([v1,...,vn], Ausdruck1, Ausdruck2, ..., AusdruckN)

Substitution von Variablen

Der Befehl T1, x=T2 substituiert jedes Auftreten der Variable x im Term T1 durch den Term T2.

(Eingabe) T: x^2+2*x+4;
(Eingabe) T, x=6;
(Ausgabe) 52

Der Befehl ev(T1,x=T2) (Abkürzung für evaluate) bewirkt das selbe, lässt sich aber flexibler verwenden.

(Eingabe) T: x^2+2*x+4;
(Eingabe) 2*ev(T,x=6);
(Ausgabe) 104

Ein Beispiel mit zwei Variablen:

(Eingabe) x^2+y^2, x=3, y=4;
(Ausgabe) 25

(Eingabe) ev(x^2+y^2,x=3,y=4);
(Ausgabe) 25

(Eingabe) ev(x^2+y^2,[x=3,y=4]);
(Ausgabe) 25

Numerische Auswertung

Die numerische Auswertung eines symbolischen Ausdrucks $A$ erfolgt mit float(A). Die Auswertung ist auf 16 Dezimalstellen begrenzt, da Fließkommazahlen doppelter Genauigkeit verwendet werden. Sind mehr Stellen gewünscht, so erfolgt die Auswertung mit bfloat(A) (big float). Die Anzahl der Stellen lässt sich nun durch Änderung der Variablen fpprec (floating point number precision) erhöhen.

(Eingabe) float(%pi);
(Ausgabe) 3.141592653589793
(Eingabe) fpprec: 40;
(Eingabe) bfloat(%pi);
(Ausgabe) 3.141592653589793238462643383279502884197b0

Funktionen plotten

plot2d(f(x), [x,-10,10], [y,-10,10]);
plot2d([parametric,x(t),y(t)], [t,-10,10]);

plot3d(f(x,y), [x,-10,10], [y,-10,10]);
contour_plot (f(x,y), [x,-10,10], [y,-10,10])$
plot3d([x(u,v),y(u,v),z(u,v)], [u,-10,10], [v,-10,10]]

load(implicit_plot);
implicit_plot(f(x,y)=0, [x,-10,10], [y,-10,10]);

Beispiele:

plot2d(sin(x), [x,-10,10], [y,-2,2]);

f(x,y) := block([r], r: sqrt(x^2+y^2), sin(r)/r);
plot3d(f(x,y), [x,-10,10], [y,-10,10]);

s(t) := (sin(5*t)+4)*[cos(t),sin(t)];
plot2d(cons(parametric,s(t)), [t,0,2*%pi], [yx_ratio,1]);

Computeralgebra

Gleichungen

Der Befehl solve(T1=T2,x) versucht, die Gleichung T1=T2 nach der Variablen x zu lösen.

(Eingabe) solve(a*x^2+b*x=0,x);
(Ausgabe) [x = -b/a, x = 0]

Der Befehl allroots(T1=T2) bestimmt die Lösungen einer Polynomgleichung numerisch.

(Eingabe) allroots(2*x^2+4*x=0,x);
(Ausgabe) [x = 0.0, x = -2.0]

Lösung eines linearen Gleichungssystems:

(Eingabe) s: [2*x+3*y=2, 4*x+5*y=3];
(Eingabe) solve(s,[x,y]);
(Ausgabe) [[x = -1/2, y = 1]]

Komplexe Zahlen

Die mathematischen Konstanten $\mathrm {e} ,\pi ,\mathrm {i}$ lauten in Maxima %e, %pi, %i. Zur Umrechnung in die Polarform dient die Funktion polarform(z), zur Umrechnung in die kartesische Form die Funktion rectform(z).

(Eingabe) polarform(2+4*%i);
(Ausgabe) 2*sqrt(5)*%e^(%i*atan(2))

(Eingabe) rectform(6*%e^(2*%i));
(Ausgabe) 6*%i*sin(2) + 6*cos(2)

Formel	Eingabe	Bedeutung
$a+b\mathrm {i}$	`a+b*%i`	kartesische Form
$r\mathrm {e} ^{\mathrm {i} \varphi }$	`r%e^(%iphi)`	Polarform
$\|z\|$	`cabs(z), abs(z)`	Absolutbetrag
$\operatorname {arg} (z)$	`carg(z)`	Phasenwinkel
$\operatorname {Re} (z)$	`realpart(z)`	Realteil
$\operatorname {Im} (z)$	`imagpart(z)`	Imaginärteil
${\overline {z}}$	`conjugate(z)`	Konjugation

Ausdrücke expandieren

Ein Ausdruck $A$ kann durch expand(A) expandiert (z. B. ausmultipliziert) werden.

(Eingabe) expand((a+b)^2);
(Ausgabe) b^2 + 2*a*b + a^2

Für Ausdrücke mit Winkelfunktionen wird trigexpand verwendet.

(Eingabe) trigexpand(sin(x+y));
(Ausgabe) cos(x)*sin(y) + sin(x)*cos(y)

Ausdrücke faktorisieren

Primfaktorzerlegung:

(Eingabe) factor(360);
(Ausgabe) 3^2 * 2^3 * 5

Faktorisierung von Termen:

(Eingabe) factor(2*x^2+x*y-y^2);
(Ausgabe) -(y-2*x)*(x+y)

Grenzwerte

Formel	Eingabe
$\lim _{n\to \infty }a_{n}$	`limit(a(n),n,inf)`
$\lim _{x\to x_{0}}f(x)$	`limit(f(x),x,x0)`

(Eingabe) limit((4*n+8)/(2*n-1),n,inf);
(Ausgabe) 2

(Eingabe) limit(sin(x)/x,x,0);
(Ausgabe) 1

Summen und Reihen

Formel	Eingabe
$\sum _{k=m}^{n}a_{k}$	`sum(a(k),k,m,n)`
$\sum _{k=m}^{\infty }a_{k}$	`sum(a(k),k,m,inf)`
$\sum _{k\in L}a_{k}$	`lsum(a(k),k,L)`

Das System kann manche Summen vereinfachen, wenn simpsum nachgestellt wird.

(Eingabe) sum(k,k,1,n), simpsum;
(Ausgabe) (n+n^2)/2

(Eingabe) sum(q^k,k,m,n-1), simpsum;
(Ausgabe) (q^n-q^m)/(q-1)

(Eingabe) sum(1/k^2,k,1,inf), simpsum;
(Ausgabe) %pi^2/6

Differentialrechnung

Formel	Eingabe	Bedeutung
${\frac {\mathrm {d} }{\mathrm {d} x}}f(x)$	`diff(f(x),x)`	Ableitung
${\frac {\mathrm {d} ^{n}}{\mathrm {d} x^{n}}}f(x)$	`diff(f(x),x,n)`	$n$ -te Ableitung
${\frac {\partial }{\partial x}}f(x,y)$	`diff(f(x,y),x)`	partielle Ableitung

(Eingabe) diff(x^2,x);
(Ausgabe) 2*x

Integralrechnung

Formel	Eingabe	Bedeutung
$\int _{a}^{b}f(x)\,\mathrm {d} x$	`integrate(f(x),x,a,b)`	bestimmtes Integral
$\int f(x)\,\mathrm {d} x$	`integrate(f(x),x)`	unbestimmtes Integral
$\int _{-\infty }^{\infty }f(x)\,\mathrm {d} x$	`integrate(f(x),x,minf,inf)`	uneigentliches Integral

(Eingabe) integrate(2*x+4,x);
(Ausgabe) x^2+4*x

Polynomdivision

Der Befehl divide(Zähler,Nenner,x) führt eine Polynomdivision bezüglich der Variablen x aus und gibt das Paar [Quotient, Rest] zurück.

Beispiel:

(x^{3}+x^{2}-10x+8):(x-2)=x^{2}+3x-4

(Eingabe) divide(x^3+x^2-10*x+8,x-2,x);
(Ausgabe) [x^2+3*x-4, 0]

Beispiel mit Rest:

x:(x-1)=1+{\frac {1}{x-1}}

(Eingabe) divide(x,x-1,x);
(Ausgabe) [1, 1]

Partialbruchzerlegung

Der Befehl partfrac(Term,x) führt eine Partialbruchzerlegung von Term nach der Variable x aus.

Voraussetzung: Das Nenner-Polynom besitzt rationale Nullstellen.

Der Befehl ratsimp(Term) macht die Partialbruchzerlegung wieder rückgängig.

1. Beispiel:

{\frac {x}{x-1}}=1+{\frac {1}{x-1}}

(Eingabe) partfrac(x/(x-1),x);
(Ausgabe) 1/(x-1) + 1

2. Beispiel:

{\frac {x}{x^{2}-1}}={\frac {1}{2(x+1)}}+{\frac {1}{2(x-1)}}

(Eingabe) partfrac(x/(x^2-1),x);
(Ausgabe) 1/(2*(x+1)) + 1/(2*(x-1))

Beispiel mit komplexen Polstellen:

{\frac {5x^{2}+2x+1}{x^{3}+x}}={\frac {1}{x}}+{\frac {4x+2}{x^{2}+1}}

(Eingabe) partfrac((5*x^2+2*x+1)/(x^3+x),x);
(Ausgabe) (2+4*x)/(x^2+1) + 1/x

Auch die komplexe Partialbruchzerlegung ist möglich:

{\frac {5x^{2}+2x+1}{x^{3}+x}}={\frac {1}{x}}+{\frac {2+\mathrm {i} }{x+\mathrm {i} }}+{\frac {2-\mathrm {i} }{x-\mathrm {i} }}

(Eingabe) partfrac((5*x^2+2*x+1)/gfactor(x^3+x),x);
(Ausgabe) -(-20-10*%i)/(10*(x+%i)) - (10*%i-20)/(10*(x-%i)) + 1/x

Der Befehl gfactor(Polynom) faktorisiert ein Polynom jedoch nur dann in Linearfaktoren, wenn Real- und Imaginärteil der Nullstellen rationale Zahlen sind.

Lineare Algebra

Vektoren

Vektoren erzeugen:

Formel	Eingabe	Beschreibung
(`v`₁, `v`₂)	`[v1,v2]`	Eine Liste lässt sich als Vektor verwenden.
(`v`₁, `v`₂)	`matrix([v1,v2])`	Ein Zeilenvektor.
${\begin{bmatrix}v_{1}\\v_{2}\end{bmatrix}}$	`matrix([v1],[v2])`	Ein Spaltenvektor.
e_k	`ematrix(1,n,1,1,k)`	Basisvektor e_k aus dem Rⁿ als Zeilenvektor.
e_k	`ematrix(n,1,1,k,1)`	Basisvektor e_k aus dem Rⁿ als Spaltenvektor.

Operationen:

Formel	Eingabe	Beschreibung
`v`_k	`v[k]`	Komponente mit dem Index `k`.
`v`_k,1	`v[k,1]`	Indizierung bei einem Spaltenvektor.
`v`_1,k	`v[1,k]`	Indizierung bei einem Zeilenvektor.
`v`+`w`	`v+w`	Addition.
`r` `v`	`r*v`	Skalarmultiplikation.
⟨`v`, `w`⟩	`v.w`	Reelles Standardskalarprodukt.
\|`v`\|	`sqrt(v.v)`	Vektorbetrag.

Matrizen

Matrizen erzeugen:

Formel	Eingabe	Beschreibung
${\begin{bmatrix}a_{11}&a_{12}\\a_{21}&a_{22}\end{bmatrix}}$	`matrix([a11,a12],[a21,a22])`	Eine Matrix.
`E`_n	`ident(n)`	Die `n`×`n`-Einheitsmatrix.
`rE_n`	`diagmatrix(n,r)`	Skalarmatrix.
0	`zeromatrix(m,n)`	Die `m`×`n`-Nullmatrix.
(`A`, `v`)	`addcol(A,v)`	Hängt den Vektor `v` als Spalte an die Matrix `A` an.
(`A`^T, `v`)^T	`addrow(A,v)`	Hängt den Vektor `v` als Zeile an die Matrix `A` an.

Operationen:

Formel	Eingabe	Beschreibung
`A`_ij	`A[i,j]`	Eintrag für das Indexpaar (`i`, `j`).
`A`^T	`transpose(A)`	Transponierte von `A`.
`AB`	`A.B`	Matrizenmultiplikation.
adj(`A`)	`adjoint(A)`	Klassische Adjungierte von `A`.
det(`A`)	`determinant(A)`	Determinante von `A`.
`A`⁻¹	`invert(A)`	Inverse Matrix zu `A`.
`A`ⁿ	`A^^n`	Potenzierte Matrix.
`P`_A(`λ`)	`charpoly(A,lambda)`	Charakteristisches Polynom von `A`.
`σ`(`A`), (`μ`_k)	`eigenvalues(A)`	Eigenwerte von `A`. Zweite Liste: algebraische Vielfachheiten.
(`v`_k)	`eigenvectors(A)`	Erste Liste: `eigenvalues(A)`. Zweite Liste: Eigenbasis.

Programmierung

Listen

Die Funktion makelist(f(k),k,a,b) erzeugt die Liste [f(a), f(a+1), ..., f(b)].

(Eingabe) makelist(k,k,1,4)
(Ausgabe) [1, 2, 3, 4]

(Eingabe) makelist(k^2*x,k,1,4)
(Ausgabe) [x, 4*x, 9*x, 16*x]

This article is issued from Wikibooks. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.