Matthew L. Wright
Assistant Professor, St. Olaf College

# Mathematica Examples

## Math 230: Differential Equations

The following examples show how to use Mathematica to perform calculations that are common in Math 230. For more information about any of the Mathematica commands used below, see the Wolfram language documentation.

### 1. Slope Fields

The VectorPlot command can draw a slope field for the differential equation $$\frac{dy}{dt} = f(t,y)$$. Since VectorPlot draws a vector field (not the same as a slope field) by default, it is necessary to specify some optional parameters to obtain a slope field. The general syntax is as follows:

VectorPlot[ {1, $$f(t,y)$$}, {t,$$t_{min}$$,$$t_{max}$$}, {y,$$y_{min}$$,$$y_{max}$$}, VectorStyle->"Segment", VectorScale->{Tiny, Tiny, None} ]

For example, the following command draws a slope field for $$\frac{dy}{dt} = ty$$ in the window $$-3 \le t \le 3$$, $$-3 \le y \le 3$$:

VectorPlot[ {1, t*y}, {t,-3,3}, {y,-3,3}, VectorStyle->"Segment", VectorScale->{Tiny, Tiny, None} ]

The output of the previous command should look like this:

### 2. Euler's Method

#### Using a loop

For example, suppose we want to approximate $$y(1)$$, where $$y(t)$$ is the solution to $$\frac{dy}{dt} = 2y - \sin(t)$$, with $$y(0)=3$$, using Euler's method with step size $$\Delta t = 0.01$$. One way to do this is to use a loop to compute the successive approximations, as shown here:

f[ t_, y_ ] = 2*y - Sin[t]; y[0] = 3; Δt = 0.01; Do[ y[ n+1 ] = f[ Δt * n, y[n] ] *Δt + y[n], {n,0,99} ]

The semicolons in the code above surpress the output of the first three lines. However, after the above code is run, y[100] constains the value 20.7345, which is our approximation of $$y(1)$$ using Euler's method with 100 steps.

To see the approximations of $$y$$ at the intermediate steps of Euler's method, use the following command:

Table[ {n, y[n]}, {n, 0, 100} ]

The above command produces a list of pairs $$(n, y_n)$$ such that $$y_n \approx y(n \cdot \Delta t)$$ is the approximation found by step $$n$$ Euler's method.

#### Using NDSovle

The NDSolve command finds numerical solutions to differential equations. It can do so via Euler's method, among other methods.

Suppose you have the initial-value problem $$y'(t) = f(t,y)$$ with $$y(0) = y_0$$, and you want to approximate $$y(t_1)$$ using Euler's method with step size $$\Delta t$$. The general syntax to do this with NDSolve is as follows:

NDSolve[ {y'[t] = $$f(t,y)$$, y[0] == $$y_0$$}, y, {t, 0, $$t_1$$}, StartingStepSize -> $$\Delta t$$, Method -> "ExplicitEuler" ]

Note that NDSolve returns a nested list containing an InterpolatingFunction object.

For example, if $$\frac{dy}{dt} = 2y - \sin(t)$$, with $$y(0)=3$$. To approximate $$y(1)$$ using Euler's method with step size $$\Delta t = 0.01$$, use the following command:

NDSolve[ {y'[t] == f[t, y[t]], y[0] == 3}, y, {t, 0, 1}, StartingStepSize -> 0.01, Method -> "ExplicitEuler" ]

The output of the above line looks like this:

Notice that the NDSolve command has returned an InterpolatingFunction inside of a nested list. To extract the function from the nested list, use the /. (the short form of ReplaceAll) as follows:

y = y /. First[ NDSolve[ {y '[t] == f[t, y[t]], y[0] == 3}, y, {t, 0, 1}, StartingStepSize -> 0.01, Method -> "ExplicitEuler" ] ]

The solution (in the form of an InterpolatingFunction) is now stored in the variable y. For example, y[1] gives you the value of the approximation of $$y(1)$$. You can also list the approximations of $$y$$ at the intermediate steps of Euler's method with this command:

Table[ {t, y[t]}, {t, 0, 1, 0.01} ]

...or plot the graph of the approximate solution like this:

Plot[ y[t], {t, 0, 1} ]

### 3. Finding Analytic Solutions

The DSolve command can find analytic solutions to some differential equations and initial-value problems.

For example, to find the general solution to $$\frac{dy}{dt} = ty$$:

DSolve[ y'[t] == t*y[t], y[t], t ]

To find the particular solution to $$\frac{dy}{dt} = ty$$ with initial condition $$y(0)=5$$:

DSolve[ {y'[t] == t*y[t], y[0] == 5}, y[t], t ]

The previous command produces the following output:

Notice that solution is returned as a mathematical rule inside of a nested list. We often want to extract the solution from the nested list—for example, to plot the solution. Here is one way to do this:

sol = DSolve[ {y'[t] == t*y[t], y[0] == 5}, y[t], t ]; Plot[ Evaluate[ y[t] /. sol ], {t, -3,3} ]

The first line above solves the initial-value problem and stores the solution (which is a nested list containng a rule) in the variable sol. We then use /. (the short form of ReplaceAll) to apply the rule contained in the nested list. Since we want to evaluate the expression y[t] /. sol inside of the Plot function, we must use Evaluate[ y[t] /. sol ]. The output is the following plot: