Hier werden die Basics von STACK und insbesondere Maxima in Moodle zusammengefasst. Originaltexte zusammengetragen und übersetzt aus https://github.com/maths/moodle-qtype_stack/tree/master/doc/en/CAS und der Dokumentation "Minimal Maxima".

STACK arbeitet im Hintergrund mit dem Computeralgebrasystem Maxima. Dies bedeutet, in STACK-Aufgaben können generell Maxima Funktionen und Berechnungen durchgeführt werden, wobei es einige Einschränkungen in STACK gibt. Weiterhin gibt es Funktionen die nur in STACK und nicht in Maxima definiert sind. Welche Funktionalitäten zur Verfügung stehen, kann man hier nachschlagen.

Objekte in Maxima sind Ausdrücke (englisch: expressions). Diese kommen generell in drei Formen vor:

• Atome wie Symbole, Strings und Zahlen
• Operatoren mit ihren Argumenten (die wiederum Operatoren oder Atome sein können)
• Mathematische Ausdrücke die mathematische Operatoren (+-*/<>=) oder Funktionen (z.B. sin(x)) enthalten

Die wichtigsten Objekte sind

• Gleichungen
• Ungleichungen
• Sets (z.B. A:{1,2} )
• Listen (z.B. L:[1,2,3] mit Zugriff auf x-tes Element durch Befehl L[x])
• Matrizen (z.B. M:matrix([1,2],[3,4]) mit jede Zeile als eigene Liste und Zugriff durch M[x][y])
• logische Ausdrücke, verknüpft mit logischem and oder or (z.B. x=1 or x=2)
• (sonstige) Ausdrücke

Listen können z.B. angelegt werden mit:

L:[1,2,3];

Es wird also der Variable L die Liste [1,2,3] zugeordnet. Dementsprechend kann mit

L[i];

auf das i-te Element der Liste zugegriffen werden. Das erste Element der Liste ist somit entsprechend L[1]. Erwähnenswert ist hier noch, dass eine Liste auch weitere Listen enthalten kann. In einer Liste L die [[1,true],[2,true],[3,false]] enthält, kann man also mit

L[3][2];

auf das zweite Element in der dritten Liste zugreifen (in diesem Fall false). Eine weitere nützliche Operation ist

map(f, L);

Hiermit wird f auf jedes Element von L angewandt. Möchte man jedes Element in der Liste aufaddieren, so kann man dies mit

apply("+",L);

tun. Eine weitere Operation ist

for x in L do ex;

Dies wendet die Operation ex für jedes Element von L an, wobei x in ex als Variable genutzt werden kann. Weiterhin kann man mit

length(L);

die Anzal der Elemente in L bestimmen.

Matrizen können mit

M:matrix(L1, ..., Ln);

angelegt werden, wobei L1 bis Ln Listen sind, die die Zeilen der Matrix repräsentieren. Mit den Befehlen

M[i,j]

oder

M[i][j]

greift man auf das Element in der i-ten Zeile und j-ten Spalte zu. Der Befehl

M:zeromatrix(n,m);

erzeugt direkt eine n x m - Nullmatrix.

Die Matrixmultiplikation wird mit dem Punkt als Operator durchgeführt. Das heißt M.L, L.M und M.N sind Matrixmultiplikationen, mit L als Liste und M und N als Matrizen.

Weitere nützliche Funktionen für Matrizen:

Sets erstellt werden mit

A:set(a,b,c,...);

oder mit

A:{a,b,c,...};

Hier sind a,b,c,… die Elemente des Sets. Beide Alternativen sind äqivalent. In Sets erscheinen die Elemente des Sets nur einmal. Das heißt

A:set(a,b,c,b,a);

liefert das Set {a,b,c}. Ist dies nicht der Fall, so ist wahrscheinlich die Simplifikation(siehe Abschnitt zu Simplifikation) nicht aktiviert. Diese kann man aber aktivieren indem man Aufgabenweites Simplify in den Optionen der STACK-Frage auf Ja setzt, indem man die simp Variable temporär in den Aufgabenvariablen auf true setzt

simp:true;
A:set(a,b,c,b,a);
simp:false;

oder indem man die Funktion ev() nutzt.

A:ev(set(a,b,c,b,a), simp);

Nützliche Funktionen für Sets:

Innerhalb Zuweisungen können Maxima-Funktionen genutzt werden.

