Copyright

Copyright 1994,  Claudia Funke
TU-Berlin, FB 13, Fachgebiet Ökonometrie und Statistik
Dieses Notebook darf ausschließlich als Unterrichtsmaterial und für 
private Zwecke verwendet und nicht ohne Zustimmung der Autorin 
verändert werden.

Interaktion mit dem Kernel

Mathematica ist in zwei Teile aufgeteilt: In ein Front End,  das die 
Interaktion mit dem oder der Benutzenden regelt und in einen Kernel, 
der die Berechnungen ausführt.

Wenn Du Mathematica unter Windows aufrufst, befindest Du Dich 
automatisch im Front-End. Die unter einem Front-End erzeugten 
Dokumente heißen Notebooks. Ein nicht kleiner Teil der Arbeit 
mit dem Windows Front-End umfaßt die Erzeugung und Manipulation 
von Notebooks. 
Der Hauptzweck eines Front-Ends ist es jedoch, dem Kernel den Input zuzuführen und von diesem den Output anzuzeigen.

Das Grundschema der Arbeit mit Mathematica ist die Eingabe des Inputs, 
dessen Weitergabe an den Kernel und die Rückgabe des Outputs vom Kernel.

Vorbereiten der Eingabe

Um einen beliebigen Input auswerten zu können, muß dieser zuerst in einem Notebook eingegeben werden. Diese Eingabe erfolgt in einer 
Zelle.

Es gibt verschiedene Arten (styles) von Zellen in einem Notebook. Dies 
hängt jeweils von ihrem Zweck ab. Es gibt z.B. Textzellen, Outputzellen 
und Graphikzellen, die sich unter anderem auch durch ihren Schrifttyp
(style) unterscheiden. Um herauszufinden, in was für einer Zelle Du Dich 
befindet, braucht Du nur die zugehörige Zellenklammer anzuklicken. 
In dem ersten Fenster der Iconleiste erscheint dann der entsprechende 
Zellstyle.

Welchen Zelltyp hat die aktuelle Zelle ?

Um irgendeinen Ausdruck von Mathematica auswerten zu lassen, muß 
dieser in einer   Inputzelle   stehen. Man erkennt eine solche Zelle meist 
daran, daß die Schrift wie eine Schreibmaschinenschrift aussieht oder 
an ihrer Klammer, die keine weiteren Verzierungen enthält.

Hier ist eine typische Inputzelle:

23 + 453

Eine Zelle ist bei ihrer "Erzeugung" automatisch eine Inputzelle. 

Der Zelltyp läßt sich folgendermaßen ändern:
1. Anklicken der Zellklammer
2. Aus dem kleinen Fenster links unterhalb der Menüleiste (Anzeige
    des Zelltyps) den gewünschen Zelltyp auswählen.

Im ersten Teil der Einleitung zur Handhabung der graphischen Oberfläche von Mathematica hattest Du eine Zelle mit einem beliebigen Text erzeugt. Diese war aber eigentlich eine Inputzelle, da eine neue Zelle automatisch als Inputzelle erzeugt wird. Deshalb:

Wiederhole diese kleine Übung, nur daß Du diesmal die neue Zelle als
Textzelle markierst.

Evaluierung des Inputs

Damit der Kernel den Ausdruck in der Inputzelle evaluieren kann, muß 
dieser ihm erst übergeben werden. Bewege dazu den Cursor irgendwo in 
die Inputzelle, klicke einmal mit der Maustaste und betätige anschließend 
Shift + Return.

Hier ist noch einmal die Inputzelle von oben:

23 + 453

Evaluiere diesen Input ! Gibt es noch andere Möglichkeiten zur 
Evaluierung des Inputs ?

Es kann sein, daß die Evalierung etwas dauert. Das kommt daher, daß
dies dann der erste Input ist, der an den Mathematic-Kernel geschickt wird. In diesem Fall muß der Kernel erst in den Arbeitsspeicher geladen werden. Durch die Menüauswahl  Options - Kernel - Preload Kernel on Startup erreichst Du, daß der Kernel bei allen zukünftigen Mathematica-Session gleich mit dem Aufruf des Front Ends geladen wird.

