Mathematische Anwendersysteme 
Sommersemester 1999
Prof. Dr. Heinz Spindler

Fachbereich Mathematik/Informatik
der Universität Osnabrück

Vorwort

In dieser Veranstaltung wird eine Einführung in moderne Computeralgebrasysteme (CAS) gegeben. Unter den vielen existierenden Produkten sind wohl zur Zeit Maple und Mathematica am bekanntesten. Allerdings werden diese Systeme zur Zeit noch recht wenig in der Schule eingesetzt (siehe: Maths & Fun, Vergleich von Computeralgebrasystemen), obwohl meiner Meinung nach sowohl Mathematica als auch Maple ideal dazu geeignet sind.  Der Einsatz von Computeralgbrasystemen in der Schule könnte den Mathematikunterricht revolutionieren! Er macht es möglich, auch komplexere Beispiele, die nicht mehr mit Papier und Bleistift zu berechnen sind, zu behandeln. Er schärft den Blick dafür,  was konstruktive Verfahren sind, die maschinell durchführbar sind. Das mathematische Denken wird geschult, denn die erfolgreiche Behandlung eines komplexen mathematischen Problems mit Computeralgebra setzt das theoretische Verständnis des Problems voraus und führt zu umso besseren Ergebnissen, je besser man das Problem mathematisch beherrscht. Außerdem wird stumpfsinnige Rechnerei jetzt vom CAS übernommen. Termumformungen durchführen, Wertetabellen erstellen, Funktionsgraphen zeichnen, Gleichungen lösen,  Grenzwerte, Ableitungen und Integrale berechnen, halt all das, was man so täglich in der Schule insbesondere die Schüler, die vorgeben in Mathe nicht durchzublicken, im Matheunterricht tun läßt, gehört mehr zu den einfachen Dingen, die jedes CAS beherrscht. Natürlich gibt es auch hier Grenzen! Der Trend, daß einfach nur Rezepte zum Lösen standardisierter Aufgaben eingesetzt werden und deren Benutzung intensiv geübt wird, dagegen die Herleitung und Entwicklung dieser Rezepte nicht ausführlich genug behandelt wird, könnte gestoppt werden. Die Herausforderung und das Faszinierende bei der Behandlung einer mathematischen Aufgabe besteht darin, ihre Struktur zu erkennen, zum Beispiel die Variablen aufzuspüren, die zwischen diesen bestehenden Beziehungen etwa in Gleichungen auszudrücken, zu analysieren, an welcher Stelle man Computeralgebra einsetzen kann. Das schafft eine ungeheuere Erweiterung der Möglichkeiten. Dinge, von denen man früher nur träumte, sind jetzt im Unterricht realisierbar. Der altmodische Taschenrechner, der einmal den Rechenschieber ablöste, wird jetzt abgelöst durch das Notebook, auf dem ein CAS installiert ist.

Wir beschränken uns in dieser Veranstaltung auf Mathematica. Hat man ein CAS kennengelernt, so kann man sich auch mühelos in ein anderes System einarbeiten.

Die mathematischen Grundvorlesungen Lineare Algebra, Einführung in die Algebra, Analysis 1 und Analysis 2 werden voraugesetzt. Kenntnisse in Geometrie, Funktionentheorie, Zahlentheorie sind nützlich.

Links zu allgemeinen Computeralgebrasystemen

Mathematica

Maple

Reduce

Axiom

Macsyma

Mathcad

Mupad

Derive

Links zu speziellen Computeralgebrasystemen

CoCoA

Macaulay

Macaulay2

Dieses System ist am Fachbereich installiert. Wie man es aufruft und weitere Informationen findet man unter www.mathematik.uni-osnabrueck.de/neuigkeiten

Singular

Gap

Die kleine Mathematica-Fibel

Version 1.0
Datum: 15. 2. 99

Einleitung

Dieses Mathematica-Notebook soll helfen, sich mit dem Computeralgebrasystem Mathematica vertraut zu machen. Beim Durcharbeiten dieser Fibel, sollte man Mathematica gestartet haben und alle vorgestellten Befehle selbst ausprobieren. Nur durch aktives Mitarbeiten lernt man den Umgang mit Mathematica.  Beachtet man einige wichtige Syntaxregeln, so ist das Arbeiten mit Mathematica nach einer relativ kurzen Einarbeitungszeit ein Kinderspiel. 
Abschnitt 1 (Getting Started) gibt einige erste Orientierungshilfen. In Abschnitt 2 (Einführung in Mathematica) wird dann an mehr oder weniger willkürlich zusammengestellten Beispielen vorgeführt, wie  man mit Mathematica  arbeitet. Dabei habe ich manchmal die verwendeten Befehle mit Absicht nicht im Detail erklärt. Vielmehr sollte durch Betrachten des Outputs oder Variation des Inputs ihre Wirkungsweise klar werden. Bleibt etwas unklar, so kann man immer auf den Help Browser zurückgreifen. Sehr zu empfehlen ist auch das Mathematica-Buch von Wolfram, die Bibel des Mathematica-Benutzers. Das Buch ist auch in deutscher Sprache erschienen. (Nähere Informationen dazu findet man unter www.wolfram.com. Deutschsprachige Bücher zu Mathematica findet man unter www.mathematica.ch.)
Die folgenden Abschnitte behandeln dann etwas systematischer den Einsatz von Mathematica bei der Behandlung von Themen aus verschiedenen Gebieten der Mathematik und Physik. Dabei habe ich darauf wert gelegt, daß die ausgewählten  Themen auch für die Schule interessant sein könnten, etwa für Projekte in der Informatik oder den Leistungskursen in Mathematik
Jeder Abschnitt endet mit einem Aufgabenteil. Es werden Aufgaben von verschiedenem Schwierigkeitsgrad und Umfang  gestellt. Die mit ☺ versehenen Aufgaben dienen nur zum Einüben der eingeführten Befehle und enthalten nichts Tiefsinniges.
Vom Leser dieser Fibel wird erwartet, daß er schon Erfahrungen mit dem PC besitzt, weiß wie man sich mit der Maus unter Windows bewegt und schon einmal ein Textverarbeitungsprogramm wie Word benutzt hat.

Literatur

[1] Kevin R. Coombes et al.: The Mathematica-Primer, Cambridge University Press 1998 (ISBN 0-521-63715-5)

[2] Roman E. Maeder: Informatik für Mathematiker und Naturwissenschaftler, Eine Einführung mit Mathematica, Addison-Wesley 1993 (ISBN 3-89319-519-X)

[3] Wolfram, S: The Mathematica-Book, 3rd edition, Wolfram Media/Cambridge University Press 1996

