Fischertechnik
AVR
Raspberry Pi
Elektronik
Netzwerk
Sonstiges


















Impressum

Einführung und Grundlagen

Von Wolfram Research, einem amerikanischen Software-Unternehmen, wurde mit Mathematica ein sehr mächtiges Werkzeug zur Mathematik entwickelt. Kennengelernt habe ich dieses schon während meines Zeit an der Universität Hannover und war damals, Ende der 80er- oder Anfang der 90er-Jahre des letzten Jahrhunderts, schon begeistert, welche Arbeitserleichterung ein Computerprogramm bieten kann. Mit Bleistift und Papier konnte ich damals durchaus gut umgehen, trotzdem schlichen sich immer wieder Fehler ein, und wenn es nur daran lag, dass ich meine eigene Schrift nicht richtig gelesen habe. Solche Fehler passieren einem Computer nicht. Darüberhinaus ist zum Beispiel das Lösen von Differentialgleichungen oft eine Fleißaufgabe, die mir nicht richtig Freude bereitet.
Die Visualisierung der Ergebnisse ist mir wichtig und gelingt mit Mathematica problemlos.
Mathematica arbeitet, solange ich es will, mit Variablen und Bezeichnern und nicht numerisch. Es war mir schon immer ein Graus, wenn Schüler bei jedem Zwischenergebnis zum Taschenrechner griffen, Zahlen eintippten und dann mit den angezeigten Ergebnis weitergeabreitet hatten. Welchen Einfluss zum Beispiel das Runden hatte, war für den weiteren Verlauf nicht transparent. Ein simpler Tippfehler bei einem frühen Zwischenergebnis sorgt für einen erheblichen Mehraufwand für den korrigierenden Lehrer.
Die Internetseite https://www.wolframalpha.com/ bietet in einer ähnlichen Syntax nahezu alle Möglichkeiten, die ich benötige. Wenn mein Raspberry Pi gerade mal nicht an ist, nutze ich diese Seite, oder die gleichnamige App auf dem Smartphone.
Was hat das mit dem Raspberry Pi zu tun? Ganz einfach: Mit jedem Raspberry Pi ist Mathematica lizensiert. Natürlich nicht für eine kommerzielle Nutzung, aber zum persönlichen Gebrauch und zur Lehre.

Aller erste Schritte

Nach dem Start von Mathematica erscheint ein leeres Dokument, Notebook genannt, und Tastatureingaben erscheinen dort. Schnell ein 1+1 getippt, aber es passiert nichts. Was ist falsch? Mathematica erwartet ein [Umschalt][Eingabetaste] ([Shift][Enter]) um die Berechnung zu starten. Ein einfaches [Enter] reiht einfach mehrer Anweisungen aneinander und erst ein abschließendes [Shift][Enter] liefert die Ergebnisse. Die vier Grundrechenarten können mit +, −, * und / eingegeben werden. Statt des * genügt ein Leerzeichen, was in Formeln sehr hilfreich ist. Mathematica ersetzt an manchen Stellen dieses Leerzeichen durch ein × was die Lesbarkeit oft deutlich verbessert. Bei den ersten Spielereien wird hier auffallen, dass 12/4 zwar 3 ergibt, 12/5 aber unverändert 12/5. Diese liegt daran, dass Mathematica so rechnet, wie ich mit Bleistift und Papier. Gekürzt wird, aber wenn dieses nicht geht, bleibt der Bruch stehen. Gut so. Der numerische Wert kann aber jederzeit ausgegeben werden. Die Funktion N[] liefert den numerischen Wert. N[12/5] liefert den Wert 2.4 und es ist auch möglich, die Anzahl der Ausgabestellen mit anzugeben. N[12/5,3] ergibt 2.40 und N[12/5,1] den Wert 2. und damit richtig abgerundet.
Die Eingabe von Brüchen kann mit [Steuerung][/] ([Strg][/] oder [Ctrl][/]) gleich optisch ansprechend erfolgen. Nach der Eingabe des Nenners kann mit [Steuerung][Leertaste] ([Ctrl][Space]) wieder auf die normale Zeilenhöhe zurückgekehrt werden.
In[1]=  1+2
        2+3
        3*4
        4×6
        12/4
        12/5
        N[12/5]
        N[12/5,3]
