Mathematische Funktionen und CAS-Befehle

a+b → Addition zweier Zahlen: \(a+b\)
a-b → Subtraktion zweier Zahlen: \(a-b\)
a*b → Multiplikation zweier Zahlen: \(a\cdot b\)
a/b → Division zweier Zahlen bzw. Bruch: \(\frac ab\)
- Maxima interpretiert Eingaben wie 1/2 als Bruch \(\frac12\)
- Soll Maxima eine Division durchführen und eine Dezimalzahl zurückgeben, muss float(1/2) eingegeben werden
mod(a,b) → Führt eine Division mit Rest durch, z. B. mod(8,3) = 2

Potenzen, Wurzeln, Logarithmen, Betrag

a^x → Potenz \(a^x\)
log(x) (in STACK auch ln(x) möglich)→ Natürlicher Logarithmus \(\log_e(x)=\ln(x)\) zur Basis der Eulerschen Zahl \(e\)
log(x)/log(b) (in STACK auch lg(x,b) möglich) → Logarithmus von \(x\) zur Basis \(b\)
sqrt(x) → Quadratwurzel \(\sqrt{x}\)
x^(1/n) (in STACK auch root(x,n) möglich) → \(n\)-te Wurzel \(\sqrt[n]{x}=x^{\frac 1n}\)
exp(x) oder %e^x (in STACK auch e^x möglich) → Exponentialfunktion \(\exp(x)=e^x\)
abs(a) → Komplexer oder reeller Betrag der Zahl \(a\)

Fakultät und Kombinatorik

n! → Fakultät, z. B. 4! = 24
binomial(n,k) → Binomialkoeffizient, z. B. binomial(49,6) = 13983816

Matrizen

M+N → Komponentenweise Addition zweier Matrizen: \(M+N\) (sofern möglich)
M*N → Komponentenweise Multiplikation zweier Matrizen \(M\) und \(N\) (sofern möglich)
M.N → Nicht-kommutative Multiplikation zweier Matrizen \(M\) und \(N\) (sofern möglich)
M^2 → Komponentenweises Quadrieren der Matrix \(M\)
M^^n → \(n\)-Fache nicht-kommutative Multiplikation der Matrix \(M\) mit sich selbst (sofern möglich)
M^^(-1) oder invert(M) → invertiert die Matrix \(M\) (sofern möglich)
a*M → Multipliziert die Zahl \(a\) mit jedem Eintrag der Matrix \(M\)

Beachten Sie bitte auch den separaten Eintrag zu Matrizen in STACK.

Maxima-Befehle und -Funktionen [edit]

Trigonometrische und hyperbolische Funktionen

Die Funktionen sin(x), cos(x), tan(x), sinh(x), cosh(x) und tanh(x) stehen wie gewohnt zur Verfügung.

Deren Umkehrfunktionen werden in Maxima mit asin(x), acos(x), atan(x), asinh(x), acosh(x) und atanh(x) bezeichnet.

Weitere nützliche Befehle und Operationen:

trigexpand(expr) → Formt den Ausdruck expr um, indem die Winkelsummeneigenschaft verwendet wird.
- Beispiel: trigexpand(sin(2*x)/2) = sin(x)*cos(x)
trigreduce(expr) → Wandelt den Ausdruck expr in eine Summe von Einzeltermen um, die entweder eine Sinus- oder eine Kosinus-Funktion beinhaltet.
- Beispiel: trigreduce(cos(x)*sin(x)) = sin(2*x)/2

Stetigkeit, Differential- und Integralrechnung

continuousp(f,x,x0) → Gibt einen Wahrheitswert true oder false zurück, je nachdem, ob die Funktion \(f\) an der Stelle \(x=x_0\) stetig ist oder nicht.
diff(f,x) → Berechnet die Ableitung der Funktion \(f\) nach der Variable \(x\)
diffp(f,x,x0) → Gibt einen Wahrheitswert true oder false zurück, je nachdem, ob die Funktion \(f\) an der Stelle \(x=x_0\) differenzierbar ist oder nicht.
integrate(f,x,a,b) → Berechnet das bestimmte Integral \(\int^b_a f(x)\;dx\)
integrate(f,x) → Berechnet das unbestimmte Integral \(\int f(x)\; dx\)

Gleichungen und Terme