[4] Wolfram, S.: Das Mathematica-Buch, Addison-Wesley 1998 (ISBN 3-8273-1338-4)

Weiterführende Literatur:

[5] Roman Maeder: The Mathematica Programmer, Academic Press 1994

[6] Richard Gass: Mathematica for Scientists and Engineers Using Mathematica to do Science, Prentice Hall 1998

1. Getting Started

Programmstart

Auf den NT-Rechnern im PC-Raum 31/149 startet man Mathematica 3.0 über

Im LAN Mathematik startet man Mathematica unter X-Windows etwa auf dem Rechner rowan mit dem Befehl

mathematica30

Das Mathematica-Programm benötigt sehr viel 'Memory'. 
Es ist deshalb ratsam, alle anderen Anwendungen zu schließen.

Das Notebook-Interface wird gestartet. Es erscheint ein Menübalken, ein Notebook-Fenster mit dem Namen "Untitled-1" und eine Palette für einige mathematische Symbole.

Man startet nun den Mathematica-Kern über das Mathematica-Menü durch

Schreiben im Notebook

Zunächst klickt man in das Notebook-Fenster, um das Fenster zu aktivieren.

Man kann dann wie in einem Textverarbeitungsprogramm arbeiten. Gibt man etwa 37+13 ein,  und drückt anschließend Shift+Return oder auch Enter, so erscheint im Fenster folgendes

37 + 13

Tippt man  Plot[(x^2),{x,-1.2,1.2}], so erhält man ein Bild der Normalparabel im Bereich -1.2 ≤ x ≤ 1.2.

Plot[(x^2), {x, -1.2, 1.2}]

Die Potenz (x^2) wird dabei mit Hilfe der Palette eingetragen. Dazu klickt man auf das Feld   (◼^□)    und tippt dann nacheinander x ⇥ 2 und dann, um die Zeile des Exponenten wieder zu verlassen, gleichzeitig Ctrl+␣.  Statt (x^2) kann man aber auch (ohne Palettenbenutzung) einfach x^2 über die Tastatur eingeben.

Wählt man nun im Menü Format den Style Text  aus, so  befindet man sich  in einer Textzelle und kann normalen Text eingeben, den Mathematica nicht auswertet. (siehe Abschnitt 2 Input und Output ) Befindet man sich im Textmodus, so gibt es einen kleinen Unterschied beim Eingeben von "zweidimensionalen" Ausdrücken wie (x^2). Durch Eingeben des Feldes   (◼^□)   wird innerhalb des Textes eine Grafikzelle (vergleichbar dem mathematischen Modus bei Tex ) erzeugt. Man geht dann zunächst wie oben beschrieben vor. Um dann die Grafikzelle zu verlassen, muß man nocheinmal die Kombination Ctrl+␣ drücken.

Speichern des Notebooks

Man wählt im Mathematica-Menü:  File => Save As . Dann erscheint ein neues Fenster, in dem man wie gewohnt fortfährt. Der Filename sollte die Endung ".nb" besitzen. Nennen wir das Notebook etwa "Mein erstes Notebook.nb" Dann kann man es schließen, ohne die Mathematica-Sitzung zu verlassen, indem man File => Close wählt (oder die bekannten Windows- Mausklicks ausführt).

Öffnen eines Notebooks

Über File => Open  kann man das vorher gespeicherte und geschlossene  Notebook wieder öffnen. Es erscheint ein neues Notebook-Fenster mit dem Namen "Mein erstes Notebook.nb". Jetzt kann man Änderungen vornehmen oder weitere Befehle ausführen lassen. Mit File => Save werden die Änderungen gespeichert.

Der Help Browser

Wählen Sie Help=>Help  aus dem Mathematica-Menü. Der Help Browser wird geöffnet. Er bietet sehr umfangreiche Informationsmöglichkeiten. Zum Beispiel ist das komplette Mathematica-Buch (allerdings nur in englischer Sprache) zugänglich. 
Um einen kleinen Eindruck zu gewinnen, beginnen Sie etwa mit 
Getting Started/Demos => Demos => Notebook-Demos => Calculating Pi. 
Sie werden etwas über die Kreiszahl π erfahren. Um die Zellen zu öffnen, muß man nur an die äußeren Zellenklammern doppelklicken.
Versuchen Sie dann:
Getting Started/Demos =>  GraphicsGallery => Animations
Sie erhalten eine Liste von Animationen. Klicken Sie zum Beispiel auf "Rolling Square". Es erscheint ein Bild. Klicken Sie nun auf die äußere rechte senkrechte blaue Linie. Sie wird fett-schwarz. Jetzt können Sie einfach die Tastenkombination Ctrl+Y drücken (Sie können auch mit der Maus im Menü Cell  nach Animate Selected Graphics suchen oder noch einfacher einfach in das Bild doppelklicken) und so die Animation starten.

Beenden der Mathematica-Sitzung

Man beendet eine Mathematica-Sitzung mit File => Exit

Aufgaben zu Abschnitt 1

☺ 1. Stellen Sie ein Notebook mit einer oder mehreren Textzellen (seihe Menü Format), einer Inputzelle und der ausgewerteten Outputzelle (Enter drücken!) her. Speichern Sie das Notebook unter einem selbsterdachten Namen mit der Extension .nb Schließen Sie das Notebook. Öffnen Sie das Notebook wieder. Fügen Sie etwas hinzu, z.B eine Grafik mit dem Befehl Plot. Speichern Sie die Änderungen.

☺ 2. Informieren Sie sich über den Befehl Plot mit Hilfe der verschiedenen Möglichkeiten im Help Browser. Plotten Sie die "Funktion" (x^3) - x im Intervall [-2, 2].

☺ 3. Machen Sie sich mit dem Menü Edit vertraut. Kopieren Sie Text von einem  Notebookfenster in ein anderes(CtrlC und CtrlV). Öffnen Sie dazu zunächst ein neues Fenster mit File => New. Es funktioniert wie in einem Standardtextverarbeitungsprogramm.

☺ 4. Folgen Sie dem folgenden Link im Help Browser: Other Information => Contact Information => World Wide Web  . Man schaue zum Beispiel unter MathSource. Gibt es dort Programme zu den Themen Geometry, Calculus, Linear Algebra?

☺ 5. Berechnen Sie nacheinander (2^64), (((23 + 567))^3),(12345^(1/3)), (∑_(k = 1)^100) k. (Benutzen Sie die Palette Basic Input)

2. Mathematica-Einführung

Input und Output

