Drucken

Mathematische Funktionen und CAS-Befehle

Inhaltsübersicht

1. Rechenoperationen [Bearbeiten]

1.1. Grundrechenarten

1.2. Potenzen, Wurzeln, Logarithmen, Betrag

1.3. Matrizen

2. Maxima-Befehle und -Funktionen [Bearbeiten]

2.1. Trigonometrische und hyperbolische Funktionen

2.2. Stetigkeit, Differential- und Integralrechnung

2.3. Gleichungen und Terme

2.4. Reelle und komplexe Zahlen

2.5. Mengen und Listen

2.6. Mathematische Konstanten

2.7. Bedingungen und Schleifen

2.8. Randomisierung

2.9. Verschiedenes

2.10. Plot-Funktion

2.11. Erstellung eigener Funktionen

2.12. Lösen von Gleichungen und Linearen Gleichungssystemen

2.12.1. Umwandeln der Lösungen

3. Intervalle [Bearbeiten]

3.1. Eingabe von Intervallen

3.2. Funktionen zu Intervallen

Rechenoperationen [Bearbeiten]

Grundrechenarten

  • 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 Fließkommazahl 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\)

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 [Bearbeiten]

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 undcoeff(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\) aus, z. B. num(2/3) = 2
  • rat(a) → Wandelt eine Fließkommazahl \(a\) in einen Bruch um (falls möglich), z. B. float(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

  • freeof(a,M) → Gibt true zurück, wenn \(a\notin M\) (funktioniert bei Listen und Mengen)
  • 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) ] \)
  • 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]
  • random_permutation(L) → Zufällige Permutation der Liste \(L\)
  • set(a,b,c) → Erstellt eine Menge \(\{a,b,c\}\)
  • setify(L) → Wandelt die Liste \(L\) in eine Menge um

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 [Bearbeiten]

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.