Out[1]= 3
Out[2]= 5
Out[3]= 12
Out[4]= 24
Out[5]= 12/5
Out[6]= 2.4
Out[7]= 2.40
Alle Ergebnisse sind durchnumeriert. Hierdurch können diese weiterverwendet werden. N[%5,1] liefert im obigen Beispiel 2. und damit den Wert des Bruches im Ergebnis Out[5] auf eine Stelle gerundet.

Was ist bis hierher gelernt?

Spezielle Eingaben

[Enter]Erweitert die Eingabe um eine Zeile. Es wird keine Berechnung gestartet.
[Shift][Enter]Startet die Berechnung der aktuellen Eingabe
[Ctrl][/]Erlaubt die Eingabe einen Nenners zu einem Bruch
[Ctrl][Space]Kehrt aus der Eingabe des Nenners zurück

Funktionen

N[]Liefert den numerischen Wert des Arguments
N[,]der optionale zweite Paramter bestimmt die Anzahl der ausgegebenen Stellen.
%referenziert das letzte Ergebnis
%nreferenziert das Ergebnis mit der Nummer n.
Mathematica nutzt eckige Klammern für die Klammerung von Argumenten einer Funktion. Funktionsnamen beginnen mit einem Großbuchstaben.

Exkurs postfix-Funktionen

Im vorangegangenen Abschnitt wurde die Funktion N[] eingeführt. Diese berechnet nach (engl./lat. "post") der Auswertung des Ausdrucks den numerischen Wert. Mathematica erlaubt eine sogenannte Postfix-Schreibweise, die vielfach geschachtelte Ausdrücke vermeiden hilft. Aus der Shell-Programmierung würde ich das als Pipe bezeichnen. Statt F1[F2[F3[a+b]]] kann mit diese Notation dann a+b // F1 // F2 // F3 geschrieben werden. Erst wird a+b ausgewertet, das Ergebnis dann der Funktion F1 übergeben und so fort. Wirklich gut lesbar.

Hilfe !!!

Die eingebaute Hilfefunktion ist sehr hilfreich und wird über ? aufgerufen. Ist die Funktion bekannt, für die Hilfe benötigt wird, dann folgt direkt auf das Fragezeichen der Name der Funktion:
In[1]=  ?N
        N[expr] gives the numerical value of expr.
        N[expr,n] attempts to gives a result with n-digit precision.
Sind nur Teile des Funktionsnamens bekannt, kann mit ? * eine Liste passender Funktionen abgefragt werden:
In[2]=  ?*Plus*
        CirclePlus  DayPlus       MinusPlus  PlusMinus  SuperPlus
        DatePlus    DotPlusLayer  Plus       SubPlus    UnionPlus
Die Ausgaben der eingebauten Hilfe sind farbig hinterlegt und werden nicht wie eine Ausgabe von Funktionen behandelt. Entsprechend fehlen die Ausgaben Out[1] und Out[2] in diesen zwei Beispielen auch.

Rechnen mit Symbolen

Wie oben beschrieben liegen die Stärken von Mathematica beim mathematische korrektem Umgang mit Symbolen, Formeln, Gleichungen und so fort. (a+b)² bleibt bei der Eingabe unverändert, weil es aus Sicht von Mathematica die kürzeste Darstellung des Ausdrucks ist. Expand[(a+b)²] oder in Postfix-Notation (a+b)² // Expand liefert die eigentlich erwartete Darstellung a² + 2 a b + b² . Die optisch ansprechende Eingabe von Exponenten erfolgt mit [Ctrl][6] vor dem Exponenten und einem abschließenden [Ctrl][Space] zur Rückkehr auf die normale Schreiblinie (wie nach der Eingabe eines Nenners). Alternativ kann ^ verwendet werden, oder auch die Funktion Power[Basis,Exponent]. Bei dieser Gelegenheit noch zwei Funktionen, die Terme vereinfachen. Simplify[] und FullSimplify[] versuchen die Komplexität von Ausdrücken zu reduzieren. Die zuletztgenannte Variante ist erfolgreicher aber auch ressourcenintensiver. Auch bei diesen beiden Funktionen ist die Postfix-Notation üblich und sinnvoll.