Übrigens: Hier siehst Du wieder, daß der Kernel und das Front End 
zwei voneinander getrennt arbeitende Programme sind, die jedoch 
eng miteinander kommunizieren. Du kannst z.B. im Front-End jede
Art von Textmanipulation vornehmen, ohne dazu den Kernel laden
zu müssen.

Das Ergebnis der obigenBerechnung kann auch einer Variablen 
zugewiesen  werden:

z = 23 + 453

Nach der "Abschicken" des Ausdrucks an den Kernel hat sich die Inputzelle etwas verändert. Sie bekam von Mathematica mit   In[ ]:=  eine Zeilennummer zugewiesen. Diese wird von Mathematica fortlaufend bei der Evaluierung von Ausdrücken vergeben.

Während der Evaluierung des Ausrucks öffnet Mathematica gleichzeitig eine neue Zelle, in der dann der Output geschrieben wird. Diese Outputzelle enthält ebenfalls einen Namen Out[ ]=  mit der Zeilennummer der Inputzelle. Die Nummerierung hat den Sinn, daß man sich später direkt auf die Ein- oder Ausgabegabezellen beziehen kann.

Beachte, daß Mathematica die In- und Outputzelle automatisch zu einem 
Abschnitt verbindet. Dies entspricht einer Voreinstellung des Front Ends,
die mit Options-Actions...  geändert werden kann.

Und noch etwas. Speichert man die (evaluierten) Input- und Outputzellen mit ab und öffnet man das Notebook bei einer späteren Mathematica-Session, so sind die Zeilennummerierungen nicht mehr vorhanden. Das ist andereseits aber auch logisch, weil man sonst alte und neue Zeilennummern nicht mehr unterscheiden könnte.

Hier nun eine etwas andere Inputzelle:

Plot[Sin[x], {x, 0, 2 Pi}]

Probiere aus, was die Evaluation dieses Inputs ergibt und schau Dir 
anschließend an, welchen Typ die für den Output erzeugten Zellen haben.

In und Out

Will man auf die Ergebnisse vorangegangener Aktionen zurückgreifen, so 
steht dafür der Character  %  zur Verfügung.

% 	das letzte von Mathematica erzeugte Ergebnis

%%	das vorletzte ...

%%%	das vorvorletzte ...

Mit dem Befehl    In[n]    wird die n-te Eingabe der laufenden Mathematica-
Session wiederholt.

Mit   ??In       werden alle Eingaben der laufenden Session aufgelistet, 
        ??Out    funktioniert analog.

Gib doch mal das Ergebnis der Berechnung von 23 + 253 aus, allerdings
ohne den Rechengang zu wiederholen! Für diese und die meisten folgenden
Aufgaben mußt Du Dir nun die Inputzellen selbst erzeugen (s. oben).

Anschließend wiederhole die Zuweisung z = 23 + 253; allerdings ohne sie neu einzugeben !

Und nun schau Dir an, was Du dem Kernel in der bisherigen Sitzung
alles zum Evaluieren geschickt und was Du von ihm zurückbekommen 
hast.

Ist die Outputzelle von  ??Out  etwas groß geraten? Du kannst sie leicht 
löschen, indem Du den Zellrand mit der Maus markierst und dann 
die Tastenkombination Shift-Entf drückst.

Wie Du sicher gesehen hast, hat Mathematica z.B. bei der Eingabe von
??In  mehr als die bisherigen Inputzeilen ausgegeben, nämlich gleichzeitig
eine Erläuterung des Befehls  In[]. Dazu später mehr.

In einer Inputzelle können auch mehrere Eingaben hintereinander stehen.
Die einzelnen Eingaben werden durch  ;  getrennt. Das Zeichen  ;  bewirkt
bei einem einzelnen Befehl, daß der erzeugte Output nicht auf dem Bild-
schirm ausgegeben wird.

Schau Dir dazu den Output der folgenden beiden Inputzellen an.

z = 23 + 253;

z = 23 + 253; z

Hilfe zur Selbsthilfe

Mathematica stellt unabhängig von der Platform eine Online-Hilfe zur
Verfügung. Bei Platformen mit grapischer Oberfläche gibt es zusätzlich
noch menügesteuerte Hilfesysteme.