coeff(expr,x,k) → Gibt den Koeffizienten der \(k\)-ten Potenz von \(x\) im Ausdruck expr aus, z. B. coeff(2*x^2+1,x,2) = 2 und coeff(2*x^2+1,x,0) = 1
expand(expr) → Multipliziert den Ausdruck expr aus, z. B. expand((x+1)^2) = x^2+2*x+1
factor(expr) → Faktorisiert den Ausdruck expr, z. B. factor(x^2+2*x+1) = (x+1)^2
lhs(eq) → Linke Seite einer Gleichung eq, z. B. lhs(x^2=4) = x^2
listofvars(expr) → Alphabetisch sortierte Liste der Variablen, die im Ausdruck expr enthalten sind, z. B. listofvars(x^2+2*a) = [a,x]
ratsimp(expr) → Vereinfacht den Ausdruck expr, z. B. ratsimp(x/3+y/3) = (x+y)/3
rhs(eq) → Rechte Seite einer Gleichung eq, z. B. rhs(x^2=4) = 4
subst(a,x,expr) → Ersetzt im Ausdruck expr die Variable \(x\) durch \(a\), z. B. subst(2,x,x^2) = 4 und subst(a,x,x^2) = a^2

Reelle und komplexe Zahlen

abs(a) → Komplexer oder reeller Betrag der Zahl \(a\)
ceiling(a) → Rundet die Zahl \(a\) auf die nächstliegende ganze Zahl auf, z. B. ceiling(%pi) = 4
decimalplaces(a,n) → Rundet die Zahl \(x\) auf \(n\) Nachkommastellen, z. B. decimalplaces(1/3,2) = 0.33
denom(a) → Nenner von \(a\), z. B. denom(2/3) = 3
float(a) → Wandelt die Zahl \(a\) in eine Dezimalzahl um, z. B. float(%e) = 2.718281828459045
floor(a) → Rundet die Zahl \(a\) auf die nächstliegende ganze Zahl ab, z. B. floor(1.9) = 1
imagpart(z) → Imaginäranteil der komplexen Zahl \(z\)
limit(f(x),x,a) → Grenzwert der Funktion \(f(x)\) für \(x\to a\), z. B. limit(1/x,x,0) = infinity
num(a) → Zähler von \(a\), z. B. num(2/3) = 2
rat(a) → Wandelt eine Fließkommazahl \(a\) in einen Bruch um (falls möglich), z. B. rat(0.25) = 1/4
realpart(z) → Realanteil der komplexen Zahl \(z\)
round(a) → Rundet die reelle Zahl \(a\) auf die nächstliegende ganze Zahl, z. B. round(%pi) = 3

Mengen und Listen

append(L1,L2,...) → Vereinigung von Listen oder Mengen
- Bei Listen bleiben doppelte Elemente erhalten, z. B. append([1,2,3],[3,4,5]) = [1,2,3,3,4,5]
- Mengen werden so reduziert, dass keine doppelte Elemente auftreten, z. B. append({1,2,3},{3,4,5}) = {1,2,3,4,5}
freeof(a,M) → Gibt true zurück, wenn \(a\notin M\) (funktioniert bei Listen und Mengen)
intersect(M1,M2) → Schnitt zweier Mengen \(M_1\cap M_2\), z. B. intersect({1,2,3},{2,3,4}) = {2,3}
listify(M) → Wandelt die Menge \(M\) in eine Liste um
length(M) → Gibt die Anzahl der Elemente von \(M\) zurück
lmax(L) → Gibt das größte Element der Liste \(L\) zurück
lmin(L) → Gibt das kleinste Element der Liste \(L\) zurück
makelist(f,i,k,n) → Erzeugt eine Liste mit Elementen \(f(i)\), \(i\in\{k,\ ...,\ n\}\), also \( [ f(k),\ f(k+1)\ f(k+2),\ ...,\ f(n) ] \), z. B. makelist(i^2, i,1,5) = [1,4,9,16,25]
map(f, L) → Wendet die Funktion \(f\) auf alle Elemente der Liste \(L\) an, z. B. map(x^2, [1,2,3]) = [1,4,9]
member(a,M) → Gibt true zurück, wenn \(a\in M\) (funktioniert bei Listen und Mengen)
random_permutation(L) → Zufällige Permutation der Liste \(L\)
set(a,b,c) → Erstellt eine Menge \(\{a,b,c\}\)
setdifference(M1,M2) → Mengentheoretische Differenz \(M_1\setminus M_2\) zweier Mengen, z. B. setdifference({1,2,3},{3,4}) = {1,2}
setify(L) → Wandelt die Liste \(L\) in eine Menge um
unique(L) → Löscht alle doppelten Elemente aus der Liste \(L\), z. B. unique([1,1,2,2,3]) = [1,2,3]

Mathematische Konstanten

Maxima beherrscht einige mathematische Konstanten. Viele von ihnen werden mit einem %-Zeichen umgesetzt:

%pi (in STACK auch pi möglich) → Kreiszahl \(\pi\)
%e (in STACK auch e möglich) → Eulersche Zahl \(e\)
%i (in STACK auch i möglich) → Imaginäre Einheit \(\text i\)
inf → Positiver unendlich großer Wert
minf → Negativer unendlich großer Wert

Bedingungen und Schleifen

Mit dem CAS Maxima können auch Kontrollstrukturen wie zum Beispiel if-Abfragen und for- bzw. while-Schleifen genutzt werden:

if-Abfragen: Eine if-Abfrage ist eine Anweisung, die durch das Stellen einer Ja-oder-Nein-Frage bestimmt, was geschehen soll. Je nach Antwort wird eine andere Aufgabe ausgeführt.
Im folgenden Beispiel bekommt die Variable text einen anderen Wert ("x ist positiv", "x ist null" oder "x ist negativ") je nachdem, welchen Wert die Variable x hat:
```
x : rand_with_step(-5,5,1);


if x > 0 then

   text: "x ist positiv"

else if x = 0 then

   text: "x ist null"

else

   text: "x ist negativ";
```
for-Schleifen: Eine for-Schleife ermöglicht es, eine Aufgabe mehrfach hintereinander auszuführen. Sie wird oft verwendet, um eine bestimmte Aktion eine festgelegte Anzahl von Malen zu wiederholen.
Im folgenden Beispiel wird die Summe der Zahlen von 1 bis 10 bestimmt. Dabei wird in jedem Durchgang der Wert der Variablen summe um 1 erhöht:
```
n : 10;

summe : 0;



for i : 1 thru n do

   summe: summe + i;
```
Beachten Sie, dass es für die Bestimmung der Summe von Zahlen auch eingebaute Maxima-Funktionen gibt. Beispielsweise kann für die Summe der natürlichen Zahlen von 1 bis 10 auch sum(k,k,1,10) verwendet werden.
while-Schleifen: Eine while-Schleife führt eine Aufgabe wiederholt aus, solange eine bestimmte Bedingung erfüllt ist. Sie eignet sich gut für Situationen, in denen die Anzahl der Wiederholungen im Voraus nicht bekannt ist, da die Schleife solange läuft, bis die Bedingung nicht mehr zutrifft.
Im folgenden Beispiel wird rekursiv die Fakultät der Zahl n bestimmt:
```
n : 5;

fakultaet : 1;

i : 1;



while i <= n do (

   fakultaet : fakultaet * i,

   i : i + 1

);
```
Beachten Sie, dass für die Bestimmung der Fakultät auch der !-Operator verwendet werden kann (z. B. 5!).

Randomisierung

Beachten Sie dazu den separaten Artikel.

Verschiedenes