Symbole

Symbole sind einzelne Buchstaben (lateinisch oder griechisch), oder Kombinationen aus diesen. Groß- und Kleinschreibung wird unterschieden. Ein beliebter Fehler ist das Weglassen von Leerzeichen bei Produkten: ωt ist ein Symbol aus zwei Zeichen und nicht wie gemeint, das Produkt aus Kreisfrequenz und Zeit. Richtig wäre hier ω t. Dieses ist einer der wenigen Fehler, die mit Bleistift und Papier nicht so leicht geschehen. Ziffern dürfen ebenfalls Bestandteil eines Symbols sein aber nicht an erster Stelle stehen.
Hoch- oder tiefgestellte Erweiterungen eines Symbols sind nicht Bestandteil des Symbols und sollten deshalb nicht, oder nur mit großer Vorsicht verwendet werden.

Besondere Symbole

Mathematica kennt die Kreiszahl π (Eingabe mit [Esc][p][Esc]), die Eulersche Zahl e (Eingabe mit [Esc][e][e][Esc]) die imaginäre Zahl i (Eingabe mit [Esc][i][i][Esc]) und Unendlich (engl. infinity, Eingabe [Esc][i][n][f][Esc]). Neben i als imaginäre Einheit wird auch die in der Elektrotechnik verwendete Variante j (Eingabe mit [Esc]jj[Esc]) unterstützt. All diese Symbole werden mit ihrer mathematischen Bedeutung richtig und eindeutig behandelt. Um eine Verwechslung mit den Symbolen e, i und j zu vermeiden, werden die Eulersche Zahl und die imaginäre Einheit von Mathematica besonders dargestellt.
Die Eingabefolge [Esc]...[Esc] eignet sich sehr gut für das griechische Alphabet. [Esc][a][Esc] ergibt entsprechend das kleine α, mit dem großen A ein großes Alpha (Α).

Symbole nehmen einen Wert an

Irgendwann wird es im Laufe einer mathematischen Aufgabe meist doch erforderlich Zahlenwerte einzusetzen. Hierfür gibt es das Zuweisungszeichen = und dieses sollte beim Zuweisen eines numerischen Wertes auch ausschließlich verwendet werden. Jetzt wird klar, dass es wohl noch eine weitere Möglichkeit einer Zuweisung gibt. Mit := erfolgt ebenfalls eine Zuweisung, und wenn auf der rechten Seite numerische Werte stehen, unterscheidet sich diese auch nicht von =. Anders verhält es sich, wenn auf der rechten Seite Symbole oder Funktionen von Symbolen stehen. In diesem Fall wird statt einer Wertzuweisung nur eine Verknüpfung zu der rechten Seite abgespeichert. Die Auswertung erfolgt bei jedem Zugriff auf die linke Seite neu und berücksichtigt die dann zugehörige rechte Seite.
In[1]=  a=1;
        b=2;
        c:=a+b
        d=a+b;
        c
        a=8;
        c
        d
Out[5]= 3
Out[7]= 10
Out[8]= 3
In diesem Beispiel wird jeweils c und d die Summe von a und b zugewiesen. Es ist schön zu sehen, dass die nachträgliche Änderung des Wertes a von 1 auf 8 nur bei c "wirkt". In diesem Beispiel ist noch eine Neuheit untergebracht. Das ; verhindert die Ausgabe, nicht aber die Erzeugung der jeweiligen Ergebnisse. Dieses ist an den Nummern der Ausgabe erkennbar. Das Ergebnis Out[1]= 1 fehlt in der Ausgabe ebenso wie Out[2]= 2, Out[4]= 3 und Out[6]= 8. Zu Out[3] gehört die Zuweisung mit := bei der die Ausgabe auch ohne das ; unterdrückt wird.

Was ist bis hierher gelernt?

Spezielle Eingaben

