(************** Content-type: application/mathematica ************** Mathematica-Compatible Notebook This notebook can be used with any Mathematica-compatible application, such as Mathematica, MathReader or Publicon. The data for the notebook starts with the line containing stars above. To get the notebook into a Mathematica-compatible application, do one of the following: * Save the data starting with the line of stars above into a file with a name ending in .nb, then open the file inside the application; * Copy the data starting with the line of stars above to the clipboard, then use the Paste menu command inside the application. Data for notebooks contains only printable 7-bit ASCII and can be sent directly in email or through ftp in text mode. Newlines can be CR, LF or CRLF (Unix, Macintosh or MS-DOS style). NOTE: If you modify the data for this notebook not in a Mathematica- compatible application, you must delete the line below containing the word CacheID, otherwise Mathematica-compatible applications may try to use invalid cache data. For more information on notebooks and Mathematica-compatible applications, contact Wolfram Research: web: http://www.wolfram.com email: info@wolfram.com phone: +1-217-398-0700 (U.S.) Notebook reader applications are available free of charge from Wolfram Research. *******************************************************************) (*CacheID: 232*) (*NotebookFileLineBreakTest NotebookFileLineBreakTest*) (*NotebookOptionsPosition[ 26086, 940]*) (*NotebookOutlinePosition[ 26944, 971]*) (* CellTagsIndexPosition[ 26900, 967]*) (*WindowFrame->Normal*) Notebook[{ Cell[CellGroupData[{Cell["Copyright ", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Copyright 1994, Claudia Funke TU-Berlin, FB 13, Fachgebiet \[CapitalODoubleDot]konometrie und Statistik Dieses Notebook darf ausschlie\[SZ]lich als Unterrichtsmaterial und f\ \[UDoubleDot]r private Zwecke verwendet und nicht ohne Zustimmung der Autorin ver\[ADoubleDot]ndert werden.\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}]}, Open]], Cell[CellGroupData[{Cell["Interaktion mit dem Kernel ", "Section", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ 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\[UDoubleDot]hrt.\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Wenn Du Mathematica unter Windows aufrufst, befindest Du Dich automatisch im Front-End. Die unter einem Front-End erzeugten Dokumente hei\[SZ]en Notebooks. Ein nicht kleiner Teil der Arbeit mit dem Windows Front-End umfa\[SZ]t die Erzeugung und Manipulation von Notebooks. Der Hauptzweck eines Front-Ends ist es jedoch, dem Kernel den Input zuzuf\ \[UDoubleDot]hren und von diesem den Output anzuzeigen.\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Das Grundschema der Arbeit mit Mathematica ist die Eingabe des Inputs, dessen Weitergabe an den Kernel und die R\[UDoubleDot]ckgabe des Outputs vom \ Kernel. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}]}, Open]], Cell["Vorbereiten der Eingabe ", "Subsection", ImageRegion->{{0, 1}, {0, 1}}], Cell[CellGroupData[{Cell["\<\ Um einen beliebigen Input auswerten zu k\[ODoubleDot]nnen, mu\[SZ] dieser \ zuerst in einem Notebook eingegeben werden. Diese Eingabe erfolgt in einer Zelle.\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Es gibt verschiedene Arten (styles) von Zellen in einem Notebook. Dies h\[ADoubleDot]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\[UDoubleDot]r einer Zelle \ Du Dich befindet, braucht Du nur die zugeh\[ODoubleDot]rige Zellenklammer \ anzuklicken. In dem ersten Fenster der Iconleiste erscheint dann der entsprechende Zellstyle. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["Welchen Zelltyp hat die aktuelle Zelle ?", "Text", ImageRegion->{{0, 1}, {0, 1}}, FontColor->RGBColor[0, 0, 0.500008], Background->GrayLevel[1]], Cell["\<\ Um irgendeinen Ausdruck von Mathematica auswerten zu lassen, mu\[SZ] dieser in einer Inputzelle stehen. Man erkennt eine solche Zelle meist daran, da\[SZ] die Schrift wie eine Schreibmaschinenschrift aussieht oder an ihrer Klammer, die keine weiteren Verzierungen enth\[ADoubleDot]lt.\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Hier ist eine typische Inputzelle: \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ 23 + 453 \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Eine Zelle ist bei ihrer \"Erzeugung\" automatisch eine Inputzelle. Der Zelltyp l\[ADoubleDot]\[SZ]t sich folgenderma\[SZ]en \[ADoubleDot]ndern: 1. Anklicken der Zellklammer 2. Aus dem kleinen Fenster links unterhalb der Men\[UDoubleDot]leiste \ (Anzeige des Zelltyps) den gew\[UDoubleDot]nschen Zelltyp ausw\[ADoubleDot]hlen.\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Im ersten Teil der Einleitung zur Handhabung der graphischen Oberfl\ \[ADoubleDot]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: \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Wiederhole diese kleine \[CapitalUDoubleDot]bung, nur da\[SZ] Du diesmal die \ neue Zelle als Textzelle markierst. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}, FontColor->RGBColor[0, 0, 0.500008], Background->GrayLevel[1]]}, Open]], Cell[CellGroupData[{Cell["Evaluierung des Inputs", "Subsection", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Damit der Kernel den Ausdruck in der Inputzelle evaluieren kann, mu\[SZ] dieser ihm erst \[UDoubleDot]bergeben werden. Bewege dazu den Cursor irgendwo \ in die Inputzelle, klicke einmal mit der Maustaste und bet\[ADoubleDot]tige \ anschlie\[SZ]end Shift + Return.\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Hier ist noch einmal die Inputzelle von oben: \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ 23 + 453 \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Evaluiere diesen Input ! Gibt es noch andere M\[ODoubleDot]glichkeiten zur Evaluierung des Inputs ? \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}, FontColor->RGBColor[0, 0, 0.500008], Background->GrayLevel[1]], Cell["\<\ Es kann sein, da\[SZ] die Evalierung etwas dauert. Das kommt daher, da\[SZ] dies dann der erste Input ist, der an den Mathematic-Kernel geschickt wird. \ In diesem Fall mu\[SZ] der Kernel erst in den Arbeitsspeicher geladen werden. \ Durch die Men\[UDoubleDot]auswahl Options - Kernel - Preload Kernel on \ Startup erreichst Du, da\[SZ] der Kernel bei allen zuk\[UDoubleDot]nftigen \ Mathematica-Session gleich mit dem Aufruf des Front Ends geladen wird. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ \[CapitalUDoubleDot]brigens: Hier siehst Du wieder, da\[SZ] 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\[UDoubleDot]ssen. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Das Ergebnis der obigenBerechnung kann auch einer Variablen zugewiesen werden: \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ z = 23 + 453 \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Nach der \"Abschicken\" des Ausdrucks an den Kernel hat sich die Inputzelle \ etwas ver\[ADoubleDot]ndert. Sie bekam von Mathematica mit In[ ]:= eine \ Zeilennummer zugewiesen. Diese wird von Mathematica fortlaufend bei der \ Evaluierung von Ausdr\[UDoubleDot]cken vergeben.\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ W\[ADoubleDot]hrend der Evaluierung des Ausrucks \[ODoubleDot]ffnet \ Mathematica gleichzeitig eine neue Zelle, in der dann der Output geschrieben \ wird. Diese Outputzelle enth\[ADoubleDot]lt ebenfalls einen Namen Out[ ]= \ mit der Zeilennummer der Inputzelle. Die Nummerierung hat den Sinn, da\[SZ] \ man sich sp\[ADoubleDot]ter direkt auf die Ein- oder Ausgabegabezellen \ beziehen kann.\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Beachte, da\[SZ] Mathematica die In- und Outputzelle automatisch zu einem Abschnitt verbindet. Dies entspricht einer Voreinstellung des Front Ends, die mit Options-Actions... ge\[ADoubleDot]ndert werden kann. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Und noch etwas. Speichert man die (evaluierten) Input- und Outputzellen mit \ ab und \[ODoubleDot]ffnet man das Notebook bei einer sp\[ADoubleDot]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\[ODoubleDot]nnte. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Hier nun eine etwas andere Inputzelle: \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Plot[Sin[x], {x, 0, 2 Pi}] \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Probiere aus, was die Evaluation dieses Inputs ergibt und schau Dir anschlie\[SZ]end an, welchen Typ die f\[UDoubleDot]r den Output erzeugten \ Zellen haben. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}, FontColor->RGBColor[0, 0, 0.500008], Background->GrayLevel[1]]}, Open]], Cell[CellGroupData[{Cell["In und Out", "Subsection", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Will man auf die Ergebnisse vorangegangener Aktionen \ zur\[UDoubleDot]ckgreifen, so steht daf\[UDoubleDot]r der Character % zur Verf\[UDoubleDot]gung. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell[" % \tdas letzte von Mathematica erzeugte Ergebnis", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell[" %%\tdas vorletzte ...", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell[" %%%\tdas vorvorletzte ...", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Mit dem Befehl In[n] wird die n-te Eingabe der laufenden Mathematica- Session wiederholt. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Mit ??In werden alle Eingaben der laufenden Session aufgelistet, ??Out funktioniert analog. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Gib doch mal das Ergebnis der Berechnung von 23 + 253 aus, allerdings ohne den Rechengang zu wiederholen! F\[UDoubleDot]r diese und die meisten \ folgenden Aufgaben mu\[SZ]t Du Dir nun die Inputzellen selbst erzeugen (s. oben). \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}, FontColor->RGBColor[0, 0, 0.500008], Background->GrayLevel[1]], Cell["\<\ Anschlie\[SZ]end wiederhole die Zuweisung z = 23 + 253; allerdings ohne sie \ neu einzugeben !\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}, FontColor->RGBColor[0, 0, 0.500008], Background->GrayLevel[1]], Cell["\<\ Und nun schau Dir an, was Du dem Kernel in der bisherigen Sitzung alles zum Evaluieren geschickt und was Du von ihm zur\[UDoubleDot]ckbekommen hast. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}, FontColor->RGBColor[0, 0, 0.500008], Background->GrayLevel[1]], Cell["\<\ Ist die Outputzelle von ??Out etwas gro\[SZ] geraten? Du kannst sie leicht l\[ODoubleDot]schen, indem Du den Zellrand mit der Maus markierst und dann die Tastenkombination Shift-Entf dr\[UDoubleDot]ckst. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Wie Du sicher gesehen hast, hat Mathematica z.B. bei der Eingabe von ??In mehr als die bisherigen Inputzeilen ausgegeben, n\[ADoubleDot]mlich \ gleichzeitig eine Erl\[ADoubleDot]uterung des Befehls In[]. Dazu sp\[ADoubleDot]ter mehr. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ In einer Inputzelle k\[ODoubleDot]nnen auch mehrere Eingaben hintereinander \ stehen. Die einzelnen Eingaben werden durch ; getrennt. Das Zeichen ; bewirkt bei einem einzelnen Befehl, da\[SZ] der erzeugte Output nicht auf dem Bild- schirm ausgegeben wird.\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Schau Dir dazu den Output der folgenden beiden Inputzellen an. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}, FontColor->RGBColor[0, 0, 0.500008], Background->GrayLevel[1]], Cell["\<\ z = 23 + 253; \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ z = 23 + 253; z \ \>", "Input", PageWidth->Infinity, Evaluatable->False, ImageRegion->{{0, 1}, {0, 1}}]}, Open]], Cell["Hilfe zur Selbsthilfe", "Section", ImageRegion->{{0, 1}, {0, 1}}], Cell[CellGroupData[{Cell["\<\ Mathematica stellt unabh\[ADoubleDot]ngig von der Platform eine Online-Hilfe \ zur Verf\[UDoubleDot]gung. Bei Platformen mit grapischer Oberfl\[ADoubleDot]che \ gibt es zus\[ADoubleDot]tzlich noch men\[UDoubleDot]gesteuerte Hilfesysteme.\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ F\[UDoubleDot]r die folgenden Erl\[ADoubleDot]uterungen gibt es \ h\[ADoubleDot]ufig Inputzellen mit Beispielen, die Du allerdings selbst \ evaluieren mu\[SZ]t. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}]}, Open]], Cell[CellGroupData[{Cell["Online Help", "Subsection", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Ein ? ergibt einen kurzen Hilfetext. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ ?Factor* \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Mit ?? erh\[ADoubleDot]lt man mehr Informationen. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ ??FactorInteger \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Der Wildcardcharacter * ist bei der Auflistung von Befehlsgruppen hilfreich. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ ?*Graphic* \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ ?*Plot* \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}]}, Open]], Cell[CellGroupData[{Cell["Hilfe zum Kernel \[UDoubleDot]ber das Front End", "Subsection", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ \[CapitalUDoubleDot]ber die Men\[UDoubleDot]funktion Help - Kernel Help sind \ die Mathematica-Befehle alphabetisch aufgelistet. Zu jedem Befehl gibt eine kleine \ Erl\[ADoubleDot]uterung und manchmal auch ein Beispiel sowie Querverweise auf verwandte Befehle.\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Schau Dir an, was Du auf diesem Weg alles \[UDoubleDot]ber die Befehle Factor[ ] , Plot[ ] und SurfaceGraphics[ ] erfahren kannst. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}, FontColor->RGBColor[0, 0, 0.500008], Background->GrayLevel[1]]}, Open]], Cell["Sonstiges Wissenswertes", "Section", ImageRegion->{{0, 1}, {0, 1}}], Cell[CellGroupData[{Cell["Die Bedeutung der verschiedenen Klammern im Mathematica", "Subsection", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Es werden verwendet: runde Klammern (...) zum Gruppieren von mathematischen Ausdr\[UDoubleDot]cken eckige Klammern [...]\t zum Umschlie\[SZ]en von Argumenten von Funktionen geschweifte Klammern {...}\t zur Definition von Listen, Vektoren und Matrizen doppelte eckige Klammern [[.]]\t f\[UDoubleDot]r die Indizierung bzw. Bezeichnung eines Objekts innerhalb von Listen, Vektoren und Matrizen (* ... *)\t f\[UDoubleDot]r Kommentare. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}]}, Open]], Cell[CellGroupData[{Cell["Lesen und Schreiben von Text und/oder Daten", "Subsection", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Im folgenden werden einige Fileoperationen in Mathematica beschrieben. An Dir liegt es nun wieder, die zu den allgemeinen Befehlsbeschreibungen geh\ \[ODoubleDot]renden Beispiele auszuprobieren. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Definitionen oder Ergebnisse k\[ODoubleDot]nnen in Files abgespeichert \ werden:\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\t\t<< file", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ liest ein Textfile als Mathematica Input ein. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ In dem File start02a.asc steht z.B. eine Folge von Zahlen. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ << start02a.asc \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["Mit", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\t\texpr >> file", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ werden Ergebnisse in der Datei file abgespeichert. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Expand[(a + b)^2] \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Expand[(a + b)^2] >> start2b.asc \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["Mit", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\t\texpr >>> file", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ wird beim Abspeichern nicht die Datei file \[UDoubleDot]berspeichert, \ sondern das Ergebnis an die Datei file angeh\[ADoubleDot]ngt. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ liste = << start02a.asc;liste \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Note: F\[UDoubleDot]r die obige Konstruktion gibt es einen eleganteren \ Befehl. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Length[liste] \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ liste >> start02c.asc \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Length[liste] >>> start02c.asc \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["Und", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\t\t!!file", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ zeigt die ersten Zeilen eines Files (Anlisten). \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ !!start02a.asc \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ !!start02b.asc \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["!!start02c.asc ", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Mit\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\t\tSave[\"file\", f, g, ...]", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ werden die Definitionen von Variablen oder Funktionen in der Datei file abgespeichert. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ f[x_] := x^2 \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Save[\"start02d.asc\", liste, f] \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ !!start02d.asc \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Note: Mit dem Befehl Save[ ] wird werden ev. vorhandene Daten in der Datei file nicht \[UDoubleDot]berspeichert. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}]}, Open]], Cell[CellGroupData[{Cell["Unterbrechen von Mathematica", "Subsection", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Wie dem Kernel mitgeteilt wird, da\[SZ] er seine momentanen Berechnungen unterbrechen oder abbrechen soll, h\[ADoubleDot]ngt von der Platform ab, auf \ der Mathematica l\[ADoubleDot]uft. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Bei text-based interfaces (keine Graphische Oberfl\[ADoubleDot]che) gen\ \[UDoubleDot]gt ein Control-C. Die laufenden Berechnungen werden unterbrochen; Mathematica meldet sich mit einem Interrupt> und wartet auf Anweisungen. Mit Return k\[ODoubleDot]nnen alle erlaubten Optionen abgerufen werden.\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ 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\[UDoubleDot]auswahl Action-Interrupt --> es erscheint ein Auswahlmen\ \[UDoubleDot]. Mit Continue wird die aktuelle Berechnung weitergef\[UDoubleDot]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. \ \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ In der n\[ADoubleDot]chsten Inputzeile wird in einer Schleife ein Z\ \[ADoubleDot]hler hochgez\[ADoubleDot]hlt. Als Interpreter braucht Mathematica dazu einige Minuten und Du hast somit die Gelegenheit, folgendes auszuprobieren: 1. Unterbreche nach einigen Sekunden die Ausf\[UDoubleDot]hrung und schaue \ Dir an, welchen Wert der Z\[ADoubleDot]hler i hat. La\[SZ] anschlie\[SZ]end \ den Kernel weiterrechnen. 2. Breche nach einigen Sekunden die Arbeit des Kernels \ vollst\[ADoubleDot]ndig ab. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}, FontColor->RGBColor[0, 0, 0.500008], Background->GrayLevel[1]], Cell["\<\ Do[i+1, {i, 1, 1000000}] \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}]}, Open]], Cell[CellGroupData[{Cell["Packages", "Section", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Der Kernel von Mathematica enth\[ADoubleDot]lt ca. 900 Funktionen und ist \ \[UDoubleDot]ber- wiegend in der Programmiersprache C geschrieben. Mathematica besitzt aber auch eine eigene Programmiersprache, mit der der Funktionsumfang erweitert werden kann. Zus\[ADoubleDot]tzliche Definitionen oder Funktionen, \ die in Files abgelegt werden, hei\[SZ]en Packages. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Um auf Funktionen zugreifen zu k\[ODoubleDot]nnen, die innerhalb eines \ Packages definiert wurden, mu\[SZ] dieses Package geladen werden.\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Um z.B. auf die Funktion zur Berechnung des arithmetischen Mittels zugreifen zu k\[ODoubleDot]nnen, mu\[SZ] das Package \tStatistics`DescriptiveStatistics`\t(UNIX) oder \tstatisti`descript` \t(DOS/Windows) geladen werden. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Beachte: Mathematica erzeugt hier nur dann eine Outputzelle, wenn es Probleme \ beim Laden des Package gab. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ <", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ ?Mean \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Mean[{1, 2, 3, 4, 5, 6, 7, 8}] \ \>", "Input", PageWidth->Infinity, ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Das Erstellen von Packages wird sp\[ADoubleDot]ter noch genauer beschrieben. Wie so ein Package aussieht, kannst Du Dir aber jetzt schon anhand des obigen Beispiels anschauen. 1. Men\[UDoubleDot]auswahl File-Open 2. Bei der Auswahl File-Type den Type Packages (*.M) \ ausw\[ADoubleDot]hlen. 3. In das Verzeichnis \\wnmath21\\packages\\statisti wechseln. 4. Das Package descript.m anklicken. Solltest Du beim Anschauen des Packages versehentlich etwas \ ge\[ADoubleDot]ndert haben, so speichere diese \[CapitalADoubleDot]nderung bitte nicht mit ab!\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}, FontColor->RGBColor[0, 0, 0.500008], Background->GrayLevel[1]], Cell["\<\ Und noch etwas: Du solltest nun Dein aktuelles Notebook neu \ \"\[ODoubleDot]ffnen\" - und zwar explizit \[UDoubleDot]ber File-Open usw. , damit der Dateizeiger wieder auf Dein Home-Directory f:\\oek\\mathkurs steht. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Im obigen Beispiel hast Du das Package mit dem Operator << ein- gelesen. Dies ist eigentlich der korrekte Weg f\[UDoubleDot]r das Einlesen \ eines ASCII-Files. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Aber: Es kann passieren, da\[SZ] man z.B. in einer l\[ADoubleDot]ngeren \ Sitzung ein Packages versehentlich ein zweites Mal l\[ADoubleDot]dt. Dies \ f\[UDoubleDot]hrt dann meist zu Schwierigkeiten, weil die meisten Packages so programmiert sind, da\[SZ] sie w\[ADoubleDot]hrend einer Session nur einmal geladen werden m\ \[UDoubleDot]ssen. \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Deshalb ist der Aufruf eines Package mit Needs[\"Package.m\"] viel eleganter, den der Befehl Needs[ ] \[UDoubleDot]berpr\[UDoubleDot]ft, ob \ das angegebene Package schon geladen wurde. Woran Needs[ ] das erkennt, erf\[ADoubleDot]hrst Du in einem der n\[ADoubleDot]chsten Notebooks - und auch, was das Apostroph vor und nach descript bedeutet.\ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ \[CapitalUDoubleDot]berpr\[UDoubleDot]fe doch mal den Vorteil von Needs[ ]. \ Lade das obige Package Statisti`descript` nun noch einmal mit << und anschlie\[SZ]end mit Needs[ ]. Was geschieht ? \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}]}, Open]], Cell[CellGroupData[{Cell["Wie geht's weiter ?", "Section", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ Die Notebooks intro01.ma - intro09.ma enthalten eine themenbezogenen Einf\ \[UDoubleDot]hrung in die Syntax von Mathematica: \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}], Cell["\<\ 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\[ADoubleDot]nderungen von Graphiken in Form und Farbe \ \>", "Text", ImageRegion->{{0, 1}, {0, 1}}]}, Open]] }, FrontEndVersion->"4.1 for Microsoft Windows", ScreenRectangle->{{0, 1024}, {0, 695}}, WindowToolbars->{}, CellGrouping->Manual, WindowSize->{499, 599}, WindowMargins->{{0, Automatic}, {Automatic, 0}}, PrivateNotebookOptions->{"ColorPalette"->{RGBColor, -1}}, ShowCellLabel->True, ShowCellTags->False, RenderingOptions->{"ObjectDithering"->True, "RasterDithering"->False} ] (******************************************************************* Cached data follows. If you edit this Notebook file directly, not using Mathematica, you must remove the line containing CacheID at the top of the file. The cache data will then be recreated when you save this file from within Mathematica. *******************************************************************) (*CellTagsOutline CellTagsIndex->{} *) (*CellTagsIndex CellTagsIndex->{} *) (*NotebookFileOutline Notebook[{ Cell[CellGroupData[{ Cell[1727, 52, 59, 1, 70, "Text"], Cell[1789, 55, 342, 8, 70, "Text"] }, Closed]], Cell[CellGroupData[{ Cell[2163, 65, 79, 1, 70, "Section"], Cell[2245, 68, 239, 5, 70, "Text"], Cell[2487, 75, 465, 9, 70, "Text"], Cell[2955, 86, 217, 7, 70, "Text"] }, Closed]], Cell[3184, 95, 79, 1, 70, "Subsection"], Cell[CellGroupData[{ Cell[3286, 98, 215, 5, 70, "Text"], Cell[3504, 105, 538, 12, 70, "Text"], Cell[4045, 119, 156, 3, 70, "Text"], Cell[4204, 124, 348, 6, 70, "Text"], Cell[4555, 132, 92, 4, 70, "Text"], Cell[4650, 138, 90, 5, 70, "Input"], Cell[4743, 145, 389, 9, 70, "Text"], Cell[5135, 156, 333, 7, 70, "Text"], Cell[5471, 165, 240, 8, 70, "Text"] }, Closed]], Cell[CellGroupData[{ Cell[5743, 175, 77, 1, 70, "Subsection"], Cell[5823, 178, 323, 8, 70, "Text"], Cell[6149, 188, 103, 4, 70, "Text"], Cell[6255, 194, 91, 5, 70, "Input"], Cell[6349, 201, 225, 7, 70, "Text"], Cell[6577, 210, 514, 9, 70, "Text"], Cell[7094, 221, 364, 9, 70, "Text"], Cell[7461, 232, 138, 5, 70, "Text"], Cell[7602, 239, 97, 5, 70, "Input"], Cell[7702, 246, 334, 6, 70, "Text"], Cell[8039, 254, 448, 8, 70, "Text"], Cell[8490, 264, 268, 5, 70, "Text"], Cell[8761, 271, 418, 8, 70, "Text"], Cell[9182, 281, 96, 4, 70, "Text"], Cell[9281, 287, 110, 5, 70, "Input"], Cell[9394, 294, 283, 8, 70, "Text"] }, Closed]], Cell[CellGroupData[{ Cell[9709, 304, 65, 1, 70, "Subsection"], Cell[9777, 307, 212, 6, 70, "Text"], Cell[9992, 315, 99, 1, 70, "Text"], Cell[10094, 318, 72, 1, 70, "Text"], Cell[10169, 321, 76, 1, 70, "Text"], Cell[10248, 324, 154, 6, 70, "Text"], Cell[10405, 332, 169, 5, 70, "Text"], Cell[10577, 339, 352, 8, 70, "Text"], Cell[10932, 349, 218, 6, 70, "Text"], Cell[11153, 357, 274, 8, 70, "Text"], Cell[11430, 367, 265, 6, 70, "Text"], Cell[11698, 375, 293, 7, 70, "Text"], Cell[11994, 384, 316, 7, 70, "Text"], Cell[12313, 393, 187, 6, 70, "Text"], Cell[12503, 401, 95, 5, 70, "Input"], Cell[12601, 408, 119, 6, 70, "Input", Evaluatable->False] }, Closed]], Cell[12732, 416, 73, 1, 70, "Section"], Cell[CellGroupData[{ Cell[12828, 419, 294, 7, 70, "Text"], Cell[13125, 428, 218, 6, 70, "Text"] }, Closed]], Cell[CellGroupData[{ Cell[13375, 436, 66, 1, 70, "Subsection"], Cell[13444, 439, 97, 4, 70, "Text"], Cell[13544, 445, 91, 5, 70, "Input"], Cell[13638, 452, 109, 4, 70, "Text"], Cell[13750, 458, 97, 5, 70, "Input"], Cell[13850, 465, 137, 5, 70, "Text"], Cell[13990, 472, 92, 5, 70, "Input"], Cell[14085, 479, 89, 5, 70, "Input"] }, Closed]], Cell[CellGroupData[{ Cell[14206, 486, 102, 1, 70, "Subsection"], Cell[14311, 489, 319, 8, 70, "Text"], Cell[14633, 499, 271, 7, 70, "Text"] }, Closed]], Cell[14916, 508, 75, 1, 70, "Section"], Cell[CellGroupData[{ Cell[15014, 511, 110, 1, 70, "Subsection"], Cell[15127, 514, 500, 20, 70, "Text"] }, Closed]], Cell[CellGroupData[{ Cell[15659, 536, 98, 1, 70, "Subsection"], Cell[15760, 539, 253, 5, 70, "Text"], Cell[16016, 546, 137, 4, 70, "Text"], Cell[16156, 552, 60, 1, 70, "Text"], Cell[16219, 555, 103, 4, 70, "Text"], Cell[16325, 561, 120, 4, 70, "Text"], Cell[16448, 567, 102, 5, 70, "Input"], Cell[16553, 574, 76, 2, 70, "Input"], Cell[16632, 578, 65, 1, 70, "Text"], Cell[16700, 581, 113, 4, 70, "Text"], Cell[16816, 587, 103, 5, 70, "Input"], Cell[16922, 594, 118, 5, 70, "Input"], Cell[17043, 601, 52, 1, 70, "Text"], Cell[17098, 604, 66, 1, 70, "Text"], Cell[17167, 607, 194, 6, 70, "Text"], Cell[17364, 615, 112, 5, 70, "Input"], Cell[17479, 622, 138, 5, 70, "Text"], Cell[17620, 629, 97, 5, 70, "Input"], Cell[17720, 636, 104, 5, 70, "Input"], Cell[17827, 643, 114, 5, 70, "Input"], Cell[17944, 650, 52, 1, 70, "Text"], Cell[17999, 653, 59, 1, 70, "Text"], Cell[18061, 656, 105, 4, 70, "Text"], Cell[18169, 662, 100, 5, 70, "Input"], Cell[18272, 669, 99, 5, 70, "Input"], Cell[18374, 676, 90, 2, 70, "Input"], Cell[18467, 680, 61, 4, 70, "Text"], Cell[18531, 686, 78, 1, 70, "Text"], Cell[18612, 689, 147, 5, 70, "Text"], Cell[18762, 696, 97, 5, 70, "Input"], Cell[18862, 703, 115, 5, 70, "Input"], Cell[18980, 710, 98, 5, 70, "Input"], Cell[19081, 717, 177, 5, 70, "Text"] }, Closed]], Cell[CellGroupData[{ Cell[19290, 724, 83, 1, 70, "Subsection"], Cell[19376, 727, 245, 6, 70, "Text"], Cell[19624, 735, 358, 8, 70, "Text"], Cell[19985, 745, 837, 19, 70, "Text"], Cell[20825, 766, 634, 16, 70, "Text"], Cell[21462, 784, 106, 5, 70, "Input"] }, Closed]], Cell[CellGroupData[{ Cell[21600, 791, 60, 1, 70, "Section"], Cell[21663, 794, 424, 9, 70, "Text"], Cell[22090, 805, 196, 5, 70, "Text"], Cell[22289, 812, 311, 11, 70, "Text"], Cell[22603, 825, 166, 5, 70, "Text"], Cell[22772, 832, 103, 5, 70, "Input"], Cell[22878, 839, 88, 5, 70, "Input"], Cell[22969, 846, 113, 5, 70, "Input"], Cell[23085, 853, 687, 16, 70, "Text"], Cell[23775, 871, 282, 7, 70, "Text"], Cell[24060, 880, 218, 6, 70, "Text"], Cell[24281, 888, 398, 9, 70, "Text"], Cell[24682, 899, 411, 8, 70, "Text"], Cell[25096, 909, 258, 6, 70, "Text"] }, Closed]], Cell[CellGroupData[{ Cell[25386, 917, 71, 1, 70, "Section"], Cell[25460, 920, 182, 5, 70, "Text"], Cell[25645, 927, 429, 12, 70, "Text"] }, Closed]] } ] *) (******************************************************************* End of Mathematica Notebook file. *******************************************************************)