Für die folgenden Erläuterungen gibt es häufig Inputzellen mit Beispielen, die Du allerdings selbst evaluieren mußt.

Online Help

Ein  ?   ergibt einen kurzen Hilfetext.

?Factor*

Mit  ??  erhält man mehr Informationen.

??FactorInteger

Der Wildcardcharacter  *  ist bei der Auflistung von 
Befehlsgruppen hilfreich.

?*Graphic*

?*Plot*

Hilfe zum Kernel über das Front End

Über die Menüfunktion  Help - Kernel Help sind die Mathematica-Befehle
alphabetisch aufgelistet. Zu jedem Befehl gibt eine kleine Erläuterung
und manchmal auch ein Beispiel sowie Querverweise auf verwandte 
Befehle.

Schau Dir an, was Du auf diesem Weg alles über die Befehle   
Factor[ ]  ,  Plot[ ]    und    SurfaceGraphics[ ]     erfahren kannst.

Sonstiges Wissenswertes

Die Bedeutung der verschiedenen Klammern im Mathematica

Es werden verwendet:

runde Klammern    (...)
zum Gruppieren von mathematischen Ausdrücken

eckige Klammern   [...]	
zum Umschließen von Argumenten von Funktionen

geschweifte Klammern {...}	
zur Definition von Listen, Vektoren und Matrizen

doppelte eckige Klammern [[.]]	 
für die Indizierung bzw. Bezeichnung eines Objekts innerhalb von 
Listen, Vektoren und Matrizen

(* ... *)	
für Kommentare.

Lesen und Schreiben von Text und/oder Daten

Im folgenden werden einige Fileoperationen in Mathematica beschrieben. 
An Dir liegt es nun wieder, die zu den allgemeinen Befehlsbeschreibungen gehörenden Beispiele auszuprobieren.

Definitionen oder Ergebnisse können in Files abgespeichert werden:

<< file

liest ein Textfile als Mathematica Input ein.

In dem File   start02a.asc   steht z.B. eine Folge von Zahlen.

<< start02a.asc

Mit

expr >> file

werden Ergebnisse in der Datei    file   abgespeichert.

Expand[(a + b)^2]

Expand[(a + b)^2] >> start2b.asc

Mit

expr >>> file

wird beim Abspeichern nicht die Datei  file  überspeichert, sondern 
das Ergebnis an die Datei file angehängt.

liste = << start02a.asc;liste

Note: Für die obige Konstruktion gibt es einen eleganteren Befehl.

Length[liste]

liste >> start02c.asc

Length[liste] >>> start02c.asc

Und

!!file

zeigt die ersten Zeilen eines Files (Anlisten).

!!start02a.asc

!!start02b.asc

!!start02c.asc

Mit

Save["file", f, g, ...]

werden die Definitionen von Variablen oder Funktionen in der Datei  file  
abgespeichert.

f[x_] := x^2

Save["start02d.asc", liste, f]

!!start02d.asc

Note: Mit dem Befehl  Save[ ] wird werden ev. vorhandene Daten 
in der Datei   file   nicht überspeichert.

Unterbrechen von Mathematica

Wie dem Kernel mitgeteilt wird, daß er seine momentanen Berechnungen
unterbrechen oder abbrechen soll, hängt von der Platform ab, auf der 
Mathematica läuft.

Bei text-based interfaces (keine Graphische Oberfläche) genügt ein 
Control-C. Die laufenden Berechnungen werden unterbrochen;
Mathematica meldet sich mit einem   Interrupt>  und wartet auf 
Anweisungen. Mit Return können alle erlaubten Optionen abgerufen
werden.

Bei dem Front End unter Windows 3.1 ist folgendes zu tun:
1. Markierung der aktuellen Zelle, deren Input vom Kernel bearbeitet
    wird (erkennbar an dem Doppelstrich).
2. Menüauswahl  Action-Interrupt --> es erscheint ein Auswahlmenü.
    Mit   Continue   wird die aktuelle Berechnung weitergeführt.
    Mit   Inspect      wird die aktuelle Berechnung unterbrochen; 
                             der Kernel befindet sich in einer Art von Dialogmodus,
                             in dem man die Werte verschiedener Variablen abfragen
                             kann. Mit   Return[ ]  werden die Berechnungen fort-
                             gesetzt.
    Mit   Aport        wird die aktuelle Berechnung des Kernels abgebrochen.