[Enter]Erweitert die Eingabe um eine Zeile. Es wird keine Berechnung gestartet.
[Shift][Enter]Startet die Berechnung der aktuellen Eingabe
[Ctrl][/]Erlaubt die Eingabe einen Nenners zu einem Bruch
[Ctrl][6]Erlaubt die Eingabe einen Exponenten
[Ctrl][Space]Kehrt aus der Eingabe des Nenners oder eines Exponenten zurück
[Esc][p][Esc]Eingabe Kreiszahl π
[Esc][e][e][Esc]Eingabe Eulersche Zahl e
[Esc][i][i][Esc]Eingabe imaginäre Einheit i
[Esc][j][j][Esc]Eingabe imaginäre Einheit j
[Esc][i][n][f][Esc]Eingabe ∞ (Unendlich)
[Esc][a][Esc]Eingabe griechischer Buchstabe α
[Esc][b][Esc]Eingabe griechischer Buchstabe β
[Esc][g][Esc]Eingabe griechischer Buchstabe γ
[Esc][o][Esc]Eingabe griechischer Buchstabe ω (Omega)
[Esc][o][m][Esc]Eingabe griechischer Buchstabe ο (Omicron)

Funktionen

N[]Liefert den numerischen Wert des Arguments
N[,]der optionale zweite Paramter bestimmt die Anzahl der ausgegebenen Stellen.
%referenziert das letzte Ergebnis
%nreferenziert das Ergebnis mit der Nummer n.
Extend[]Erweitern (z.B. Ausmultiplizieren) eines Terms
Simplify[]Vereinfachen eines Terms
FullSimplify[]Vereinfachen eines Terms mit noch mehr Rechenaufwand
Mathematica nutzt eckige Klammern für die Klammerung von Argumenten einer Funktion. Funktionsnamen beginnen mit einem Großbuchstaben.

Funktionsgleichungen, Lösen von Gleichungen, Plot

In diesem Kapitel werden wesentliche Grundlagen von Mathematica eingeführt. Als Beispiel werden zwei Geradengleichungen aufgestellt, die Geraden als 2D-Plot visualisiert und dann der Schnittpunkt der Geraden berechnet.
 In[1]= f[x_] := -3 x + 4
        g[x_] := x + 2
        Plot[{f[x], g[x]}, {x, -4, 4},
         PlotRange -> {{-2, 6}, {-2, 6}},
         AspectRatio -> 1, GridLines -> {{0.5}, {2.5}}, 
         PlotLabels -> "Expressions"]
        Solve[ f[x] == g[x], x]
Out[3]=
        
Out[4]= {{x → 1/2}}

Funktionsgleichungen

Die Definition eigener Funktionen erfolgt durch ein Symbol für den Funktionsnamen (bei mir ist der erste Buchstabe nicht zwingend groß geschrieben), eckige Klammer auf, eine Liste der Parameternamen (jeweils mit einem angehängten Unterstrich), der schließenden eckigen Klammer und dem Zuweisungszeichen := gefolgt von der zugehörigen Abhängigkeit des Funktionswertes von den Parametern. Die Parameter werden hier ohne den Unterstrich referenziert. Die Beispiele der zwei Geradengleichungen sollten als Beispiel für einfache Funktionen Erklärung genug sein. Es sei aber erwähnt, dass die Funktion von mehrdimensionalen Vektoren identisch aussehen kann und sich nur durch den Typ der Parameter und Funktionswerte unterscheidet.

Listen

Bei der Visualisierung der Geradengleichungen mittels Plot[] tauchen erstmalig die geschweiften Klammern { } auf. Diese verwalten eines der wichtigsten Grundelemente von Mathematica, nämlich Listen. Im Beispiel wird der erste Parameter von Plot[] durch eine Liste mit zwei Elementen ersetzt. In Folge wird Plot[] für beide Listenelemente abgearbeitet.
Listen sammeln einfach nur irgendwelche Objekte, haben selber aber keine Funktion im Sinne einer automatischen Aktion. Listen können geschachtelt werden. Der Zugriff auf einzelne Listenelement ist mittels Part[Liste,Element] oder kurz Liste[[Element]] möglich.
 In[1]= L := { a, b, c}
        Part[L,1]
        L[[2]]
Out[2]= a
Out[3]= b
Viele Mathematica-Funktionen liefern als Ergebnis eine Liste. Im obigen Beispiel liefert die Funktion Solve[] eine Liste von Ergebnissen.

Range[]