Ein Mathematica-Notebook besteht aus verschiedenen Zellen. Es gibt im wesentlichen drei Typen von Zellen: Input-Zellen, Output-Zellen und Text-Zellen. Am rechten Rand des Fensters werden Zellen-Klammern angezeigt. Bewegt man die Maus in eine Zelle, so bekommt der Mauszeiger die Gestalt eines senkrechten Balkens. Zieht man die Maus zwischen zwei Zellen oder ans Ende des Notebooks, so bekommt der Mauszeiger die Form eines waagerechten Balkens. Klickt man dann auf die linke Maustaste, so entsteht eine durchgezogene waagerechte Linie, und man kann eine neue Zelle beginnen. Mit Alt+7 wechselt man zum Textmodus. Der Zelleninhalt einer Text-Zelle wird von Mathematica nicht ausgewertet. Die Default-Einstellung für das Format einer Zelle ist Input. Eine Input-Zelle wird, wenn sie aktiv ist, durch gleichzeitiges Drücken von ⇧+⏎ oder von Enter (ganz rechts auf der Tastatur) ausgewertet. Eine Zelle ist aktiv, wenn sich der Mauszeiger in der Zelle befindet, oder wenn die Zellen-Klammer fett-schwarz ist.

Beispiel: Man tippe (((a + b))^3) und werte dies dann wie oben beschrieben aus. Das Ergebnis sollte so aussehen:

(((a + b))^3)

Schade! Mathematica beherrscht die binomischen Formeln nicht. Dem ist natürlich nicht so. Wir sollten Expand[(((a + b))^3)] tippen. Dann ergibt Auswerten das gewünschte Ergebnis:

Expand[(((a + b))^3)]

Wir sehen, daß wir schon 4 Eingaben gemacht haben. Manchmal wird man Fehler machen. Dann wird eine Fehlermeldung ausgegeben, und man hat die Möglichkeit, die Eingabe zu korrigieren. Ein Beispiel:

Expand[b (((a + b))^3))

Man kann mit der Maus in die fehlerhafte Input-Zelle gehen und den Fehler verbessern.

Expand[b (((a + b))^3)]

Strebt man an, Text und Input in der üblichen mathematischen Notation zu schreiben, so es ist es ratsam, die Paletten zu benutzen. Dazu gehe man zum Menü  File =>Palettes. Neben Basic Input ist die Palette Complete Characters wichtig. Die Bedienung ist selbsterklärend.  Mit der Palette Basic Input kann man zum Beispiel ein bestimmtes Integral in der üblichen Form eingeben. Dabei werden nach und nach die Einträge in die geschwärzten Felder vorgenommen. Man springt mit der Tabulatortaste ⇥ von einem Feld zum nächsten.

(∫_1^2) (1/(1 + (x^2))) \[DifferentialD]x

Man versuche es nachzumachen! Falls es nicht klappt, informiere man sich im Help Browser unter Getting Started => Tour of Mathematica => Palettes and Buttons.

Man kann das bestimmte Integral auch über die Tastatur eingeben. Um zu sehen wie, schaue man sich die InputForm an. Damit nichts berechnet wird, wende man außerdem Hold an:

Hold[InputForm[(∫_1^2) (1/(1 + (x^2))) \[DifferentialD]x]]

Der Befehl lautet also in InputForm:

Integrate[1/(1 + x^2), {x, 1, 2}]

Zahlen

Ganze Zahlen

Man kann in gewohnter Weise mit ganzen Zahlen rechnen. Das Malzeichen * kann man durch ein Blank ersetzen. Beispiel:

(200 - 302) 123  - 1 + (2^10)

Die Summe der ersten 10 natürlichen Zahlen:

(∑_(k = 1)^10) k

Die Summe der ersten 10 Quadratzahlen:

(∑_(j = 1)^10) (j^2)

Die Primfaktorzerlegung einer ganzen Zahl:

FactorInteger[12121212]

Mit dem Befehl Head erfährt man etwas über den Typ eines Ausdrucks. Der Kopf einer ganzen Zahl ist Integer. Beispiel:

Head[1234501]

Rationale Zahlen

Gibt man einen Bruch ein, so wird seine gekürzte Form bestimmt. Beispiel:

(24/36)

Die Arithmetik mit rationalen Zahlen ergibt stets exakte Werte. Als Beispiel berechnen wir eine harmonische Zahl:

(∑_(k = 1)^10) (1/k)

Der Kopf eines Bruches, der nicht ganz ist,  ist Rational. Beispiele:

Head[(1/2)]

Head[(4/2)]

Reelle Zahlen

Reelle Zahlen werden als Dezimalbrüche eingegeben. Natürlich kann man nur endliche Dezimalbrüche eingeben. Das Komma wird dabei als Punkt notiert. Auch eine ganze oder eine rationale Zahl kann als reelle Zahl dargestellt werden. Beispiele:

{Head[2123], Head[2123.0], Head[2123. ]}

Head[(1/2.) ]

(Sqrt[2]) wird als formaler Ausdruck Power[2,(1/2)] aufgefaßt und nicht als reelle Zahl. Demzufolge ergibt sich:

Head[(Sqrt[2])]

Man kann aber mit dem Befehl N zu einem reellen Wert übergehen. Hier der Wert von (Sqrt[2]) auf 12 Dezimalstellen genau (Die Ziffern vor dem Komma werden natürlich mitgezählt!):

N[(Sqrt[2]), 12]

Eine andere Möglichkeit:

(Sqrt[2.])

Die Gaußklammer ⌊x⌋ ist die größte ganze Zahl, die kleiner oder gleich x ist. Man kann auch Floor verwenden.

{⌊123.4⌋, Floor[123.4], Floor[(Sqrt[2])], 
      Floor[(345/57)]}

Komplexe Zahlen

Die letzte Stufe in der Hierarchie des Zahlensystems sind die komplexen Zahlen. Die Zahl (Sqrt[-1]) wird in Mathematica mit dem festen Symbol I bezeichnet. Beispiele:

(3 + 4  I) (2 - I)

Head[3 + 4  I]

Head[3.  + 4.  I]

Algebraische Terme

Ein Buchstabe oder ein Wort wird von Mathematica als ein Symbol oder eine Variable betrachtet. Aus solchen Symbolen kann man durch arithmetische Operationen, Verschachteln mit Klammern neue Ausdrücke bilden. Einige Beispiele:

Head[a]

(a + b) (a + b) (a - b) (a - 3)

Expand[%]

Mit % bezeichnet man den vorhergehenden Output. Man sollte dieses Zeichen möglichst nicht verwenden.

Factor[%]

Im folgenden Term tauchen drei Variable auf: a,b und ab. Dabei wird ab nicht etwa als Produkt von a und b gelesen, sondern als ein einziges Symbol mit dem Namen ab.

a (b^2) - (ab^2)

Das kann man mit dem Befehl Variables abfragen.

Variables[%]

