(***********************************************************************
Mathematica-Compatible Notebook
This notebook can be used on any computer system with Mathematica 3.0,
MathReader 3.0, or any compatible application. The data for the notebook
starts with the line of 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[ 24962, 723]*)
(*NotebookOutlinePosition[ 26069, 759]*)
(* CellTagsIndexPosition[ 26025, 755]*)
(*WindowFrame->Normal*)
Notebook[{
Cell[TextData["2. Course Goals and Themes"], "Title",
Evaluatable->False,
AspectRatioFixed->True],
Cell["Last revision: January 13 1998", "SmallText",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"In this section we introduce the primary goals and themes of the course and \
explore some of them in the context of solving equations numerically."],
"Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[CellGroupData[{
Cell[TextData["Mathematica, a Programming Language"], "Section",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"By now you are becoming familiar with the Mathematica environment and the \
evaluation of one-line expressions in input cells. Mathematica may seem at \
this point irrelevant to programming, seemingly a simple---albeit \
powerful---calculator. Do not despair! At this early stage we will continue \
to examine some basic programming terms while applying them to some easily \
posed mathematical problems. In the next section we will begin defining \
functions, and soon after that we will learn how to construct modules, or \
procedures, with which we can instruct Mathematica to perform a series of \
steps, test conditions, and so on. At that stage, we will be learning how to \
program."], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[CellGroupData[{
Cell[TextData["Course Goals"], "Subsection",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[{
StyleBox[
"The organizing principle of this course is that the best introduction to \
programming is an introduction in the broadest sense, covering different \
programming ",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["principles",
Evaluatable->False,
AspectRatioFixed->True,
FontSlant->"Italic"],
StyleBox[
", which apply to most computer languages, as well as different programming \
",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["paradigms",
Evaluatable->False,
AspectRatioFixed->True,
FontSlant->"Italic"],
StyleBox[
", each of which might apply to certain languages but not others. (A ",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["paradigm",
Evaluatable->False,
AspectRatioFixed->True,
FontSlant->"Italic"],
StyleBox[
", for the purposes of this course, will be any method of organizing \
computer instructions which privileges certain types of action or certain \
types of data representation over others. We will first take up paradigms \
explicitly in section 5.) We have chosen Mathematica for the language of the \
course because within Mathematica---and comparatively few other \
languages---we can program using many different principles and many different \
paradigms. We believe that when students satisfactorily complete this course, \
they will not only have come to terms with programming as a broad discipline \
but will also able to pick up the particulars of another language (C or \
Pascal being conscious instances) quickly and productively. Thus, moving \
from this course to a \"second-semester\" programming course focussing on C \
or Pascal (or on their object-oriented cousins, C++, Java, and Delphi) should \
be relatively smooth, and you will take from this course many ideas and \
perspectives you would not have gained had you studied only C or Pascal from \
the beginning.",
Evaluatable->False,
AspectRatioFixed->True]
}], "Text",
Evaluatable->False,
AspectRatioFixed->True]
}, Closed]],
Cell[CellGroupData[{
Cell[TextData["Course Themes"], "Subsection",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"We also, however, believe that an introductory programming course should \
seek to introduce students to some fundamental programming issues in which \
the programmer must balance sometimes competing goals. These issues we call \
themes of our course, and we attempt to consider each of these themes at \
several points in the course. One theme is the tradeoff between using an \
interpreted language, such as Mathematica is in its basic form, and a \
compiled language, such as most implementations of C and Pascal. Another is \
the tradeoff between data security within a program and speed of execution; \
this issue is raised in choosing between call-by-value functions and \
call-by-reference functions, as well as in whether or not to use an \
object-oriented programming paradigm. Still another is the tradeoff between \
having a program save results it has already computed, in case it may need \
them later, and having a program maintain as small a demand on computer \
resources as possible, as for instance when one considers whether to use \
dynamic programming. One final issue is the balance between the simplest \
solution to a problem from the programmer's perspective and the fastest \
solution to a problem from a user's perspective, leading students to consider \
a course in data structures and algorithms."], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"In this section we will consider some themes briefly, while introducing a \
few built-in, numerical functions of Mathematica."], "Text",
Evaluatable->False,
AspectRatioFixed->True]
}, Closed]]
}, Open ]],
Cell[CellGroupData[{
Cell[TextData["Exploring Tradeoffs"], "Section",
Evaluatable->False,
AspectRatioFixed->True],
Cell[CellGroupData[{
Cell[TextData["Source Code, Interpreted vs. Compiled Languages"], "Subsection",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[{
StyleBox[
"Let's begin by introducing some terms. We already introduced some terms \
in section 1; you should know what",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox[" data types",
Evaluatable->False,
AspectRatioFixed->True,
FontSlant->"Italic"],
StyleBox[" are (and some examples of them in Mathematica), why",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox[" operator precedence",
Evaluatable->False,
AspectRatioFixed->True,
FontSlant->"Italic"],
StyleBox[" matters in the evaluation of expressions, and what a",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox[" boolean",
Evaluatable->False,
AspectRatioFixed->True,
FontSlant->"Italic"],
StyleBox[" value is.",
Evaluatable->False,
AspectRatioFixed->True]
}], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[{
StyleBox[
"The instructions we write to computers, in some computer language, are \
generically called ",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["source code. ",
Evaluatable->False,
AspectRatioFixed->True,
FontSlant->"Italic"],
StyleBox[
"All of the Mathematica instructions, or commands, or expressions, which we \
evaluated in input cells in the section before were examples of source code. \
A microprocessor, such as the one inside the computer your are working on, \
however, does not understand these statements of source code; it understands \
only ",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["machine code",
Evaluatable->False,
AspectRatioFixed->True,
FontSlant->"Italic"],
StyleBox[
". Hence computer programmers face a conversion problem, that of taking \
the source code they have written and converting it to instructions the \
microprocessor can understand. Depending on the particular language and its \
implementation, this conversion happens typically in one of two possible \
ways. Either a program converts the source code to machine code ",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["when we ask the computer to execute our source code",
Evaluatable->False,
AspectRatioFixed->True,
FontSlant->"Italic"],
StyleBox[" or",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox[" beforehand",
Evaluatable->False,
AspectRatioFixed->True,
FontSlant->"Italic"],
StyleBox[". In the first case, we say that the source code is ",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["interpreted",
Evaluatable->False,
AspectRatioFixed->True,
FontSlant->"Italic"],
StyleBox["; in the second we say that the source code is ",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["compiled",
Evaluatable->False,
AspectRatioFixed->True,
FontSlant->"Italic"],
StyleBox[". ",
Evaluatable->False,
AspectRatioFixed->True]
}], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"Deciding which system of conversion is better depends, to a large extent, on \
how a programmer balances ease of programming with fast execution. Because \
the conversion process happens every time the source code is executed, and \
because the conversion process takes a fair amount of time, interpreted \
languages tend to be much slower then compiled languages. Practically all of \
the programs you find on your computer were written in a computer language \
and then compiled, because the expectation is that you will run these \
programs hundreds, if not millions, of times and would like to see them \
execute as fast as possible. However, suppose that we do not intend to run \
our programs hundreds of times, but wish instead to be spared the tiresome \
process of writing code, compiling it, running it, realizing that there is an \
error, rewriting the code, recompiling, and so on. Suppose instead that we \
wish to be able to correct the code immediately and then execute the program \
again. In this case we would opt for an interpreted language, such as \
Mathematica. Notice that you may execute any cell of code at any time; it is \
only then that Mathematica converts the code to machine code and executes \
it."], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[
"The decision, even before any code is written, of whether or not to use a \
language which encourages or demands compilation versus one which encourages \
or demands interpretation is essentially the first of many ways in which a \
programmer comes up against one of the many tradeoffs in computer \
programming, balancing one goal against another."], "Text",
Evaluatable->False,
AspectRatioFixed->True]
}, Closed]],
Cell[CellGroupData[{
Cell[TextData["Dynamic Programming (NSolve)"], "Subsection",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[{
"Mathematica has a built-in command, \"",
StyleBox["NSolve[]",
FontFamily->"Courier"],
"\", which takes an equation involving a variable and attempts to find \
numeric approximations to the values of the variable for which the equation \
holds true. For example:"
}], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell["NSolve[x^2==4,x]", "Input",
AspectRatioFixed->True],
Cell["NSolve[x^2==-4,x]", "Input",
AspectRatioFixed->True],
Cell[TextData[{
StyleBox["The first argument to the function \"",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["NSolve[]",
FontFamily->"Courier"],
StyleBox[
"\" is the equation involving the variable, where double equals signs (\"",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["==",
Evaluatable->False,
AspectRatioFixed->True,
FontFamily->"Courier"],
StyleBox[
"\") are substituted where a standard equals sign would reside. The second \
argument is the name of the variable. We notice that the values Mathematica \
has found, which do in fact make the equation true, are each placed inside a \
list, and each of these lists is placed into one large list. The values \
themselves are expressed in what Mathematica calls ",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["rules",
Evaluatable->False,
AspectRatioFixed->True,
FontSlant->"Italic"],
StyleBox[
", where the variable appears on the left-hand side of an arrow (\"",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["->",
Evaluatable->False,
AspectRatioFixed->True,
FontFamily->"Courier"],
StyleBox["\"), and the value appears on the right. We can use \"",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["NSolve[]",
FontFamily->"Courier"],
StyleBox[
"\" to find solutions to many, many equations, though sometimes Mathematica \
fails. Compare the results of evaluating the following expressions.",
Evaluatable->False,
AspectRatioFixed->True]
}], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell["NSolve[Exp[x] == x+2, x]", "Input",
AspectRatioFixed->True],
Cell["NSolve[Exp[x] == Abs[x+2], x]", "Input",
AspectRatioFixed->True],
Cell["NSolve[Exp[x] == x + 2 Cos[x], x]", "Input",
AspectRatioFixed->True],
Cell[TextData[{
StyleBox[
"Let us pause to consider the best way Mathematica might implement a \
function such as \"",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["NSolve[]",
FontFamily->"Courier"],
StyleBox["\". One method Mathematica might consider is that of ",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["dynamic programming",
Evaluatable->False,
AspectRatioFixed->True,
FontSlant->"Italic"],
StyleBox[
", which means the process of retaining the solutions it has found every \
time it performs an \"",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["NSolve[]",
FontFamily->"Courier"],
StyleBox[
"\" command. If it were to do so, then it could check the next time when \
asked it to execute an \"",
Evaluatable->False,
AspectRatioFixed->True],
StyleBox["NSolve[]",
FontFamily->"Courier"],
StyleBox[
"\" command, and, if we had already executed the same one before, it could \
simply look up the old answer, a process which would take much less time than \
actually trying to solve the equation. At what cost, though? Here we have a \
tradeoff between storage space (memory or hard disk) and speed: if we are \
willing to give up space, we can have many answers to questions at our \
fingertips, while if we are not, we force Mathematica to derive answers to \
equations over and over again. In this case, as you might probably imagine, \
dynamic programming is a poor choice for a programming method, since the \
number of possible equations is so enormous that no computer would have space \
enough to hold all possible solutions. For another problem, however, dynamic \
programming might be a great choice. This example illustrates another \
tradeoff common in computer programming, that of space versus time.",
Evaluatable->False,
AspectRatioFixed->True]
}], "Text",
Evaluatable->False,
AspectRatioFixed->True]
}, Closed]],
Cell[CellGroupData[{
Cell["Simple vs. Complex Algorithms (FindRoot)", "Subsection",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[{
"If \"",
StyleBox["NSolve[]",
FontFamily->"Courier"],
"\" does not work, another Mathematica function which is appropriate is \"",
StyleBox["FindRoot[]",
FontFamily->"Courier"],
"\". \"",
StyleBox["FindRoot[]",
FontFamily->"Courier"],
"\" uses a mathematical process called Newton's method, which begins with \
an estimate for a root of the equation---a value of the variable for which \
the equation is true---and attempts gradually to refine this estimate into a \
very good approximation. For example:"
}], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell["FindRoot[x^2==4,{x,1}]", "Input",
AspectRatioFixed->True],
Cell[TextData[{
"To be sure, another root exists (namely ",
StyleBox["x=-2",
FontFamily->"Courier"],
"), but the 1 was refined into the 2 which is, correctly, a root of the \
equation. Let us try \"",
StyleBox["FindRoot[]",
FontFamily->"Courier"],
"\" on one of the equations which \"",
StyleBox["NSolve[]",
FontFamily->"Courier"],
"\" could not crack."
}], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell["FindRoot[Exp[x]==x+2Cos[x],{x,1}]", "Input",
AspectRatioFixed->True],
Cell["FindRoot[Exp[x]==x+2Cos[x],{x,-1}]", "Input",
AspectRatioFixed->True],
Cell[TextData[{
"How did we know to guess ",
StyleBox["1",
FontFamily->"Courier"],
" and ",
StyleBox["-1",
FontFamily->"Courier"],
"? One way is to plot the two functions \"",
StyleBox["Exp[x]",
FontFamily->"Courier"],
"\" and \"",
StyleBox["x+2Cos[x]",
FontFamily->"Courier"],
"\" and see if we can determine where they might cross."
}], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell["Plot[{Exp[x], x + 2 Cos[x]}, {x,-5,5}];", "Input"],
Cell[TextData[{
"Sometimes ",
StyleBox["Mathematica",
FontSlant->"Italic"],
" warns you it might be missing a solution, and sometimes it doesn't. \
Recall our earlier attempt at solving\n\t",
StyleBox[" Exp[x] == x+2 \n",
FontFamily->"Courier"],
"and at solving\n\t",
StyleBox[" Exp[x] == Abs[x+2]",
FontFamily->"Courier"],
"."
}], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell["NSolve[Exp[x] == x+2, x]", "Input",
AspectRatioFixed->True],
Cell["NSolve[Exp[x] == Abs[x+2], x]", "Input",
AspectRatioFixed->True],
Cell["Check out the graphs... ", "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell["Plot[{Exp[x],x+2},{x,-5,5}];", "Input",
AspectRatioFixed->True],
Cell["\<\
Plot[{Exp[x], Abs[x+2]}, {x,-4,2},
\tPlotRange->{0,4}
];\
\>", "Input"],
Cell[TextData[{
StyleBox["Mathematica",
FontSlant->"Italic"],
" warned us it might miss solutions to",
StyleBox[" Exp[x] == x+2",
FontFamily->"Courier"],
", but actually found all of them. It didn't warn us concerning",
StyleBox[" Exp[x] == Abs[x+2]",
FontFamily->"Courier"],
", but missed all three solutions. Darn!"
}], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[{
"Some calculus courses teach a process of approximating a root to a \
function (a solution to ",
StyleBox["f(x)",
FontSlant->"Italic"],
" = 0) called Newton's method. Newton's method was developed hundreds of \
years ago and represents a good, if not foolproof, way to approach this \
problem. It is an ",
StyleBox["iterative",
FontSlant->"Italic"],
" method of successively improving estimates. The idea is to start with an \
initial estimate for your answer and to replace your estimate with a \"better\
\" estimate. Then replace the better estimate with an even better estimate. \
Continue until you are satisfied with the accuracy of the latest estimate \
(perhaps because it doesn't differ by much from the previous estimate) . The \
step which improves an estimated root to a \"better\" estimate is as \
follows:"
}], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[{
"Let the estimate be \"",
StyleBox["x",
FontSlant->"Italic"],
"\", and denote the value of the function at this estimate by \"",
StyleBox["f(x)",
FontSlant->"Italic"],
"\". Find the derivative \"",
StyleBox["d(x)",
FontSlant->"Italic"],
"\" of the function at the estimate \"",
StyleBox["x",
FontSlant->"Italic"],
"\" using some calculus, either approximately or exactly, depending on the \
method chosen. Evaluate \"",
StyleBox["x \[Dash] f(x)/d(x)",
FontSlant->"Italic"],
"\", and use this value as the new \"better\" estimate. "
}], "Text",
Evaluatable->False,
TextAlignment->Left,
TextJustification->0,
AspectRatioFixed->True],
Cell[TextData[{
"To an untrained observer, however, Newton's method may seem needlessly \
complicated, using the theory of calculus. One might imagine someone making \
the claim that a simpler algorithm, or method, might be used to find a point \
where two functions intersect, using the following argument: manipulate the \
equation so that the right-hand side is a zero. Now proceed through the \
integers, one at a time, beginning with 1, substituting them inside the \
left-hand side of the equation. When we reach two consecutive integers for \
which the signs of the numbers we find on the left-hand sides are opposite, \
we surmise that a root occurs between the two integers and then check numbers \
equally spaced between the two integers, say at intervals of one-tenth. \
Let's do this for the functions above. We'll define a function \"",
StyleBox["f[]",
FontFamily->"Courier"],
"\" which gives us the value of the left-hand side of the equation \"",
StyleBox["Exp[x]-(x+2Cos[x])==0",
FontFamily->"Courier"],
"\"."
}], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell["\<\
Clear[f];
f[x_] := Exp[x]-(x + 2 Cos[x])\
\>", "Input",
AspectRatioFixed->True],
Cell["f[0.]", "Input",
AspectRatioFixed->True],
Cell["f[1.]", "Input",
AspectRatioFixed->True],
Cell[TextData[{
"In this case, we already guess that a root lies between 0 and 1, and we \
explore further by examining \"",
StyleBox["f[1.0]",
FontFamily->"Courier"],
"\", \"",
StyleBox["f[1.1]",
FontFamily->"Courier"],
"\", \"",
StyleBox["f[1.2]",
FontFamily->"Courier"],
"\", \"",
StyleBox["f[1.3]",
FontFamily->"Courier"],
"\", and so on."
}], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell[TextData[{
"Is the method simpler? Perhaps, but it is not as good as Newton's method. \
Consider the problem of approximating solutions to ",
StyleBox["(x\[Dash].5)^2=.15",
FontSlant->"Italic"],
". Let's try Newton's method, as implemented by ",
StyleBox["Mathematica",
FontSlant->"Italic"],
"'s FindRoot command, using an initial estimate of 0. "
}], "Text",
Evaluatable->False,
AspectRatioFixed->True],
Cell["FindRoot[(x-.5)^2==.15,{x,0}]", "Input",
AspectRatioFixed->True],
Cell["\<\
There are actually two solutions between 0 and 1, as shown by the \
following graph.\
\>", "Text"],
Cell["Plot[{(x-.5)^2, .15}, {x,0,1}];", "Input",
AspectRatioFixed->True],
Cell["Now try the \"simpler\" method.", "Text"],
Cell["\<\
Clear[f]
f[x_] := (x-.5)^2 - .15;\
\>", "Input",
AspectRatioFixed->True],
Cell["f[0]", "Input",
AspectRatioFixed->True],
Cell["f[1]", "Input",
AspectRatioFixed->True],
Cell[TextData[{
"Notice that, although two solutions to",
StyleBox[" (x-.5)^2 = .15 ",
FontFamily->"Courier"],
"occur between ",
StyleBox["x=0",
FontSlant->"Italic"],
" and ",
StyleBox["x=1",
FontSlant->"Italic"],
", the \"simpler\" method fails to recognize that there is any solution in \
this interval. This illustrates a third tradeoff in computer programming. \
Sometimes the more intuitive method fails, sometimes because it never works, \
and sometimes because it only works some of the time. While all programmers \
would like simple methods to work, they must balance this desire against the \
other concerns of correctness, execution time, memory or hard drive space, \
and so on. In this course you will be presented at times with problems which \
require somewhat complicated solutions, and you must strive to understand why \
your solution should work in every possible case. It also helps, of course, \
to try your solution out on lots of examples."
}], "Text",
Evaluatable->False,
AspectRatioFixed->True]
}, Closed]]
}, Open ]]
},
FrontEndVersion->"Macintosh 3.0",
ScreenRectangle->{{0, 832}, {0, 604}},
WindowToolbars->{},
CellGrouping->Manual,
WindowSize->{520, 509},
WindowMargins->{{28, Automatic}, {30, Automatic}},
PrintingCopies->1,
PrintingPageRange->{1, Automatic},
PrivateNotebookOptions->{"ColorPalette"->{RGBColor, -1}},
ShowCellLabel->True,
ShowCellTags->False,
RenderingOptions->{"ObjectDithering"->True,
"RasterDithering"->False},
MacintoshSystemPageSetup->"\<\
00<0004/0B`000003809T?o>old"
]
(***********************************************************************
Cached data follows. If you edit this Notebook file directly, not using
Mathematica, you must remove the line containing CacheID at the top of
the file. The cache data will then be recreated when you save this file
from within Mathematica.
***********************************************************************)
(*CellTagsOutline
CellTagsIndex->{}
*)
(*CellTagsIndex
CellTagsIndex->{}
*)
(*NotebookFileOutline
Notebook[{
Cell[1709, 49, 101, 2, 136, "Title",
Evaluatable->False],
Cell[1813, 53, 99, 2, 26, "SmallText",
Evaluatable->False],
Cell[1915, 57, 225, 5, 46, "Text",
Evaluatable->False],
Cell[CellGroupData[{
Cell[2165, 66, 112, 2, 50, "Section",
Evaluatable->False],
Cell[2280, 70, 769, 12, 142, "Text",
Evaluatable->False],
Cell[CellGroupData[{
Cell[3074, 86, 92, 2, 46, "Subsection",
Evaluatable->False],
Cell[3169, 90, 2054, 48, 260, "Text",
Evaluatable->False]
}, Closed]],
Cell[CellGroupData[{
Cell[5260, 143, 93, 2, 30, "Subsection",
Evaluatable->False],
Cell[5356, 147, 1405, 20, 155, "Text",
Evaluatable->False],
Cell[6764, 169, 200, 4, 25, "Text",
Evaluatable->False]
}, Closed]]
}, Open ]],
Cell[CellGroupData[{
Cell[7013, 179, 96, 2, 30, "Section",
Evaluatable->False],
Cell[CellGroupData[{
Cell[7134, 185, 127, 2, 46, "Subsection",
Evaluatable->False],
Cell[7264, 189, 891, 29, 51, "Text",
Evaluatable->False],
Cell[8158, 220, 2107, 60, 129, "Text",
Evaluatable->False],
Cell[10268, 282, 1310, 19, 142, "Text",
Evaluatable->False],
Cell[11581, 303, 423, 7, 51, "Text",
Evaluatable->False]
}, Closed]],
Cell[CellGroupData[{
Cell[12041, 315, 108, 2, 30, "Subsection",
Evaluatable->False],
Cell[12152, 319, 350, 9, 38, "Text",
Evaluatable->False],
Cell[12505, 330, 59, 1, 22, "Input"],
Cell[12567, 333, 60, 1, 22, "Input"],
Cell[12630, 336, 1624, 46, 90, "Text",
Evaluatable->False],
Cell[14257, 384, 67, 1, 22, "Input"],
Cell[14327, 387, 72, 1, 22, "Input"],
Cell[14402, 390, 76, 1, 22, "Input"],
Cell[14481, 393, 1947, 46, 155, "Text",
Evaluatable->False]
}, Closed]],
Cell[CellGroupData[{
Cell[16465, 444, 110, 2, 30, "Subsection",
Evaluatable->False],
Cell[16578, 448, 612, 17, 64, "Text",
Evaluatable->False],
Cell[17193, 467, 65, 1, 22, "Input"],
Cell[17261, 470, 440, 14, 38, "Text",
Evaluatable->False],
Cell[17704, 486, 76, 1, 22, "Input"],
Cell[17783, 489, 77, 1, 22, "Input"],
Cell[17863, 492, 429, 16, 38, "Text",
Evaluatable->False],
Cell[18295, 510, 56, 0, 22, "Input"],
Cell[18354, 512, 414, 14, 77, "Text",
Evaluatable->False],
Cell[18771, 528, 67, 1, 22, "Input"],
Cell[18841, 531, 72, 1, 22, "Input"],
Cell[18916, 534, 88, 2, 25, "Text",
Evaluatable->False],
Cell[19007, 538, 71, 1, 22, "Input"],
Cell[19081, 541, 82, 4, 40, "Input"],
Cell[19166, 547, 403, 12, 38, "Text",
Evaluatable->False],
Cell[19572, 561, 919, 19, 90, "Text",
Evaluatable->False],
Cell[20494, 582, 699, 22, 51, "Text",
Evaluatable->False],
Cell[21196, 606, 1109, 20, 116, "Text",
Evaluatable->False],
Cell[22308, 628, 91, 4, 30, "Input"],
Cell[22402, 634, 48, 1, 22, "Input"],
Cell[22453, 637, 48, 1, 22, "Input"],
Cell[22504, 640, 437, 17, 38, "Text",
Evaluatable->False],
Cell[22944, 659, 433, 11, 51, "Text",
Evaluatable->False],
Cell[23380, 672, 72, 1, 22, "Input"],
Cell[23455, 675, 108, 3, 25, "Text"],
Cell[23566, 680, 74, 1, 22, "Input"],
Cell[23643, 683, 47, 0, 25, "Text"],
Cell[23693, 685, 84, 4, 30, "Input"],
Cell[23780, 691, 47, 1, 22, "Input"],
Cell[23830, 694, 47, 1, 22, "Input"],
Cell[23880, 697, 1054, 22, 103, "Text",
Evaluatable->False]
}, Closed]]
}, Open ]]
}
]
*)
(***********************************************************************
End of Mathematica Notebook file.
***********************************************************************)