Mit der Funktion Range[,,] kann eine Liste von aufeinanderfolgenden Zahlenwerten erzeugt werden. Wird nur ein Parameter angegeben, wird eine Liste ganzer Zahlen von 1 bis zum angegebenen Endwert erstellt. Werden zwei Parameter angegeben, bestimmt der erste Parameter den Startwert und der zweite den Endwert; ist der Startwert keine ganze Zahl, erfolgt die Berechnung, der Listenelemente solange durch Erhöhung um 1.0, bis kein weiterer Wert kleiner oder gleich dem Endwert verfügbar ist. Der dritte mögliche Parameter erlaubt es eine Schrittweite anzugeben. Die zweite und dritte Variante des Aufrufs funktioniert auch für komplexe Zahlen; bei der dritten Variante kann auch der imaginäre Anteil schrittweise erhöht werden. Listen können einem Symbol zugewiesen werden, und an den Stellen, wo Mathematica eine Liste als Parameter erwartet, kann dann das Symbol verwendet werden. Im obigen Beispiel erwartet die Option GridLines eine Liste von zwei Listen. Sollen jetzt alle Gitterlinien (und nicht nur die zwei im Beispiel) gezeichnet werden, könnte vor dem Aufruf von Plot[] eine Liste L=Range[-2, 6, 0.5]; erstellt werden und im Aufruf von Plot[..., GridLines -> {L,L}, ...] verwendet werden. Die Funktion Range[] kann auch eine Liste von Listen erzeugen. Für die Erzeugung des vollständigen Gitternetzes könnte mit GL = Range[{-2, -2}, {6, 6}, {0.5, 0.5}]; und Plot[..., GridLines -> GL, ...] derselbe Plot erstellt werden, wie mit der vorgenannten Variante. Hier ist darauf zu achten, dass GL bereits eine Liste von Listen enthält, und deshalb nicht noch in geschweiften Klammern steht. Bei dieser Variante kann bei der Erstellung von GL Start, Ende und Inkrement Komponentenweise festgelegt werden.
Hier noch ein Beispiel der Erstellung einer Liste von Listen und dem Zugriff auf die Elemente. Zu Demonstrationszwecken wurde keine Ausgabe von Ergebnissen unterdrückt. Mit der Funktion Range[] wird eine Liste von zwei Listen erzeugt. Jeder der drei Paramter enthät deshalb eine Liste von zwei Werten. Der jeweils erste gilt für die erste Liste, und der zweite für die zweite Liste. Die Ausgabe Out[1] zeigt das Ergebnis. Außen eine Liste mit zwei Elementen; innen zwei Listen mit vier Elementen. Die Ausgabe Out[2] zeigt den Zugriff auf das erste Element der Liste GL und zeigt die erste innere Liste von Zahlenwerten. Entsprechend zeigt Out[3] die zweite innere Liste. In Out[4] steht jetzt das zweite Listenelment aus der ersten inneren Liste.
 In[1]= GL = Range[{-4, 1}, {-1, 4}, {1, 1}]
        GL[[1]]
        GL[[2]]
        GL[[1, 2]]
Out[1]= {{-4, -3, -2, -1}, {1, 2, 3, 4}}
Out[2]= {-4, -3, -2, -1}
Out[3]= {1, 2, 3, 4}
Out[4]= -3

Table[]

Eine weitere mächtige Funktion zum Erstellen von Listen ist Table[,]. Hier ein einfaches Beispiel:
 In[5]= Table[ n a,{n,1,8,2}]
        Table[ n m a,{n,1,8,2}, {m, 3}]
        Table[ {n, n^2, n^3}, {n,0,4}]