Die Namen von Variablen können beliebig lang sein, dürfen aber keine Blanks enthalten, weil ein Blank als Malzeichen gelesen wird. Ein weiteres Bespiel:

Expand[(((variablea + variableb))^2)]

Mathematica hat eine Fehlermeldung ausgegeben, die darauf aufmerksam macht, daß wir uns eventuell verschrieben haben. Das ist hier nicht der Fall. Also können wir, ohne die Fehlermeldung zu beachten, fortfahren.

In der Palette Algebraic Manipulation findet man viele weitere Befehle zum Vereinfachen oder Umformen algebraischer Ausdrücke. Hier illustrieren wir noch die Wirkung von Simplify:

Simplify[(((x^3) - (y^3))/(x - y))]

Simplify[(((x^4) - (y^4))/(x - y))]

Beim nächsten Beispiel ist der Term nach dem Kürzen zu lang, deshalb bleibt der Ausdruck unverändert.

Simplify[(((x^5) - (y^5))/(x - y))]

Manchmal bringt Ausmultiplizieren eine Vereinfachung. Beispiel:

Simplify[(1 + x + (x^2)) (1 - x + (x^2))]

oft aber auch nicht:

Simplify[(1 + 2  x + 6  (x^2)) (3 - x + (x^2))]

Manchmal liefert umgekehrt Faktorisieren eine Vereinfachung. Beispiel:

Simplify[(1 + 2  x + (x^2)) (9 - 6  x + (x^2))]

Ein letztes Beispiel:

(1 - x) (∑_(k = 0)^7) (x^k)

Simplify[%]

Hilfe

Will man Informationen zu einem Befehl, etwa Expand haben, so tippt man 
?Expand oder ??Expand. Kennt man den Namen des Befehls, nach dem man sucht nicht genau, so kann man auch den Stern * verwenden. Es werden dann alle dazu passenden Befehle angezeigt. Einige Beispiele:

?*pand

?Si*

?Exp*

?? Expand

Optionen

Viele Mathematica-Befehle besitzen Optionen, die verschiedene Werte annehmen können. Eine Option wird festgelegt nach dem Schema (den Pfeil entnimmt der Palette Basis Input oder man kombiniert ihn aus den Zeichen - und   > ) Optionsname->Optionswert.

Einige Beispiele:

1. In den folgenden Beispielen werden in der binomischen Formel die Binomialkoeffizienten modulo 2, 3 und schließlich modulo 5 reduziert.

Expand[(((x + y))^5), Modulus -> 2]

Expand[(((x + y))^5), Modulus -> 3]

Expand[(((x + y))^5), Modulus -> 5]

2. Der Befehl Plot besitzt eine Fülle von Optionen. Welche und mit welchen aktuellen Werten, kann man mit dem Befehl Options feststellen.

Options[Plot]

Man kann die Werte ändern. Hier einige Beispiele:
a)  Die Normalparabel in der Farbe Hue[0.56]. Die Farbtafeln zu Hue findet man im Mathematica-Buch unter G.2.43. Zum Aufruf Plot[(x^2),{x,-1.2,1.2}]haben wir die Optionen  Axes,DefaultColor,Background,PlotLabel,TextStyle mit neuen Werten hinzugefügt. Etwas schwierig ist es allerdings, herauszubekommen, welche Werte für eine gegebene Option möglich sind.

Plot[(x^2), {x, -1.2, 1.2}, Axes -> False, 
      DefaultColor -> Hue[0.56], Background -> GrayLevel[0.9], 
      PlotLabel -> "Parabel", 
      TextStyle -> {FontFamily -> Helvetica, FontSize -> 10}]

b)  Die Normalparabel mit einem zusätzlich durch Epilog->Grafikobjekt eingefügten Grafikobjekt, hier: eine Kreisscheibe und eine Kreislinie. Man beachte, daß der Defaultwert der Option Epilog für den Befehl Plot leer ist. Die Optionen Epilog und Prolog sind offensichtlich sehr nützlich. Mehr darüber später.

Plot[(x^2), {x, -1.2, 1.2}, Axes -> False, 
      DefaultColor -> Hue[0.56], Background -> GrayLevel[0.9], 
      Epilog -> {{Hue[0.22], Disk[{0.4, (0.4^2)}, 0.1]}, 
                                   {Hue[0.56], 
            Circle[{0.4, (0.4^2)}, 0.05]}}]

Über die verwendeten Befehle  GrayLevel, Hue, Disk, Circle informiere man sich im Help Browser.

3. Mit dem Befehl Factor kann man zum Beispiel Polynome in irreduzible Faktoren zerlegen. Bekanntlich kommt es dabei auch auf den Grundkörper an. Mit der Option Extension kann man vom Körper ℚ der rationalen Zahlen zu einem geeigneten Erweiterungskörper übergehen.

Options[Factor]

Factor[(x^2) - 2]

Factor[(x^2) - 2, Extension -> (Sqrt[2])]

Factor[(x^4) - 2, Extension -> {I (Sqrt[ 2]), (2^(1/4))}]

Namen und Zuweisungen

Einem Symbol kann man mit Hilfe eines einfachen Gleichheitszeichen einen Wert zuweisen. Der Wert kann eine Zahl, ein neues Symbol oder ein komplizierter Ausdruck sein. Beispiele:

a = 23

Denselben Effekt hat

Set[a, 23]

b = Plot[Sin[x], {x, 0, 2  π}]

c = f[x] - (x^2) - 4 + y

Wenn man nun a,b oder c im weiteren Verlauf benutzt, werden diese durch ihre zugewiesenen Werte ersetzt. Beispielsweise erhält man:

(a^2) - 1

Show[b, AspectRatio -> Automatic]

(((c - y))^2) // Expand

Man kann natürlich die Zuweisungen löschen oder durch neue Zuweisungen ändern. Durch a=. oder Clear[a] wird ein eventuell vorhandener Wert  von a gelöscht.

Clear[a]

a

Man betrachte die folgende Kette von Befehlen und versuche ihre Wirkungsweise zu verstehen.

c

x = π

f = Sin

f[x]

c

x =. ; f =. ; c

Es ist ratsam Wertzuweisungen aufzuheben, wenn die Werte nicht mehr gebraucht werden. So vermeidet man Fehler im späteren Verlauf einer Mathematica-Sitzung.  Beispielsweise erhält man mit den jetztigen Werten von b,c ein merkwürdiges Ergebnis:

d = (((b + c))^2)

Wir löschen die Werte:

Clear[a, b, c, f, d]

Wir erfragen die bisher in der Mathematica-Sitzung eingeführten Namen. Sie haben den Kontext Global.

Names["Global`*"]

Wir entfernen alle Namen:

Map[Remove, Names["Global`*"]];

Jetzt gibt es keine Namen mehr:

Names["Global`*"]

Gleichungen

Eine Gleichung ist eine Aussageform der Bauart linkeseite==rechteseite. Das Gleichheitszeichen in einer Gleichung besteht also aus zwei nebeneinanderstehenden Gleichheitszeichen ==. Sind konkrete Werte, etwa Zahlen, gegeben, so besitzt eine Gleichung einen der beiden Wahrheitswerte True oder False. Einige Beispiele:

2 == 3

Dasselbe leistet (== ist das Infixzeichen für den Operator Equal)

Equal[2, 3]

2 + 2 == 4

(∑_(n = 1)^∞) (1/(n^2)) == ((π^2)/6)

Kommen unbestimmte Symbole vor, so wird die Gleichung nicht ausgewertet. Beispiele:

x + 2 == 3

gleichungssystem = {3  x + 4  y == 3, 6  x + 9  y == -4}

Mit dem Befehl Solve kann man Gleichungen und Gleichungssysteme lösen. Solve[gl,t] löst die Gleichung gl nach t auf. gl darf auch eine Liste von Gleichungen und t darf eine Liste von Variablen sein. Für unsere beiden Beispiele ergibt sich:

Solve[x + 2 == 3, x]

Solve[gleichungssystem, {x, y}]

Die Lösungen werden in der Form von Einsetzungsregeln angegeben. Das ist auf den ersten Blick vielleicht etwas aufwendig, erweist sich aber als sehr praktisch. 
Man kann die Lösungen durch Einsetzen mit Hilfe des Befehls /. (ReplaceAll) erhalten:

x /. x -> z

x /. Solve[x + 2 == 3, x]

{x, y} /. Solve[gleichungssystem, {x, y}]

Natürlich gibt es kompliziertere Gleichungen, die man nicht symbolisch auflösen kann! Einige Beispiele mögen dies illustrieren:

1. Wenn nicht nur Polynome in der Gleichung vorkommen, klappt die Berechnung in der Regel nicht:

Solve[Sin[x] - (x^2) + (Sqrt[x]) == 2, x]

Manchmal wenigstens teilweise:

Solve[Sin[x] == Cos[x], x]

2. Bekanntlich kann man Polynomgleichungen vom Grad größer als vier im allgemeinen nicht durch Wurzeln lösen:

Solve[(x^5) + 2  (x^3) - x == 1, x]

In speziellen Fällen geht es doch:

Solve[-1 + 5 x - 10 (x^2) + 10 (x^3) - 5 (x^4) + (x^5) == 1, x]

3. Für Polynome vom Grad ≤4 gibt es stets Lösungen durch Radikale:

Solve[(x^4) - (x^2) + 12  x - 36 == 0, x]

Sie können allerdings sehr kompliziert sein. Ersetzt man etwa in obiger Gleichung 12x  durch 10x, so sind die Lösungen sehr  komplizierte Ausdrücke. Wir geben die erste der vier Lösungen an:

a = x /. Solve[(x^4) - (x^2) + 10  x - 36 == 0, x][[1]]

Man kann das Ergebnis auch in traditioneller Form aufschreiben:

TraditionalForm[a]

Die Lösung ist zwar durch Wurzeln beschrieben, man sieht aber nicht annähernd, welchen numerischen Wert sie hat. Doch dafür haben wir ja den Befehl N. Es ergibt sich:

N[a]

Clear[a]

Mit dem Befehl NSolve kann man stets numerische Lösungen bestimmen

NSolve[(x^5) + 2  (x^3) - x == 1, x]

Eingebaute Funktionen

Mathematica kennt alle wichtigen mathematischen Funktionen. Wir begnügen uns mit einigen Beispielen. Die vollständige Liste und ausführliche Informationen erhält man im Help Browser unter
Built-in Functions.

Zunächst laden wir mit dem Befehl Get oder kurz << die Pakete Graphics`Colors` und Graphics`Legend`.

?Get

<< Graphics`Colors`

<< Graphics`Legend`

Jetzt hat man die Möglichkeit eine Grafik mit einer Legende zu versehen. Mehr zur Struktur des Befehls Plot findet man im Abschnitt Grafik mit Plot

Die trigonometrischen Funktionen:

Plot[{Sin[x], Cos[x], Tan[x], Cot[x], Sec[x], Csc[x]}, {x, 0, 2  Pi}, 
      AspectRatio -> Automatic, PlotRange -> {-4, 4}, 
      PlotStyle 
        -> {DeepPink, CadmiumLemon, DodgerBlue, PermanentGreen, Oak, 
          Ultramarine}, Background -> Titanium, 
      PlotLegend 
        -> {"sin", "cos", "tan", "cot", "sec", 
          "cosec"}]

Die Hyperbelfunktinen:

Plot[{Sinh[x], Cosh[x], Tanh[x], Coth[x], Sech[x], Csch[x]}, {x, 
        -3, 3}, AspectRatio -> Automatic, 
      PlotRange -> {-4, 4}, 
      PlotStyle -> {Yellow, Red, Green, SkyBlue, Ultramarine, Blue}, 
      Background -> Titanium, 
      PlotLegend 
        -> {"sinh", "cosh", "tanh", "coth", "sech", 
          "cosech"}, PlotPoints -> 300]

Die komplexe Exponentialfunktion (Es werden Real- und Imaginärteil dargestellt):

Plot3D[Re[Exp[x + I y]], {x, -1, 1.5}, {y, 0, 4  Pi}, 
      BoxRatios -> {1, 1.5, 1}, PlotPoints -> {25, 50}]

Plot3D[Im[Exp[x + I y]], {x, -1, 1.5}, {y, 0, 4  Pi}, 
      BoxRatios -> {1, 1.5, 1}, PlotPoints -> {25, 50}]

Der natürliche Logarithmus ist die Stammfunktion der Funktion (1/x).

(Log^′)[x]

Wir definieren das n-te Taylorpolynom der Funktion log(x + 1):

taylorpolynom[n_] := Normal[Series[Log[x + 1], {x, 0, n}]]

Ein Beispiel:

taylorpolynom[10]

Plot[
      Evaluate[Append[Table[taylorpolynom[2  n], {n, 1, 4}], Log[x + 1]]], {
        x, -0.4, 2}, 
      PlotStyle -> 
        First[Outer[
            List, {Thickness[0.003]}, {Yellow, Orange,  Red, DeepPink, 
              Ultramarine}]], Background -> Titanium, 
      PlotLegend -> {"2", "4", "6", "8", "log"}]

Am Rande sei bemerkt (mehr über Listenprogrammierung folgt später): Der Befehl zur Beschreibung des Plotstils, der oben auftritt, geht so:

First[Outer[List, {a}, {b, c, d}]]

