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

Beispiele

Die folgenden Beispiel zeigen sowohl die Definition der Funktion als auch die Auswertung der Funktion an einer bestimmten Stelle im Definitionsbereich

• Eindimensionaler Definitions- und Wertebereich

   f(x):=x^2; 
   f(3);

Auswertung der Funktion $f(3)$ liefert dann $9$ als Ausgabe-

• Mehrdimensionaler Definitionsbereich und eindimensionaler Wertebereich f(x,y):=cos(x)+sin(y);

   g(x,y) := sqrt(x^2+y^2);
   g(3,4);

Auswertung der Funktion $g(3,4)$ liefert dann $5$ als Ausgabe-

• Eindimensionaler Definitionsbereich und mehrdimensionaler Wertebereich (Kurve im $\mathbb {R} ^{n}$

   h(t):=matrix(
        [t], 
        [sin(t)], 
        [cos(t)]
    ); 
   h(3);

zum Zeitpunkt $t$ gibt $h(t)\in \mathbb {R} ^{3}$ den Bildpunkt im dreidimensionalen Euklischen Raum an.

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

Im Folgenden wird zunächst eine Funktion definiert, die dann in einem Koordinatensystem im Bereich $x\in [-10.+10]$ und $y\in [-10.+10]$

f(x):= x^2;
plot2d(f(x), [x,-10,10], [y,-10,10]);

Sollte Maxima die Skalierung selbst festlegen in Abhängigkeit von Bilder $f(x)$ mit $x\in [-10.+10]$ so kann man den Plotparameter [y,-10,10] auch weglassen.

f(x):= x^2;
plot2d(f(x), [x,-10,10]);

Kurven in der Ebene

Möchte man die Spur einer Kurve im $\mathbb {R} ^{2}$ plotten. Dazu definiert man zwei Komponentenfunktionen f1 und f2 der Kurve im $\mathbb {R} ^{2}$- Dabei ist die Kurve wie folgt definiert:

$f(t)=(f_{1}(t),f_{2}(t))=(t\cdot \cos(t),t\cdot \sin(t))\in \mathbb {R} ^{2}{\mbox{ mit }}x\in [-10,+10]$

Der folgende Plot zeigt eine Spirale

f1(t) := t * cos(t);
f2(t) := t * sin(t);
plot2d([parametric,f1(t),f2(t)], [t,-10,10]);

Funktionen mit zwei Veränderlichen

f(x,y):= cos(x) + sin(y);
plot3d(f(x,y), [x,-5,5], [y,-5,5]);

Contour-Plot der gleichen Funktion

contour_plot (f(x,y), [x,-10,10], [y,-10,10])$

Kurven im dreidimensionalen Raum

Möchte man die Spur einer Kurve im $\mathbb {R} ^{3}$ plotten, geht man wie folgt vor. Dazu definiert man drei Komponentenfunktionen f1, f2 und f3 der Kurve im $\mathbb {R} ^{3}$- Dabei ist die Kurve wie folgt definiert:

$f(t)=(f_{1}(t),f_{2}(t),f_{3}(t))=(t\cdot \cos(t),t\cdot \sin(t))\in \mathbb {R} ^{2}{\mbox{ mit }}x\in [-5,+5]$

Der folgende 3D-Plot zeigt eine Schraubenlinie als Spur im dreidimensionalen Raum $\mathbb {R} ^{3}$ mit $t\in [0,6\pi ]$.

f1(t) := cos(t);
f2(t) := sin(t);
f3(t) := t
plot3d([f1(t), f2(t), f3(t)], [t,0,6*%pi], [y,-5,5],[grid,100,30], [gnuplot_pm3d,false]);

Der Parameter für $y\in [-5+5]$ muss mit angegeben werden, der aber für den parametrischn Plot der Spur nicht verwendet wird. Der grid-Parameter legt die Diskretisierung der Kurve als Polygonzug fest. Hier wird $t$ mit 100 Punkten diskretisiert (der zweite grid-Parameter 30 legt eine Diskretisierung für $y$ fest, die wieder angegeben werden muss, obwohl das für den Plot dieser Kurve keine Rolle spielt)

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^(%i*phi)	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

Beispiele

Die folgenden Beispiele zeigen die Anwendung des diff-Operators:

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
(v1, v2)	[v1,v2]	Eine Liste lässt sich als Vektor verwenden.
(v1, v2)	matrix([v1,v2])	Ein Zeilenvektor.
${\begin{bmatrix}v_{1}\\v_{2}\end{bmatrix}}$	matrix([v1],[v2])	Ein Spaltenvektor.
ek	ematrix(1,n,1,1,k)	Basisvektor ek aus dem Rn als Zeilenvektor.
ek	ematrix(n,1,1,k,1)	Basisvektor ek aus dem Rn als Spaltenvektor.

Operationen:

Formel	Eingabe	Beschreibung
vk	v[k]	Komponente mit dem Index k.
vk,1	v[k,1]	Indizierung bei einem Spaltenvektor.
v1,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.
En	ident(n)	Die n×n-Einheitsmatrix.
rEn	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.
(AT, v)T	addrow(A,v)	Hängt den Vektor v als Zeile an die Matrix A an.

Operationen:

Formel	Eingabe	Beschreibung
Aij	A[i,j]	Eintrag für das Indexpaar (i, j).
AT	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−1	invert(A)	Inverse Matrix zu A.
An	A^^n	Potenzierte Matrix.
PA(λ)	charpoly(A,lambda)	Charakteristisches Polynom von A.
σ(A), (μk)	eigenvalues(A)	Eigenwerte von A. Zweite Liste: algebraische Vielfachheiten.
(vk)	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]

Siehe auch

• Maxima CAS