Out[5]= {a, 3 a, 5 a, 7 a}
Out[6]= {{a, 2 a, 3 a}, {3 a, 6 a, 9 a}, {5 a, 10 a, 15 a}, {7 a, 14 a, 21 a}
Out[7]= {{0, 0, 0}, {1, 1, 1}, {2, 4, 8}, {3, 9, 27}, {4, 16, 64}}
Der erste Parameter der Funktion ist ein Ausdruck, der die Basis aller Listenelemente bildet. Ist der zweite Parameter einfach nur eine natürliche Zahl, dann gibt dieser nur die Anzahl der Wiederholungen des Ausdrucks an. Diesen einfachen Fall betrachte ich nicht. Der erste Aufruf im Beispiel ist wohl der übliche. Er bedeutet hier konkret: Ersetze im Ausdruck n a, den Wert n erst mit dem Startwert 1. Die folgenden Elemente der Liste werden gebildet, indem n um die Schrittweite 2 erhöht wird, geprüft wird, ob die Obergrenze 8 noch nicht überschritten wurde, und dann im Ausdruck entsprechend ersetzt wird. So entsteht eine einfache Liste mit vier Elementen. Der zweite Aufruf liefert eine geschachtelte Liste. Die Abarbeitung erfolgt durch eine äßere Schleife über n und eine innere Schleife über m. Für m ist weder ein Startwert, noch eine Schrittweite angegeben; hier wird, wie bei Range[] auch, jeweils der Wert 1 eingesetzt.
Der dritte Aufruf zeigt eine Liste als Ausdruck, diese wird dann für die fünf Werte (Startwert 0) von n abgearbeitet.

Weitere Operationen zu Listen

Length[Liste]Gibt die Anzahl der Elemente der Liste aus
Append[Liste,Element]Gibt die Liste verlängert um das angegebene Element aus
Prepend[Liste,Element]Gibt das Element verlängert um die Liste aus
Insert[Liste,Element,pos]Gibt die Liste um das an der angegebenen Position ergänzte Elelement aus
Delete[Liste,pos]Gibt die Liste ohne das Element an der angegebenen Position Elelement aus
Join[Liste1,Liste2,..]Gibt die Verkettung der Listen aus
First[Liste]Gibt das erste Element der Liste aus
Take[Liste,n]Gibt die ersten n Elemente der Liste aus
Last[Liste]Gibt das letzte Element der Liste aus
Drop[Liste,n]Gibt die Liste ohne die ersten n Elemente der Liste aus

Regeln →

Ebenfalls erstmalig taucht eine dritte Art der Zuweisung auf. Sie wird mit [-][>] eingegeben und wird von Mathematica als Pfeil nach rechts (→) dargestellt. Die Wirkung ist eine einmalige, begrenzt auf die eine zugehörige Anwendung; bei den Plot-Optionen der jeweilige Ersatz der Standardbelegung der Option durch den angegebenen Wert. Bei dem nächsten Aufruf von Plot[] ist die Wirkung wieder wie vorher.

Plot

Die vorletzte Neuigkeit in dem einführenden Beispiel in diesem Kapitel ist die Funktion Plot[,]. Der erste Paramter (hier eine Liste) gibt die Funktion an, die dargestellt werden soll. Der zweite Parameter im einfachsten Fall, in welchem Bereich der angegebene Parameter (meist x) variiert werden soll. Meist erfolgen dann noch Regeln, wie die Standardparameter (Optionen) angepasst werden sollen. Die Ausgabe erfolgt sehr minimalistisch, also ohne Legende, ohne Titel und ohne Achsbeschriftung. Mit $PlotTheme="Detailed" kann für alle Aufrufe von Plot[] im Geltungsbereich eingestellt werden, dass einige Gitternetzlinien und auch die Legende automatisch erzeugt wird. Die Skalierung erfolgt auch ohne Angaben gut und sinnvoll. Die Optionen sind sehr, sehr umfangreich.

Plot Optionen

OptionWerteBeschreibung
AspectRationMit dem Wert 1 wird sichergestellt, dass zum Beispiel ein Kreis wirklich rund dargestellt wird.
FillingNone
AxisZwischen Kurve und Achse
BottomZwischen Kurve und oberen Rand
TopZwischen Kurve und unterem Rand
vZwischen Kurve und Wert v
{m}Jeweils zur m-ten Kurve
Filling->{{1->{2}},3->{4}} Füllt den Bereich zwischen der ersten und der zweiten Kurve und zwischen der dritten und vierten.
Filling->{1->{{2},{Red,Green}}} Nutzt die Farben rot (Kurve 1 liegt unterhalb) und grün (Kurve 1 liegt oberhalb von Kurve 2) zum Füllen.
PlotLabelsNone
Automatic
{,,}Nutzt die hier angegebenen Ausdrücke als Beschriftung
Placed[{"..",...},Above]statt Above auch Before, After oder Below
PlotLegendsNone
Automatic
"Expressions"Nutzt die angegebenen Funktionen auch als Beschriftung
{,,}Nutzt die hier angegebenen Ausdrücke als Beschriftung
expr
Placed[{"..",...},Above]statt Above auch Before, After oder Below
PlotTheme"Business"Acht Grundthemen
"Detailed"
"Marketing"
"Minimal"
"Monochrome"
"Scientific"
"Web"
"Classic"
"NoAxes"
"MinimalAxes"
"Grid"
"SingleAxis"
"FullAxes"
"Frame"
"HeightGrid""
"FullAxesGrid"
"FrameGrid"
Ergänzende Angaben zu Achsen, Gitter, Rahmen:
"BlackBackground"
"BackgroundColor"
{"BackgroundColor",color}
"BoldColor"
"CoolColor"
"GrayColor"
"NeonColor"
"PastelColor""
"RoyalColor"
"VibrantColor"
"WarmColor"
"ThinLines"
"MediumLines"
"ThickLines"
"DashedLines"
Ergänzende Angaben zu Farben und Linien
"DarkMesh"
"GrayMesh"
"LightMesh"
"ZMesh"
"ThickSurface"
"FilledSurface"
Ergänzende Angaben für 3D

Solve

Mathematica löst Gleichungssysteme algebraisch, oder auch numerisch. Die Funktion zur algebraischen Lösung heißt Solve[,]. Der erste Paramenter ist eine Liste von Gleichungen, der zweite eine Liste von Variablen, die als Ergebnis gesucht sind. Im einfachen Beispiel bestehen beide Listen nur aus einem Element und die geschweiften Klammern einer Liste sind nicht erforderlich. Hier eine Erweiterung des Beispiels, bei der beide Koordinaten des Schnittpunkts der beiden Gerade bestimmt werden:
 In[1]= f[x_] := -3 x + 4
        g[x_] := x + 2
        Lsg = Solve[ { f[x] == g[x], y==f[x]},{ x, y} ]
        { x/. Lsg, y /. Lsg }
        Plot[{f[x], g[x]}, {x, -4, 4},
         PlotRange -> {{-2, 6}, {-2, 6}},
         AspectRatio -> 1, GridLines -> { x/. Lsg, y /. Lsg }, 
         PlotLabels -> "Expressions"]
Out[3]= {{x → 1/2, y → 5/2}}
Out[4]= {{1/2},{5/2}}
Out[5]= 
Das Ergebnis von Solve[] ist jetzt eine Liste mit einem Ergebnis mit Regeln für x und y. Die Weiterverwendung ist in der Folgezeile gezeigt und auch bei den Gridlines im Plot[] wiederzufinden. Der Vorteil dieser Variante ist, dass sie sofort auch für andere Geradengleichungen (oder andere Funktionen) die Schnittpunkte richtig mit den Gridlines markiert.
 In[6]= f[x_] := ( x - 1 )^2 + 1
        g[x_] := 1/2 x + 7/2
        Lsg = Solve[ { f[x] == g[x], y==f[x]},{ x, y} ]
        { x/. Lsg, y /. Lsg }
Out[8]= {{x → -1/2, y → 13/4},{x → 3, y → 5}}
Out[9]= {{-1/2,3},{13/4,5}}
Das Ergebnis von Solve[] ist jetzt eine Liste mit zwei Schnittpunkten, und die Zeile Out[9] zeigt die richtige Umsetzung für die Gridlines.

Weitere Funktionen

Eine der wesentlichen Funktionen ist Map[] für die es auch die Kurzform /@ gibt. Beispiel:
 In[1]= Map[Factorial, {0, 1, 2, 3, 4, 5, 6, 7, 8}]
Out[1]= {1, 1, 2, 6, 24, 120, 720, 5040, 40320}
 In[2]= Factorial /@ {0, 1, 2, 3, 4, 5, 6, 7, 8}
Out[2]= {1, 1, 2, 6, 24, 120, 720, 5040, 40320}
Aus der angebenen Liste wird eine neue Liste erstellt, auf jeden Wert wird die angegebene Funktion (hier Fakultät) angewendet.