Beispiel:

a:expand((x+1)*(x-5));

Um eine Funktion zu defnieren gibt es zwei Möglichkeiten. Eine ist der Operator := und die zweite ist die Funktion define(). Die erstere haben wir bereits im vorangehenden Kapitel gesehen.

1. Die erste Möglichkeit ist eine Funktion mit dem Operator := zu definieren. So kann man z.B. eine Funktion foo(x) definieren mit foo(x) := diff(x^2 + x + 5, x). Unter foo(x) ist nun die Funkion diff(x^2 + x + 5, x) hinterlegt. Hier wird nun bei jedem Aufruf von foo(x) die Funktion x^2 + x + 5 nach x differenziert und der übergebene Wert an der Stelle x eingesetzt. Es ist eventuell nicht gewollt, bei jedem Aufruf die Funktion erneut zu differenzieren, daher gibt es noch eine zweite Möglichkeit Funktionen zu definieren.
2. Es ist auch möglich eine Funktion mit der Maxima Funktion define() zu definieren. Mit define(foo(x), diff(x^2 + x + 5, x)) wird direkt beim Definieren der Funktion diff() ausgeführt und so ist letzten Endes die Funktion 2*x + 1 unter foo(x) hinterlegt.

Gleichungen können mit der Funktion solve(ex, x) gelöst werden.

solve(x^2 + x - 30 = 0, x);

löst die Gleichung x^2 + x - 30 = 0 nach x auf und gibt die Liste

[x = -6, x = 5]

aus, die die Lösungen enthält. Ist ex keine Gleichung, so wird ex = 0 angenommen.

Auch Gleichungssysteme können mit solve([ex1, …, exn], [x1, …, xn]) gelöst werden.

solve([x + y = 0, x - y = 10], [x, y]);

liefert als Ergebnis

[[x=5, y=-5]]

Hierbei ist zu beachten, dass die Lösung eine Liste innerhalb einer Liste ist. Dies liegt daran, dass jede mögliche Lösung als eigene Liste aufgelistet wird.

Mit Hilfe von Maxima kann man mit Hilfe von Funktionen sehr einfach Integrale berechnen lassen und differenzieren.

Es können mit integrate(ex, x) uneigentliche und mit integrate(ex, x, a, b) eigenliche Integrale ausgewertet werden, wobei ex die zu integrierende Funktion beschreibt, x die Variable und a und b die Grenzen definieren.

So liefert z.B.

integrate(1/(1+x), x);

entsprechend das Ergebnis

ln(|x+1|)

Einige Maxima Funktionen können beim Integrieren sehr nützlich sein. Möchte man das eben genannte Integral zwischen den Grenzen 0 und a berechnen, so sollte man vorher angeben, dass a größer 0 ist. Dies kann man vor dem Integrieren mit dem Befehl

assume(a>0);

erreichen. Andernfalls würde

integrate(1/(1+x), x, 0, a);

zu Fehlermeldungen führen.

Möchte man das Integral nicht ausrechnen, sondern einfach nur als Integral ausgeben, so kann man dies mit einem Apostroph vor dem Befehl erreichen, was die Ausführung der Funktion in Maxima unterdrückt, also z.B.

'integrate(1/(1+x), x, 0, a);

Möchte man diesen Ausdruck dann doch integrieren kann man das mit dem Befehl

ev(ex, integrate);

tun. Wird auch ohne das Apostroph nur das Integral angezeigt, so konnte kein Integral gefunden werden und man muss eventuell manuell mit Substiution nach einer Lösung suchen.

Einfaches differenzieren einer Funktion ex nach Variable x funktioniert mit dem Befehl

diff(ex, x);

Die n-te Ableitung erhält man mit

diff(ex, x, n);

Mit

diff(ex, x_1, n_1, x_2, n_2, ..., x_m, n_m);

wird ein Ausdruck ex zunächst n_1 mal nach x_1 differenziert, dann n_2 mal nach x_2 differenziert, etc.