Plot[Log[x + 1], {x, -0.4, 1}, 
      PlotStyle -> {Thickness[0.01], Magenta, Dashing[{0.05, 0.03}]}, 
      GridLines -> Automatic]

Die Namen der eingebauten Mathematica-Funktionen beginnen stets mit einem Großbuchstaben und sind so ausführlich, daß man in der Regel ihre Bedeutung am Namen ablesen kann. Ist ein Name zusammengestzt, so werden die einzelnen Teile groß geschrieben, z. B. GridLines, PlotPoints, NSolve, aber Background, Epilog. Der Wert einer Funktion mit dem Namen f an einer Stelle x wird stets mit f[x] bezeichnet. Es müssen eckige Klammern benutzt werden! Es kann auch f[x, y, option -> a] und ähnliches vorkommen.

Benutzterdefinierte Funktionen

Es gibt verschiedene Möglichkeiten eigene Funktionen zu definieren. Die folgenden Beispiele definieren alle die Funktion f(x) = (x^2) + 1.

1. Diese Methode entspricht der in der Mathematik üblichen Methode Funktionen zu definieren am ehesten. Um deutlich zu machen, daß x eine Variable ist, muß die Schreibweise x_ benutzt werden. (Das Zeichen := ist die Infixdarstellung der Mathematica-Funktion SetDelayed und bedeutet, daß die Zuweisung bei jedem Aufruf neu erfolgt. Mehr dazu später.)

f[x_] := (x^2) + 1

Setzt man nun irgenwelche Werte ein, so wird die Vorschrift ausgeführt:

f[2]

f[wert]

Plot[f[x], {x, -1, 1}];

2. Man kann auch die eingebaute Mathematica-Funktion Function benutzen:

g = Function[x, (x^2) + 1]

Damit ist g diejenige Funktion, die einem Wert x den Funktionswert (x^2) + 1 zuordnet. Beispiel:

g[2]

Wir sehen, daß f und g dasselbe leisten:

a

f[a] == g[a]

3. Man kann schließlich ohne Bezug auf Variablennamen die Funktion als sogenannte reine Funktion einführen. # stellt in Mathematica dabei den Platzhalter für eine Variable dar. Das Zeichen & signalisiert, daß der vorstehende Term als Funktion zu lesen ist.