In der nächsten Inputzeile wird in einer Schleife ein Zähler hochgezählt. 
Als Interpreter braucht Mathematica dazu einige Minuten und Du hast
somit die Gelegenheit, folgendes auszuprobieren:  
1. Unterbreche nach einigen Sekunden die Ausführung und schaue Dir an,
    welchen Wert der Zähler  i  hat.  Laß anschließend den Kernel 
    weiterrechnen.
2. Breche nach einigen Sekunden die Arbeit des Kernels vollständig ab.

Do[i+1, {i, 1, 1000000}]

Packages

Der Kernel von Mathematica enthält ca. 900 Funktionen und ist über-
wiegend in der Programmiersprache C geschrieben. Mathematica besitzt 
aber auch eine eigene Programmiersprache, mit der der Funktionsumfang 
erweitert werden kann. Zusätzliche Definitionen oder Funktionen, die in 
Files abgelegt werden, heißen  Packages.

Um auf Funktionen zugreifen zu können, die innerhalb eines Packages 
definiert wurden, muß dieses Package geladen werden.

Um z.B. auf die Funktion zur Berechnung des arithmetischen Mittels 
zugreifen zu können, muß das Package      

	Statistics`DescriptiveStatistics`	(UNIX)
oder 
	statisti`descript`                       	(DOS/Windows)

geladen werden.

Beachte: Mathematica erzeugt hier nur dann eine Outputzelle, wenn es Probleme beim Laden des Package gab.

<<statisti`descript`

?Mean

Mean[{1, 2, 3, 4, 5, 6, 7, 8}]

Das Erstellen von Packages wird später noch genauer beschrieben. 
Wie so ein Package aussieht, kannst Du Dir aber jetzt schon 
anhand des obigen Beispiels anschauen.
1. Menüauswahl File-Open
2. Bei der Auswahl    File-Type   den Type   Packages  (*.M) auswählen.
3. In das Verzeichnis    \wnmath21\packages\statisti wechseln.
4. Das Package  descript.m  anklicken.

Solltest Du beim Anschauen des Packages versehentlich etwas geändert
haben, so speichere diese Änderung bitte nicht mit ab!

Und noch etwas: Du solltest nun Dein aktuelles Notebook neu "öffnen" -
und zwar explizit über    File-Open usw.  , damit der Dateizeiger
wieder auf Dein Home-Directory   f:\oek\mathkurs   steht.

Im obigen Beispiel hast Du das Package mit dem Operator <<  ein-
gelesen. Dies ist eigentlich der korrekte Weg für das Einlesen eines
ASCII-Files.

Aber: Es kann passieren, daß man z.B. in einer längeren Sitzung ein
Packages versehentlich ein zweites Mal lädt. Dies führt dann meist
zu Schwierigkeiten, weil die meisten Packages so programmiert sind,
daß sie während einer Session nur einmal geladen werden müssen.

Deshalb ist der Aufruf eines Package mit    Needs["Package.m"] viel
eleganter, den der Befehl   Needs[ ]  überprüft, ob das angegebene
Package schon geladen wurde. Woran Needs[ ] das erkennt, erfährst
Du in einem der nächsten Notebooks - und auch, was das Apostroph
vor und nach    descript   bedeutet.

Überprüfe doch mal den Vorteil von Needs[ ]. Lade das obige Package
Statisti`descript`  nun noch einmal mit   <<     und anschließend mit
Needs[ ]. Was geschieht ?

Wie geht's weiter ?

Die Notebooks intro01.ma - intro09.ma enthalten eine themenbezogenen Einführung in die Syntax von Mathematica:

intro01.ma : Numerische Berechnungen
intro02.ma : Algebraische und Symbolische Berechnungen
intro03.ma : Manipulation von Listen
intro04.ma : Zuweisungen
intro05.ma : Eigene Funktionen
intro06.ma : Programmierung (Packages)
intro07.ma : Programmierung (Verfahren)
intro08.ma : Graphik mit Mathematica
intro09.ma : Veränderungen von Graphiken in Form und Farbe