(************** Content-type: application/mathematica ************** CreatedBy='Mathematica 5.2' Mathematica-Compatible Notebook This notebook can be used with any Mathematica-compatible application, such as Mathematica, MathReader or Publicon. The data for the notebook starts with the line containing stars above. To get the notebook into a Mathematica-compatible application, do one of the following: * Save the data starting with the line of stars above into a file with a name ending in .nb, then open the file inside the application; * Copy the data starting with the line of stars above to the clipboard, then use the Paste menu command inside the application. Data for notebooks contains only printable 7-bit ASCII and can be sent directly in email or through ftp in text mode. Newlines can be CR, LF or CRLF (Unix, Macintosh or MS-DOS style). NOTE: If you modify the data for this notebook not in a Mathematica- compatible application, you must delete the line below containing the word CacheID, otherwise Mathematica-compatible applications may try to use invalid cache data. For more information on notebooks and Mathematica-compatible applications, contact Wolfram Research: web: http://www.wolfram.com email: info@wolfram.com phone: +1-217-398-0700 (U.S.) Notebook reader applications are available free of charge from Wolfram Research. *******************************************************************) (*CacheID: 232*) (*NotebookFileLineBreakTest NotebookFileLineBreakTest*) (*NotebookOptionsPosition[ 18207, 567]*) (*NotebookOutlinePosition[ 22062, 664]*) (* CellTagsIndexPosition[ 21251, 644]*) (*WindowFrame->Normal*) Notebook[{ Cell["First-Order Ordinary Differential Equations", "Title"], Cell[CellGroupData[{ Cell["Background--Simple iteration", "Subtitle", CellTags->"mmtag:19:simple_forward_time_interation"], Cell["\<\ Suppose a function, F[i], changes proportional to its current \ size, i.e., F[i+1] = F[i] + \[Alpha]F[i]\ \>", "Text"], Cell[BoxData[ \(ExampleFunction[i_, \ alpha_]\ := \ \(ExampleFunction[i, alpha]\ = ExampleFunction[i - 1, alpha]\ + \ alpha*ExampleFunction[i - 1, alpha]\)\)], "Input"], Cell["\<\ In the above, the symbol is assigned (ExampleFunction[i,alpha] = \ ...) as part of the function definition, so that intermediate values are \ ``remembered.'' The function needs some value at some time (an initial condition) from which \ it obtains all its other values:\ \>", "Text"], Cell[BoxData[ \(ExampleFunction[0, 0.25]\ = \ \[Pi]/4\)], "Input"], Cell[BoxData[ \(ExampleFunction[18, 0.25]\)], "Input"], Cell["\<\ ExampleFunction[0,0.25] = \[Pi]/4 above serves as an initial value \ for the function. The initial value and \[Alpha] determine the value at any \ later time. The initial value can be expressed as another parameter for the \ function:\ \>", "Text"], Cell[BoxData[{ \(ExampleFunction[0\ , \ alpha_, \ InitialValue_]\ := \ InitialValue\), "\[IndentingNewLine]", \(ExampleFunction[Increment_Integer, \ alpha_, \ InitialValue_]\ := \ \(ExampleFunction[i, alpha, \ InitialValue]\ = ExampleFunction[i - 1, alpha, \ InitialValue]\ + \ alpha*ExampleFunction[i - 1, alpha, InitialValue]\)\)}], "Input"], Cell["\<\ One might as well write a function to calculate a vector \ representing `trajectory', here is an implementation to compute a trajectory \ vector of specified length.\ \>", "Text"], Cell[BoxData[ \(Trajectory[alpha_, \ \ Steps_, \ InitialValue_]\ := \ Table[ExampleFunction[i, alpha, InitialValue], {i, 0, Steps - 1}]\)], "Input"], Cell[BoxData[ \(ListPlot[Trajectory[0.01, 300, \ 0.0001], PlotJoined \[Rule] True]\)], "Input"], Cell[BoxData[ \(<< Graphics`MultipleListPlot`\)], "Input", CellTags->"mmtag:19:Graphics_Package__MultipleListPlot[]"], Cell["\<\ Plotting a bunch of curves for the same positive \[Alpha] value, \ but each corresponding to a different initial value, demonstrates that a \ point in space \"belongs\" to a curve.\ \>", "Text"], Cell[BoxData[ \(MultipleListPlot[Trajectory[ .01, 300, \(- .5\)], Trajectory[ .01, 300, .5], Trajectory[ .01, 300, 1], Trajectory[ .01, 300, 1.5], PlotJoined \[Rule] True]\)], "Input", CellTags->"mmtag:19:MultipleListPlot[]"], Cell["\<\ Making a similar plot for a family of curves corresponding to a \ negative \[Alpha] value \ \>", "Text"], Cell[BoxData[ \(MultipleListPlot[Trajectory[\(- .01\), 300, \(- .5\)], Trajectory[\(- .01\), 300, .5], Trajectory[\(- .01\), 300, 1], Trajectory[\(- .01\), 300, 1.5], PlotJoined \[Rule] True]\)], "Input"] }, Closed]], Cell[CellGroupData[{ Cell["Background- Forward Differencing", "Subtitle"], Cell[TextData[{ "Create a function to return a list of values by forward differencing with \ a function (these examples were modified from those found in ``Computer \ Science with ", StyleBox["Mathematica", FontSlant->"Italic"], "'' by Roman E. Maeder, Cambridge University Press, (2000).)" }], "Text", CellTags->"mmtag:19:Roman_Maeder__Computer_Science_with_Mathematica"], Cell[TextData[{ "The ", StyleBox["Module", FontWeight->"Bold"], " function makes the variables inside local variables. " }], "Subsubsection"], Cell[BoxData[ \(ForwardDifferenceListV1[AFunction_\ , \ InitialValue_\ , \ delta_, \ ListLength_Integer]\ := \[IndentingNewLine]Module[{TheResultList\ = \ \ {InitialValue}, TheValue = InitialValue}, \[IndentingNewLine]Do[ TheValue\ = \ TheValue\ + \ delta\ AFunction[TheValue]; \ AppendTo[TheResultList, TheValue], {ListLength}]; TheResultList]\)], "Input", CellTags->"mmtag:19:Module[]"], Cell[BoxData[ \(exampleFunction[x_]\ := \ 0.1\ x\)], "Input"], Cell[BoxData[ \(\(result\ = \ ForwardDifferenceListV1[exampleFunction, \ 1, \ 0.01, \ 500];\)\)], "Input"], Cell[BoxData[ \(result // Short\)], "Input"], Cell[BoxData[ \(ListPlot[result, PlotJoined \[Rule] True]\)], "Input"], Cell[TextData[{ "Write another version of this forward difference function that returns a \ list of values\nand the \"x\" value for subsequent use in ListPlot, this one \ will take ", Cell[BoxData[ \(TraditionalForm\`x\_o\)]], " and y(", Cell[BoxData[ \(TraditionalForm\`x\_o\)]], ") as an argument in a list" }], "Text"], Cell[BoxData[ \(Clear[ForwardDifferenceListV2]\)], "Input"], Cell[BoxData[ \(ForwardDifferenceListV2[AFunction_\ , x0_\ , \ fx0_\ , \ delta_, \ Xlast_]\ := \[IndentingNewLine]Module[{TheResultList\ = \ {{x0, fx0}}, TheValue = fx0, CurrentX\ \ = \ x0}, \[IndentingNewLine]While[ CurrentX\ < \ Xlast, \[IndentingNewLine]CurrentX\ = CurrentX\ + \ delta; \[IndentingNewLine]\ TheValue = \ TheValue\ + \ delta\ AFunction[TheValue]; \ AppendTo[ TheResultList, {CurrentX, TheValue}]]; \[IndentingNewLine]TheResultList]\)], "Input"], Cell[BoxData[ \(\(result\ = \ ForwardDifferenceListV2[exampleFunction, 0, 1, \ 0.01, 4];\)\)], "Input"], Cell[BoxData[ \(result // Short\)], "Input"], Cell[BoxData[ \(ListPlot[result]\)], "Input"] }, Closed]], Cell[CellGroupData[{ Cell["Background-Repeated Operations on a Function", "Subtitle"], Cell[TextData[{ "Because each iteration is the same, the iteration can be considered a \ functional operation, for the case considered above,\n{", Cell[BoxData[ \(TraditionalForm\`x\_\(i + 1\)\)]], ", ", Cell[BoxData[ \(TraditionalForm\`y\_\(i + 1\)\)]], "} = {", Cell[BoxData[ \(TraditionalForm\`x\_i\)]], "+ \[Delta], ", Cell[BoxData[ \(TraditionalForm\`y\_i\)]], "+ \[Delta] f(", Cell[BoxData[ \(TraditionalForm\`y\_i\)]], ")}. Therefore a \"Incrementing Operator\" can be obtained that updates \ the values:" }], "Text", CellTags->"mmtag:19:increment_operator"], Cell[BoxData[ \(StepOnce[{x_, y_}, \ AFunction_, \ delta_]\ := \ {x + \ delta, \ y\ + \ delta\ AFunction[y]}\)], "Input"], Cell[TextData[{ "Then, the trajectory should be obtained from:\n \ {{xo,yo},StepOnce[{xo,yo}], StepOnce[StepOnce[{xo,yo}]], \[TripleDot]\ \[TripleDot]\[TripleDot]}\n This is what the built-in ", StyleBox["Mathematica", FontSlant->"Italic"], " function ", StyleBox["NestList", FontWeight->"Bold"], "[function, initialvalue,depth] does:" }], "Text"], Cell[BoxData[ \(OurStepOnce[{x_\ , \ y_}]\ := \ StepOnce[{x, y}, exampleFunction, \ 0.01]\)], "Input"], Cell[BoxData[ \(\(result\ = \ NestList[OurStepOnce, {0, 1}, 400];\)\)], "Input", CellTags->"mmtag:19:NestList[]"], Cell[BoxData[ \(ListPlot[result]\)], "Input"], Cell[TextData[{ "Using a ", StyleBox["Mathematica", FontSlant->"Italic"], " trick of a ``pure function'' one can eliminate the intervening function \ (OurStepOnce) definition:" }], "Text"], Cell[BoxData[ \(ListPlot[ NestList[StepOnce[#, exampleFunction, 0.01] &, {0, 1}, 400]]\)], "Input",\ CellTags->"mmtag:19:pure_function"], Cell[BoxData[{ \(\(DisplayLater\ = \ DisplayFunction \[Rule] Identity;\)\), "\[IndentingNewLine]", \(\(DisplayNow\ = \ DisplayFunction \[Rule] $DisplayFunction;\)\)}], "Input", CellTags->"mmtag:19:DisplayNow_DisplayLater__example"], Cell[BoxData[ \(\(lp[i_]\ := ListPlot[NestList[StepOnce[#, exampleFunction, 0.01] &, {0, i}, 400], DisplayLater];\)\)], "Input"], Cell["\<\ This will plot a family of related curves, each for a different \ starting value of the iterated function:\ \>", "Text"], Cell[BoxData[ \(Show[Table[lp[i], {i, \(-4\), 4, .5}], DisplayNow]\)], "Input"], Cell["\<\ To summarize what was done up to now, we've seen how a given \ function can be changed incrementally by stepping forward the independent \ variables and calculating a corresponding change in the function's value. By \ doing so, we trace out trajectories in space, the paths of which depend on \ the starting values of the independent variables.\ \>", "Subsubsection"] }, Closed]], Cell[CellGroupData[{ Cell["Visualizing Geometry of First-Order ODEs", "Subtitle", CellTags->{ "mmtag:19:first-order_ODES__visualizing", "mmtag:19:first-order_ODES"}], Cell[TextData[{ "Newton's law of cooling ", Cell[BoxData[ \(TraditionalForm\`dT\/dt\)]], "= -k(T - ", Cell[BoxData[ \(TraditionalForm\`T\_o\)]], ") can be written in the non-dimensional form ", Cell[BoxData[ \(TraditionalForm\`d\[CapitalTheta]\/d\[Tau]\)]], "= 1-\[CapitalTheta] " }], "Text"], Cell[TextData[{ "In the general case, ", Cell[BoxData[ \(TraditionalForm\`d\[CapitalTheta]\/d\[Tau]\)]], " will depend on both \[CapitalTheta] and t, i.e., ", Cell[BoxData[ \(TraditionalForm\`d\[CapitalTheta]\/d\[Tau]\)]], " = ", Cell[BoxData[ \(TraditionalForm\`d\[CapitalTheta]\/d\[Tau]\)]], "(\[CapitalTheta],t). This the equation of a surface in three dimensions, \ as shown in the following plot (in this specific case there is no t \ dependence):" }], "Text"], Cell[BoxData[ \(\(ZeroPlane[xmin_, \ xmax_, ymin_, ymax_] := \ {Graphics3D[SurfaceColor[GrayLevel[0.6]]], Plot3D[0, {tau, \ xmin, xmax}, \ {\[CapitalTheta], \ ymin, ymax}, PlotPoints -> \ 4, DisplayFunction -> Identity]};\)\)], "Input"], Cell[BoxData[ \(Show[ Plot3D[1 - \[CapitalTheta], \ {tau, \ \(-1\), 1}, \ {\[CapitalTheta], \ \(-2\), 3}, AxesLabel \[Rule] {"\<\[Tau]\>", "\<\[CapitalTheta]\>", \*"\"\<\!\(d\ \[CapitalTheta]\/d\[Tau]\)\>\""}, DisplayFunction -> Identity], ZeroPlane[\(-1\), 1, \(-2\), 3], DisplayFunction -> $DisplayFunction, ViewPoint -> {17.830, \ 10.191, \ 4.064}]\)], "Input"], Cell[TextData[{ "Plot the vector (d\[Tau],d\[CapitalTheta]) = d\[Tau](1, ", Cell[BoxData[ \(d\[CapitalTheta]\/d\[Tau]\)]], ") at each point:", "\n", "We want to make a plot of", Cell[BoxData[ \(d\[CapitalTheta]\/d\[Tau]\)]], "in the \[CapitalTheta]-\[Tau] plane. We can do so by plotting vectors of \ the form {d\[Tau], d\[CapitalTheta]} = d\[Tau]{1, ", Cell[BoxData[ \(d\[CapitalTheta]\/d\[Tau]\)]], "} which will be proportional to the vector {1, 1-\[CapitalTheta]}. This is \ done as follows:" }], "Text"], Cell[BoxData[ \(<< Graphics`PlotField`\)], "Input", CellTags->"mmtag:19:Graphics_Package__PlotVectorField[]"], Cell[BoxData[ \(PlotVectorField[{1, 1 - \[CapitalTheta]}, {tau, \ 0, 4}, \ {\[CapitalTheta], \(-2\), 4}, Axes \[Rule] True, AxesLabel \[Rule] {"\<\[Tau]\>", "\<\[CapitalTheta]\>"}]\)], "Input"], Cell[TextData[{ "Note in the equations and the plot that", Cell[BoxData[ \(d\[CapitalTheta]\/d\[Tau]\)]], "is independent of \[Tau]." }], "Text"], Cell[TextData[{ "Slightly more complicated example: ", Cell[BoxData[ \(TraditionalForm\`dy\/dt\)]], "= y sin(", Cell[BoxData[ \(TraditionalForm\`yt\/\(1\ + \ t\ + y\)\)]], "),\n(dt,dy) = dt(1,ysin", Cell[BoxData[ \(TraditionalForm\`yt\/\(1\ + \ t\ + y\)\)]], "))" }], "Subsection"], Cell["\<\ As in the simpler example above we first plot the derivative's \ value as a surface using Plot3D, then we represent the behavior as a vector \ field\ \>", "Text"], Cell[BoxData[ \(Show[ Plot3D[y\ \ Sin[\ \(y\ t\)\/\(t + y + 1\)], {t, 0, 10}, {y, 0, 10}, AxesLabel \[Rule] {"\", "\", \*"\"\<\!\(dy\/dt\)\>\""}, PlotPoints \[Rule] 40, DisplayFunction -> Identity], ZeroPlane[0, 10, 0, 10], DisplayFunction -> $DisplayFunction, ViewPoint -> {14.795, \ 5.556, \ 13.731}]\)], "Input"], Cell[BoxData[ \(PlotVectorField[{1, y\ \ Sin[\ \(y\ t\)\/\(t + y + 1\)]}, {t, \ 0, 10}, \ {y, 0, 10}, Axes \[Rule] True, AxesLabel \[Rule] {"\", "\"}]\)], "Input"], Cell["\<\ To summarize this part, we have seen how first-order differential \ equations have associated trajectories in the plane of the dependent \ variables, analogous to what we simulated above by incrementing a certain \ functional relationship. Numerical differential equation solvers use similar \ techniques.\ \>", "Subsubsection"] }, Closed]], Cell[CellGroupData[{ Cell[TextData[{ "Using ", StyleBox["Mathematica", FontSlant->"Italic"], "'s DSolve function" }], "Subtitle"], Cell[TextData[{ StyleBox["Mathematica", FontSlant->"Italic"], "'s ", StyleBox["DSolve", FontWeight->"Bold"], " function finds closed-form expressions for solutions to differential \ equations, when possible. There is a related function called ", StyleBox["NDSolve", FontWeight->"Bold"], " that finds numerical solutions that can be used when ", StyleBox["DSolve", FontWeight->"Bold"], " gives up. Here are some examples of using ", StyleBox["DSolve", FontWeight->"Bold"], ":" }], "Text"], Cell[BoxData[ \(dsol\ = \ DSolve[\ \(y'\)[x]\ \ + x\ *y[x]\ \[Equal] 0, y[x], x]\)], "Input", CellTags->"mmtag:19:DSolve[]"], Cell[TextData[{ "Note that the solution is given as a rule, just like for the function ", StyleBox["Solve", FontWeight->"Bold"], ". Because no initial condition was specified, the solution involves an \ unknown constant, C[1]." }], "Text", CellTags-> "mmtag:19:ordinary_differential_equations__constants_of_integration"], Cell[BoxData[ \(dsol\ = \ DSolve[\ {\(y'\)[x]\ \ + \ Sin[x]\ *y[x]\ \[Equal] 0, y[0] \[Equal] 1}, y[x], x]\)], "Input"], Cell["\<\ In this case an initial condition was specified for the \ differential equation, so there is no undetermined constant in the solution. \ The next statement extracts y(x) for plotting...\ \>", "Text"], Cell[BoxData[ \(exactplot\ = Plot[y[x] /. Flatten[dsol], {x, 0, 10}]\)], "Input"], Cell[CellGroupData[{ Cell[TextData[{ "Compare this to the forward differencing scheme:\nRecall how\n", Cell[BoxData[ \(exampleFunction[x_]\ := \ 0.1\ x\)], "Input"], "\n", Cell[BoxData[ \(StepOnce[{x_, y_}, \ AFunction_, \ delta_]\ := \ {x + \ delta, \ y\ + \ delta\ AFunction[y]}\)], "Input"], "\n", Cell[BoxData[{ \(OurStepOnce[{x_\ , \ y_}]\ := \ StepOnce[{x, y}, exampleFunction, \ 0.01]\), "\n", \(\(result\ = \ NestList[OurStepOnce, {0, 1}, 400];\)\), "\n", \(ListPlot[result]\)}], "Input"], "\nwere used to create a plot for a function that grew at a rate that was \ 0.1 times its current size, try this for the ODE that was solved for above, \ let the new function be y':" }], "Text"], Cell[BoxData[ \(ExampleFun[x_\ , \ y_]\ := \ \(-Sin[x]\)\ y\)], "Input"] }, Open ]], Cell[BoxData[ \(StepOnce[{x_, \ y_}, \ AFunctionXY_\ , \ delta_]\ := \ {x\ + \ delta, \ y\ + \ delta\ AFunctionXY[x, y]}\)], "Input"], Cell[BoxData[ \(OurStepOnce[{x_, \ y_}]\ := \ StepOnce[{x, y}, ExampleFun, 0.01]\)], "Input"], Cell[BoxData[ \(\(result\ = \ NestList[OurStepOnce, {0, 1}, 1000];\)\)], "Input"], Cell[BoxData[ \(result // Short\)], "Input"], Cell[BoxData[ \(forwarddifferenceplot\ = ListPlot[result, PlotStyle \[Rule] {Hue[1]}]\)], "Input"], Cell["\<\ Now we superpose the exact solution with that obtained by the \ forward-differencing approximation.\ \>", "Text"], Cell[BoxData[ \(Show[forwarddifferenceplot, exactplot]\)], "Input"], Cell["\<\ Generalize to see how the step-size on the forward differencing \ scheme affects result\ \>", "Section"], Cell[BoxData[ \(res[delta_]\ := NestWhileList[\((StepOnce[#, ExampleFun, delta])\) &, {0, 1}, \ \((#[\([1]\)]\ < \ 10)\) &\ ]\)], "Input"], Cell[BoxData[ \(Table[\[IndentingNewLine]Show[exactplot, ListPlot[res[del], PlotStyle -> {Hue[0.75\ del], Thickness[0.01]}, PlotJoined -> True, DisplayFunction -> Identity], PlotRange -> {{0, 10}, {0, 1}}], {del, 0.01, 1, 0.02}]\)], "Input"] }, Closed]] }, FrontEndVersion->"5.2 for Macintosh", ScreenRectangle->{{4, 1280}, {0, 832}}, ScreenStyleEnvironment->"Presentation", ShowPageBreaks->False, CellGrouping->Manual, WindowSize->{829, 766}, WindowMargins->{{136, Automatic}, {Automatic, 70}}, WindowTitle->"Lecture 19 MIT 3.016 (Fall 2006) \[Copyright] W. Craig Carter \ 2003-2006", PrintingCopies->1, PrintingPageRange->{1, Automatic}, IndexCreationOptions->{"Format"->"Text"}, ShowCellLabel->False, CellLabelAutoDelete->True, StyleDefinitions -> "3016_Carter.nb" ] (******************************************************************* 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->{ "mmtag:19:simple_forward_time_interation"->{ Cell[1839, 55, 103, 1, 72, "Subtitle", CellTags->"mmtag:19:simple_forward_time_interation"]}, "mmtag:19:Graphics_Package__MultipleListPlot[]"->{ Cell[3839, 112, 123, 2, 47, "Input", CellTags->"mmtag:19:Graphics_Package__MultipleListPlot[]"]}, "mmtag:19:MultipleListPlot[]"->{ Cell[4172, 122, 246, 4, 68, "Input", CellTags->"mmtag:19:MultipleListPlot[]"]}, "mmtag:19:Roman_Maeder__Computer_Science_with_Mathematica"->{ Cell[4853, 143, 384, 8, 113, "Text", CellTags->"mmtag:19:Roman_Maeder__Computer_Science_with_Mathematica"]}, "mmtag:19:Module[]"->{ Cell[5394, 160, 437, 7, 110, "Input", CellTags->"mmtag:19:Module[]"]}, "mmtag:19:increment_operator"->{ Cell[7498, 226, 620, 20, 152, "Text", CellTags->"mmtag:19:increment_operator"]}, "mmtag:19:NestList[]"->{ Cell[8751, 268, 120, 2, 47, "Input", CellTags->"mmtag:19:NestList[]"]}, "mmtag:19:pure_function"->{ Cell[9127, 283, 149, 4, 47, "Input", CellTags->"mmtag:19:pure_function"]}, "mmtag:19:DisplayNow_DisplayLater__example"->{ Cell[9279, 289, 262, 5, 68, "Input", CellTags->"mmtag:19:DisplayNow_DisplayLater__example"]}, "mmtag:19:first-order_ODES__visualizing"->{ Cell[10334, 320, 148, 2, 74, "Subtitle", CellTags->{ "mmtag:19:first-order_ODES__visualizing", "mmtag:19:first-order_ODES"}]}, "mmtag:19:first-order_ODES"->{ Cell[10334, 320, 148, 2, 74, "Subtitle", CellTags->{ "mmtag:19:first-order_ODES__visualizing", "mmtag:19:first-order_ODES"}]}, "mmtag:19:Graphics_Package__PlotVectorField[]"->{ Cell[12549, 384, 115, 2, 47, "Input", CellTags->"mmtag:19:Graphics_Package__PlotVectorField[]"]}, "mmtag:19:DSolve[]"->{ Cell[15126, 469, 140, 3, 47, "Input", CellTags->"mmtag:19:DSolve[]"]}, "mmtag:19:ordinary_differential_equations__constants_of_integration"->{ Cell[15269, 474, 334, 8, 86, "Text", CellTags-> "mmtag:19:ordinary_differential_equations__constants_of_integration"]} } *) (*CellTagsIndex CellTagsIndex->{ {"mmtag:19:simple_forward_time_interation", 19185, 593}, {"mmtag:19:Graphics_Package__MultipleListPlot[]", 19342, 596}, {"mmtag:19:MultipleListPlot[]", 19485, 599}, {"mmtag:19:Roman_Maeder__Computer_Science_with_Mathematica", 19639, 602}, {"mmtag:19:Module[]", 19783, 605}, {"mmtag:19:increment_operator", 19899, 608}, {"mmtag:19:NestList[]", 20017, 611}, {"mmtag:19:pure_function", 20129, 614}, {"mmtag:19:DisplayNow_DisplayLater__example", 20263, 617}, {"mmtag:19:first-order_ODES__visualizing", 20413, 620}, {"mmtag:19:first-order_ODES", 20598, 625}, {"mmtag:19:Graphics_Package__PlotVectorField[]", 20802, 630}, {"mmtag:19:DSolve[]", 20935, 633}, {"mmtag:19:ordinary_differential_equations__constants_of_integration", \ 21090, 636} } *) (*NotebookFileOutline Notebook[{ Cell[1754, 51, 60, 0, 116, "Title"], Cell[CellGroupData[{ Cell[1839, 55, 103, 1, 72, "Subtitle", CellTags->"mmtag:19:simple_forward_time_interation"], Cell[1945, 58, 130, 3, 86, "Text"], Cell[2078, 63, 195, 3, 89, "Input"], Cell[2276, 68, 293, 6, 152, "Text"], Cell[2572, 76, 71, 1, 47, "Input"], Cell[2646, 79, 58, 1, 47, "Input"], Cell[2707, 82, 259, 5, 113, "Text"], Cell[2969, 89, 392, 6, 131, "Input"], Cell[3364, 97, 189, 4, 86, "Text"], Cell[3556, 103, 171, 3, 68, "Input"], Cell[3730, 108, 106, 2, 47, "Input"], Cell[3839, 112, 123, 2, 47, "Input", CellTags->"mmtag:19:Graphics_Package__MultipleListPlot[]"], Cell[3965, 116, 204, 4, 86, "Text"], Cell[4172, 122, 246, 4, 68, "Input", CellTags->"mmtag:19:MultipleListPlot[]"], Cell[4421, 128, 114, 3, 59, "Text"], Cell[4538, 133, 223, 3, 68, "Input"] }, Closed]], Cell[CellGroupData[{ Cell[4798, 141, 52, 0, 74, "Subtitle"], Cell[4853, 143, 384, 8, 113, "Text", CellTags->"mmtag:19:Roman_Maeder__Computer_Science_with_Mathematica"], Cell[5240, 153, 151, 5, 55, "Subsubsection"], Cell[5394, 160, 437, 7, 110, "Input", CellTags->"mmtag:19:Module[]"], Cell[5834, 169, 66, 1, 47, "Input"], Cell[5903, 172, 131, 3, 47, "Input"], Cell[6037, 177, 48, 1, 47, "Input"], Cell[6088, 180, 74, 1, 47, "Input"], Cell[6165, 183, 343, 10, 152, "Text"], Cell[6511, 195, 63, 1, 47, "Input"], Cell[6577, 198, 583, 10, 173, "Input"], Cell[7163, 210, 128, 3, 47, "Input"], Cell[7294, 215, 48, 1, 47, "Input"], Cell[7345, 218, 49, 1, 47, "Input"] }, Closed]], Cell[CellGroupData[{ Cell[7431, 224, 64, 0, 74, "Subtitle"], Cell[7498, 226, 620, 20, 152, "Text", CellTags->"mmtag:19:increment_operator"], Cell[8121, 248, 136, 2, 47, "Input"], Cell[8260, 252, 371, 10, 164, "Text"], Cell[8634, 264, 114, 2, 47, "Input"], Cell[8751, 268, 120, 2, 47, "Input", CellTags->"mmtag:19:NestList[]"], Cell[8874, 272, 49, 1, 47, "Input"], Cell[8926, 275, 198, 6, 86, "Text"], Cell[9127, 283, 149, 4, 47, "Input", CellTags->"mmtag:19:pure_function"], Cell[9279, 289, 262, 5, 68, "Input", CellTags->"mmtag:19:DisplayNow_DisplayLater__example"], Cell[9544, 296, 153, 3, 68, "Input"], Cell[9700, 301, 130, 3, 86, "Text"], Cell[9833, 306, 84, 1, 47, "Input"], Cell[9920, 309, 377, 6, 118, "Subsubsection"] }, Closed]], Cell[CellGroupData[{ Cell[10334, 320, 148, 2, 74, "Subtitle", CellTags->{ "mmtag:19:first-order_ODES__visualizing", "mmtag:19:first-order_ODES"}], Cell[10485, 324, 325, 11, 126, "Text"], Cell[10813, 337, 497, 13, 133, "Text"], Cell[11313, 352, 275, 4, 110, "Input"], Cell[11591, 358, 408, 7, 121, "Input"], Cell[12002, 367, 544, 15, 204, "Text"], Cell[12549, 384, 115, 2, 47, "Input", CellTags->"mmtag:19:Graphics_Package__PlotVectorField[]"], Cell[12667, 388, 213, 3, 68, "Input"], Cell[12883, 393, 157, 5, 79, "Text"], Cell[13043, 400, 317, 11, 125, "Subsection"], Cell[13363, 413, 172, 4, 86, "Text"], Cell[13538, 419, 365, 6, 125, "Input"], Cell[13906, 427, 191, 3, 100, "Input"], Cell[14100, 432, 338, 6, 118, "Subsubsection"] }, Closed]], Cell[CellGroupData[{ Cell[14475, 443, 118, 5, 74, "Subtitle"], Cell[14596, 450, 527, 17, 140, "Text"], Cell[15126, 469, 140, 3, 47, "Input", CellTags->"mmtag:19:DSolve[]"], Cell[15269, 474, 334, 8, 86, "Text", CellTags-> "mmtag:19:ordinary_differential_equations__constants_of_integration"], Cell[15606, 484, 144, 3, 47, "Input"], Cell[15753, 489, 209, 4, 113, "Text"], Cell[15965, 495, 86, 1, 47, "Input"], Cell[CellGroupData[{ Cell[16076, 500, 742, 17, 332, "Text"], Cell[16821, 519, 77, 1, 47, "Input"] }, Open ]], Cell[16913, 523, 158, 3, 68, "Input"], Cell[17074, 528, 105, 2, 47, "Input"], Cell[17182, 532, 86, 1, 47, "Input"], Cell[17271, 535, 48, 1, 47, "Input"], Cell[17322, 538, 110, 2, 47, "Input"], Cell[17435, 542, 123, 3, 86, "Text"], Cell[17561, 547, 71, 1, 47, "Input"], Cell[17635, 550, 114, 3, 66, "Section"], Cell[17752, 555, 162, 3, 68, "Input"], Cell[17917, 560, 274, 4, 110, "Input"] }, Closed]] } ] *) (******************************************************************* End of Mathematica Notebook file. *******************************************************************)