args(expr) → Gibt eine Liste von Argumenten des Ausdrucks expr zurück. Beispiele:
- Wandelt eine Menge in eine Liste um: args( (set(1,2,3) ) = [1,2,3]
- Gibt die Zeilenvektoren einer Matrix zurück: args( matrix([1,2,4],[1,4,5]) ) = [ [1,2,3], [4,5,6] ]
- args( a+b+c ) = [a,b,c]
is(expr) → Gibt einen Wahrheitswert true oder false zurück, je nachdem, ob die Aussage expr korrekt ist, z. B. is(1>2) = false und is(2>1) = true

Plot-Funktion

Für die vielfältigen Möglichkeiten, die es in Maxima für die Erstellung von Plots gibt, beachten Sie bitte den separaten Artikel.

Erstellung eigener Funktionen

Auch die Erstellung eigener Funktionen ist in Maxima möglich:

Funktionen definieren: Funktionen definiert man in Maxima mit dem Operator :=, z. B.
function(x) := x^2+3;
Hat man eine Funktion definiert, kann diese im Folgenden verwendet werden, z. B.
function(2) = 7
Mehrere Anweisungen zusammenfassen (Funktion block): Manchmal ist es sinnvoll eine Funktion zu definieren, die mehrere Operationen hintereinander ausführt. Dafür kann die Funktion block verwendet werden.
Im folgenden Beispiel wird eine Funktion definiert, die die Summe der Quadrate der natürlichen Zahlen von 1 bis n zurückgibt:
```
sum_of_squares(n) := block(

   [sum : 0, i], 

   for i : 1 thru n do

       sum : sum + i^2,

   return(sum)

);
```
Zwischen den eckigen Klammern in der zweiten Zeile werden lokale Variablen definiert (d. h. diese gelten nur innerhalb der Funktion). Man kann sie auch bereits dort auf Werte setzen (sum:0 im obigen Beispiel). Mit return kann am Ende ein Ergebnis ausgegeben werden.

Lösen von Gleichungen und Linearen Gleichungssystemen

solve(eq,x) → Löst die Gleichung eq nach der Variable \(x\) auf, z. B. solve(x^2-1=0, x) = [x=1, x=-1]
linsolve([eq1, eq2, eq3],[x,y,z]) → Löst das lineare Gleichungssystem aus den drei Gleichungeneq1, eq2 und eq3 mit den drei Variablen \(x\), \(y\) und \(z\).

Umwandeln der Lösungen

Für das Weiterrechnen mit den Lösungen einer Gleichung bzw. eines Gleichungssystems, kann es nützlich sein, auf einzelne Lösungen zuzugreifen oder die Namen der Variablen zu eliminieren.

map(rhs, LSG) → Eliminiert in der Lösung LSG die Namen der Variablen. Beispiel:
- Ohne den map-Befehl: solve(x^2-1=0, x) = [x=1, x=-1]
- Mit dem map-Befehl: map(rhs, solve(x^2-1=0, x)) = [1, -1]
A[k] → Gibt das \(k\)-te Element der Liste \(A\) zurück

Beispiele:


A: map(rhs, solve(x^2-1=0, x)) = [1, -1];
A[1] = 1;
A[2] = -1;

Intervalle [edit]

In STACK können Sie auch offene, geschlossene und halboffene Intervalle verwenden. Dafür bringt STACK einige Befehle mit, die keine Maxima-Funktionen sind.

Eingabe von Intervallen

oo(x,y) → Offenes Intervall
- Beispiel: oo(1,5) → \((1,5)\)
cc(x,y) → Geschlossenes Intervall
- Beispiel: cc(1,5) → \([1,5]\)
co(x,y) bzw. oc(x,y) → Halboffene Intervalle
- Beispiel 1: co(1,5) → \([1,5)\)
- Beispiel 2: oc(1,5) → \((1,5]\)

Funktionen zu Intervallen

inintervalp(p,A) → Gibt einen Wahrheitswert (true oder false) zurück, je nachdem, ob \(p\) im Intervall \(A\) liegt.
- Beispiel 1: inintervalp( 3, oo(1,4) ) → true
- Beispiel 2: inintervalp( 3, oo(1,3) ) → false
intervalp(X) → Gibt einen Wahrheitswert (true oder false) zurück, je nachdem, ob \(X\) ein Intervall ist.
trivialintervalp(ex) → Verhindert triviale Fälle wie \(oo(a,a)\) oder \(co(-\infty, -\infty)\)
SimpleUnion(X,Y) → Vereinigung zweier einfacher Mengen
- Beispiel: SimpleUnion( oo(2,9), oo(9,30) ) → \((2,9) \cup (9,30)\)
SimpleIntersect(X,Y) → Schnitt zweier einfacher Mengen
- Beispiel 1: SimpleIntersect( oo(2,9), oo(9,30) ) → \( \varnothing \)
- Beispiel 2: SimpleIntersect( oo(2,9), oo(6,30) ) → \((6,9)\)
SimpDisjointp(A,B) → Wenn SimpleIntersect(X,Y)=\(\{ \}\) dann true, sonst false
SortUnion(X) → Die Liste disjunkter Intervalle \(X\) wird in aufsteigende Reihenfolge gebracht
- Beispiel: SortUnion( [oo(2,10), oo(20,30), oo(10,20)] ) → \([(2,10), (10,12), (20,30)]\)
ConnectIntervals(X) → Die Vereinigung disjunkter Intervalle \(X\) wird darauf überprüft, ob die Intervalle veknüpft sind. Ist dies der Fall, so wird die geänderte Vereinigung ausgegeben.
TidyUnion(X) → Gibt für die disjunkte Vereinigung von Mengen \(X\) die "kanonische" Form der Vereinigung an.
Union(X,Y) → Findet die Vereinigung zweier Mengen.
- Beispiel: Union( oo(2,9), oo(6,30) ) → \((2,30)\)
JoinedUnion(X) → Vereinfacht eine gegebene Vereinigung von Intervallen \(X\), indem verknüpfte Intervalle zusammengeschlossen werden
Intersection(X,Y) → Schnitt von Intervallen
- Beispiel: Intersection( oo(2,9), oo(6,30) ) → \((6,9)\)
ListIntersect(X) → Für eine Liste von Intervallen wird der Schnitt ausgegeben
- Beispiel: ListIntersect( [oo(2,10), oo(3,12)] ) → \((3,10)\)
Complement(X) → Komplement eines Intervalls
- Beispiel: Complement( oo(2,9) ) → \([(-\infty,2],[9,\infty)]\)
SetComplement(X) → Gibt das mengentheoretische Komplement der Menge \(X\) zurück.