Auch hier kann man genauso wie beim Integrieren, die tatsächliche Berechnung durch ein vorgestelltes Apostroph unterbinden (z.B. 'diff(x^2, x)).

Funktionen in STACK/Maxima die als Input einen Ausdruck nehmen und true oder false ausgeben.

ex steht für den Ausdruck (expression). Beachte: Jeder Name einer Prädikats-Funktion endet auf „p“.

rationalized(ex) gibt zudem false zurück, falls der Ausdruck ex Brüche enthält, die im Hauptnenner z.B. Wurzelausdrücke enthalten mit einer Liste der Funde und true sonst. Ist aber an sich keine Prädikats-Funktion.

Manche Zahlen wie z.B. e oder pi sind schon automatisch als Variablen angelegt. Das heißt pi: %pi ist nicht notwendig. Möchte man jedoch pi nur als Symbol und nicht als Zahl benutzen so kann man den Befehl stack_reset_vars(true) mit in die Aufgabenvariablen aufnehmen.

Mit der Funktion float(ex) kann aus ex eine Gleitkommazahl gemacht werden. Mit rat(ex) kann ex „rationalisiert“ werden. Für

rat(0.25);

erhalten wir entsprechend den Bruch 1/4 als Output.

Aufpassen muss man, wenn Ausdrücke wie 2e5 (im Sinne von 2 x 10^5) benutzt werden sollen, da wie oben schon beschrieben e als Eulersche Zahl angelegt wird. Hier muss man die strikte Syntax in Fragen aktivieren, da sonst der Ausdruck 2e5 als 2*e*5 interpretiert wird.

Gerundet wird standardmäßig in STACK mit

round(x);

wobei hier zu beachten ist, dass das symmetrische Runden genutzt wird. Es wird also bei .5 auf die nächste gerade Zahl gerundet. Das heißt, 2.5 wird auf 2 abgerundet und 3.5 auf 4 aufgerundet. Kaufmännisches Runden kann dennoch mit der Funktion

significantfigures(x, n);

erreicht werden.

Die Maxima Funktion random() erzeugt Zufallszahlen, jedoch sollte dies nicht für STACK-Aufgaben genutzt werden, denn dies verursacht, dass ein Student, der eine Frage ein weiteres Mal ansieht, neue Zufallswerte erhält. Um dies zu vermeiden, wurde für STACK eine Funktion rand(), mit festgesetztem seed, definiert. Diese ist also dementsprechend für STACK zu bevorzugen.

Es ist ratsam beim Erzeugen von Zufallszahlen keine bedingte Anweisungen wie z.B. if zu benutzen sondern auf einfachere Mittel zurückzugreifen. Möchte man beispielsweise eine Zufallszahl erzeugen, die eine kleine Primzahl ist, dann ist der Ausdruck

rand([2, 3, 5, 7, 11, 13, 17, 19]);

vielleicht nicht die schönste, aber dafür die zuverlässigste Variante.

Weiterer Tipp: Möchte man Zufallszahlen nicht ab 0 aufwärts sondern z.B. zwischen -5 und 10 oder zwischen 11 und 42 erzeugen, so kann man dies mit der Kombination von Zufallswerten und der Addition oder Substraktion von festen Werten erreichen.

Zufallswerte zwischen 11 und 42:

p: rand(32)+11;

Matrix mit Zufallswerten zwischen -5 und 10:

A: rand(matrix([16,16],[16,16]))-matrix([5,5],[5,5]);

Zufallszahl aus {-5, -2, 1}:

a: rand_with_step(-5, 3, 3);

Zufallszahl aus {-5, -4, -3, 3, 4, 5}:

b: rand_with_prohib(-5, 5, [-2, -1, 0, 1, 2]);

Diese Funktion ist z.B. nützlich um bei Brüchen zu vermeiden durch 0 zu teilen.

Drei zufällige Elemente aus [1, 2, 3, 4, 5] ziehen:

c: rand_selection([1, 2, 3, 4, 5], 3);

Folgender Befehl könnte beispielsweise [4, 3, 5, 1, 2] liefern:

d: rand_permutation([1, 2, 3, 4, 5]);

Erzeugen eines Polynoms vierten Grades mit zufälligen Koeffizienten zwischen 0 und 6:

polynom: apply("+", makelist(rand(7)*x^k, k, 0, 4))

Hier wird zunächst mit makelist(ex, k, i, j) eine Liste erstellt, die aus den Elementen ex besteht, wobei jeweils die Variable k in ex mit den Zahlen zwischen i und j ersetzt wurde. Die Koeffizienten sind randomisiert und mit apply(„+“, ex) werden schließlich die Listenelemente aufaddiert, so dass wir ein Polynom erhalten.

Fragentext:

Ein Pendel befindet sich auf dem Planeten {@p@}. Welche Länge muss das Pendel besitzen um eine Periode von {@t@}s zu haben?

Aufgabenvariablen:

t:rand(5)+3;
idx:rand(3)+1;  /* Index bei Listen starten bei 1, rand(n) liefert 0,...,n-1.  */
l1:["Merkur", "Erde", "Mars"];
l2:[3.61, 9.8, 3.75];
p:l1[idx];
ta:t*l2[idx]/(4*%pi^2);

Folgende Funkionen sind nur in STACK und nicht Maxima definiert:

Als Voreinstellung ordnet Maxima Terme automatisch in umgekehrter lexikographischen Ordnung an. Also würde man z.B. eine Variable mit dem Term a+b+c belegen und diese im Fragetext ausgeben, so erscheint als Output automatisch c+b+a.

Die Ordnung kann man mit den Befehlen

ordergreat(v_1, v_2, ..., v_n);

oder

orderless(v_1, v_2, ..., v_n);

geändert werden. Dabei würde die Ordnung v_1 > v_2 > … > v_n bzw. v_1 < v_2 < … < v_n angenommen werden.

Das heißt bei einer Eingabe von

ordergreat(a, b, c)

erhält man im obigen Beispiel einen Output von a+b+c.

In STACK-Aufgaben kann man in den Optionen des Potential response tree die globale Variable simp ändern. Dies geschieht unter dem Optionspunkt Auto-Vereinfachung. Es wird dementsprechend die Variable simp auf true oder false gesetzt. Dies kann man auch manuell tun mit dem Befehl simp:true. Is diese Variable auf false gesetzt, so werden Terme wie 4+5 von Maxima nicht automatisch zu 9 vereinfacht, sondern so belassen.

Ist simp:false gesetzt, so kann mit ev(ex, simp) ein Ausdruck ex mit Vereinfachung ausgewertet werden.

Möchte man in einer STACK-Aufgabe plotten, so muss man aufpassen, in welche Dokumentationen man schaut. Obwohl STACK mit dem CAS Maxima operiert, können vor allem in diesem Themengebiet nicht die gleichen Funktionen wie in Maxima benutzt werden. In Maxima existieren allgemein Funktionen wie plot2d() und plot3d() mit denen man wunderschöne plots und Grafiken erstellen kann. In Moodle existieren diese nicht. Es wurde eine neue Funktion plot() angelegt, die ausgewählte Funktionalitäten von plot2d() enthält. Wie man die plot() Funktion nutzen kann und was im Vergleich zu plot2d() möglich oder nicht möglich ist, werden wird in diesem Kapitel weiter erläutert.

Zur Erklärung der Plotfunktion in STACK zunächst ein einfaches Beispiel:

plot(x^2,[x,-5,5])

Hier wird ein plot der Funktion x^2 im Bereich -5 < x < 5 erzeugt.

Die y-Achse kann man folgendermaßen festlegen:

plot(x^2,[x,-5,5],[y,-2,5])

Also in diesem Fall von -2 bis 5. Dies funktioniert aber nicht immer problemlos in STACK.

Mehrere Funktionen kann man mit Hilfe einer Liste in der selben Grafik ausgeben:

plot([x^2,sin(x)],[x,-1,1])

Traditionelle Axen, die nicht in Kastenform angezeigt werden können mit dem folgenden Einstellungen der plot() Funktion erzeugt werden:

plot([x^2/(1+x^2),2*x/(1+x^2)^2], [x, -2, 2], [y,-2.1,2.1], [box, false], [yx_ratio, 1], [axes, solid], [xtics, -2, 0.5, 2], [ytics, -2, 0.5, 2])

Beschriftungen von z.B. Achsen können generell mit den Befehlen bzw. Optionen ylabel und xlabel eingefügt werden (konkretes Beispiel hierfür folgt weiter unten). Die ylabel Option rotiert jedoch die Beschriftung um 90 Grad. Möchte man eine horizontale Beschriftung der y-Achse einfügen so kann die Option label genutzt werden, wie man im folgenden Beispiel sehen kann:

plot([x^2/(1+x^2),2*x/(1+x^2)^2], [x, -2, 2], [y,-2.1,2.1], [label,["y",-2.5,0.25]])

Hier wird an der Koordinate (-2.5, 0.25) die Beschriftung „y“ der Grafik hinzugefügt. So kann man natürlich auch beliebig Beschriftungen innerhalb der Grafik einfügen und somit auch z.B. Funktionen oder Punkte beschriften.

Um ein Koordinatennetz in einer Grafik zu hinterlegen, kann die Option grid2d benutzt werden.

plot([x^2/(1+x^2),2*x/(1+x^2)^2], [x, -2, 2], [y,-2.1,2.1], grid2d)

Hier eine Liste aller Optionen die von plot() in STACK und damit in Moodle unterstützt werden:

style: lines (für Linienabschnitte), points (für isolierte Punkte), linespoints (für Linienabschnitte und Punkte), oder dots

color: red, green, blue, magenta, cyan, yellow, orange, violet, brown, gray, black, white

point_type: bullet, circle, plus, times, asterisk, box, square, triangle, delta, wedge, nabla, diamond, lozenge

Für einige erstellte Aufgaben kann es sinnvol sein den zugeordneten Text der Grafik selbst zu ändern. Besteht die Aufgabe beispielsweise darin, dass ein Student vom Verlauf der Funktion zuordnen soll um welche Funktion es sich handelt, so könnte er dies in den Bildeigenschaften einfach nachschauen. Ein Standardtext für eine solche Grafik lautet z.B. „STACK auto-generated plot of [x^2] with parameters [[x,-2,2],[y,-2.1,2.1]]“. Um dies zu vermeiden kann mit der alt Option dieser Text geändert werden.

plot(x^2,[x,-2,2],[alt,"These aren't the functions you're looking for."])

Einfache diskrete funktionen kann man mit dem Befehl discrete[ [x_1, y_1], …, [x_n, y_n]] darstellen. Beispiel:

plot([discrete,[[0,0],[1,1],[0,2]]]);

Dies ergibt den folgenden Graphen:

Diese Funktionen können wie in den Beispielen zuvor auch mit anderen Funktionen in Grafiken kombiniert werden.

plot([[discrete, [[10, .6], [20, .9], [30, 1.1], [40, 1.3], [50, 1.4]]], [discrete, [[11, .5], [15, .9], [25, 1.2], [40, 1.3], [50, 1.4]]]], [style,points], [point_type,circle,square], [color,black,green]);

plot(x*sin(1/x),[x,-1,2],[xlabel,"Independent variable"],[ylabel,"Dependent variable"],[legend,"This is a plot"]);

r: (exp(cos(t))-2*cos(4*t)-sin(t/12)^5);
p: plot([parametric, r*sin(t), r*cos(t), [t, -8*%pi, 8*%pi]]);

plot(exp(3*s),[s, -2, 2],[logy],[color,red]);

(Beachte die angepassten Achsenbeschriftungen)

Normale Einstellung:

plot([parametric, (exp(cos(t))-2*cos(4*t)-sin(t/12)^5)*sin(t), (exp(cos(t))-2*cos(4*t)-sin(t/12)^5)*cos(t), [t, -8*%pi, 8*%pi]], [nticks, 100]);

Ohne Axen und Rahmen:

plot([parametric, (exp(cos(t))-2*cos(4*t)-sin(t/12)^5)*sin(t), (exp(cos(t))-2*cos(4*t)-sin(t/12)^5)*cos(t), [t, -8*%pi, 8*%pi]], [nticks, 100], [axes,false], [box,false]);

Eine abschnittsweise definierte Funktion kann mit der if Anweisung definiert werden.

f0:x^3;
f1:sin(x);
x0:2;
pg1:if x<(x0-1/1000) then f0 else if x<(x0+1/1000) then 5000 else f1;

Achtung: An plot() müssen Ausdrücke und nicht Funktionen übergeben werden, also nutzen wir f0:x^3 und nicht f(x):=x^3. Die Werte (x0-1/1000) und (x0+1/1000) sorgen dafür, dass eine kleine Lücke im Grafen entsteht. Nun können im CASText der plot ausgegeben werden:

{@plot(pg1,[x,(x0-5),(x0+5)],[y,-10,10])@}

Um die Endpunkte einzurkreisen kann die Aufgabe folgendermaßen erweitert werden:

f0:x^3
f1:sin(x)
x0:2
pg1:if x<(x0-1/1000) then f0 else if x<x0+1/1000 then 5000 else f1;
ps:[style, lines, points, points];
pt:[point_type,circle,circle,bullet];
pc:[color, blue,red,blue];

Mit zugehörigem Aufgabentext:

{@plot([pg1, [discrete,[ [x0,ev(f0,x=x0)], [x0,ev(f1,x=x0)]]], [discrete,[ [x0,ev((f0+f1)/2,x=x0)]]] ], [x,(x0-5),(x0+5)], [y,-10,10], ps, pt, pc)@}

Ist eine Grafik bereits vorhanden, so kann diese natürlich einfacher die Bilddatei auf einer Internetplattform hochzuladen und per HTML mit der entsprechenden URL direkt in den Aufgabentext einzubinden.

Nicht unterstützt sind folgende Eigenschaften und Funktionalitäten:

• Das draw Paket
• Die implicit_plot() Funktion
• Die plot2d() und plot3d() Funktionen

Nützlich für die Bearbeitung und Erstellung von Fragen, sind natürlich auch Kommentare. Zum einen um für eigene Zwecke zu dokumentieren, was gewisse Eingaben tun, aber auch damit andere wissen, was dort getan wurde.

Im Textfeld für Aufgabenvariablen können Kommentare geschrieben werden mit

/* Dieser Satz wird vom CAS ignoriert */

/*
Es können auch mehrere Sätz auskommentiert werden.
Somit können einfach auch ganze Kommentarblöcke geschrieben werden.
So wie dieser hier.
*/

Im Fragentext, der für die Studenten erscheint, können Kommentare mit einem Kommentarblock eingefügt werden.

[[comment]] Diesen Kommentar werden Studenten in ihrere Frage nicht sehen. [[/comment]]

Es ist teilweise, durch immer wieder erneutes Eingeben, Speichern und Anzeigen der Fragenvorschau, sehr umständlich neue Aufgabenstellungen zu verfassen, Maxima Funktionen zu testen oder Fehler in der Aufgabenimplementierung zu finden. Daher ist es ratsam auf dem eigenen Rechner wxMaxima zu installieren um dort mit Maxima Befehlen herumspielen zu können. wxMaxima ist ein Programm, das eine grafische Benutzeroberfläche, Menüs und Dialoge bietet um Maxima Code auszuführen.

Um wxMaxima nutzen zu können, muss zunächst Maxima selbst auf dem Rechner installiert werden. Downloadlinks und Installationsanleitungen findet man unter folgendem Link: Maxima

Das Programm wxMaxima kann man danach herunterladen unter: wxMaxima

Befehle können in wxMaxima mit Shift + Enter ausgeführt werden. Um jedoch tatsächlich alle Funktionen von Maxima nutzen zu können, die auch in STACK vorhanden sind, braucht man die Maxima Sandbox. Dazu mehr im nächsten Abschnitt.

Mit Maxima und wxMaxima alleine kann man zwar Maxima Funktionen und Operationen durchführen, doch nicht alle Funktionen, die in Maxima verfügbar sind, sind (aus Sicherheitsgründen) auch in Moodle bzw. STACK verfügbar. Zudem gibt es Funktionen, die in STACK nutzbar sind, aber so nicht in Maxima existieren.

Um wxMaxima so einzurichten, dass sich das Programm wie in Moodle/STACK verhält, brauchen wir die Maxima Sandbox. Diese kann unter folgendem Link heruntereladen werden: Maxima Sandbox

Alle Dateien die wir benötigen befinden sich im Verzeichnis

.../stack/maxima/

Die sandbox.wmx Datei, die sich in diesem Verzeichnis befindet, muss dann nur noch (nach jedem erneuten Start von wxMaxima) in wxMaxima geöffnet und ausgeführt werden. Je nach Betriebssystem sind dort einige Teile auszukommentieren (siehe dazu die Informationen innerhalb der Befehle).

Um den Einstieg in die Funktionalitäten von wxMaxima zu erleichtern, kann sich auf der Website von wxMaxima ein kleines Tutorial heruntergeladen werden. Einen Link dorthin finden Sie hier: wxMaxima Dokumentation

Einen direkten Link zu der deutschen Version finden Sie hier verlinkt: 10 minute (wx)Maxima Tutorial (German)

• moodle-qtype_stack (Github)
• Minimal Maxima
• Maxima Dokumentation