(***********************************************************************
Mathematica-Compatible Notebook
This notebook can be used on any computer system with Mathematica 4.0,
MathReader 4.0, or any compatible application. 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[ 86762, 2707]*)
(*NotebookOutlinePosition[ 100178, 3109]*)
(* CellTagsIndexPosition[ 99971, 3098]*)
(*WindowFrame->Normal*)
Notebook[{
Cell[TextData[{
"Tour of ",
StyleBox["Mathematica",
FontSlant->"Italic"]
}], "Title"],
Cell[TextData[{
"To start this slide show, click the ",
StyleBox["start",
FontFamily->"Courier",
FontWeight->"Bold",
FontColor->GrayLevel[0]],
" button:"
}], "Text",
FontColor->RGBColor[1, 0, 0]],
Cell[BoxData[
ButtonBox[
StyleBox["start",
FontSize->36,
FontWeight->"Bold"],
ButtonFunction:>CompoundExpression[
NotebookFind[
SelectedNotebook[ ], "start", All, CellTags],
FrontEndExecute[
FrontEndToken[ "EvaluateCells"]]],
ButtonEvaluator->Automatic,
Active->True]], NotebookDefault],
Cell[TextData[{
"Clicking ",
StyleBox["start",
FontFamily->"Courier",
FontWeight->"Bold",
FontColor->GrayLevel[0]],
" will open a palette with nine buttons:"
}], "Text",
FontColor->RGBColor[1, 0, 0]],
Cell[BoxData[
StyleBox[GridBox[{
{
ButtonBox["next",
ButtonFunction:>SlideShow`NextSlide[ False]],
ButtonBox["back",
ButtonFunction:>SlideShow`PreviousSlide],
ButtonBox["first",
ButtonFunction:>SlideShow`FirstSlide]},
{
ButtonBox["skip",
ButtonFunction:>SlideShow`SkipSlide],
ButtonBox["notes",
ButtonFunction:>SlideShow`NotesToggle],
ButtonBox["demo",
ButtonFunction:>SlideShow`NextSlide[ True]]},
{
ButtonBox["stop",
ButtonFunction:>FrontEndExecute[
FrontEndToken[ Automatic, "EvaluatorQuit"]],
ButtonEvaluator->None],
ButtonBox["reset",
ButtonFunction:>CompoundExpression[
Set[ SlideShow`reset,
First[
Select[
Notebooks[ ], SameQ[
ReplaceAll[ WindowTitle,
Options[ #]], "reset"]&]]],
FrontEndExecute[ {
FrontEndToken[ SlideShow`reset, "SelectAll"],
FrontEndToken[ SlideShow`reset, "EvaluateCells"]}]]],
ButtonBox["close",
ButtonFunction:>CompoundExpression[
NotebookClose[ SlideShow`notes],
NotebookClose[ SlideShow`reset],
NotebookClose[ SlideShow`source],
NotebookClose[ SlideShow`nb],
NotebookClose[ SlideShow`cache],
NotebookClose[
ButtonNotebook[ ]]]]}
},
RowSpacings->0,
ColumnSpacings->0],
ButtonBoxOptions->{ButtonEvaluator->Automatic,
Active->True,
ButtonMargins->12}]], NotebookDefault,
CellTags->"palette"],
Cell[TextData[{
"The ",
StyleBox["next",
FontFamily->"Courier",
FontWeight->"Bold",
FontColor->GrayLevel[0]],
" button shows the next slide"
}], "Text",
FontColor->RGBColor[1, 0, 0]],
Cell[TextData[{
"The ",
StyleBox["back",
FontFamily->"Courier",
FontWeight->"Bold",
FontColor->GrayLevel[0]],
" button shows the previous slide"
}], "Text",
FontColor->RGBColor[1, 0, 0]],
Cell[TextData[{
"The ",
StyleBox["first",
FontFamily->"Courier",
FontWeight->"Bold",
FontColor->GrayLevel[0]],
" button jumps to the first slide"
}], "Text",
FontColor->RGBColor[1, 0, 0]],
Cell[TextData[{
"The ",
StyleBox["skip",
FontFamily->"Courier",
FontWeight->"Bold",
FontColor->GrayLevel[0]],
" button skips to the next section"
}], "Text",
FontColor->RGBColor[1, 0, 0]],
Cell[TextData[{
"The ",
StyleBox["notes",
FontFamily->"Courier",
FontWeight->"Bold",
FontColor->GrayLevel[0]],
" button shows (or hides) lecture notes"
}], "Text",
FontColor->RGBColor[1, 0, 0]],
Cell[TextData[{
"The ",
StyleBox["demo",
FontFamily->"Courier",
FontWeight->"Bold",
FontColor->GrayLevel[0]],
" button includes examples intended for manual demonstration"
}], "Text",
FontColor->RGBColor[1, 0, 0]],
Cell[TextData[{
"The ",
StyleBox["stop",
FontFamily->"Courier",
FontWeight->"Bold",
FontColor->GrayLevel[0]],
" button stops the kernel"
}], "Text",
FontColor->RGBColor[1, 0, 0]],
Cell[TextData[{
"The ",
StyleBox["reset",
FontFamily->"Courier",
FontWeight->"Bold",
FontColor->GrayLevel[0]],
" button attempts error recovery"
}], "Text",
FontColor->RGBColor[1, 0, 0]],
Cell[TextData[{
"The ",
StyleBox["close",
FontFamily->"Courier",
FontWeight->"Bold",
FontColor->GrayLevel[0]],
" button closes all of the notebooks used in this slide show"
}], "Text",
FontColor->RGBColor[1, 0, 0]],
Cell[BoxData[
\(SlideShow`controls = Notebooks[];
SlideShow`source = SelectedNotebook[]; SlideShow`$ShowFirstSlide = True;
SetOptions[SlideShow`source, Visible \[Rule] False];\)], "Input",
CellTags->"start"],
Cell[BoxData[
\(NotebookFind[SlideShow`source, "\", All, CellTags];
FrontEndExecute[
FrontEndToken[SlideShow`source, "\"]];\)], "Input",
CellTags->"start"],
Cell[BoxData[
\(SlideShow`controls =
First[Complement[Notebooks[], SlideShow`controls]];
SetOptions[SlideShow`controls, Editable \[Rule] True];
SetOptions[SlideShow`controls, WindowTitle \[Rule] "\",
WindowMargins \[Rule] {{Automatic, 50}, {40, Automatic}}];
SlideShow`reset =
NotebookCreate[WindowTitle \[Rule] "\", Visible \[Rule] False];
NotebookFind[SlideShow`source, "\", All, CellTags];
FrontEndExecute[{FrontEndToken[SlideShow`source, "\"],
FrontEndToken[SlideShow`reset, "\"],
FrontEndToken[SlideShow`reset, "\"],
FrontEndToken[SlideShow`reset, "\"]}]\)], "Input",
CellTags->"start"],
Cell[BoxData[
\(\(Begin["\"];\)\)], "Input",
CellTags->"reset"],
Cell[BoxData[
\(\(SlideShow`source =
With[{nb =
Select[Notebooks[],
SameQ[WindowTitle /.
Options[#], "\"] &]},
If[Length[nb] > 0, nb[\([1]\)],
NotebookPut[
Notebook[{Cell["\", "\",
FontSize \[Rule] 24, ShowCellBracket \[Rule] False]},
WindowSize \[Rule] {250, 70},
WindowMargins \[Rule] {{Automatic, 50}, {40, Automatic}},
WindowTitle \[Rule] "\", WindowElements \[Rule] {},
WindowFrameElements \[Rule] "\"]]]];\)\)], "Input",\
CellTags->"reset"],
Cell[BoxData[
\(\(SlideShow`nb =
With[{nb =
Select[Notebooks[],
SameQ[WindowTitle /.
Options[#], "\"] &]},
If[Length[nb] > 0, nb[\([1]\)],
NotebookCreate[WindowTitle \[Rule] "\",
DelimiterFlashTime \[Rule] 0, Magnification \[Rule] 2,
WindowSize \[Rule] {760, 560},
WindowMargins \[Rule] {{20, Automatic}, {Automatic, 20}},
StyleDefinitions \[Rule] "\",
ScreenStyleEnvironment \[Rule] "\"]]];\)\)], "Input",
CellTags->"reset"],
Cell[BoxData[
\(\(SlideShow`notes =
With[{nb =
Select[Notebooks[],
SameQ[WindowTitle /. Options[#], "\"] &]},
If[Length[nb] > 0, nb[\([1]\)],
NotebookCreate[Visible \[Rule] True, WindowTitle -> "\",
WindowSize \[Rule] {520, 120},
WindowMargins \[Rule] {{20, Automatic}, {20,
Automatic}}]]];\)\)], "Input",
CellTags->"reset"],
Cell[BoxData[
\(\(SlideShow`$EvaluationToggle = False;\)\)], "Input",
CellTags->"reset"],
Cell[BoxData[
\(SlideShow`ShortPause := Do[2 + 2, {10000}]\)], "Input",
CellTags->"reset"],
Cell[BoxData[
\(SlideShow`TypeInput[p_] :=
If[StringQ[p],
Scan[\((NotebookWrite[nb, #]; ShortPause)\) &, Characters[p]],
NotebookWrite[nb, p]]\)], "Input",
CellTags->"reset"],
Cell[BoxData[
\(SlideShow`HeadingCell[data_] :=
MemberQ[{"\", "\", "\"},
Part[NestWhile[First,
data, \((Head[#] =!= Cell || Length[#] < 2)\) &], 2]]\)], "Input",\
CellTags->"reset"],
Cell[BoxData[
\(\(\(SlideShow`ShowSlide[data_]\)\(:=\)\)\)], "Input"],
Cell[BoxData[
\(SlideShow`NextSlide[p_] :=
If[$EvaluationToggle, $EvaluationToggle = False;
FrontEndExecute[FrontEndToken[nb, "\"]],
Module[{data}, SelectionMove[source, Next, CellGroup];
data = NotebookRead[source];
If[data === {}, SelectionMove[source, Previous, CellGroup],
If[First[data] === "\",
If[p, SelectionMove[source, Next, CellGroup];
data = NotebookRead[source],
NotebookFind[source, "\", Next];
SelectionMove[source, Next, CellGroup];
data = NotebookRead[source]]];
If[First[data] === "\",
SelectionMove[source, Next, CellGroup];
data = NotebookRead[source]];
If[SameQ[Last[data], CellTags \[Rule] "\"],
FrontEndExecute[{FrontEndToken[notes, "\"],
FrontEndToken[source, "\"],
FrontEndToken[notes, "\"],
FrontEndToken[notes, "\"]}];
SelectionMove[source, Next, CellGroup];
data = NotebookRead[source]];
If[Last[data] === "\ ", \
\[IndentingNewLine]$EvaluationToggle = True;
SelectionMove[nb, After, Notebook];
TypeInput[data[\([1]\)]], \[IndentingNewLine]If[
SameQ[Last[data],
CellTags \[Rule] "\"], \($Line--\);
FrontEndExecute[FrontEndToken[source, "\"]],
If[HeadingCell[data],
FrontEndExecute[{FrontEndToken[source, "\"],
FrontEndToken[nb, "\"],
FrontEndToken[nb, "\"],
FrontEndToken[nb, "\"]}],
SelectionMove[nb, After, Notebook];
NotebookWrite[nb, data]]]]]]]\)], "Input",
CellTags->"reset"],
Cell[BoxData[
\(SlideShow`NotesToggle :=
SetOptions[notes, \
Visible \[Rule] Not[TrueQ[Visible /. Options[notes]]]]\)], "Input",
CellTags->"reset"],
Cell[BoxData[
\(\(SlideShow`PreviousSlide :=
Module[{data}, \[IndentingNewLine]$EvaluationToggle = False;
While[SelectionMove[source, Previous, CellGroup];
data = NotebookRead[source];
Which[First[
data] === "\", \[IndentingNewLine]NotebookFind[
source, "\", Previous]; True, HeadingCell[data],
SelectionMove[source, Previous, Cell];
SelectionMove[source, Before, Cell]; NextSlide[True]; False,
Last[data] === \((CellTags \[Rule] "\")\),
NextSlide[True]; False, True, True]]];\)\)], "Input",
CellTags->"reset"],
Cell[BoxData[
\(SlideShow`FirstSlide := \(($EvaluationToggle = False;
NotebookFind[source, "\", All, CellTags];
SetSelectedNotebook[notes];
SetSelectedNotebook[nb]; \[IndentingNewLine]FrontEndExecute[
FrontEndToken[source, "\"]])\)\)], "Input",
CellTags->"reset"],
Cell[BoxData[
\(If[SlideShow`$ShowFirstSlide, SlideShow`$ShowFirstSlide = False;
SlideShow`FirstSlide]\)], "Input",
CellTags->"reset"],
Cell[BoxData[
\(SlideShow`SkipSlide := \(($EvaluationToggle = False;
While[SelectionMove[source, Next, CellGroup];
data = NotebookRead[source];
Which[data === {}, SelectionMove[source, Previous, CellGroup];
False, First[data] === "\",
NotebookFind[source, "\", Next]; True,
HeadingCell[data], SelectionMove[source, Previous, Cell];
SelectionMove[source, Before, Cell]; \[IndentingNewLine]NextSlide[
True]; False, True, True]])\)\)], "Input",
CellTags->"reset"],
Cell[BoxData[
\(SetSelectedNotebook[nb]; End[]; $Line = 0;\)], "Input",
CellTags->"reset"],
Cell[BoxData[
\($Line = 0; SlideShow`NextSlide[True];\)], "Input",
CellTags->"first"],
Cell[TextData[{
"This is a tour of calculations that you can do using ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" without doing any programming. This session covers much of the same \
material that is covered in the Tour of ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" section of The ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" Book, except for interface features, such as notebooks and typesetting, \
and programming features, all of which is covered in separate sessions."
}], "Text",
CellTags->"notes"],
Cell[TextData[{
"Tour of ",
StyleBox["Mathematica",
FontSlant->"Italic"]
}], "Title"],
Cell["\<\
Here is a list of topics for this session. I will not here be going \
through each of these topics and systematically describing all of the \
functionality in each area. What I will do instead in each area is comment on \
the available functionality and describe some of the general issues that will \
be relevant when you come to exploring those areas of the system.\
\>", "Text",\
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Tour of Mathematica", "Section"],
Cell["System organization", "Contents",
CellDingbat->"\[FilledCircle]"],
Cell["Symbolic calculations", "Contents"],
Cell["Linear algebra", "Contents"],
Cell["Numerical computation", "Contents"],
Cell["Graphics", "Contents"],
Cell["External files", "Contents"],
Cell[TextData[StyleBox["MathLink",
FontSlant->"Italic"]], "Contents"]
}, Open ]],
Cell[TextData[{
"The first topic is system organization. If you installed ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" yourself or if you examined your computer after installation you may have \
noticed that the installer put hundreds of files and programs and notebooks \
and other components on your computer. All of these components are organized \
around two main programs: the part that does the calculations, which we call \
the kernel, and the part that manages the interface, which we call the \
notebook interface, or the notebook front end."
}], "Text",
CellTags->"notes"],
Cell[TextData[{
"Components of ",
StyleBox["Mathematica",
FontSlant->"Italic"]
}], "Subsection"],
Cell[TextData[{
"Here is a drawing of that organization. The part of ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" that manages what you see on the screen is the notebook interface, and \
the part of ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" that does the calculations is the kernel. Communication between the two \
programs is through ",
StyleBox["MathLink.",
FontSlant->"Italic"],
" In a typical operating cycle you type something in to a notebook using \
the notebook interface, send your calculation over to the kernel, the kernel \
does the calculation, sends the result back, and the result gets displayed in \
the notebook.\nSince the only part that you usually see is the notebook \
interface, you can in many cases ignore what is going on internally and think \
of ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" as one big program. In other cases, however, it is useful to know which \
part of the program is doing what."
}], "Text",
ParagraphIndent->24,
CellTags->"notes"],
Cell[BoxData[
\(\(Block[{inlevel, outlevel, fef, fe, kf, k, sh, s, pi, po, in, result,
as, ra, la, g},
inlevel = 1.5; \[IndentingNewLine]outlevel =
0.9; \[IndentingNewLine]fef =
Line[{{0, 0.2}, {0, 2.2}, {3, 2.2}, {3, 0.2}, {0,
0.2}}]; \[IndentingNewLine]fe =
Text[StyleForm["\",
FontFamily \[Rule] "\",
FontSize \[Rule] 14], {1.5, \(- .2\)}]; \[IndentingNewLine]kf =
Circle[{5.6, 1.3}, {1.2, 1}]; \[IndentingNewLine]k =
Text[StyleForm["\", FontFamily \[Rule] "\",
FontSize \[Rule] 14], {5.6, \(- .1\)}]; \[IndentingNewLine]sh =
1.25; \[IndentingNewLine]s = {Text[
StyleForm["\< 2\n+ 2\n\n 4\>", \[IndentingNewLine]FontFamily \
\[Rule] "\", FontSize \[Rule] 12,
FontWeight \[Rule] "\"], {5.8, sh}], {Thickness[
0.004],
Line[{{5.55, sh - 0.15}, {6.03,
sh - 0.15}}]}}; \[IndentingNewLine]pi =
Text[StyleForm["\", FontFamily \[Rule] "\",
FontColor \[Rule] RGBColor[0, 0, 1]], {0.6,
inlevel}]; \[IndentingNewLine]po =
Text[StyleForm["\", FontFamily \[Rule] "\",
FontColor \[Rule] RGBColor[0, 0, 1]], {0.6,
outlevel}]; \[IndentingNewLine]in =
Text[StyleForm["\<2\[ThinSpace]+\[ThinSpace]2\>",
FontSize \[Rule] 12, FontFamily \[Rule] "\",
FontWeight \[Rule] "\"], {1.4,
inlevel}]; \[IndentingNewLine]result =
Text[StyleForm["\<4\>", FontSize \[Rule] 12,
FontFamily \[Rule] "\"], {1.2,
outlevel}]; \[IndentingNewLine]as =
0.14; \[IndentingNewLine]ra = {Line[{{2.2, inlevel}, {5.1 - as,
inlevel}}],
Polygon[{{5.1 - as, inlevel + as}, {5.1 + as,
inlevel}, {5.1 - as, inlevel - as}}],
Text[StyleForm["\ ", FontFamily \[Rule] "\",
FontSize \[Rule] 12], {3.7,
inlevel + 0.25}]}; \[IndentingNewLine]la = {Line[{{2.0 + as,
outlevel}, {5.3, outlevel}}],
Polygon[{{2.0 + as, outlevel + as}, {2.0 - as,
outlevel}, {2.0 + as, outlevel - as}}],
Text[
StyleForm["\", FontFamily \[Rule] "\",
FontSize \[Rule] 12], {3.7,
outlevel + 0.25}]}; \[IndentingNewLine]g =
Graphics[
Rectangle[{0, 0}, {1, 1},
Graphics[{Thickness[0.01], fe, fef, k, kf, Thickness[0.008], s,
pi, po, in, result, ra, la}, AspectRatio \[Rule] 0.3]],
AspectRatio \[Rule] 0.3]; \[IndentingNewLine]NotebookWrite[
SlideShow`nb,
Cell[GraphicsData["\",
DisplayString[g]]]]];\)\)], "Input",
CellTags->"evaluate"],
Cell[TextData[{
"For example, the kernel and the notebook interface can run on different \
computers, in which case the file system that is available to each part of ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" is the file system that is available for a program running on that \
computer. If you are reading and writing data files with the kernel, those \
files would normally be files on the computer that is running the kernel, and \
if you are opening and closing notebooks, the notebook files would be the \
files on the computer the is running the notebook interface."
}], "Text",
CellTags->"notes"],
Cell["\<\
The kernel and the notebook interface can run on separate computers\
\
\>", "Text"],
Cell["\<\
The topic for the present session is primarily functionality of the \
kernel, although for many things the two are inseparable. When making a plot, \
for example, the kernel can do the calculations to construct the image but \
the interface is needed to display that image. Typesetting and notebooks are \
for the most part interface functionality, and will be discussed later.\
\>", \
"Text",
CellTags->"notes"],
Cell["This is a tour of kernel functionality", "Text"],
Cell["The first topic on the tour is symbolic calculations.", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Tour of Mathematica", "Section"],
Cell["System organization", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Symbolic calculations", "Contents",
CellDingbat->"\[FilledCircle]"],
Cell["Linear algebra", "Contents"],
Cell["Numerical computation", "Contents"],
Cell["Graphics", "Contents"],
Cell["External files", "Contents"],
Cell[TextData[StyleBox["MathLink",
FontSlant->"Italic"]], "Contents"]
}, Open ]],
Cell[TextData[{
"Here is a list of some of the symbolic functions in ",
StyleBox["Mathematica",
FontSlant->"Italic"],
". The functions that are probably the most widely recognizable are \
functions for calculus like Integrate and FourierTransform, and the functions \
for solving equations, like Solve. To better understand what you can expect \
from these functions, it is useful to know that essentially all of these \
functions are based at some level on polynomial operations, such as Factor, \
which factors polynomials, Apart, which does partial fraction decomposition, \
and Together, which collects things over a common denominator."
}], "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Symbolic operations", "Subsection"],
Cell[TextData[Cell[BoxData[GridBox[{
{"Integrate", "Limit"},
{"D", "Series"},
{"Derivative", "Solve"},
{"DSolve", "Simplify"},
{"Expand", "Apart"},
{"Together", "Factor"},
{"PolynomialGCD", "Collect"},
{"FourierTransform", "LaplaceTransform"},
{"GroebnerBasis", "PolynomialReduce"}
}]],
GridBoxOptions->{ColumnAlignments->{Left}}]], "Text",
FontWeight->"Bold"]
}, Open ]],
Cell["\<\
If what you want to accomplish can somehow be broken down into \
basic polynomial operations then it can usually be done.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Polynomial operations", "Subsection"],
Cell[TextData[Cell[BoxData[GridBox[{
{"Expand", "Apart"},
{"Together", "Factor"},
{"FactorSquareFree", "Resultant"},
{"Decompose", "FactorList"},
{"PolynomialGCD", "Collect"},
{"Coefficient", "CoefficientList"},
{"GroebnerBasis", "PolynomialReduce"}
}]],
GridBoxOptions->{ColumnAlignments->{Left}}]], "Text",
FontWeight->"Bold"]
}, Open ]],
Cell["For example, Expand is a basic polynomial operation.", "Text",
CellTags->"notes"],
Cell["Expand[(1+x+y)^3]", "Input"],
Cell["And Factor is a basic polynomial operation.", "Text",
CellTags->"notes"],
Cell["Factor[1+2x+x^2+2y+2x y+y^2]", "Input"],
Cell["\<\
Combining terms over a common denominator is a basic polynomial \
operation.\
\>", "Text",
CellTags->"notes"],
Cell["Together[1/(1+x)+y/(1+x)^2]", "Input"],
Cell["\<\
Partial fraction decomposition is a basic polynomial operation. The \
Apart function does partial fraction decomposition. You can use the Apart \
function with one argument, but I wouldn't recommend that, since the second \
argument specifies the variable with respect to which to do the partial \
fraction decomposition, and if you omit the second variable then Apart will \
just pick something, and that may not be the variable that you want.\
\>", \
"Text",
CellTags->"notes"],
Cell["Apart[(1+x+y)/(1+x)^2,x]", "Input"],
Cell["\<\
Another basic operation is picking out coefficients of a \
polynomial. Here is an example using CoefficientList to pick out the \
coefficients of powers of x in this polynomial.\
\>", "Text",
CellTags->"notes"],
Cell["CoefficientList[b x^2+x y +(1+x)^3,x]", "Input"],
Cell["\<\
Even if you are not interested directly in polynomial operations, \
it is still useful to know about the internal importance of polynomials, \
since this will help you to anticipate what you can or cannot expect from \
symbolic calculations, and perhaps design your calculations to take advantage \
of the strengths of computer algebra. I have several illustrations of that, \
the first being a discussion of how Solve works.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Solve", "Subsection"],
Cell["The basic Solve algorithm handles polynomials", "Text"]
}, Open ]],
Cell["\<\
Here is a simple Solve example. To understand what Solve did, you \
can think about how you might solve these equations by hand. The process \
basically involves three steps. The first step would be to eliminate \
variables between these equations to get an equation in one variable, the \
next step is to find the roots of that equation, and the last step is to \
back-substitute those roots into the remaining equations.\
\>", "Text",
CellTags->"notes"],
Cell["Solve[{x==y,x^2+y^2==2},{x,y}]", "Input"],
Cell["\<\
Although it is perhaps not essential to know this, the underlying \
algorithm that Solve uses to do the first step, combining the equations to \
get an equation in on variable, is called construction of a \
GroebnerBasis.\
\>", "Text",
CellTags->"notes"],
Cell["GroebnerBasis[{x-y,x^2+y^2-2},{x,y}]", "Input"],
Cell["\<\
Then the second step is root extraction, for which the Solve \
function calls another function called Roots, and then substitute those roots \
into the original equation.\
\>", "Text",
CellTags->"notes"],
Cell["Roots[-1+y^2\[Equal]0,y]", "Input"],
Cell["\<\
Non-polynomial equations are solved by converting them to \
polynomial equations.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Solving non-polynomial equations", "Subsection"],
Cell["\<\
Non-polynomial equations are solved by converting them to \
polynomial equations.\
\>", "Text"]
}, Open ]],
Cell["\<\
For example, this equation is solved by recognizing that although \
it isn't a polynomial in x, it is a polynomial in Cos[x], then solving for \
Cos[x] using the polynomial equation solver, and taking the arccosine of \
those solutions to get values of x.
This example illustrates one issue that comes up when solving non-polynomial \
equations, which is that, as indicated by the warning message, Solve will not \
necessarily find all of the solutions. In this example, since Cos[x] is \
periodic, if x is a solution then so is x+2nPi, where n is any integer, so \
this equation has an infinite number of solutions. Solve isn't equipped to \
return an infinite number of solutions, and so generates this warning message \
to indicate that it may have missed some of the solutions.\
\>", "Text",
ParagraphIndent->24,
CellTags->"notes"],
Cell["Solve[Cos[x]^2\[Equal]b,x]", "Input"],
Cell[TextData[{
"Another effect is illustrated by this example, where, since the Sqrt \
function in ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" is defined to be the positive square root, this result is not technically \
correct, since if b is negative this equation has no solution."
}], "Text",
CellTags->"notes"],
Cell["Solve[Sqrt[x]==b,x]", "Input"],
Cell["\<\
If the symbolic parameter b is replaced by a negative number, then \
Solve correctly reports that there is no solution.\
\>", "Text",
CellTags->"notes"],
Cell["Solve[Sqrt[x]==-2,x]", "Input"],
Cell["\<\
Thinking about how Solve came up with this solution, it might seem \
that there should have been a solution. Solve solves Sqrt[x]==-2 by squaring \
both sides of the equation to get a polynomial equation, which in this case \
gives x==4, so one might wonder what happened to that solution. In fact Solve \
came up with this solution and rejected it, because although this solution \
solves the polynomial equation, it does not solve the original equation. \
Solutions that are introduced like this in the process of converting a \
non-polynomial equation into a polynomial equation are called parasitic \
solutions. Parasitic solutions are rejected by the solution verifier in \
Solve. If you for some reason want to see these parasitic solutions, you can \
turn the solution verifier off using the option VerifySolutions->False.\
\>", \
"Text",
CellTags->"notes"],
Cell["\<\
Solve[Sqrt[x]==-2,x,VerifySolutions->False]\
\>", "Input"],
Cell["\<\
Non-polynomial equations are solved by converting them to \
polynomial equations.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Solve for large examples", "Subsection"],
Cell["Simple examples sometimes have large solutions.", "Text"]
}, Open ]],
Cell["\<\
To illustrate that, here is an example of a pair of equations that \
has a solution that goes on for several pages.\
\>", "Text",
CellTags->"notes"],
Cell["Solve[{x^3+x\[Equal]y,y^2\[Equal]y+1},{x,y}]", "Input"],
Cell["\<\
If I use really small characters I can get this result to fit \
mostly on the screen, but this is just a simple pair of equations. If there \
were more equations or higher-order polynomials, the calculation could \
overwhelm the computational resources of any realistic computer, or take an \
unrealistically large amount of time, even for a calculation like this that \
is conceptually straightforward.\
\>", "Text",
CellTags->"notes"],
Cell[BoxData[
\(SelectionMove[SlideShow`nb, Previous, Cell];
SetOptions[NotebookSelection[SlideShow`nb],
Magnification \[Rule] 0.5]\)], "Input",
CellTags->"evaluate"],
Cell["\<\
In summary, some suggestions when working with Solve are to first \
try to get your calculation into a system of polynomial equations. If that \
doesn't work, or if it is difficult, keep in mind that issues like parasitic \
solutions and not finding all solutions can come up for non-polynomial \
equations. Even if you have polynomial equations, computing symbolic \
solutions can require more time and computer memory than you have available, \
and finally, for really large problems unless you absolutely need a symbolic \
solution it is reasonable to look for ways to get what you want by computing \
solutions numerically.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Suggestions for using Solve", "Subsection"],
Cell["Solve works best for polynomial equations", "BulletItem"],
Cell["\<\
Non-polynomial equations raise non-trivial mathematical \
issues\
\>", "BulletItem"],
Cell["Symbolic solutions can be computationally demanding", "BulletItem"],
Cell["Consider numerical alternatives for complicated equations", "BulletItem"]
}, Open ]],
Cell["\<\
Another prominent topic in symbolic computation can broadly be \
described as \"simplification\", which transforming expressions into any more \
convenient form. The obvious problem is that simple in one situation or for \
one person may not be the same thing as simple in another situation or for \
someone else. A consequence of this ambiguity is that some simplifications \
are easy and some simplifications are not so easy.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Simplification", "Subsection"],
Cell["\"Simple\" has different meanings in different situations", "Text"]
}, Open ]],
Cell["\<\
As an example, here is an expression involving trigonometric \
functions. There are of course an infinite number of forms in which one might \
imagine writing this expression.\
\>", "Text",
CellTags->"notes"],
Cell["expr=Cos[x]^2+3Cos[x]^2Sin[x]-Sin[x]^2-Sin[x]^3", "Input"],
Cell["\<\
For example, one very convenient form for many purposes is to write \
this expression as complex exponentials. This is convenient for operations \
such as symbolic integration, since the integral is then nearly trivial. This \
transformation is done by a function called TrigToExp. So this one possible \
meaning for \"simple\".\
\>", "Text",
CellTags->"notes"],
Cell["TrigToExp[expr]", "Input"],
Cell["\<\
If I want to retain trigonometric functions there are many other \
possibilities. For example, there is a function called TrigReduce that will \
make this considerably shorter.\
\>", "Text",
CellTags->"notes"],
Cell["TrigReduce[expr]", "Input"],
Cell["\<\
There are perhaps a hundred functions that you might consider for \
transforming this expression into something that might arguably be considered \
simpler, or at least more convenient. In many cases, however, you just want \
the expression to be smaller and don't want to have to dig through hundreds \
of functions to find a function that will do it. One function that is \
intended for such occasions is Simplify, which works by applying a collection \
of transformations and returning the expression that it thinks is simplest.\
\
\>", "Text",
CellTags->"notes"],
Cell["Simplify[expr]", "Input"],
Cell["\<\
FullSimplify works the same way except that it applies even more \
transformations, and here gets the same result that TrigReduce got. Of \
course, TrigReduce was a lot faster, since it went straight to TrigReduce, \
while FullSimplify tried hundreds or probably thousands of other \
transformations before it found something equivalent to TrigReduce,\
\>", \
"Text",
CellTags->"notes"],
Cell["FullSimplify[expr]", "Input"],
Cell["\<\
Many simplifying transformations only apply for certain values of \
the variables.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Simplification with assumptions", "Subsection"],
Cell[TextData[{
"The second argument of ",
StyleBox["Simplify",
FontFamily->"Courier",
FontWeight->"Bold"],
" or ",
StyleBox["FullSimplify",
FontFamily->"Courier",
FontWeight->"Bold"],
" can include assumptions about parameters."
}], "Text"]
}, Open ]],
Cell["\<\
For example, here is an expression that might come up and that \
obviously can be simplified if x is positive and n is an integer.\
\>", "Text",\
CellTags->"notes"],
Cell["expr=Sqrt[x^2]+Sin[2n \[Pi]+x]", "Input"],
Cell["\<\
The assumption that x is positive can be included by inserting x>0 \
as the second argument in Simplify.\
\>", "Text",
CellTags->"notes"],
Cell["Simplify[expr,x>0]", "Input"],
Cell["\<\
The assumption that n is an integer can be inserted by including \
Element[n,Integers] as the second argument in Simplify.\
\>", "Text",
CellTags->"notes"],
Cell["Simplify[expr,Element[n,Integers]]", "Input"],
Cell["\<\
The Element[n,Integers] assumption can be inserted in more \
traditional notation by entering the \[Element] character. This character is \
in the BasicInput palette, or you can enter it using the alias elem, or there \
are other ways to enter it that will be discussed when we get to the section \
on typesetting.\
\>", "Text",
CellTags->"notes"],
Cell["Simplify[expr,n\[Element]Integers]", "Input"],
Cell["\<\
Both assumptions can be entered by including them in a list.\
\>", \
"Text",
CellTags->"notes"],
Cell["\<\
Simplify[expr,{x>0,n\[Element]Integers}]\
\>", "Input"],
Cell["\<\
Or both assumptions can be included using && between the \
assumptions, which is the notation for the logical And function. I usually \
prefer the && notation because I like the aesthetics of it, but it doesn't \
make any difference.\
\>", "Text",
CellTags->"notes"],
Cell["Simplify[expr,x>0&&n\[Element]Integers]", "Input"],
Cell["Clear expr before moving on.", "Text",
CellTags->"notes"],
Cell["Clear[expr]", "Input"],
Cell["\<\
Continuing on the subject of simplification I would like to make a \
few remarks about controlling the form of results.\
\>", "Text",
CellTags->"notes"],
Cell["Controlling the form of results", "Subsection"],
Cell["\<\
As an illustration, here is a integral which is computed and gives \
the result in terms of a logarithm. This result is mathematically correct for \
all values of x, but, for example, if the parameter b is bigger than x, then \
this logarithm is complex, so I might want to get this result as Log[b-x] \
rather than Log[-b+x]. These results differ by a constant of integration, so \
both results are correct.\
\>", "Text",
CellTags->"notes"],
Cell["result=Integrate[1/(x-b),x]", "Input"],
Cell["\<\
Simplify by itself will not do this, because the result is already \
simple, and Simplify finds no reason to change it.\
\>", "Text",
CellTags->"notes"],
Cell["Simplify[result,b>x]", "Input"],
Cell["\<\
Another function to consider in this situation is ComplexExpand, \
which will break this expression up into real and imaginary parts.\
\>", \
"Text",
CellTags->"notes"],
Cell["ComplexExpand[result]", "Input"],
Cell["\<\
You can combine transformations now to get a result which may be \
useful, since it does contain the result Log[b-x] that we want, and the rest \
is obviously a constant and can be considered as the constant of integration.\
\
\>", "Text",
CellTags->"notes"],
Cell["Simplify[ComplexExpand[result],b>x]", "Input"],
Cell["\<\
Another way to get this result is to tell Simplify not to use its \
default notion of what is simple but to instead program your own definition \
of \"simple\". You can program your own definition of \"simple\" and pass \
that definition to Simplify using the ComplexityFunction option. This \
definition says that the simpleness of an expression p is the number of \
leaves in the expression plus 100 multiplied by the number of times that -b+x \
occurs. This is a programmatic way of instructing Simplify to do whatever it \
has to do to get rid of -b+x.\
\>", "Text",
CellTags->"notes"],
Cell["\<\
MyDefinitionOfSimple[p_]:=LeafCount[p]+100Count[p,-b+x]\
\>", \
"Input"],
Cell["\<\
This will get a result with Log[b-x] plus a constant, which is \
about as close as we can realistically get to the original objective, which \
was to just get Log[b-x] as the result.\
\>", "Text",
CellTags->"notes"],
Cell["\<\
Simplify[result,b>x,ComplexityFunction->MyDefinitionOfSimple]\
\>", \
"Input"],
Cell["Clear result before moving on.", "Text",
CellTags->"notes"],
Cell["Clear[result]", "Input"],
Cell[TextData[{
"Some conclusions about getting symbolic results into particular forms:\n\
Getting results into a particular form is straightforward if the form that \
you want corresponds to a form generated by a standard function, especially a \
standard polynomial operation, such as full expanded or fully factors. \
Conversely, getting a result into any other form can be very difficult, and \
perhaps not worth the effort.\nSecond, Simplify and FullSimplify are among \
the few functions in the current version of ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" that take assumptions about parameters, which can be very useful.\nAnd \
finally, although Simplify and FullSimplify are wonderful functions, keep in \
mind that these functions work by applying a long list of transformations and \
using the simplest result, and that process can be very time consuming and \
can use a lot of memory if some of those transformations are time-consuming \
or use a lot of memory."
}], "Text",
ParagraphIndent->24,
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Suggestions about simplification", "Subsection"],
Cell["\<\
Simplification is easiest if the form you want corresponds to a \
standard polynomial form or a form generated by a standard function\
\>", \
"BulletItem"],
Cell[TextData[{
StyleBox["Simplify",
FontFamily->"Courier",
FontWeight->"Bold"],
" and ",
StyleBox["FullSimplify",
FontFamily->"Courier",
FontWeight->"Bold"],
" can be used for simplification that depends on properties of parameters."
}], "BulletItem"],
Cell[TextData[{
StyleBox["Simplify",
FontFamily->"Courier",
FontWeight->"Bold"],
" and ",
StyleBox["FullSimplify",
FontFamily->"Courier",
FontWeight->"Bold"],
" can require much more time and memory than a function chosen to perform a \
specific simplification"
}], "BulletItem"]
}, Open ]],
Cell[TextData[{
"Another important area of symbolic computation is symbolic calculus. Here \
are some of the functions that are included with ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" for symbolic calculus. In most cases these functions pretty much do what \
you would expect them to do, and you can just look them up in the \
documentation and type in your example."
}], "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Symbolic calculus", "Subsection"],
Cell[BoxData[
StyleBox[GridBox[{
{"D", "Derivative"},
{"Integrate", "FourierTransform"},
{"Series", "LaplaceTransform"},
{"Limit", "ZTransform"},
{"DSolve", "DiracDelta"}
},
ColumnAlignments->{Left}],
FontWeight->"Bold"]], "Text"]
}, Open ]],
Cell["\<\
For example, here is an input that computes a symbolic derivative \
using the D function.\
\>", "Text",
CellTags->"notes"],
Cell["D[x Cos[x],x]", "Input"],
Cell["\<\
For functions that are unknown or that are not differentiable like \
Abs[x] the result is represented using Derivative, which is formatted with \
the prime notation that you see here.\
\>", "Text",
CellTags->"notes"],
Cell["D[Abs[x],x]", "Input"],
Cell[TextData[{
"You can see Derivative more explicitly by using FullForm, which tells ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" not to use any special notations in displaying the result. This is the \
notation that you would use if you wanted to enter your ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" inputs using nothing but letters, numbers, commas, and square brackets. \
This means the first derivative of a function Abs with respect to its first \
argument and evaluated at x."
}], "Text",
CellTags->"notes"],
Cell["FullForm[D[Abs[x],x]]", "Input"],
Cell[TextData[{
"Here is an integral. Notice that this particular result does not exclude \
the possibility that b is minus one. The Integrate function is designed like \
the Solve function and most other functions in ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" to assume generic values of the parameters, and usually does not check \
for values that might be pathological."
}], "Text",
CellTags->"notes"],
Cell["Integrate[x^b,x]", "Input"],
Cell["\<\
Here is an example where Solve does something similar. This result \
does not allow for the possibility that b might be zero.\
\>", "Text",
CellTags->"notes"],
Cell["Solve[b x==1,x]", "Input"],
Cell["\<\
Some definite integrations will, however, report inequality \
assumptions about parameters. Here is a definite integral where the result is \
returned using an If expression.\
\>", "Text",
CellTags->"notes"],
Cell["Integrate[Exp[-b x],{x,0,Infinity}]", "Input"],
Cell["\<\
Definite integration is another operation like Simplify and \
FullSimplify that allows you to specify assumptions about parameters, except \
that in Integrate this is done using an option.\
\>", "Text",
CellTags->"notes"],
Cell["Integrate[Exp[-b x],{x,0,Infinity},Assumptions->(b>0)]", "Input"],
Cell[TextData[{
"There are many other symbolic calculations that you can do using ",
StyleBox["Mathematica",
FontSlant->"Italic"],
". Whether or not ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" will be able to do a calculation you want to do usually depends on \
whether or not there is an algorithm to do it. Getting results into a \
particular form is an example of something that is very difficult to do \
because there isn't an algorithm to do it. There are many functions, however, \
where there are algorithms even though those algorithms may not be widely \
known."
}], "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Other symbolic algebra", "Subsection"],
Cell["\<\
The existence of a function or package to do something depends \
mostly on whether or not there is a general computer algorithm to do \
it.\
\>", "Text"]
}, Open ]],
Cell["\<\
For example, there is an algorithm for solving certain classes of \
recursion relations. To get the functions that do that it is necessary to \
load a package. This is the notation for loading a package called \
DiscreteMath RSolve. There will be a separate discussion later about what a \
package is and about this notation and what it means to load a package.\
\>", \
"Text",
CellTags->"notes"],
Cell["<", "Text",
CellTags->"notes"],
Cell["RSolve[{b x[n]==x[n-1]+1,x[0]==a},x[n],n]", "Input"],
Cell["\<\
Another interesting package is that InequalitySolve package which \
defines functions for solving inequalities. Again, it turns out that there is \
an algorithm to do this type of calculation.\
\>", "Text",
CellTags->"notes"],
Cell["<", "Text",
CellTags->"notes"],
Cell["InequalitySolve[Abs[x^2+1]>3,x]", "Input"],
Cell["\<\
The next topic is linear algebra, which was mentioned earlier. Most \
of what I want to say about linear algebra here has to do with symbolic \
linear algebra.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Tour of Mathematica", "Section"],
Cell["System organization", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Symbolic calculations", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Linear algebra", "Contents",
CellDingbat->"\[FilledCircle]"],
Cell["Numerical computation", "Contents"],
Cell["Graphics", "Contents"],
Cell["External files", "Contents"],
Cell[TextData[StyleBox["MathLink",
FontSlant->"Italic"]], "Contents"]
}, Open ]],
Cell["\<\
Vectors and matrices can be constructed using Table and \
Array.\
\>", "Text",
CellTags->"notes"],
Cell["Constructing matrices", "Subsection"],
Cell["\<\
For example, this input generates a 3 by 3 matrix of random \
numbers.\
\>", "Text",
CellTags->"notes"],
Cell["Table[Random[],{3},{3}]", "Input"],
Cell["\<\
The functionality of Array can be seen in a simple example. This \
input constructs a matrix in which the elements are of the form b[i,j].\
\>", \
"Text",
CellTags->"notes"],
Cell["Array[b,{3,3}]", "Input"],
Cell["This same result can also be constructed using Table.", "Text",
CellTags->"notes"],
Cell["Table[b[i,j],{i,1,3},{j,1,3}]", "Input"],
Cell[TextData[{
"Here are some of the functions that are available for working with \
matrices in ",
StyleBox["Mathematica",
FontSlant->"Italic"],
". This is the same list as was shown in the introduction segment."
}], "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Matrix functions", "Subsection"],
Cell[TextData[Cell[BoxData[GridBox[{
{"Eigenvalues", "Eigenvectors"},
{"Eigensystem", "SchurDecomposition"},
{"LinearSolve", "QRDecomposition"},
{"Det", "CholeskyDecomposition"},
{"MatrixExp", "LUDecomposition"},
{"MatrixPower", "LUBackSubstitution"},
{"Tr", "SingularValues"},
{"Transpose", "JordanDecomposition"},
{"Inverse", "PseudoInverse"}
}]],
GridBoxOptions->{ColumnAlignments->{Left}}]], "Text",
FontWeight->"Bold"]
}, Open ]],
Cell[TextData[{
"Most of the functions that operate on matrices in ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" work for symbolic matrices as well as for numerical matrices. Symbolic \
results are often convenient, but symbolic matrix computations can require a \
large amount of time and memory."
}], "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Symbolic linear algebra", "Subsection"],
Cell["\<\
Symbolic results are often convenient, but can be computationally \
demanding.\
\>", "Text"]
}, Open ]],
Cell["\<\
To illustrate that, here is an input that constructs a general 2 by \
2 matrix and computes the inverse of that matrix.\
\>", "Text",
CellTags->"notes"],
Cell["Inverse[Array[b,{2,2}]]", "Input"],
Cell["\<\
This does the same calculation for a general 3 by 3 symbolic \
matrix.\
\>", "Text",
CellTags->"notes"],
Cell["Inverse[Array[b,{3,3}]]", "Input"],
Cell["\<\
Since I am not really interested here in the actual result, but \
only in the size of the result, I can used ByteCount to estimate the number \
of bytes used to store the expression.\
\>", "Text",
CellTags->"notes"],
Cell["ByteCount[Inverse[Array[b,{3,3}]]]", "Input"],
Cell["Here is that result for a 4 by 4 matrix.", "Text",
CellTags->"notes"],
Cell["ByteCount[Inverse[Array[b,{4,4}]]]", "Input"],
Cell["Here is that result for a 5 by 5 matrix.", "Text",
CellTags->"notes"],
Cell["ByteCount[Inverse[Array[b,{5,5}]]]", "Input"],
Cell["\<\
Here is a useful and very general technique for estimating the \
amount of memory that might be required to store the result for the inverse \
of a large matrix. This input uses the Table function to generate a list of \
results, and each result give the size of the matrix and uses the ByteCount \
function to show the amount of memory used to store the inverse. By studying \
this result we can see that the memory requirement grows by about a factor of \
10 for each step in the size of the matrix, and that the inverse of a general \
6 by 6 matrix already uses about ten megabytes of memory.
From this result one can correctly conclude that the practical limit to \
general operations on symbolic matrices is matrices with dimension about 6 by \
6, which is not a very big matrix in practical calculations, where people \
routinely need to work with matrices more like a thousand by a thousand with \
a million elements.\
\>", "Text",
ParagraphIndent->24,
CellTags->"notes"],
Cell["Table[{k,ByteCount[Inverse[Array[b,{k,k}]]]},{k,6}]", "Input"],
Cell["\<\
Another important topic that I will mention just briefly so that \
you will know that the functions are there are functions for discrete Fourier \
transform using the FFT algorithm. The functions are Fourier and \
InverseFourier.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Discrete Fourier transforms", "Subsection"],
Cell[TextData[Cell[BoxData[GridBox[{
{"Fourier"},
{"InverseFourier"}
}]],
GridBoxOptions->{ColumnAlignments->{Left}}]], "Text",
FontWeight->"Bold"]
}, Open ]],
Cell["\<\
Here is an example showing Fourier to compute the discrete Fourier \
transform of a list of real numbers.\
\>", "Text",
CellTags->"notes"],
Cell["ft=Fourier[{1.7,2.3,5.8,2.5,1.0}]", "Input"],
Cell["\<\
And here is the corresponding inverse discrete Fourier transform \
which returns the original list, or more generally, since this is a numerical \
operation with inexact numbers, it will return the original list to within \
numerical error.\
\>", "Text",
CellTags->"notes"],
Cell["InverseFourier[ft]", "Input"],
Cell["\<\
Having explained that symbolic linear algebra is sometimes \
impractical except for relatively small matrices, the obvious question is \
what to do about that. One solution of course is to use numerical \
methods.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Tour of Mathematica", "Section"],
Cell["System organization", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Symbolic calculations", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Linear algebra", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Numerical computation", "Contents",
CellDingbat->"\[FilledCircle]"],
Cell["Graphics", "Contents"],
Cell["External files", "Contents"],
Cell[TextData[StyleBox["MathLink",
FontSlant->"Italic"]], "Contents"]
}, Open ]],
Cell["\<\
To quantify the comparison of symbolic and numerical calculations, \
here is an example comparing time and memory requirements for symbolic and \
numerical matrix inverse.\
\>", "Text",
CellTags->"notes"],
Cell["Numeric and symbolic matrices", "Subsection"],
Cell["\<\
First time and get the memory requirement using the Timing and \
ByteCount functions for the inverse of a 270 by 270 random matrix.\
\>", \
"Text",
CellTags->"notes"],
Cell["Timing[ByteCount[Inverse[Table[Random[],{270},{270}]]]]", "Input"],
Cell["\<\
Roughly the same amount of time and about 20 times as much memory \
is used for computing the inverse of a 6 by 6 matrix. It is not uncommon to \
be able to do a numerical computation millions of times over with less time \
and memory than is required to do a symbolic computation once. Symbolic \
linear algebra is still useful, but time and memory requirements are the main \
limitations.\
\>", "Text",
CellTags->"notes"],
Cell["Timing[ByteCount[Inverse[Array[b,{6,6}]]]]", "Input"],
Cell["\<\
What I would mainly like to discuss under numerical computation is \
not numerical linear algebra but numerical operations on functions. Many \
symbolic functions have numerical counterparts. The ND function is used for \
numerical differentiation, the NIntegrate function is used for numerical \
integration, and so forth.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Numerical operations", "Subsection"],
Cell[BoxData[
StyleBox[GridBox[{
{"ND", "NIntegrate"},
{"NLimit", "FindRoot"},
{"FindMinimum", "NDSolve"},
{"NSum", "NProduct"}
},
ColumnAlignments->{Left}],
FontWeight->"Bold"]], "Text"]
}, Open ]],
Cell["\<\
Here for example is a numerical integral using NIntegrate, which \
uses the same syntax as the corresponding symbolic integral using \
Integrate.\
\>", "Text",
CellTags->"notes"],
Cell["NIntegrate[Exp[-x Cos[x]],{x,0,10}]", "Input"],
Cell["\<\
Numerical root finding can be done using the FindRoot \
function.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Numerical solutions of equations", "Subsection"],
Cell[BoxData[
\(FindRoot\)], "Input",
Evaluatable->False]
}, Open ]],
Cell["The result is returned as a list of rules.", "Text",
CellTags->"notes"],
Cell["solution=FindRoot[Exp[x]==4 Sin[x],{x,0}]", "Input"],
Cell["\<\
You can pick out the value of x by applying the solution as a \
replacement to x.\
\>", "Text",
CellTags->"notes"],
Cell["x/.solution", "Input"],
Cell["\<\
If you want to assign this result as the value of something, you \
can put this replacement operation on the right side of an assignment. This \
input assigns the value of x at the solution as the value of a variable xval.\
\
\>", "Text",
CellTags->"notes"],
Cell["xval=x/.solution", "Input"],
Cell["\<\
You can even assign this value as the value of x, although that \
would lead to obvious problems if you later try to use x as a variable again.\
\
\>", "Text",
CellTags->"notes"],
Cell["x=x/.solution", "Input"],
Cell["\<\
For example, the solution here is a rather peculiar replacement \
rule. The FindRoot function used a different starting value for x, and so \
converged to a different root. The assigned value of x was inserted on the \
left side of the rule.\
\>", "Text",
CellTags->"notes"],
Cell["FindRoot[Exp[x]==4 Sin[x],{x,1}]", "Input"],
Cell["\<\
To avoid similar problems like this, I will clear x before moving \
on.\
\>", "Text",
CellTags->"notes"],
Cell["Clear[x,xval]", "Input"],
Cell["\<\
Numerical minimization can be done using a function called \
FindMinimum.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Minimization", "Subsection"],
Cell[BoxData[
\(FindMinimum\)], "Input",
Evaluatable->False]
}, Open ]],
Cell["\<\
Here is an example showing the use of FindMinimum. The result is a \
list that gives the value of the function at the minimum and a list of rules \
giving the values of the variables at that minimum.\
\>", "Text",
CellTags->"notes"],
Cell["FindMinimum[Sin[x] Cos[y],{x,1},{y,1}]", "Input"],
Cell["\<\
Numerical approximation can be done using the NSum function, and \
numerical products can be computed using NProduct.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Numerical sums and products", "Subsection"],
Cell[TextData[Cell[BoxData[GridBox[{
{"NSum"},
{"NProduct"}
}]],
GridBoxOptions->{ColumnAlignments->{Left}}]], "Text",
FontWeight->"Bold"]
}, Open ]],
Cell["\<\
Here is an example showing a use of NSum to do an infinite \
sum.\
\>", "Text",
CellTags->"notes"],
Cell["NSum[Exp[-n],{n,0,Infinity}]", "Input"],
Cell["\<\
This sum can also be evaluated symbolically, since it is just a \
simple geometric sum.\
\>", "Text",
CellTags->"notes"],
Cell["expr=Sum[Exp[-n],{n,0,Infinity}]", "Input"],
Cell["\<\
The symbolic and numeric results can be compared by computing a \
numerical approximation for the exact result using the N function.\
\>", \
"Text",
CellTags->"notes"],
Cell["N[expr]", "Input"],
Cell["Clear expr before moving on.", "Text",
CellTags->"notes"],
Cell["Clear[expr]", "Input"],
Cell[TextData[{
"You can also do linear programming in ",
StyleBox["Mathematica",
FontSlant->"Italic"],
", which means constrained minimization of a linear function subject to \
linear constraints. There is a well-known algorithm called a simplex \
algorithm for solving this problem, which is implemented in ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" in the functions ConstrainedMin, ConstrainedMax, and LinearProgramming, \
all of which access exactly the same internal algorithm.\nThere is not a \
built-in function in ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" for constrained nonlinear optimization. There are third-party packages \
that will do this."
}], "Text",
ParagraphIndent->24,
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Linear programming", "Subsection"],
Cell[TextData[Cell[BoxData[GridBox[{
{"ConstrainedMin"},
{"ConstrainedMax"},
{"LinearProgramming"}
}]],
GridBoxOptions->{ColumnAlignments->{Left}}]], "Text",
FontWeight->"Bold"]
}, Open ]],
Cell["\<\
Here is an example showing the use of ConstrainedMin. The first \
argument is the linear function to minimize, the second argument gives the \
linear constraints in terms of inequalities, and the last argument is a list \
of the variables. All of these inputs can also be specified as coefficient \
matrices. The LinearProgramming function takes coefficient matrices instead \
of functions and inequalities with the variables given explicitly, but \
otherwise does the same calculation.\
\>", "Text",
CellTags->"notes"],
Cell["\<\
ConstrainedMin[x + y - 3 z,
{x < y, 2 z < 3 x, x < 4},
{x, y, z}]\
\>", "Input"],
Cell[TextData[{
"The most elaborate numerical function in ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" is NDSolve, which is the function that constructs numerical solution of \
differential equations. The NDSolve function can do initial value problems, \
some boundary value problems, and partial differential equations in 2 \
variables, (or 1+1 variables)."
}], "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Differential equations", "Subsection"],
Cell[TextData[{
StyleBox["NDSolve",
FontFamily->"Courier",
FontWeight->"Bold"],
" provides solvers for"
}], "Text"],
Cell["Initial value problems", "BulletText"],
Cell["Boundary value problems", "BulletText"],
Cell["Partial differential equations", "BulletText"]
}, Open ]],
Cell["\<\
Here is an example showing the use of NDSolve to solve an initial \
value problem. You may recognize this pair of differential equations as a \
simple harmonic oscillator.\
\>", "Text",
CellTags->"notes"],
Cell["NDSolve example", "Subsection"],
Cell["\<\
The first argument is a list of equations giving the differential \
equations and the initial values. Here there are two differential equations \
and two initial values. Derivatives are entered using prime notation, so, for \
example, f'[x] denotes the first derivative of a function f. The second \
argument lists the two functions to solve for, and the last argument is a \
list giving the independent variable and the range of the independent \
variable. The result, as with the result from Solve, is a list of solutions \
and each solution is a list of rules. The right side of each rule is an \
InterpolatingFunction expression that represents the solution. In this \
example there is only one solution, and that solution involves rules for the \
two functions f and g.\
\>", "Text",
CellTags->"notes"],
Cell["\<\
sol = NDSolve[
{f'[x] + g[x] == 0,
g'[x] == f[x], f[0] == 0,
g[0] == 1}, {f, g},
{x, 0, 10}]\
\>", "Input"],
Cell["\<\
This result can be used much like the results from Solve, except \
that now the solutions are functions rather than numbers or simple \
expressions. For example, this input gives the value of f[5].\
\>", "Text",
CellTags->"notes"],
Cell["f[5]/.sol", "Input"],
Cell["\<\
That result is a list containing a number rather than a number \
because I applied all of the solutions to f[5], rather than the first (and \
only) solution. This picks out just the one solution, so the result is a \
number.\
\>", "Text",
CellTags->"notes"],
Cell["f[5]/.sol[[1]]", "Input"],
Cell["This plots the solution function f.", "Text",
CellTags->"notes"],
Cell["Plot[f[x]/.sol[[1]],{x,0,10}]", "Input"],
Cell["\<\
This plots both f and g. If you interpret this as describing a \
simple harmonic oscillatory, then f could be the position and g could be the \
velocity.\
\>", "Text",
CellTags->"notes"],
Cell["Plot[{f[x]/.sol[[1]],g[x]/.sol[[1]]},{x,0,10}]", "Input"],
Cell["\<\
That is the end of the mathematical part of the tour. The next \
topic is graphics.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Tour of Mathematica", "Section"],
Cell["System organization", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Symbolic calculations", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Linear algebra", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Numerical computation", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Graphics", "Contents",
CellDingbat->"\[FilledCircle]"],
Cell["External files", "Contents"],
Cell[TextData[StyleBox["MathLink",
FontSlant->"Italic"]], "Contents"]
}, Open ]],
Cell["\<\
We saw this list of plotting functions earlier in the introduction.\
\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Plotting", "Subsection"],
Cell[TextData[Cell[BoxData[GridBox[{
{"Plot", "Plot3D"},
{"ContourPlot", "DensityPlot"},
{"ParametricPlot", "ParametricPlot3D"},
{"LogPlot", "LogLinearPlot"},
{"LogLogPlot", "PolarPlot"}
}]],
GridBoxOptions->{ColumnAlignments->{Left}}]], "Text",
FontWeight->"Bold"]
}, Open ]],
Cell["\<\
Here is a contour plot, using syntax which follows the same pattern \
as related functions. The point I wanted to add here is that plotting \
functions are essentially numerical functions. ContourPlot works by \
evaluating the function on a 15 by 15 grid and then drawing contours as best \
as it can through those points. Most of the jaggedness that you see in this \
plot comes from the fact that the underlying grid is actually fairly course. \
There are features of this function that change on a scale smaller than you \
get from a 15 by 15 grid.\
\>", "Text",
CellTags->"notes"],
Cell[BoxData[
\(SetOptions[ContourPlot, ImageSize \[Rule] {150, 150}];
SlideShow`NextSlide[True];\)], "Input",
CellTags->"evaluate"],
Cell["ContourPlot[Sin[x y],{x,0,4},{y,0,4}]", "Input"],
Cell["\<\
The number of grid points is controlled by the value of the \
PlotPoints option. The default value is 15.\
\>", "Text",
CellTags->"notes"],
Cell["Options[ContourPlot,PlotPoints]", "Input"],
Cell["\<\
Here is a plot of the same function but with a higher resolution.\
\
\>", "Text",
CellTags->"notes"],
Cell[BoxData[
\(SetOptions[ContourPlot, ImageSize \[Rule] {150, 150}];
SlideShow`NextSlide[True];\)], "Input",
CellTags->"evaluate"],
Cell["ContourPlot[Sin[x y],{x,0,4},{y,0,4},PlotPoints->50]", "Input"],
Cell["\<\
The other point I wanted to add here about plotting and graphics is \
that, to construct a plot, after starting with data or computed points on a \
function, the graphics expression is constructed from graphics primitives, \
graphics directives, and graphics options.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Graphics expressions", "Subsection"],
Cell["\<\
Graphics expressions are constructed from graphics primitives, \
graphics directives, and graphics options.\
\>", "Text"]
}, Open ]],
Cell["\<\
To illustrate how all of these things work together, here is a \
typical graphics expression, which has a head of Graphics, a Line primitive \
that draws one line, a Thickness directive to make all subsequent lines \
thicker, another Line primitive, and finally the option Axes->True to draw \
axes on the plot.\
\>", "Text",
CellTags->"notes"],
Cell[BoxData[
\(Graphics[{Line[{{0, 0}, {2, 2}}], Thickness[0.025],
Line[{{0, 1}, {2, 1}}]}, Axes \[Rule] True]\)], "Input"],
Cell[TextData[{
"The Show function can be used to generate an image corresponding to this \
graphics expression. This same structure is used for all graphical output in \
",
StyleBox["Mathematica",
FontSlant->"Italic"],
". The output is a Graphics expressions which displays as dash Graphics \
dash, but that is just the display form."
}], "Text",
CellTags->"notes"],
Cell[BoxData[
\(SelectionMove[SlideShow`source, Next, Cell];
FrontEndExecute[{FrontEndToken[SlideShow`source, "\"],
FrontEndToken[SlideShow`nb, "\"]}];
SelectionMove[SlideShow`nb, Previous, Cell];\)], "Input",
CellTags->"evaluate"],
Cell[BoxData[
\(Show[
Graphics[{Line[{{0, 0}, {2, 2}}], Thickness[0.025],
Line[{{0, 1}, {2, 1}}]}, Axes \[Rule] True]]\)], "Input"],
Cell[BoxData[
\(FrontEndExecute[FrontEndToken[SlideShow`nb, "\"]];
SelectionMove[SlideShow`source, Next, Cell];
FrontEndExecute[
FrontEndToken[SlideShow`source, "\"]]\)], "Input",
CellTags->"evaluate"],
Cell[BoxData[
\(Do[FrontEndExecute[
FrontEndToken[SlideShow`nb, "\"]], {3}]\)], "Input",
CellTags->"evaluate"],
Cell["\<\
Here first are some graphics primitives.Graphics primitives are \
expressions based on Line or Point or Polygon that generates geometric \
elements of the plot.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Graphics primitives", "Subsection"],
Cell[BoxData[GridBox[{
{"Line", "Circle", "Cuboid"},
{"Point", "Text", "Rectangle"},
{"Polygon", "Disk", "Raster"},
{"RasterArray", "PostScript", "Text"}
},
ColumnAlignments->{Left}]], "Text",
Evaluatable->False,
FontWeight->"Bold"]
}, Open ]],
Cell["\<\
Graphics directives are expressions based on items from this list, \
that specify the color of lines or points or polygons, the size of points, \
the thickness of lines, and so forth.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Graphics directives", "Subsection"],
Cell[BoxData[GridBox[{
{"GrayLevel", "CMYKColor"},
{"Hue", "Thickness"},
{"RGBColor", "PointSize"},
{"SurfaceColor", "FaceForm"},
{"EdgeForm", "StyleForm"},
{"Dashing", "AbsoluteThickness"},
{"AbsoluteDashing", "AbsolutePointSize"}
},
ColumnAlignments->{Left}]], "Text",
Evaluatable->False,
FontWeight->"Bold"]
}, Open ]],
Cell["\<\
Graphics options control a variety of characteristics of the \
plotting process. Some of graphics options we've already seen. Here are some \
frequently-used graphics options.\
\>", "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Graphics options", "Subsection"],
Cell[BoxData[GridBox[{
{"PlotPoints", "PlotJoined"},
{"PlotStyle", "Ticks"},
{"Axes", "AxesLabel"},
{"Frame", "FrameLabel"},
{"GridLines", "PlotRange"},
{"DefaultFont", "Epilog"}
},
ColumnAlignments->{Left}]], "Text",
Evaluatable->False,
FontWeight->"Bold"]
}, Open ]],
Cell["\<\
There are a variety of situations in which you might want to \
construct graphics expressions or parts of graphics expressions \
directly.\
\>", "Text",
CellTags->"notes"],
Cell["Drawing", "Subsection"],
Cell[TextData[{
"The illustrating from the beginning of this presentation was constructed \
using ",
StyleBox["Mathematica",
FontSlant->"Italic"],
". Constructing a drawing like this, although possible, can be fairly \
time-consuming. Future versions of ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" are expected to include more sophisticated features for interactive \
graphics."
}], "Text",
CellTags->"notes"],
Cell[BoxData[
\(\(Block[{inlevel, outlevel, fef, fe, kf, k, sh, s, pi, po, in, result,
as, ra, la, g},
inlevel = 1.5; \[IndentingNewLine]outlevel =
0.9; \[IndentingNewLine]fef =
Line[{{0, 0.2}, {0, 2.2}, {3, 2.2}, {3, 0.2}, {0,
0.2}}]; \[IndentingNewLine]fe =
Text[StyleForm["\",
FontFamily \[Rule] "\",
FontSize \[Rule] 14], {1.5, \(- .2\)}]; \[IndentingNewLine]kf =
Circle[{5.6, 1.3}, {1.2, 1}]; \[IndentingNewLine]k =
Text[StyleForm["\", FontFamily \[Rule] "\",
FontSize \[Rule] 14], {5.6, \(- .1\)}]; \[IndentingNewLine]sh =
1.25; \[IndentingNewLine]s = {Text[
StyleForm["\< 2\n+ 2\n\n 4\>", \[IndentingNewLine]FontFamily \
\[Rule] "\", FontSize \[Rule] 12,
FontWeight \[Rule] "\"], {5.8, sh}], {Thickness[
0.004],
Line[{{5.55, sh - 0.15}, {6.03,
sh - 0.15}}]}}; \[IndentingNewLine]pi =
Text[StyleForm["\", FontFamily \[Rule] "\",
FontColor \[Rule] RGBColor[0, 0, 1]], {0.6,
inlevel}]; \[IndentingNewLine]po =
Text[StyleForm["\", FontFamily \[Rule] "\",
FontColor \[Rule] RGBColor[0, 0, 1]], {0.6,
outlevel}]; \[IndentingNewLine]in =
Text[StyleForm["\<2\[ThinSpace]+\[ThinSpace]2\>",
FontSize \[Rule] 12, FontFamily \[Rule] "\",
FontWeight \[Rule] "\"], {1.4,
inlevel}]; \[IndentingNewLine]result =
Text[StyleForm["\<4\>", FontSize \[Rule] 12,
FontFamily \[Rule] "\"], {1.2,
outlevel}]; \[IndentingNewLine]as =
0.14; \[IndentingNewLine]ra = {Line[{{2.2, inlevel}, {5.1 - as,
inlevel}}],
Polygon[{{5.1 - as, inlevel + as}, {5.1 + as,
inlevel}, {5.1 - as, inlevel - as}}],
Text[StyleForm["\ ", FontFamily \[Rule] "\",
FontSize \[Rule] 12], {3.7,
inlevel + 0.25}]}; \[IndentingNewLine]la = {Line[{{2.0 + as,
outlevel}, {5.3, outlevel}}],
Polygon[{{2.0 + as, outlevel + as}, {2.0 - as,
outlevel}, {2.0 + as, outlevel - as}}],
Text[
StyleForm["\", FontFamily \[Rule] "\",
FontSize \[Rule] 12], {3.7,
outlevel + 0.25}]}; \[IndentingNewLine]g =
Graphics[
Rectangle[{0, 0}, {1, 1},
Graphics[{Thickness[0.01], fe, fef, k, kf, Thickness[0.008], s,
pi, po, in, result, ra, la}, AspectRatio \[Rule] 0.3]],
AspectRatio \[Rule] 0.3]; \[IndentingNewLine]NotebookWrite[
SlideShow`nb,
Cell[GraphicsData["\",
DisplayString[g]]]]];\)\)], "Input",
CellTags->"evaluate"],
Cell[TextData[{
StyleBox["Mathematica",
FontSlant->"Italic"],
" is an ideal system, however, for generating images that originate with \
data, or for images that are generated by computation. See the Graphics \
Gallery in The ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" Book for examples."
}], "Text",
CellTags->"notes"],
Cell[BoxData[
\(HelpBrowserLookup["\", "\"]\)], "Input",
CellTags->"evaluate"],
Cell[BoxData[
\(HelpBrowserLookup["\", "\"]\)], "Input",
CellTags->"evaluate"],
Cell[BoxData[
\(SetSelectedNotebook[SlideShow`notes];
SetSelectedNotebook[SlideShow`nb];\)], "Input",
CellTags->"evaluate"],
Cell[TextData[{
"The next topic on this tour is a discussion of external files, such as \
will be of interest if you want to read data files in to ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" or write data out from ",
StyleBox["Mathematica",
FontSlant->"Italic"],
". The central comment I wanted to make here is the relationship between \
this functionality and the next topic, which is ",
StyleBox["MathLink",
FontSlant->"Italic"],
"."
}], "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Tour of Mathematica", "Section"],
Cell["System organization", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Symbolic calculations", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Linear algebra", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Numerical computation", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Graphics", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["External files", "Contents",
CellDingbat->"\[FilledCircle]"],
Cell[TextData[StyleBox["MathLink",
FontSlant->"Italic"]], "Contents"]
}, Open ]],
Cell[TextData[{
"Here are some of the functions that are available for reading and writing \
data and formatted files in ",
StyleBox["Mathematica",
FontSlant->"Italic"],
". The most general functions for reading and writing data, which can in \
principle be used to read or write any file format, are the first few \
functions on this list, like OpenWrite, which opens a file for writing, Write \
and WriteString, which writes information to that file, Read, which reads \
data elements from a file, and so forth."
}], "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["External files", "Subsection"],
Cell[BoxData[GridBox[{
{"OpenWrite", "OpenAppend"},
{"OpenRead", "Read"},
{"ReadList", "Write"},
{"WriteString", "Display"},
{"Put", "Save"},
{"PutAppend", "Get"},
{"Import", "Export"},
{"TeXSave", "HTMLSave"}
},
ColumnAlignments->{Left}]], "Text",
Evaluatable->False,
FontWeight->"Bold"]
}, Open ]],
Cell[TextData[{
"Here is a typical example of writing a number to a file and reading the \
number back in to ",
StyleBox["Mathematica",
FontSlant->"Italic"],
". First, open the file for writing. OpenWrite opens a stream to the file."
}], "Text",
CellTags->"notes"],
Cell["s=OpenWrite[\"file\"]", "Input"],
Cell["This writes a number to that stream.", "Text",
CellTags->"notes"],
Cell["Write[s,123.456]", "Input"],
Cell["This closes the stream.", "Text",
CellTags->"notes"],
Cell["Close[s]", "Input"],
Cell["This opens the stream to the file for reading.", "Text",
CellTags->"notes"],
Cell["s=OpenRead[\"file\"]", "Input"],
Cell["This reads a number from the stream.", "Text",
CellTags->"notes"],
Cell["Read[s,Number]", "Input"],
Cell[TextData[{
"This closes the stream to the file. This general strategy of opening, \
writing or reading, and closing files can be used with strings, numbers, ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" expressions, binary data, or any other file elements. The most difficult \
issue in many cases is getting a specification of the file format."
}], "Text",
CellTags->"notes"],
Cell["Close[s]", "Input"],
Cell["\<\
Working out how to read and write particular file formats can be \
laborious, which is why the functions Import and Export are included. These \
functions are already programmed to handle many common file formats.\
\>", \
"Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Special file formats", "Subsection"],
Cell[BoxData[GridBox[{
{"Import", "Export"},
{"TeXSave", "HTMLSave"}
},
ColumnAlignments->{Left}]], "Text",
Evaluatable->False,
FontWeight->"Bold"]
}, Open ]],
Cell[TextData[{
"Here is a list of the file formats that can be imported using Import in \
this version of ",
StyleBox["Mathematica",
FontSlant->"Italic"],
"."
}], "Text",
CellTags->"notes"],
Cell["$ImportFormats", "Input"],
Cell["\<\
And here is a list of the formats that can be exported. Included in \
these lists are graphics and image formats that would be difficult to read \
and write using lower-level functions.\
\>", "Text",
CellTags->"notes"],
Cell["$ExportFormats", "Input"],
Cell[TextData[{
"Finally, here are a few comments about ",
StyleBox["MathLink",
FontSlant->"Italic"],
", to illustrate the type of thing that you can do and roughly what is \
involved with using it, and to relate back to these functions for reading and \
writing files."
}], "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Tour of Mathematica", "Section"],
Cell["System organization", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Symbolic calculations", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Linear algebra", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Numerical computation", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["Graphics", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell["External files", "Contents",
CellDingbat->"\[EmptyCircle]"],
Cell[TextData[StyleBox["MathLink",
FontSlant->"Italic"]], "Contents",
CellDingbat->"\[FilledCircle]"]
}, Open ]],
Cell[TextData[{
"To illustrate a bit of how ",
StyleBox["MathLink",
FontSlant->"Italic"],
" works, I will here demonstrate setting up a link to an external program \
that has already been compiled as one of the examples that is included with \
",
StyleBox["Mathematica",
FontSlant->"Italic"],
"."
}], "Text",
CellTags->"notes"],
Cell[TextData[{
StyleBox["MathLink",
FontSlant->"Italic"],
" example"
}], "Subsection"],
Cell[TextData[{
"This input tries to open a link to a program called \"addtwo\", which is \
already compiled on this computer. The exact way that ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" finds the link works differently on different computers. On this \
computer, since this program isn't in the default path to look for programs \
to link, the computer asks me to find the file."
}], "Text",
CellTags->"notes"],
Cell["link=Install[\"addtwo\"]", "Input"],
Cell["\<\
This introduces a function called AddTwo that adds two \
numbers.\
\>", "Text",
CellTags->"notes"],
Cell["?AddTwo", "Input"],
Cell["For example.", "Text",
CellTags->"notes"],
Cell["AddTwo[4,7]", "Input"],
Cell[TextData[{
"The interesting part is to notice how this works. This function is calling \
an external compiled program to do the addition. You can see the rule that is \
invoked by using a double question mark, which works like the single question \
mark notation, except it reveals more information. Notice here that the \
definition of AddTwo involves functions like ExternalCall that perform the \
actions of writing arguments to the external program and reading the result \
from that program back in to ",
StyleBox["Mathematica",
FontSlant->"Italic"],
"."
}], "Text",
CellTags->"notes"],
Cell["??AddTwo", "Input"],
Cell[TextData[{
"An instructive way to demonstrate a bit more of what is going on here is \
to read and write information directly, rather than by calling the AddTwo \
function. To write information to the link to the external program, I use a \
function called LinkWrite. The CallPacket function is there because this \
particular external program was set up using a general mechanism that you can \
read about in the online ",
StyleBox["MathLink",
FontSlant->"Italic"],
" tutorial to take CallPacket expressions that contain the function \
arguments rather than just the function arguments 4 and 7. This is useful if \
the external program involves more than one function. The CallPacket \
expression tells the external program to which function the arguments should \
be passed. This particular external program only defines one function, so the \
CallPacket is unnecessary overhead included for the purpose of the example."
}], "Text",
CellTags->"notes"],
Cell["LinkWrite[link,CallPacket[0,{4,7}]]", "Input"],
Cell["\<\
Having written the function arguments to the link I can read the \
result back from the link using LinkRead.\
\>", "Text",
CellTags->"notes"],
Cell["LinkRead[link]", "Input"],
Cell["I can repeat that operation with different arguments.", "Text",
CellTags->"notes"],
Cell["LinkWrite[link,CallPacket[0,{1000,25}]]", "Input"],
Cell["and get another result.", "Text",
CellTags->"notes"],
Cell["LinkRead[link]", "Input"],
Cell["\<\
When I am finished with the external program, I can close the link \
and shut down the external program using LinkClose\
\>", "Text",
CellTags->"notes"],
Cell["LinkClose[link]", "Input"],
Cell[TextData[{
"To set up a ",
StyleBox["MathLink",
FontSlant->"Italic"],
" connection to an external program you typically need three things. The \
first is ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" and ",
StyleBox["MathLink",
FontSlant->"Italic"],
" which is easy if you have ",
StyleBox["Mathematica",
FontSlant->"Italic"],
", because ",
StyleBox["MathLink",
FontSlant->"Italic"],
" is included with ",
StyleBox["Mathematica",
FontSlant->"Italic"],
". The second is a C-language interface to the other program. If you want \
to connect to a spreadsheet program, for example, you would need to figure \
out the C-language interface to that other program -- that is, how the other \
program communicates with C programs. The third is a C compiler, and \
knowledge of how to use it. This isn't needed if the program to which you \
want to connect is already set up, as in my example, but it is needed \
otherwise.\nIn the overwhelming majority of cases, the most difficult items \
are the second two, which do not relate directly to ",
StyleBox["Mathematica",
FontSlant->"Italic"],
". The need take the time to figure out ",
StyleBox["MathLink",
FontSlant->"Italic"],
" and a C-language interface to another program and a C compiler, even \
though all of those things may be simple, so probably the biggest obstacle to \
writing ",
StyleBox["MathLink",
FontSlant->"Italic"],
" programs."
}], "Text",
ParagraphIndent->24,
CellTags->"notes"],
Cell[CellGroupData[{
Cell[TextData[{
"Setting up ",
StyleBox["MathLink",
FontSlant->"Italic"],
" connections"
}], "Subsection"],
Cell[TextData[{
StyleBox["Mathematica",
FontSlant->"Italic"],
" and ",
StyleBox["MathLink",
FontSlant->"Italic"]
}], "BulletItem"],
Cell["A C-language interface to the external program", "BulletItem"],
Cell["A compiler", "BulletItem"]
}, Open ]],
Cell[TextData[{
"And finally I wanted to relate this back to the earlier topic of reading \
and writing files. You can exchange information with other programs using ",
StyleBox["MathLink",
FontSlant->"Italic"],
" or through files. Some people have wondered, for example, if they \
absolutely need ",
StyleBox["MathLink",
FontSlant->"Italic"],
" in order to get data from an spreadsheet or database in to ",
StyleBox["Mathematica",
FontSlant->"Italic"],
", and the answer is no. If you want to exchange information on the fly or \
if you want other conveniences of a direct connection, then ",
StyleBox["MathLink",
FontSlant->"Italic"],
" is useful, but you can still write data to a file from ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" and read it in to the other program, or write data from the other program \
in to ",
StyleBox["Mathematica",
FontSlant->"Italic"],
", without using ",
StyleBox["MathLink",
FontSlant->"Italic"],
"."
}], "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell["Communication with external programs", "Subsection"],
Cell[TextData[{
"You can call external programs from ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" using ",
StyleBox["MathLink",
FontSlant->"Italic"]
}], "BulletItem"],
Cell[TextData[{
"You can use ",
StyleBox["MathLink",
FontSlant->"Italic"],
" to call ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" from an external program"
}], "BulletItem"],
Cell[TextData[{
"Programs can also exchange information through files, without using ",
StyleBox["MathLink",
FontSlant->"Italic"]
}], "BulletItem"]
}, Open ]]
},
FrontEndVersion->"4.0 for Macintosh",
ScreenRectangle->{{0, 1024}, {0, 748}},
AutoGeneratedPackage->None,
ScreenStyleEnvironment->"WorkingSlides",
CellGrouping->Manual,
WindowSize->{638, 675},
WindowMargins->{{Automatic, 111}, {8, Automatic}},
WindowTitle->"Source for Tour of Mathematica",
ShowCellTags->True,
Magnification->1,
StyleDefinitions -> "Training.nb",
MacintoshSystemPageSetup->"\<\
AVU/I@1804P000000b@^4?oQon82n@9608dh`08034BDX
H000081Q05A850=M0bC3481Q051850=A\>"
]
(***********************************************************************
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->{
"palette"->{
Cell[2634, 88, 1912, 47, 127, NotebookDefault,
CellTags->"palette"]},
"start"->{
Cell[6482, 227, 223, 4, 104, "Input",
CellTags->"start"],
Cell[6708, 233, 200, 4, 84, "Input",
CellTags->"start"],
Cell[6911, 239, 740, 13, 284, "Input",
CellTags->"start"]},
"reset"->{
Cell[7654, 254, 82, 2, 44, "Input",
CellTags->"reset"],
Cell[7739, 258, 724, 15, 224, "Input",
CellTags->"reset"],
Cell[8466, 275, 661, 13, 224, "Input",
CellTags->"reset"],
Cell[9130, 290, 462, 10, 144, "Input",
CellTags->"reset"],
Cell[9595, 302, 94, 2, 44, "Input",
CellTags->"reset"],
Cell[9692, 306, 96, 2, 44, "Input",
CellTags->"reset"],
Cell[9791, 310, 205, 5, 84, "Input",
CellTags->"reset"],
Cell[9999, 317, 248, 6, 104, "Input",
CellTags->"reset"],
Cell[10326, 328, 2045, 37, 664, "Input",
CellTags->"reset"],
Cell[12374, 367, 169, 4, 64, "Input",
CellTags->"reset"],
Cell[12546, 373, 688, 12, 244, "Input",
CellTags->"reset"],
Cell[13237, 387, 330, 6, 124, "Input",
CellTags->"reset"],
Cell[13570, 395, 147, 3, 84, "Input",
CellTags->"reset"],
Cell[13720, 400, 587, 10, 204, "Input",
CellTags->"reset"],
Cell[14310, 412, 96, 2, 44, "Input",
CellTags->"reset"]},
"first"->{
Cell[14409, 416, 91, 2, 44, "Input",
CellTags->"first"]},
"notes"->{
Cell[14503, 420, 553, 14, 98, "Text",
CellTags->"notes"],
Cell[15155, 442, 414, 8, 98, "Text",
CellTags->"notes"],
Cell[15990, 473, 600, 11, 134, "Text",
CellTags->"notes"],
Cell[16700, 492, 1038, 24, 188, "Text",
CellTags->"notes"],
Cell[20837, 575, 623, 11, 134, "Text",
CellTags->"notes"],
Cell[21559, 593, 424, 8, 98, "Text",
CellTags->"notes"],
Cell[22043, 605, 90, 1, 44, "Text",
CellTags->"notes"],
Cell[22587, 630, 684, 12, 152, "Text",
CellTags->"notes"],
Cell[23799, 663, 166, 4, 62, "Text",
CellTags->"notes"],
Cell[24447, 686, 89, 1, 44, "Text",
CellTags->"notes"],
Cell[24576, 691, 80, 1, 44, "Text",
CellTags->"notes"],
Cell[24707, 696, 121, 4, 44, "Text",
CellTags->"notes"],
Cell[24878, 704, 491, 9, 116, "Text",
CellTags->"notes"],
Cell[25416, 717, 222, 5, 62, "Text",
CellTags->"notes"],
Cell[25698, 726, 470, 8, 116, "Text",
CellTags->"notes"],
Cell[26299, 743, 467, 8, 116, "Text",
CellTags->"notes"],
Cell[26819, 755, 266, 6, 80, "Text",
CellTags->"notes"],
Cell[27144, 765, 215, 5, 62, "Text",
CellTags->"notes"],
Cell[27406, 774, 126, 4, 44, "Text",
CellTags->"notes"],
Cell[27734, 790, 851, 14, 188, "Text",
CellTags->"notes"],
Cell[28634, 808, 333, 8, 80, "Text",
CellTags->"notes"],
Cell[29009, 820, 164, 4, 62, "Text",
CellTags->"notes"],
Cell[29216, 828, 877, 14, 188, "Text",
CellTags->"notes"],
Cell[30167, 848, 126, 4, 44, "Text",
CellTags->"notes"],
Cell[30445, 861, 160, 4, 62, "Text",
CellTags->"notes"],
Cell[30672, 869, 448, 8, 116, "Text",
CellTags->"notes"],
Cell[31310, 885, 672, 11, 152, "Text",
CellTags->"notes"],
Cell[32392, 914, 472, 8, 116, "Text",
CellTags->"notes"],
Cell[33016, 931, 220, 5, 62, "Text",
CellTags->"notes"],
Cell[33306, 940, 373, 7, 98, "Text",
CellTags->"notes"],
Cell[33717, 951, 221, 5, 62, "Text",
CellTags->"notes"],
Cell[33977, 960, 578, 10, 134, "Text",
CellTags->"notes"],
Cell[34592, 974, 398, 8, 98, "Text",
CellTags->"notes"],
Cell[35031, 986, 127, 4, 44, "Text",
CellTags->"notes"],
Cell[35521, 1009, 177, 5, 62, "Text",
CellTags->"notes"],
Cell[35751, 1018, 149, 4, 62, "Text",
CellTags->"notes"],
Cell[35941, 1026, 167, 4, 62, "Text",
CellTags->"notes"],
Cell[36165, 1034, 359, 7, 98, "Text",
CellTags->"notes"],
Cell[36581, 1045, 107, 4, 44, "Text",
CellTags->"notes"],
Cell[36759, 1055, 278, 6, 80, "Text",
CellTags->"notes"],
Cell[37099, 1065, 65, 1, 44, "Text",
CellTags->"notes"],
Cell[37198, 1070, 164, 4, 62, "Text",
CellTags->"notes"],
Cell[37421, 1078, 453, 8, 116, "Text",
CellTags->"notes"],
Cell[37924, 1090, 164, 4, 62, "Text",
CellTags->"notes"],
Cell[38131, 1098, 180, 5, 62, "Text",
CellTags->"notes"],
Cell[38355, 1107, 270, 6, 80, "Text",
CellTags->"notes"],
Cell[38683, 1117, 602, 10, 134, "Text",
CellTags->"notes"],
Cell[39373, 1134, 227, 5, 62, "Text",
CellTags->"notes"],
Cell[39694, 1146, 67, 1, 44, "Text",
CellTags->"notes"],
Cell[39797, 1151, 1049, 18, 224, "Text",
CellTags->"notes"],
Cell[41693, 1205, 419, 9, 98, "Text",
CellTags->"notes"],
Cell[42502, 1232, 134, 4, 44, "Text",
CellTags->"notes"],
Cell[42672, 1240, 228, 5, 62, "Text",
CellTags->"notes"],
Cell[42934, 1249, 550, 12, 116, "Text",
CellTags->"notes"],
Cell[43528, 1265, 424, 9, 98, "Text",
CellTags->"notes"],
Cell[43991, 1278, 170, 4, 62, "Text",
CellTags->"notes"],
Cell[44199, 1286, 219, 5, 62, "Text",
CellTags->"notes"],
Cell[44476, 1295, 233, 5, 62, "Text",
CellTags->"notes"],
Cell[44786, 1304, 629, 14, 134, "Text",
CellTags->"notes"],
Cell[45665, 1331, 408, 8, 98, "Text",
CellTags->"notes"],
Cell[46118, 1343, 233, 5, 62, "Text",
CellTags->"notes"],
Cell[46415, 1352, 237, 5, 80, "Text",
CellTags->"notes"],
Cell[46701, 1361, 114, 4, 44, "Text",
CellTags->"notes"],
Cell[46869, 1369, 204, 5, 62, "Text",
CellTags->"notes"],
Cell[47560, 1399, 109, 4, 44, "Text",
CellTags->"notes"],
Cell[47718, 1407, 115, 4, 44, "Text",
CellTags->"notes"],
Cell[47879, 1415, 185, 5, 62, "Text",
CellTags->"notes"],
Cell[48101, 1424, 90, 1, 44, "Text",
CellTags->"notes"],
Cell[48243, 1429, 257, 7, 62, "Text",
CellTags->"notes"],
Cell[49088, 1457, 346, 8, 80, "Text",
CellTags->"notes"],
Cell[49624, 1477, 164, 4, 62, "Text",
CellTags->"notes"],
Cell[49834, 1485, 115, 4, 44, "Text",
CellTags->"notes"],
Cell[49995, 1493, 227, 5, 62, "Text",
CellTags->"notes"],
Cell[50279, 1502, 77, 1, 44, "Text",
CellTags->"notes"],
Cell[50413, 1507, 77, 1, 44, "Text",
CellTags->"notes"],
Cell[50547, 1512, 992, 16, 224, "Text",
CellTags->"notes"],
Cell[51613, 1532, 274, 6, 80, "Text",
CellTags->"notes"],
Cell[52154, 1552, 150, 4, 62, "Text",
CellTags->"notes"],
Cell[52360, 1560, 285, 6, 80, "Text",
CellTags->"notes"],
Cell[52686, 1570, 258, 6, 80, "Text",
CellTags->"notes"],
Cell[53464, 1602, 216, 5, 62, "Text",
CellTags->"notes"],
Cell[53737, 1611, 178, 5, 62, "Text",
CellTags->"notes"],
Cell[53993, 1620, 435, 8, 116, "Text",
CellTags->"notes"],
Cell[54493, 1632, 369, 7, 98, "Text",
CellTags->"notes"],
Cell[55202, 1656, 190, 5, 62, "Text",
CellTags->"notes"],
Cell[55450, 1665, 110, 4, 44, "Text",
CellTags->"notes"],
Cell[55720, 1680, 79, 1, 44, "Text",
CellTags->"notes"],
Cell[55863, 1685, 126, 4, 44, "Text",
CellTags->"notes"],
Cell[56023, 1693, 269, 6, 80, "Text",
CellTags->"notes"],
Cell[56331, 1703, 190, 5, 62, "Text",
CellTags->"notes"],
Cell[56557, 1712, 286, 6, 80, "Text",
CellTags->"notes"],
Cell[56898, 1722, 116, 4, 44, "Text",
CellTags->"notes"],
Cell[57050, 1730, 118, 4, 44, "Text",
CellTags->"notes"],
Cell[57311, 1745, 244, 5, 80, "Text",
CellTags->"notes"],
Cell[57616, 1754, 162, 4, 62, "Text",
CellTags->"notes"],
Cell[58036, 1772, 110, 4, 44, "Text",
CellTags->"notes"],
Cell[58197, 1780, 132, 4, 44, "Text",
CellTags->"notes"],
Cell[58384, 1788, 179, 5, 62, "Text",
CellTags->"notes"],
Cell[58593, 1797, 65, 1, 44, "Text",
CellTags->"notes"],
Cell[58692, 1802, 755, 18, 152, "Text",
CellTags->"notes"],
Cell[59743, 1835, 531, 9, 134, "Text",
CellTags->"notes"],
Cell[60376, 1852, 407, 9, 98, "Text",
CellTags->"notes"],
Cell[61147, 1881, 216, 5, 62, "Text",
CellTags->"notes"],
Cell[61406, 1890, 820, 13, 170, "Text",
CellTags->"notes"],
Cell[62366, 1913, 242, 5, 80, "Text",
CellTags->"notes"],
Cell[62640, 1922, 269, 6, 80, "Text",
CellTags->"notes"],
Cell[62946, 1932, 72, 1, 44, "Text",
CellTags->"notes"],
Cell[63070, 1937, 198, 5, 62, "Text",
CellTags->"notes"],
Cell[63337, 1946, 128, 4, 44, "Text",
CellTags->"notes"],
Cell[64018, 1977, 114, 4, 44, "Text",
CellTags->"notes"],
Cell[64522, 1998, 597, 10, 134, "Text",
CellTags->"notes"],
Cell[65325, 2017, 150, 4, 62, "Text",
CellTags->"notes"],
Cell[65529, 2025, 112, 4, 44, "Text",
CellTags->"notes"],
Cell[65862, 2038, 312, 6, 80, "Text",
CellTags->"notes"],
Cell[66390, 2056, 356, 7, 98, "Text",
CellTags->"notes"],
Cell[66889, 2069, 378, 9, 80, "Text",
CellTags->"notes"],
Cell[68099, 2104, 205, 5, 62, "Text",
CellTags->"notes"],
Cell[68670, 2126, 228, 5, 62, "Text",
CellTags->"notes"],
Cell[69366, 2151, 220, 5, 62, "Text",
CellTags->"notes"],
Cell[69990, 2175, 183, 5, 62, "Text",
CellTags->"notes"],
Cell[70208, 2184, 436, 12, 98, "Text",
CellTags->"notes"],
Cell[73743, 2255, 345, 10, 80, "Text",
CellTags->"notes"],
Cell[74442, 2280, 501, 14, 98, "Text",
CellTags->"notes"],
Cell[75529, 2322, 557, 11, 116, "Text",
CellTags->"notes"],
Cell[76535, 2354, 276, 7, 62, "Text",
CellTags->"notes"],
Cell[76855, 2365, 73, 1, 44, "Text",
CellTags->"notes"],
Cell[76967, 2370, 60, 1, 44, "Text",
CellTags->"notes"],
Cell[77058, 2375, 83, 1, 44, "Text",
CellTags->"notes"],
Cell[77184, 2380, 73, 1, 44, "Text",
CellTags->"notes"],
Cell[77294, 2385, 398, 8, 98, "Text",
CellTags->"notes"],
Cell[77723, 2397, 260, 6, 80, "Text",
CellTags->"notes"],
Cell[78249, 2418, 202, 7, 62, "Text",
CellTags->"notes"],
Cell[78488, 2429, 230, 5, 62, "Text",
CellTags->"notes"],
Cell[78755, 2438, 313, 8, 80, "Text",
CellTags->"notes"],
Cell[79687, 2475, 347, 11, 80, "Text",
CellTags->"notes"],
Cell[80135, 2494, 433, 9, 98, "Text",
CellTags->"notes"],
Cell[80615, 2507, 110, 4, 44, "Text",
CellTags->"notes"],
Cell[80755, 2515, 49, 1, 44, "Text",
CellTags->"notes"],
Cell[80838, 2520, 607, 12, 134, "Text",
CellTags->"notes"],
Cell[81476, 2536, 970, 16, 206, "Text",
CellTags->"notes"],
Cell[82504, 2556, 153, 4, 62, "Text",
CellTags->"notes"],
Cell[82694, 2564, 90, 1, 44, "Text",
CellTags->"notes"],
Cell[82846, 2569, 60, 1, 44, "Text",
CellTags->"notes"],
Cell[82943, 2574, 164, 4, 62, "Text",
CellTags->"notes"],
Cell[83145, 2582, 1527, 41, 242, "Text",
CellTags->"notes"],
Cell[85081, 2647, 1033, 28, 170, "Text",
CellTags->"notes"]},
"evaluate"->{
Cell[17741, 518, 3093, 55, 864, "Input",
CellTags->"evaluate"],
Cell[31123, 879, 184, 4, 64, "Input",
CellTags->"evaluate"],
Cell[65122, 2010, 143, 3, 64, "Input",
CellTags->"evaluate"],
Cell[65644, 2031, 143, 3, 64, "Input",
CellTags->"evaluate"],
Cell[67270, 2080, 271, 5, 124, "Input",
CellTags->"evaluate"],
Cell[67699, 2092, 255, 5, 124, "Input",
CellTags->"evaluate"],
Cell[67957, 2099, 139, 3, 64, "Input",
CellTags->"evaluate"],
Cell[70647, 2198, 3093, 55, 864, "Input",
CellTags->"evaluate"],
Cell[74091, 2267, 104, 2, 44, "Input",
CellTags->"evaluate"],
Cell[74198, 2271, 104, 2, 44, "Input",
CellTags->"evaluate"],
Cell[74305, 2275, 134, 3, 64, "Input",
CellTags->"evaluate"]}
}
*)
(*CellTagsIndex
CellTagsIndex->{
{"palette", 87766, 2734},
{"start", 87859, 2737},
{"reset", 88077, 2744},
{"first", 89114, 2775},
{"notes", 89195, 2778},
{"evaluate", 99147, 3071}
}
*)
(*NotebookFileOutline
Notebook[{
Cell[1717, 49, 93, 4, 96, "Title"],
Cell[1813, 55, 215, 8, 30, "Text"],
Cell[2031, 65, 378, 11, 41, NotebookDefault],
Cell[2412, 78, 219, 8, 30, "Text"],
Cell[2634, 88, 1912, 47, 127, NotebookDefault,
CellTags->"palette"],
Cell[4549, 137, 202, 8, 30, "Text"],
Cell[4754, 147, 206, 8, 30, "Text"],
Cell[4963, 157, 207, 8, 30, "Text"],
Cell[5173, 167, 207, 8, 30, "Text"],
Cell[5383, 177, 213, 8, 30, "Text"],
Cell[5599, 187, 233, 8, 30, "Text"],
Cell[5835, 197, 198, 8, 30, "Text"],
Cell[6036, 207, 206, 8, 30, "Text"],
Cell[6245, 217, 234, 8, 30, "Text"],
Cell[6482, 227, 223, 4, 104, "Input",
CellTags->"start"],
Cell[6708, 233, 200, 4, 84, "Input",
CellTags->"start"],
Cell[6911, 239, 740, 13, 284, "Input",
CellTags->"start"],
Cell[7654, 254, 82, 2, 44, "Input",
CellTags->"reset"],
Cell[7739, 258, 724, 15, 224, "Input",
CellTags->"reset"],
Cell[8466, 275, 661, 13, 224, "Input",
CellTags->"reset"],
Cell[9130, 290, 462, 10, 144, "Input",
CellTags->"reset"],
Cell[9595, 302, 94, 2, 44, "Input",
CellTags->"reset"],
Cell[9692, 306, 96, 2, 44, "Input",
CellTags->"reset"],
Cell[9791, 310, 205, 5, 84, "Input",
CellTags->"reset"],
Cell[9999, 317, 248, 6, 104, "Input",
CellTags->"reset"],
Cell[10250, 325, 73, 1, 30, "Input"],
Cell[10326, 328, 2045, 37, 664, "Input",
CellTags->"reset"],
Cell[12374, 367, 169, 4, 64, "Input",
CellTags->"reset"],
Cell[12546, 373, 688, 12, 244, "Input",
CellTags->"reset"],
Cell[13237, 387, 330, 6, 124, "Input",
CellTags->"reset"],
Cell[13570, 395, 147, 3, 84, "Input",
CellTags->"reset"],
Cell[13720, 400, 587, 10, 204, "Input",
CellTags->"reset"],
Cell[14310, 412, 96, 2, 44, "Input",
CellTags->"reset"],
Cell[14409, 416, 91, 2, 44, "Input",
CellTags->"first"],
Cell[14503, 420, 553, 14, 98, "Text",
CellTags->"notes"],
Cell[15059, 436, 93, 4, 96, "Title"],
Cell[15155, 442, 414, 8, 98, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[15594, 454, 38, 0, 54, "Section"],
Cell[15635, 456, 73, 1, 26, "Contents"],
Cell[15711, 459, 41, 0, 26, "Contents"],
Cell[15755, 461, 34, 0, 26, "Contents"],
Cell[15792, 463, 41, 0, 26, "Contents"],
Cell[15836, 465, 28, 0, 26, "Contents"],
Cell[15867, 467, 34, 0, 26, "Contents"],
Cell[15904, 469, 71, 1, 26, "Contents"]
}, Open ]],
Cell[15990, 473, 600, 11, 134, "Text",
CellTags->"notes"],
Cell[16593, 486, 104, 4, 58, "Subsection"],
Cell[16700, 492, 1038, 24, 188, "Text",
CellTags->"notes"],
Cell[17741, 518, 3093, 55, 864, "Input",
CellTags->"evaluate"],
Cell[20837, 575, 623, 11, 134, "Text",
CellTags->"notes"],
Cell[21463, 588, 93, 3, 30, "Text"],
Cell[21559, 593, 424, 8, 98, "Text",
CellTags->"notes"],
Cell[21986, 603, 54, 0, 30, "Text"],
Cell[22043, 605, 90, 1, 44, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[22158, 610, 38, 0, 54, "Section"],
Cell[22199, 612, 72, 1, 26, "Contents"],
Cell[22274, 615, 75, 1, 26, "Contents"],
Cell[22352, 618, 34, 0, 26, "Contents"],
Cell[22389, 620, 41, 0, 26, "Contents"],
Cell[22433, 622, 28, 0, 26, "Contents"],
Cell[22464, 624, 34, 0, 26, "Contents"],
Cell[22501, 626, 71, 1, 26, "Contents"]
}, Open ]],
Cell[22587, 630, 684, 12, 152, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[23296, 646, 41, 0, 58, "Subsection"],
Cell[23340, 648, 444, 12, 186, "Text"]
}, Open ]],
Cell[23799, 663, 166, 4, 62, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[23990, 671, 43, 0, 58, "Subsection"],
Cell[24036, 673, 396, 10, 146, "Text"]
}, Open ]],
Cell[24447, 686, 89, 1, 44, "Text",
CellTags->"notes"],
Cell[24539, 689, 34, 0, 30, "Input"],
Cell[24576, 691, 80, 1, 44, "Text",
CellTags->"notes"],
Cell[24659, 694, 45, 0, 30, "Input"],
Cell[24707, 696, 121, 4, 44, "Text",
CellTags->"notes"],
Cell[24831, 702, 44, 0, 30, "Input"],
Cell[24878, 704, 491, 9, 116, "Text",
CellTags->"notes"],
Cell[25372, 715, 41, 0, 30, "Input"],
Cell[25416, 717, 222, 5, 62, "Text",
CellTags->"notes"],
Cell[25641, 724, 54, 0, 30, "Input"],
Cell[25698, 726, 470, 8, 116, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[26193, 738, 27, 0, 58, "Subsection"],
Cell[26223, 740, 61, 0, 30, "Text"]
}, Open ]],
Cell[26299, 743, 467, 8, 116, "Text",
CellTags->"notes"],
Cell[26769, 753, 47, 0, 30, "Input"],
Cell[26819, 755, 266, 6, 80, "Text",
CellTags->"notes"],
Cell[27088, 763, 53, 0, 30, "Input"],
Cell[27144, 765, 215, 5, 62, "Text",
CellTags->"notes"],
Cell[27362, 772, 41, 0, 30, "Input"],
Cell[27406, 774, 126, 4, 44, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[27557, 782, 54, 0, 58, "Subsection"],
Cell[27614, 784, 105, 3, 30, "Text"]
}, Open ]],
Cell[27734, 790, 851, 14, 188, "Text",
CellTags->"notes"],
Cell[28588, 806, 43, 0, 30, "Input"],
Cell[28634, 808, 333, 8, 80, "Text",
CellTags->"notes"],
Cell[28970, 818, 36, 0, 30, "Input"],
Cell[29009, 820, 164, 4, 62, "Text",
CellTags->"notes"],
Cell[29176, 826, 37, 0, 30, "Input"],
Cell[29216, 828, 877, 14, 188, "Text",
CellTags->"notes"],
Cell[30096, 844, 68, 2, 30, "Input"],
Cell[30167, 848, 126, 4, 44, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[30318, 856, 46, 0, 58, "Subsection"],
Cell[30367, 858, 63, 0, 30, "Text"]
}, Open ]],
Cell[30445, 861, 160, 4, 62, "Text",
CellTags->"notes"],
Cell[30608, 867, 61, 0, 30, "Input"],
Cell[30672, 869, 448, 8, 116, "Text",
CellTags->"notes"],
Cell[31123, 879, 184, 4, 64, "Input",
CellTags->"evaluate"],
Cell[31310, 885, 672, 11, 152, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[32007, 900, 49, 0, 58, "Subsection"],
Cell[32059, 902, 63, 0, 30, "BulletItem"],
Cell[32125, 904, 94, 3, 30, "BulletItem"],
Cell[32222, 909, 73, 0, 30, "BulletItem"],
Cell[32298, 911, 79, 0, 30, "BulletItem"]
}, Open ]],
Cell[32392, 914, 472, 8, 116, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[32889, 926, 36, 0, 58, "Subsection"],
Cell[32928, 928, 73, 0, 30, "Text"]
}, Open ]],
Cell[33016, 931, 220, 5, 62, "Text",
CellTags->"notes"],
Cell[33239, 938, 64, 0, 30, "Input"],
Cell[33306, 940, 373, 7, 98, "Text",
CellTags->"notes"],
Cell[33682, 949, 32, 0, 30, "Input"],
Cell[33717, 951, 221, 5, 62, "Text",
CellTags->"notes"],
Cell[33941, 958, 33, 0, 30, "Input"],
Cell[33977, 960, 578, 10, 134, "Text",
CellTags->"notes"],
Cell[34558, 972, 31, 0, 30, "Input"],
Cell[34592, 974, 398, 8, 98, "Text",
CellTags->"notes"],
Cell[34993, 984, 35, 0, 30, "Input"],
Cell[35031, 986, 127, 4, 44, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[35183, 994, 53, 0, 58, "Subsection"],
Cell[35239, 996, 267, 10, 48, "Text"]
}, Open ]],
Cell[35521, 1009, 177, 5, 62, "Text",
CellTags->"notes"],
Cell[35701, 1016, 47, 0, 30, "Input"],
Cell[35751, 1018, 149, 4, 62, "Text",
CellTags->"notes"],
Cell[35903, 1024, 35, 0, 30, "Input"],
Cell[35941, 1026, 167, 4, 62, "Text",
CellTags->"notes"],
Cell[36111, 1032, 51, 0, 30, "Input"],
Cell[36165, 1034, 359, 7, 98, "Text",
CellTags->"notes"],
Cell[36527, 1043, 51, 0, 30, "Input"],
Cell[36581, 1045, 107, 4, 44, "Text",
CellTags->"notes"],
Cell[36691, 1051, 65, 2, 30, "Input"],
Cell[36759, 1055, 278, 6, 80, "Text",
CellTags->"notes"],
Cell[37040, 1063, 56, 0, 30, "Input"],
Cell[37099, 1065, 65, 1, 44, "Text",
CellTags->"notes"],
Cell[37167, 1068, 28, 0, 30, "Input"],
Cell[37198, 1070, 164, 4, 62, "Text",
CellTags->"notes"],
Cell[37365, 1076, 53, 0, 58, "Subsection"],
Cell[37421, 1078, 453, 8, 116, "Text",
CellTags->"notes"],
Cell[37877, 1088, 44, 0, 30, "Input"],
Cell[37924, 1090, 164, 4, 62, "Text",
CellTags->"notes"],
Cell[38091, 1096, 37, 0, 30, "Input"],
Cell[38131, 1098, 180, 5, 62, "Text",
CellTags->"notes"],
Cell[38314, 1105, 38, 0, 30, "Input"],
Cell[38355, 1107, 270, 6, 80, "Text",
CellTags->"notes"],
Cell[38628, 1115, 52, 0, 30, "Input"],
Cell[38683, 1117, 602, 10, 134, "Text",
CellTags->"notes"],
Cell[39288, 1129, 82, 3, 30, "Input"],
Cell[39373, 1134, 227, 5, 62, "Text",
CellTags->"notes"],
Cell[39603, 1141, 88, 3, 48, "Input"],
Cell[39694, 1146, 67, 1, 44, "Text",
CellTags->"notes"],
Cell[39764, 1149, 30, 0, 30, "Input"],
Cell[39797, 1151, 1049, 18, 224, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[40871, 1173, 54, 0, 58, "Subsection"],
Cell[40928, 1175, 165, 4, 48, "BulletItem"],
Cell[41096, 1181, 276, 9, 48, "BulletItem"],
Cell[41375, 1192, 303, 10, 48, "BulletItem"]
}, Open ]],
Cell[41693, 1205, 419, 9, 98, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[42137, 1218, 39, 0, 58, "Subsection"],
Cell[42179, 1220, 308, 9, 108, "Text"]
}, Open ]],
Cell[42502, 1232, 134, 4, 44, "Text",
CellTags->"notes"],
Cell[42639, 1238, 30, 0, 30, "Input"],
Cell[42672, 1240, 228, 5, 62, "Text",
CellTags->"notes"],
Cell[42903, 1247, 28, 0, 30, "Input"],
Cell[42934, 1249, 550, 12, 116, "Text",
CellTags->"notes"],
Cell[43487, 1263, 38, 0, 30, "Input"],
Cell[43528, 1265, 424, 9, 98, "Text",
CellTags->"notes"],
Cell[43955, 1276, 33, 0, 30, "Input"],
Cell[43991, 1278, 170, 4, 62, "Text",
CellTags->"notes"],
Cell[44164, 1284, 32, 0, 30, "Input"],
Cell[44199, 1286, 219, 5, 62, "Text",
CellTags->"notes"],
Cell[44421, 1293, 52, 0, 30, "Input"],
Cell[44476, 1295, 233, 5, 62, "Text",
CellTags->"notes"],
Cell[44712, 1302, 71, 0, 30, "Input"],
Cell[44786, 1304, 629, 14, 134, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[45440, 1322, 44, 0, 58, "Subsection"],
Cell[45487, 1324, 163, 4, 48, "Text"]
}, Open ]],
Cell[45665, 1331, 408, 8, 98, "Text",
CellTags->"notes"],
Cell[46076, 1341, 39, 0, 30, "Input"],
Cell[46118, 1343, 233, 5, 62, "Text",
CellTags->"notes"],
Cell[46354, 1350, 58, 0, 30, "Input"],
Cell[46415, 1352, 237, 5, 80, "Text",
CellTags->"notes"],
Cell[46655, 1359, 43, 0, 30, "Input"],
Cell[46701, 1361, 114, 4, 44, "Text",
CellTags->"notes"],
Cell[46818, 1367, 48, 0, 30, "Input"],
Cell[46869, 1369, 204, 5, 62, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[47098, 1378, 38, 0, 54, "Section"],
Cell[47139, 1380, 72, 1, 26, "Contents"],
Cell[47214, 1383, 74, 1, 26, "Contents"],
Cell[47291, 1386, 68, 1, 26, "Contents"],
Cell[47362, 1389, 41, 0, 26, "Contents"],
Cell[47406, 1391, 28, 0, 26, "Contents"],
Cell[47437, 1393, 34, 0, 26, "Contents"],
Cell[47474, 1395, 71, 1, 26, "Contents"]
}, Open ]],
Cell[47560, 1399, 109, 4, 44, "Text",
CellTags->"notes"],
Cell[47672, 1405, 43, 0, 58, "Subsection"],
Cell[47718, 1407, 115, 4, 44, "Text",
CellTags->"notes"],
Cell[47836, 1413, 40, 0, 30, "Input"],
Cell[47879, 1415, 185, 5, 62, "Text",
CellTags->"notes"],
Cell[48067, 1422, 31, 0, 30, "Input"],
Cell[48101, 1424, 90, 1, 44, "Text",
CellTags->"notes"],
Cell[48194, 1427, 46, 0, 30, "Input"],
Cell[48243, 1429, 257, 7, 62, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[48525, 1440, 38, 0, 58, "Subsection"],
Cell[48566, 1442, 507, 12, 186, "Text"]
}, Open ]],
Cell[49088, 1457, 346, 8, 80, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[49459, 1469, 45, 0, 58, "Subsection"],
Cell[49507, 1471, 102, 3, 30, "Text"]
}, Open ]],
Cell[49624, 1477, 164, 4, 62, "Text",
CellTags->"notes"],
Cell[49791, 1483, 40, 0, 30, "Input"],
Cell[49834, 1485, 115, 4, 44, "Text",
CellTags->"notes"],
Cell[49952, 1491, 40, 0, 30, "Input"],
Cell[49995, 1493, 227, 5, 62, "Text",
CellTags->"notes"],
Cell[50225, 1500, 51, 0, 30, "Input"],
Cell[50279, 1502, 77, 1, 44, "Text",
CellTags->"notes"],
Cell[50359, 1505, 51, 0, 30, "Input"],
Cell[50413, 1507, 77, 1, 44, "Text",
CellTags->"notes"],
Cell[50493, 1510, 51, 0, 30, "Input"],
Cell[50547, 1512, 992, 16, 224, "Text",
CellTags->"notes"],
Cell[51542, 1530, 68, 0, 30, "Input"],
Cell[51613, 1532, 274, 6, 80, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[51912, 1542, 49, 0, 58, "Subsection"],
Cell[51964, 1544, 175, 5, 46, "Text"]
}, Open ]],
Cell[52154, 1552, 150, 4, 62, "Text",
CellTags->"notes"],
Cell[52307, 1558, 50, 0, 30, "Input"],
Cell[52360, 1560, 285, 6, 80, "Text",
CellTags->"notes"],
Cell[52648, 1568, 35, 0, 30, "Input"],
Cell[52686, 1570, 258, 6, 80, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[52969, 1580, 38, 0, 54, "Section"],
Cell[53010, 1582, 72, 1, 26, "Contents"],
Cell[53085, 1585, 74, 1, 26, "Contents"],
Cell[53162, 1588, 67, 1, 26, "Contents"],
Cell[53232, 1591, 75, 1, 26, "Contents"],
Cell[53310, 1594, 28, 0, 26, "Contents"],
Cell[53341, 1596, 34, 0, 26, "Contents"],
Cell[53378, 1598, 71, 1, 26, "Contents"]
}, Open ]],
Cell[53464, 1602, 216, 5, 62, "Text",
CellTags->"notes"],
Cell[53683, 1609, 51, 0, 58, "Subsection"],
Cell[53737, 1611, 178, 5, 62, "Text",
CellTags->"notes"],
Cell[53918, 1618, 72, 0, 30, "Input"],
Cell[53993, 1620, 435, 8, 116, "Text",
CellTags->"notes"],
Cell[54431, 1630, 59, 0, 30, "Input"],
Cell[54493, 1632, 369, 7, 98, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[54887, 1643, 42, 0, 58, "Subsection"],
Cell[54932, 1645, 255, 8, 88, "Text"]
}, Open ]],
Cell[55202, 1656, 190, 5, 62, "Text",
CellTags->"notes"],
Cell[55395, 1663, 52, 0, 30, "Input"],
Cell[55450, 1665, 110, 4, 44, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[55585, 1673, 54, 0, 58, "Subsection"],
Cell[55642, 1675, 63, 2, 30, "Input",
Evaluatable->False]
}, Open ]],
Cell[55720, 1680, 79, 1, 44, "Text",
CellTags->"notes"],
Cell[55802, 1683, 58, 0, 30, "Input"],
Cell[55863, 1685, 126, 4, 44, "Text",
CellTags->"notes"],
Cell[55992, 1691, 28, 0, 30, "Input"],
Cell[56023, 1693, 269, 6, 80, "Text",
CellTags->"notes"],
Cell[56295, 1701, 33, 0, 30, "Input"],
Cell[56331, 1703, 190, 5, 62, "Text",
CellTags->"notes"],
Cell[56524, 1710, 30, 0, 30, "Input"],
Cell[56557, 1712, 286, 6, 80, "Text",
CellTags->"notes"],
Cell[56846, 1720, 49, 0, 30, "Input"],
Cell[56898, 1722, 116, 4, 44, "Text",
CellTags->"notes"],
Cell[57017, 1728, 30, 0, 30, "Input"],
Cell[57050, 1730, 118, 4, 44, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[57193, 1738, 34, 0, 58, "Subsection"],
Cell[57230, 1740, 66, 2, 30, "Input",
Evaluatable->False]
}, Open ]],
Cell[57311, 1745, 244, 5, 80, "Text",
CellTags->"notes"],
Cell[57558, 1752, 55, 0, 30, "Input"],
Cell[57616, 1754, 162, 4, 62, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[57803, 1762, 49, 0, 58, "Subsection"],
Cell[57855, 1764, 166, 5, 46, "Text"]
}, Open ]],
Cell[58036, 1772, 110, 4, 44, "Text",
CellTags->"notes"],
Cell[58149, 1778, 45, 0, 30, "Input"],
Cell[58197, 1780, 132, 4, 44, "Text",
CellTags->"notes"],
Cell[58332, 1786, 49, 0, 30, "Input"],
Cell[58384, 1788, 179, 5, 62, "Text",
CellTags->"notes"],
Cell[58566, 1795, 24, 0, 30, "Input"],
Cell[58593, 1797, 65, 1, 44, "Text",
CellTags->"notes"],
Cell[58661, 1800, 28, 0, 30, "Input"],
Cell[58692, 1802, 755, 18, 152, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[59472, 1824, 40, 0, 58, "Subsection"],
Cell[59515, 1826, 213, 6, 66, "Text"]
}, Open ]],
Cell[59743, 1835, 531, 9, 134, "Text",
CellTags->"notes"],
Cell[60277, 1846, 96, 4, 66, "Input"],
Cell[60376, 1852, 407, 9, 98, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[60808, 1865, 44, 0, 58, "Subsection"],
Cell[60855, 1867, 127, 5, 30, "Text"],
Cell[60985, 1874, 44, 0, 22, "BulletText"],
Cell[61032, 1876, 45, 0, 22, "BulletText"],
Cell[61080, 1878, 52, 0, 22, "BulletText"]
}, Open ]],
Cell[61147, 1881, 216, 5, 62, "Text",
CellTags->"notes"],
Cell[61366, 1888, 37, 0, 58, "Subsection"],
Cell[61406, 1890, 820, 13, 170, "Text",
CellTags->"notes"],
Cell[62229, 1905, 134, 6, 102, "Input"],
Cell[62366, 1913, 242, 5, 80, "Text",
CellTags->"notes"],
Cell[62611, 1920, 26, 0, 30, "Input"],
Cell[62640, 1922, 269, 6, 80, "Text",
CellTags->"notes"],
Cell[62912, 1930, 31, 0, 30, "Input"],
Cell[62946, 1932, 72, 1, 44, "Text",
CellTags->"notes"],
Cell[63021, 1935, 46, 0, 30, "Input"],
Cell[63070, 1937, 198, 5, 62, "Text",
CellTags->"notes"],
Cell[63271, 1944, 63, 0, 30, "Input"],
Cell[63337, 1946, 128, 4, 44, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[63490, 1954, 38, 0, 54, "Section"],
Cell[63531, 1956, 72, 1, 26, "Contents"],
Cell[63606, 1959, 74, 1, 26, "Contents"],
Cell[63683, 1962, 67, 1, 26, "Contents"],
Cell[63753, 1965, 74, 1, 26, "Contents"],
Cell[63830, 1968, 62, 1, 26, "Contents"],
Cell[63895, 1971, 34, 0, 26, "Contents"],
Cell[63932, 1973, 71, 1, 26, "Contents"]
}, Open ]],
Cell[64018, 1977, 114, 4, 44, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[64157, 1985, 30, 0, 58, "Subsection"],
Cell[64190, 1987, 317, 8, 106, "Text"]
}, Open ]],
Cell[64522, 1998, 597, 10, 134, "Text",
CellTags->"notes"],
Cell[65122, 2010, 143, 3, 64, "Input",
CellTags->"evaluate"],
Cell[65268, 2015, 54, 0, 30, "Input"],
Cell[65325, 2017, 150, 4, 62, "Text",
CellTags->"notes"],
Cell[65478, 2023, 48, 0, 30, "Input"],
Cell[65529, 2025, 112, 4, 44, "Text",
CellTags->"notes"],
Cell[65644, 2031, 143, 3, 64, "Input",
CellTags->"evaluate"],
Cell[65790, 2036, 69, 0, 30, "Input"],
Cell[65862, 2038, 312, 6, 80, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[66199, 2048, 42, 0, 58, "Subsection"],
Cell[66244, 2050, 131, 3, 48, "Text"]
}, Open ]],
Cell[66390, 2056, 356, 7, 98, "Text",
CellTags->"notes"],
Cell[66749, 2065, 137, 2, 50, "Input"],
Cell[66889, 2069, 378, 9, 80, "Text",
CellTags->"notes"],
Cell[67270, 2080, 271, 5, 124, "Input",
CellTags->"evaluate"],
Cell[67544, 2087, 152, 3, 50, "Input"],
Cell[67699, 2092, 255, 5, 124, "Input",
CellTags->"evaluate"],
Cell[67957, 2099, 139, 3, 64, "Input",
CellTags->"evaluate"],
Cell[68099, 2104, 205, 5, 62, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[68329, 2113, 41, 0, 58, "Subsection"],
Cell[68373, 2115, 282, 8, 88, "Text",
Evaluatable->False]
}, Open ]],
Cell[68670, 2126, 228, 5, 62, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[68923, 2135, 41, 0, 58, "Subsection"],
Cell[68967, 2137, 384, 11, 148, "Text",
Evaluatable->False]
}, Open ]],
Cell[69366, 2151, 220, 5, 62, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[69611, 2160, 38, 0, 58, "Subsection"],
Cell[69652, 2162, 323, 10, 128, "Text",
Evaluatable->False]
}, Open ]],
Cell[69990, 2175, 183, 5, 62, "Text",
CellTags->"notes"],
Cell[70176, 2182, 29, 0, 58, "Subsection"],
Cell[70208, 2184, 436, 12, 98, "Text",
CellTags->"notes"],
Cell[70647, 2198, 3093, 55, 864, "Input",
CellTags->"evaluate"],
Cell[73743, 2255, 345, 10, 80, "Text",
CellTags->"notes"],
Cell[74091, 2267, 104, 2, 44, "Input",
CellTags->"evaluate"],
Cell[74198, 2271, 104, 2, 44, "Input",
CellTags->"evaluate"],
Cell[74305, 2275, 134, 3, 64, "Input",
CellTags->"evaluate"],
Cell[74442, 2280, 501, 14, 98, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[74968, 2298, 38, 0, 54, "Section"],
Cell[75009, 2300, 72, 1, 26, "Contents"],
Cell[75084, 2303, 74, 1, 26, "Contents"],
Cell[75161, 2306, 67, 1, 26, "Contents"],
Cell[75231, 2309, 74, 1, 26, "Contents"],
Cell[75308, 2312, 61, 1, 26, "Contents"],
Cell[75372, 2315, 68, 1, 26, "Contents"],
Cell[75443, 2318, 71, 1, 26, "Contents"]
}, Open ]],
Cell[75529, 2322, 557, 11, 116, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[76111, 2337, 36, 0, 58, "Subsection"],
Cell[76150, 2339, 370, 12, 168, "Text",
Evaluatable->False]
}, Open ]],
Cell[76535, 2354, 276, 7, 62, "Text",
CellTags->"notes"],
Cell[76814, 2363, 38, 0, 30, "Input"],
Cell[76855, 2365, 73, 1, 44, "Text",
CellTags->"notes"],
Cell[76931, 2368, 33, 0, 30, "Input"],
Cell[76967, 2370, 60, 1, 44, "Text",
CellTags->"notes"],
Cell[77030, 2373, 25, 0, 30, "Input"],
Cell[77058, 2375, 83, 1, 44, "Text",
CellTags->"notes"],
Cell[77144, 2378, 37, 0, 30, "Input"],
Cell[77184, 2380, 73, 1, 44, "Text",
CellTags->"notes"],
Cell[77260, 2383, 31, 0, 30, "Input"],
Cell[77294, 2385, 398, 8, 98, "Text",
CellTags->"notes"],
Cell[77695, 2395, 25, 0, 30, "Input"],
Cell[77723, 2397, 260, 6, 80, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[78008, 2407, 42, 0, 58, "Subsection"],
Cell[78053, 2409, 181, 6, 48, "Text",
Evaluatable->False]
}, Open ]],
Cell[78249, 2418, 202, 7, 62, "Text",
CellTags->"notes"],
Cell[78454, 2427, 31, 0, 30, "Input"],
Cell[78488, 2429, 230, 5, 62, "Text",
CellTags->"notes"],
Cell[78721, 2436, 31, 0, 30, "Input"],
Cell[78755, 2438, 313, 8, 80, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[79093, 2450, 38, 0, 54, "Section"],
Cell[79134, 2452, 72, 1, 26, "Contents"],
Cell[79209, 2455, 74, 1, 26, "Contents"],
Cell[79286, 2458, 67, 1, 26, "Contents"],
Cell[79356, 2461, 74, 1, 26, "Contents"],
Cell[79433, 2464, 61, 1, 26, "Contents"],
Cell[79497, 2467, 67, 1, 26, "Contents"],
Cell[79567, 2470, 105, 2, 26, "Contents"]
}, Open ]],
Cell[79687, 2475, 347, 11, 80, "Text",
CellTags->"notes"],
Cell[80037, 2488, 95, 4, 58, "Subsection"],
Cell[80135, 2494, 433, 9, 98, "Text",
CellTags->"notes"],
Cell[80571, 2505, 41, 0, 30, "Input"],
Cell[80615, 2507, 110, 4, 44, "Text",
CellTags->"notes"],
Cell[80728, 2513, 24, 0, 30, "Input"],
Cell[80755, 2515, 49, 1, 44, "Text",
CellTags->"notes"],
Cell[80807, 2518, 28, 0, 30, "Input"],
Cell[80838, 2520, 607, 12, 134, "Text",
CellTags->"notes"],
Cell[81448, 2534, 25, 0, 30, "Input"],
Cell[81476, 2536, 970, 16, 206, "Text",
CellTags->"notes"],
Cell[82449, 2554, 52, 0, 30, "Input"],
Cell[82504, 2556, 153, 4, 62, "Text",
CellTags->"notes"],
Cell[82660, 2562, 31, 0, 30, "Input"],
Cell[82694, 2564, 90, 1, 44, "Text",
CellTags->"notes"],
Cell[82787, 2567, 56, 0, 30, "Input"],
Cell[82846, 2569, 60, 1, 44, "Text",
CellTags->"notes"],
Cell[82909, 2572, 31, 0, 30, "Input"],
Cell[82943, 2574, 164, 4, 62, "Text",
CellTags->"notes"],
Cell[83110, 2580, 32, 0, 30, "Input"],
Cell[83145, 2582, 1527, 41, 242, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[84697, 2627, 116, 5, 58, "Subsection"],
Cell[84816, 2634, 144, 6, 30, "BulletItem"],
Cell[84963, 2642, 68, 0, 30, "BulletItem"],
Cell[85034, 2644, 32, 0, 30, "BulletItem"]
}, Open ]],
Cell[85081, 2647, 1033, 28, 170, "Text",
CellTags->"notes"],
Cell[CellGroupData[{
Cell[86139, 2679, 58, 0, 58, "Subsection"],
Cell[86200, 2681, 188, 7, 30, "BulletItem"],
Cell[86391, 2690, 197, 8, 30, "BulletItem"],
Cell[86591, 2700, 155, 4, 30, "BulletItem"]
}, Open ]]
}
]
*)
(***********************************************************************
End of Mathematica Notebook file.
***********************************************************************)