\(h = \((#\^2 + 1)\)&\)

h[a]

4. Man kann auch zunächst dem formalen Ausdruck 1 + (t^2) einen Namen geben, etwa p. p ist dann sozusagen ein Polynom in der Unbestimmten t.

p = (t^2) + 1

Jetzt ergibt, wie man vermuten wird, der Ausdruck p[2] nicht den Wert 5, sondern:

p[2]

Man muß hier anders vorgehen. Einsetzen von Werten erfolgt jetzt durch Anwenden der Regel t->x. Beispiel:

p /. t -> 2

Man beachte, daß man p plotten kann. Was ist der Unterschied zu dem entprechenden Befehl für f?

Plot[p, {t, -1, 1}]

Verwandeln wir nun p in eine Funktion:

q[x_] := p /. t -> x

Beispiele:

{q[2], q[wert]}

?q

Wir löschen die Definition von q:

Clear[q]

Jetzt wird nichts mehr berechnet:

{q[2], q[wert]}

Ab und an aufräumen:

Names["Global`*"]

ToExpression[%]

Map[Remove, Names["Global`*"]];

Listen

Eine Mathematica-Liste der Länge n ist ein geordnetes n-tupel irgendwelcher Mathematica-Ausdrücke: Anstelle der in der Mathematik üblichen runden Klammern werden in Mathematica geschweifte Klammern verwendet. Beispiele:

A = {a, b, c}

B = {b, c, a}

Es kommt auf die Reihenfolge an:

a = 1; b = 2; c = 3; A == B

a =. ; b =. ; c =. ;

Wichtig ist die Funktion Part. Beispiele:

Part[A, 2]

Dasselbe erhält man mit:

A[[2]]

Weitere Beispiele mit verschachtelten Listen:

Part[{{x, y}, {a, b, c}}, 1]

Part[{{x, y}, {a, b, c}}, 1, 2]

oder gleichbedeutend:

{{x, y}, {a, b, c}}[[1, 2]]

{{x, y}, {a, b, c}}[[2, 2]]

M = {{{{a}, {{c, b}, x}, y, t}}, r}

M[[1, 1, 2]]

Man kann die Baumstruktur von M anzeigen:

TreeForm[M]

M[[1, 1, 1]]

Clear[M]

Viele Funktionen kann man auch auf Listen anwenden, z. B. die Sinusfunktion:

Attributes[Sin]

Sin[A]

Das ermöglicht es, auf sehr einfache Weise eine Wertetabelle von Sin zu berechnen. Mit dem Befehl Table stellt man zunächst eine Liste der gewünschten x-Werte her. Darauf wendet man Sin an. Mit dem Befehl Transpose kann man dann aus zwei Listen mit jeweils n Elementen eine Liste aus n Paaren machen.

Die Liste der Zahlen von 0 bis 6 in Abständen 0.5:

tabelle = Table[x, {x, 0, 6, 0.5}]

wertetabelle = Transpose[{tabelle, Sin[tabelle]}];

Mit dem Befehl TableForm wird die Tabelle auch wirklich in Tabellenform angezeigt:

TableForm[wertetabelle]

Man kann diese Wertetabelle auch plotten:

Show[Graphics[Line[wertetabelle]]]

Was ist passiert? Die Punkte der Wertetabelle sind durch Strecken miteinander verbunden worden. Dazu diente der Befehl  Line. Mit Show[Graphics[◼]] wurde schließlich das Grafikobjekt ◼ =  Line[wertetabelle] gezeichnet.
Jetzt folgt dasselbe nocheinmal mit Achsenkreuz und gelben Hintergrund:

Show[
      Graphics[Line[wertetabelle], Axes -> True, 
        Background -> RGBColor[1, 1, 0]]]

Das Baumuster des letzten Befehls ist f[g[ h[x],a->b,c->d[r,g,t] ]].

Bemerkung: (Dies kann man zunächst getrost überlesen) Auch der Befehl Plot erzeugt eine Liste von Koordinatenpaaren, allerdings werden die x-Werte auf raffinierte Weise gewählt, so daß ein glattes Bild entsteht. Wir wollen uns das einmal anschauen: Mit dem Befehl InputForm erhält man die gewünschte Information, die wir hier wegen seiner Länge nicht auf dem Bildschirm ausgeben (deshalb das Semikolon am Ende):

sinus = 
      InputForm[
        Plot[Sin[x], {x, 0, 6}, Background -> RGBColor[1, 1, 0]]];

Wir können einen Teil anschauen. Dazu ist der Befehl Short nützlich. Die Kurzinformation zu sinus:

Short[sinus, 25]

Das Symbol sinus hat jetzt einen komplizierten verschachtelten Mathematica-Ausdruck als Wert. An der Stelle  (1,1,1,1,1) steht die Liste der berechneten Wertepaare. Wir setzen deshalb

wertetabelle2 = Part[sinus, 1, 1, 1, 1, 1];

Zurück zu unserem Beispiel. Es wurden 82 Wertepaare berechnet, wie man mit dem Befehl  Length nachprüft:

Length[wertetabelle2]

Wir lassen uns die ersten 6 Paare in Tabellenform anzeigen

wertetabelle2
        [[{1, 2, 3, 4, 5, 6}]] // 
      TableForm

Den n-ten x-Wert der Wertetabelle bekommt man durch die folgende Definition:

x[n_] := wertetabelle2[[n, 1]]

M = Table[x[n], {n, 1, 10}]

Das folgende Bild zeigt, wie die x-Werte der Sinusfunktion angepaßt sind.

Show[
      Graphics[Table[{Thickness[0.0001], 
            Line[{{x[n], 0}, {x[n], Sin[x[n]]}}]}, {n, 1, 82}]]];

Man kann auch elementare Mengenlehre betreiben. In den Paletten findet man die Zeichen für die mengentheoretischen Operationen. Einige Beispiele:

Clear[a, b, c, d, e, f, g, h, x, y, z, u, v, w, r, s, t]

Wir definieren Mengen 𝒜, ℬ, 
      𝒞.

𝒜 = {a, b, c, d, e, f, g, h}

ℬ = {e, f, g, h, x, y, z, u, v}

𝒞 = {b, c, d, z, u, v, w, r, s, t}

Der Durchschnitt:

𝒜 ⋂ ℬ

Die Vereinigung

𝒜 ⋃ 𝒞

Ein dreifacher Durchschnitt

𝒜 ⋂ ℬ ⋂ 
      𝒞

Der Unterschied zwischen Union und Join.

Union[𝒜, ℬ]

Join[𝒜, ℬ]

Union[{d, a, a, b, b, c, c}]

Die Mengendifferenz.

Complement[𝒜, ℬ]

Aufgabe: Aus einer Menge von Zahlen zwischen 1 und 100 picke man die geraden Zahlen heraus. Es gibt verschiedene Lösungen. Zunächst wählen wir zufällig 40 natürliche Zahlen zwischen 1 und 100:

M = Table[Random[Integer, {1, 100}], {40}]

Wie entfernen die Wiederholungen und ordnen der Größe nach:

M = Union[M]

Aus der Menge M sollen nun die geraden Zahlen herausgesucht werden:

1. Lösung: Die Liste aller geraden Zahlen zwischen 1 und 100:

G = Table[2  x, {x, 1, 50}];

G ⋂ M

2. Lösung: Die Liste der geraden Zahlen können wir auch dadurch erhalten, daß wir die Liste Range[1,50] mit 2 multiplizieren. Wenn man sich im Help Browser über den Befehl Range informiert, findet man eine noch einfachere Methode.

2  Range[1, 50] ⋂ M

3. Lösung: Am elegantesten ist es wohl, die Eigenschaft "gerade" durch die Funktion Mod[#,2]==0 auszudrücken und dann den Mathematica-Befehl Select anzuwenden.

Select[M, Mod[#, 2] == 0&]

Vektoren und Matrizen

Eine Matrix ist die Liste ihrer Zeilen. Ein Beispiel:

(Subscript[M, 1]) = {{1, 2, 3}, {3, 4, 5}};  MatrixForm[(Subscript[M, 1])]

Man beachte: Mit (Subscript[M, 1]) kann man rechnen, mit MatrixForm[(Subscript[M, 1])] nicht!

Man kann Matrizen über das Menü Input=>Create Matrix  eingeben.  Mit der  Maus und mit der Tabulator-Taste kann man sich in der Matrix bewegen. Man versuche es. Beispiel:

(Subscript[M, 2])=(({{1, 2, 4}, {6, 4, 9}, {1, 0, 5}}))

In der ersten Zeile an der zweiten Stelle steht:

(Subscript[M, 2])[[1, 2]]

Das Matrizenprodukt wird durch einen Punkt "." (Dot) bezeichnet. Man beachte, daß man hier auf keinen Fall den Punkt weglassen darf!

(Subscript[M, 1])  . (Subscript[M, 2])

Ohne Punkt geht es hier nicht:

(Subscript[M, 1]) (Subscript[M, 2])

Ein weiteres Beispiel:

(Subscript[M, 3])=(({{a, b, c}, {0, d, e}, {0, 0, f}}));(Subscript[M, 2])  . (Subscript[M, 3]);

MatrixForm[%]

Läßt man den Punkt weg, so wird diesmal keine Fehlermeldung ausgegeben, da die Operation möglich ist, weil beide Listen dieselbe Länge haben. Es wird einfach komponentenweise multipliziert, solange dies möglich ist. Hier werden einfach alle Einträge von(Subscript[M, 2]) und (Subscript[M, 3]) komponentenweise multipliziert, was natürlich nicht das Matrizenprodukt ist! Es ist also bei der Matrizenmultiplkation unbedingt auf den Punkt zu achten.

TableForm[{{MatrixForm[(Subscript[M, 2])], MatrixForm[(Subscript[M, 3])], 
          MatrixForm[(Subscript[M, 2]) (Subscript[M, 3])]}}]

\(\(M\_1\^*\) = Transpose[M\_1]\)

\(M\_2\ \(M\_1\^*\)\)

(Subscript[M, 2]) {x, y, z}

{x, y, z} (Subscript[M, 2])

Ein Vektor ist die Liste seiner Koeffizienten. Es wird hier nicht zwischen Zeilen- und Spaltenvektor unterschieden! Man kann Vektoren und Matrizen miteinander multiplizieren. Das Ergebnis ist wieder ein Vektor. Man kann praktischerweise von links und rechts multiplizieren. Das ist ein Unterschied zur üblichen mathematischen Notation, an den man sich gewöhnen muß.

(Subscript[M, 2])  . {x, y, z}

{x, y, z} . (Subscript[M, 2])

Ein Zeilenvektor ist eine Matrix mit nur einer Zeile, d. h. eine 1×n-Matrix. Man achte auf das zusätzliche Klammerpaar!

w = {{x, y, z}}

Eine Verallgemeinerung des Befehls Length ist der Befehl Dimensions, mit dem man bequem den Typ einer Matrix bestimmen kann. (In Mathematica werden Matrizen als spezielle Tensoren betrachtet.)

Dimensions[w]

Dimensions[{x, y, z}]

Dimensions[{{{{x, y, z}}}}]

Dimensions[(Subscript[M, 2])]

Das Matrizenprodukt (Subscript[M, 2])   . w kann man nicht bilden, wohl aber w . (Subscript[M, 2]).

(Subscript[M, 2])  . w

w . (Subscript[M, 2])

Ein Spaltenvektor ist eine Matrix mit Zeilen der Länge 1, also eine n×1-Matrix.

v = Transpose[w]

Dimensions[v]

(Subscript[M, 2])  . v

Mehr zur Matrizenrechnug in Abschnitt 3.

Grafik mit dem Befehl Plot

In den vorangegangenen Abschnitten haben wir schon eingige Grafikbefehle benutzt. Grafik ist eine der Stärken von Mathematica.  Es gibt eine Fülle von Möglichkeiten.  Der Befehl Plot zeichnet, wie wir schon gesehen haben, Funktionsgraphen. Wir wollen  eine Familie von Funktionen zeichnen und dabei einige der vielen Möglichkeiten kennenlernen.

F = Table[Sin[(k/10) x], {k, 1, 10}]

f = F[[10]]

Plot[f, {x, 0, 2  π}];

Das Semikolon bewirkt, daß nur geplottet wird, aber kein Output gezeigt wird.

Um die Liste F plotten zu können, muß man diese zunächst auswerten.

Plot[Evaluate[F], {x, 0, 2  π}];

Wir verändern die Option PlotStyle.  Man beachte jeweils die Wirkung.

Needs["Graphics`Colors`"]

Alle Kurven sind blau.

Plot[Evaluate[F], {x, 0, 2  π}, PlotStyle -> {Blue}];

Die Kurven werden abwechselnd blau und rot dargestellt.

Plot[Evaluate[F], {x, 0, 2  π}, PlotStyle -> {Blue, Red}];

Die Farben blau, grün, rot werden in dieser Reihenfolge wiederholt.

Plot[Evaluate[F], {x, 0, 2  π}, 
      PlotStyle -> {Blue, Green, Red}];

Die Kurven werden abwechselnd blau, dick, gestrichelt gezeichnet.

Plot[Evaluate[F], {x, 0, 2  π}, 
      PlotStyle -> {Blue, Thickness[0.01], Dashing[{0.02, 0.02}]}];

Was ein zusätzliches Klammerpaar alles bewirken kann! Machen Sie sich die Struktur klar! Jetzt werden alle Kurven blau, dick und gestrichelt gezeichnet.

Plot[Evaluate[F], {x, 0, 2  π}, 
      PlotStyle -> {{Blue, Thickness[0.01], Dashing[{0.02, 0.02}]}}];

Mit dem Colorselector im Menü Input kann man beliebige Farben wählen

stil1 = {RGBColor[0.187503,  0.929702,  0.968765], Thickness[0.005]}; 
    stil2 = {GrayLevel[0.4], Thickness[0.001]};

Plot[Evaluate[F], {x, 0, 2  π}, 
      PlotStyle 
        -> {stil2, stil2, stil2, stil2, stil2, stil2, stil2, stil2, 
          stil2, stil1}];

Etwas Spielerei soll erlaubt sein:

?Text

?FontForm

Plot[Evaluate[F], {x, 0, (3/2) π}, 
      PlotStyle 
        -> {stil2, stil2, stil2, stil2, stil2, stil2, stil2, stil2, 
          stil2, stil1}, AspectRatio -> Automatic, Frame -> True, 
      Axes -> None, FrameTicks -> None, 
      FrameStyle 
        -> {RGBColor[0.0742199,  0.664073,  0.980484], 
          Thickness[0.01]}, 
      Background -> RGBColor[0.992203,  0.937514,  0.777356], 
      Prolog -> {{Magenta, 
            Text[FontForm["Sinus", {"Arial", 16}], {0.3, 0.8}]}, {
            RGBColor[0.644541,  0.992203,  0.992203], 
            Polygon[{{0, -1}, {π, -1}, {π, 0}, {0, 0}}]}, {
            RGBColor[0.4336,  0.988296,  0.906264], 
            Disk[{(π/2), -(1/2)}, (1/2)]}}];

Clear[f, F]

Eine wichtige Option ist PlotRange. Beispiel: Der Tangens wird wegen seiner Pole nicht gut dargestellt. Deshalb ist es wichtig, die zugelassenen y-Werte anzugeben.

Plot[Tan[x], {x, 0, 2  π}];

Plot[Tan[x], {x, 0, 2  π}, PlotRange -> {-4, 4}]

Plot[Tan[x], {x, 0, 4  π}, PlotRange -> {-4, 4}];

Programmieren

Module

Mathematica ist ein vollwertige Pragrammiersprache. Hier wollen wir nur ein einfaches Beispiel betrachten. Ein Programm zur Berechnug des größten gemeinsamen Teilers zweier Zahlen a, b. Dazu verwendet man bekanntlich den euklidischen Algorithmus. Es ist sinnvoll, die im Verlauf des Programm benötigten Variablen als lokale Variable zu deklarieren. Das geht mit dem Mathematica-Befehl  
Module[{lokale Variablen},Programm]
Im folgenden Programm werden lokale Variable d, r deklariert. Am Anfang wird d = a, r = b gesetzt. Solange r ≠ 0 gilt, wird nun der Rest  Mod[d,r] beim Teilen von d durch r berechnet und d = r,  r = Mod[d, r] gesetzt. Dazu benutzt man den Mathematica-Befehl
While[Bedingung,Anweisung].
Am Ende wird das Ergebnis d ausgegeben. Man beachte, daß die einzelnen Anweisungen nach der Variablendeklaration durch ein Semikolon (nicht durch ein Komma) zu trennen sind.

ggt[a_, b_] := 
      Module[{d, r}, {d, r} = {a, b}; 
        While[r ≠ 0, {d, r} = {r, Mod[d, r]}]; d]

ggt[778, 660]

Remove[ggt]

Ein kleines Paket

Will man zu den vorhandenen Mathematica-Funktionen neue eigene Funktionen hinzufügen, so bietet es sich an, diese als Mathematica-Package zusammenzufassen. Hier unser obiges Beispiel als Package:

BeginPackage["GGT`"]ggT::usage = 
      "ggT[a,b] ergibt den größten gemeinsamen Teiler von a \
und b. Beispiel: ggT[6,4]=2"\(		Begin["`Private`"]\)ggT[a_, b_] := 
      Module[{d, r}, {d, r} = {a, b}; 
        While[r ≠ 0, {d, r} = {r, Mod[d, r]}]; d]End[]EndPackage[]

?ggT

ggT[12, 345]