Professional Documents
Culture Documents
2
SOLVING ORDINARY DIFFERENTIAL EQUATIONS USING MATLAB
1. Objective(s):
The activity aims to solve differential equations using matlab.
3. Discussion :
Ordinary differential equations tend to arise whenever you need to model changing quantities that depend on the
amount of other quantities around it. For example, in chemistry, the time rate of change of concentration ( dx/dt )
of a chemical solution often depends on the concentrations of other chemicals that surround it. In biology,
differential equations are often used in population dynamics, to model the evolution and/or extinction of a
particular species (like people, animals, bacteria, or even viruses like HIV) (eg., Volterra Equations). In finance,
the stock market is often modeled via sets of coupled differential equations (e.g., Black-Scholes equation). In
physics, dfq's are everywhere { we've seen them in Cosmology (e.g., Friedmann's Equations, non-linear structure
growth and perturbation theory), Classical Dynamics (e.g., the orbits of planets, stars, and galaxies as specialized
N-body problems, hydrodynamics),and Radioactive Transfer. Most differential equations are too complicated to
write down a solution by hand (an "analytical solution"), so one has to revert to numerics to find any kind of
solution at all.
Numerical methods are commonly used for solving mathematical problems that are formulated in science
and engineering where it is difficult or even impossible to obtain exact solutions. Only a limited number of
differential equations can be solved analytically. Numerical methods, on the other hand, can give an approximate
solution to (almost) any equation. An ordinary differential equation (ODE) is an equation that contains an
independent variable, a dependent variable and derivatives of the dependent variable.
The MATLAB ODE solvers are written to solve problems of the form
dx/dt = F(t,x)
The Matlab ODE solvers are accesses by calling a function of the form
Options (if omitted or set to [], the default A data structure which allows the user to set
settings are used various options associated with the ode solver
dx_dt = …
return
ODE45 (an explicit Runge-Kutta method) is efficient, but can become unstable with stiff systems. This
will manifest itself by the solver taking shorter and shorter time steps to compensate. The solution will
either take a long time, or the time step will be reduced to the point where machine precision causes
the routine to fail.
The problems of solving an ODE are classified into initial-value problems (IVP) and boundary
value problems (BVP), depending on how the conditions at the endpoints of the domain are specified.
All the conditions of an initial-value problem are specified at the initial point. On the other hand, the
problem becomes a boundary-value problem if the conditions are needed for both initial and final
points. The ODE in the time domain are initial-value problems, so all the conditions are specified at the
initial time, such as t = 0 or x = 0. For notations, we use t or x as an independent variable.Some
literatures use t as time for independent variable.
4. Resources:
Matlab
5. Procedure:
1. Though Matlab is primarily a numeric package, it can solve straightforward differential equations
symbolically. Suppose, for example, we want to solve the first order differential equation y’ = xy where
y’ = dy/dx =y’(x).
2. We can use Matlab’s built-in dsolve(). The input for solving this problem in Matlab is given below:
>>y = dsolve(‘Dy = y*x’,’x’) where y’(x) must be written as Dy. If it is y” (x), same as d 2 y/ x 2 ,it must be written
as D2y.If it is y’’’(x), same as d 3 y/ x3 , it must be written as D3y. It is 8y’(x), same as 8dy/dx, it must be
written as 8*Dy. All in Java command window. Press enter and record the results.
3. Notice in particular that MATLAB uses capital D to indicate the derivative and requires that the entire
equation appear in single quotes. MATLAB takes t to be the independent variable by default, so here x
must be explicitly defined as the independent variable. Alternatively, if you are going to use the same
equation a number of times, you might choose to define it as a variable, say eqn 1.
>>eqn1 = ‘Dy=y*x’;
>>y = dsolve(eqn1,’x’)
>>z= eval(vectorize(y));
>>plot(x,z)
6. Suppose we want to solve and plot the solution to the second order equation
y”(x) + 8y’(x) + 2y(x) = cos(x) ; y(0) = 0 , y’(0)=1
>>y = dsolve(eqn2,inits2,’x’)
>>z = eval(vectorize(y));
>>plot(x,z)
8. Suppose we want to solve and plot the solutions to the system of three ordinary differential equations
x’(t) = x(t) + 2y(t) –z(t)
To find a general solution, each equation is now braced in its own pair of (single) quotation marks:
Press enter and record the results. Notice that since no independent variable is specified, MATLAB
used its default, t.
With conditions:
>> yy = eval(vectorize(y));
10. To find numerical solutions, MATLAB has a number of tools for numerically solving ordinary differential
equations. Built-in functions ode23 and ode45, which implement versions of Runge-Kutta 2nd/3rd order
and Runge-Kutta 4th and 5th order, respectively. Numerically approximate the solution of the first order
differential equation
dy/dx = xy 2 + y ; y(0) =1 on the interval x ∈ [0,0.5]
For any differential equation in the form y’ = f(x,y), we begin by defining the function f(x,y). For single
equations, we can define f(x,y) as an inline function
11. The basic usage for MATLAB’s solver ode45 is ode45(function, domain, initial condition). That is , we
use
>>[x,y] = ode45(f,[0,0.5],1)
13. Choosing the partition. In approximating this solution, the algorithm ode 45 has selected a certain
partition [0,0.5] and MATLAB has returned a value of y at each point in this partition. It is often the case
that we would like to specify the partition of values on which MATLAB returns an approximation. For
example, we might only want to approximate y(0.1),y(0.2)…… y(0.5).We can specify this by entering
the vector values [0,0.1,0.2,0.3,0.4,0.5] as the domain in ode45. That is, we use
>>xvalues = 0:.1:.5
>>[x,y]=ode45(f,xvalues,1)
where the default values are RelTol=.001 and AbsTol=.000001. As an example for when we might want
to change these values, observe that if yk becomes large, then the error ek will be allowed to grow
quite large. In this case, we increase the value of RelTol. For the equation y’ = xy 2 + y, with y(0)=1, the
values of y get quite large as x near 1. In fact, with the default error tolerances, we find that the
command
Leads to an error message,caused by the fact that the values of y are getting too large as x nears 1.In
order to fix this problem,we choose a smaller value for RelTol
>>options = odeset(‘RelTol’,1e-10);
>>[x,y]=ode45(f,[0,1],1,options);
>>max(y)
15. Alternatively, we can solve the same ODE by first defining f(x,y) as an M-file firstode.m
function yprime = firstode(x,y);
yprime = x*y^2 + y;
In this case, we only require one change in the ode45 command: we must use a pointer @ to indicate
the m-file. That is, we use the following commands
>>xspan=[0,.5];
>>y0=1;
>.[x,y]=ode23(@firstode,xspan,y0);
>>x
dy/dt = -σx + σy
dy/dt = ρx – y -xz
dy/dt = -βz + xy
where for the purposes of this example, we will take σ = 10, β = 8/3, and ρ=28, as well as x(0)=-8,
y(0)=8, and z(0)=27. The MATLAB M-file containing the Lorenz equations appears below
sig = 10;
beta = 8/3;
rho=28;
17. Observe that x is stored as x(1), y is stored as x(2) and z is stored as x(3).Additionally, xprime is a
column vector,as is evident from semicolon following appearance of x(2).In the command window,we
type
>>x0=[-8 8 27];
>>tspan=[0,20];
>>[t,x]= ode45(@lorenz,tspan,x0)
18. The matrix has been denoted x in the statement calling ode45, and in general any coordinate of the
matrix can be specified as x(m,n) where m denotes the row and n denotes the column.What we will be
most interested in is referring to the columns x, which correspond with values of the components of the
system. Along these lines, we can denote all row or all x by a colon : . For example, x(:,1) refers to all
rows in the first column of the matrix x; that is, it refers to all values of our original x component. Using
this information, we can easily plot the Lorenz strange attractor, which is a plot of z versus x:
>>plot(x(:,1),x(:,3))
>>plot(t,x(:,1))
>>subplot(3,1,2)
>>plot(t,x(:,2)
>>subplot(3,1,3)
>>plot(t,x(:,3)
20. In analyzing system of differential equations, we often want to experiment with different parameter
values. For example, in studying the Lorenz equations we might want to consider the behavior as a
function of the values of σ,β and ρ. Of course, one way to change this is to manually re-open the M-file
Lorenz.m each time we want to try new values, but not only is a slow way to do it, it’s unwieldy to
automate it. What we can do instead is pass parameter values directly to our M-file through the ode45
call statement.Alter Lorenz.m into lorenz1.m, the latter of which accepts a vector of parameters that we
denote p.
Function xprime = lorenz1(t,x,p);
sig=p(1);beta=p(2);rho=p(3);
>>[t,x]=ode45(@lorenz1,tspan,x0,[],p)
22. The first step in solving a second (or higher) order ordinary differential equation in MATLAB is to write
the equation as a first order system. For the equation
y”(x) + 8y’(x) + 2y(x) = cos(x) ; y(0) = 0 , y’(0)=1
y1‘(x) = y2(x)
23. Another class of ODE’s that often arise in applications are boundary value problems (BVP’s).
Consider ,for example, the differential
y” – 3y’ + 2y = 0
y(0) = 0
y(1)=10
where our conditions y(0)=0 and y(1) = 10 are specified on the boundary of the interval of
interest
interest x ∈ [0,1]. The first step in solving this type of equation is to write it as a first order system
y1 ‘ = y2
y2 ‘ = -2y1 + 3y2
25. Next , we write the boundary conditions as the M-file bc.m, which records boundary residues
Function res = bc(y0,y1)
Res=[y0(1);y1(1)-10];
By residue, we mean the left-hand side of the boundary condition once it has been set to 0.In this case,
the second boundary condition is y(1)=10, so its residue is y(1)-10, which is recorded in the second
component of the vector that bc.m returns The variables y0 and y1 represent the solution at x=0 and at
x=1 respectively, while the 1 in the parenthesis indicates the first component of the vector. In the event
that the second boundary condition was y’(1) = 10, we would replace y1(1)-10 with y1(2)-10.
26. We are now in a position to begin solving the boundary value problem. In the following code, we first
specify a grid of x values for MATLAB to solve on and an initial guess for the vector that would be given
for an initial value problem [y(0),y’(0)].We solve the boundary value problem with MATLAB’s built-in
solver bvp4c.
>>sol = bvpinit(linspace(0,1,25),[0 1]);
>>sol = bvp4c(@bvpexample,@bc,sol);
>>sol.x
27. We observe that in this case MATLAB returns the solution as a structure whose first component sol.x
simply contains the x values we specified.The second component of the structure sol is sol.y, which is
the matrix containing as its first row values of y(x) at the grid points we specified, and as its second row
the corresponding values of y’(x).
28. For the first order differential equation where the highest derivative of the function is one :
From calculus, we all know that the solution to this equation is y(t) = Ce-5t, where C is some arbitrary
constant. If we specified an initial condition (say, y(0)= 1.43), then our analytical solution would be y(t) =
1.43 e-5t.
29. In Matlab, we can use numerical integration techniques to solve differential equations like this one.For
the differential equation in Procedure No. 28, you would make two .m files (one will be a function file,
and the other will be a script that calls the function file).Using Matlab editor, create the file below and
save it as ilovecats.m.
Function dy= ilovecats(t,y)
dy = zeros(1,1);
dy = -5 * y;
[t,y]=ode45(‘ilovecats’,[0,10],1.43);
plot(t,y,’-‘)
xlabel(‘time’);
ylabel(‘y(t)’);
30. Type ‘help ode45’ at the prompt. As a general rule of thumb, ode45 is the best function to apply as a
first try for most problems.Ode 45 is an explicit (4,5) Runge-Kutta integrating technique.At Matlab
prompt, type happyscript.m. Press enter and record the results.
31. A 2nd order differential equation is one where the highest derivative term is of order 2:
To integrate this in Matlab, we have to rewrite this single equation into a set of 2 first order differential
equations. The reason behind this is because all Runge-Kutta solvers, including ode45, are built to only
integrate over equations of the type dy/dt = f(t,y).We can easily do this by hand, by setting:
dy1/ dt = y2
dy2/dt = - ω2 sin(y1)
dy = zeros(2,1);
omega = 1;
dy(1) = y(2);
dy(2) = -omega*omega*sin(y(1));
plot(t,y(:,1),’-‘);
xlabel (‘time’);
ylabel(‘y_{1}(t)’);
title(‘\theta (t)’);
figure;
plot(t,y(:,2),'-');
xlabel('time');
ylabel('y_{2}(t)');
title('d \theta / dt (t)');
figure;
plot(y(:,1),y(:,2),'-');
xlabel('\theta (t)');
ylabel('d \theta / dt (t)');
title('Phase Plane Portrait for undamped pendulum');
34. The change in the function file, pendulumcats.m, is the initialization part in line two – dy = zeros(2,1);
This is because we now have two equations we are integrating over (y1(t) and y2(t), so Matlab will
store their data into a matrix with two columns.If you just type y at your Matlab prompt, you will get two
columns of data that display.The first column is the set of y(t) (or y1(t)), whose data points you can
alone access by typing y(:,1) at your prompt.The second column of y are the datapoints for y2(t), which
you can access by themselves by typing y(:,2) at your prompt.
35. Run the commands. Record the results.
36. Back in the day, scientists didn't know as much, and thought they could accurately predict the weather
once computers became more powerful. This is because weather people used many sets of differential
equations to model the weather, and it took a long time to integrate those equations (keep in mind that
awesome things like Matlab weren't around in the 50s and 60s { people still used slide rulers and tables
to calculate many things, and the computers that were available back in the day had very little
computing power, so integrating some ODEs, like those in the pendulum example, would take a crazy
long time for the computer to chug through!).
Edward Lorenz was a mathematician and weather forecaster for the US Army Air Corps, and
later an MIT professor. For many years, he was interested in solving a simple set of 3 coupled
differential equations just because he wanted to find out what the weather would be like during the next
week." These equations are called the Lorenz Equations, and were derived from simplified equations of
convection rolls rising in the atmosphere. They are pretty simple and can be expressed as:
dx/dt = -Px + Py
dy/dt = rx – y – xz
dz/dt = xy –bz
where P, r and b are all constants ( P represents the Prandtl number, and r is the ratio of Rayleigh
number to the critical Rayleigh number), and x, y and z are all functions of time. We can use Matlab to
look at trajectories (i.e. plots of x(t) vs time, y(t) vs. time and z(t) vs. time) or phase plane portraits (i.e.
x(t) vs y(t), x(t) vs z(t), and/or y(t) vs z(t) for this system.
37. The function file lorenz.m) should look like:
function dy = lorenz(t,y)
dy = zeros(3,1);
P=10;
r=28;
b=8/3
dy(1)=P*(y(2)-y(1));
subplot(221)
plot (y(:,1),y(:,2),’-);
xlable(‘x(t)’);
ylabel(‘y(t)’);
subplot(222)
plot(y(:,1),y(:,3),’-‘);
xlabel(“x(t)”);
ylabel(‘ z(t)’);
subplot(223)
plot(‘ y(:,2),y(:,3,)’-’);
xlabel(‘y(t)’);
ylabel(‘z(t)’);
plot(0,0,’.’);
xlabel(‘Edward Lorenz’);
ylabel(‘Kitties’);
title(‘Kitties vs Lorenz’);
39. Run the script.It should take a little while to run. Record the results.
40. To make a 3D plot ,add the following to the bottom of the script.
plot3(y(:,1),y(:,2),y(:,3),’-‘)
xlabel(‘x(t)’);
ylabel(‘y(t)’);
zlabel(‘z(t));
41. The Matlab code to solve dy/dx = y(x) with no initial conditions is shown below:
ODE1= ‘dy = y’
ODE1solved=dsolve(ODE1, ‘x’)
y_values = eval(vectorize(ODE1solved);
plot(x,y_values)
ODE2solved = simplify)dissolve(ODE2,initConds));
pretty(ODE2solved)
t=-5 :0.01:5;
y_values=eval(vectorize(ODE2solved));
plot(t,y_values)
45. Systems of ODEs can be solved in a similar manner.One simply defines each equation as before. The
only thing that changes is the return of the dsolve function, which is now an array containing the explicit
solutions of each of the functions in the system
sysODE1 = ‘Dx = 2*x + 3*z’
[x,y,z] = dsolve(sysODE1,sysODE2,sysODE3,initConds)
C1*exp(x^2/2)
3 y=
C1*exp(x^2/2)
4 y=
exp(-1/2)*exp(x^2/2)
5
7.a y=
8.a x=
y=
z=
y=
z=
10*exp(3*t) - 12*exp(2*t) + 5*exp(t)
9
10 f=
Inline function:
f(x,y) = x*y^2 + y
11 x=
0
0.0500
0.1000
0.1500
0.2000
0.2500
0.3000
0.3500
0.4000
0.4500
0.5000
y=
1.0000
1.0526
1.1111
1.1765
1.2500
1.3333
1.4286
1.5384
1.6666
1.8181
1.9999
12
13.a xvalues =
Columns 1 through 4
Columns 5 through 6
0.4000 0.5000
13.b x=
0
0.1000
0.2000
0.3000
0.4000
0.5000
y=
1.0000
1.1111
1.2500
1.4286
1.6666
1.9999
14 ans =
5.0407e+06
15 x=
0
0.0500
0.1000
0.1500
0.2000
0.2500
0.3000
0.3500
0.4000
0.4500
0.5000
16 >>unction xprime = Lorenz(t,x);
%LORENZ: Computes the derivatives involved in solving the Lorenz equations
>>sig = 10;
>>beta = 8/3;
>>rho=28;
>>xprime=[-sig*x(1) + sig*x(2);rho*x(1)-x(2)-x(1)*x(3);-beta*x(3) +x(1)*x(2)];
17 >> x0=[-8 8 27];
tspan=[0,20];
[t,x]=ode45(@Lorenz,tspan,x0)
t=
0
0.0025
0.0050
0.0075
0.0100
0.0226
0.0352
0.0477
0.0603
0.0716
0.0830
0.0943
………..
20.0000
x=
-8.0000 8.0000 27.0000
-7.6036 7.9571 26.6639
-7.2182 7.9093 26.3387
-6.8436 7.8574 26.0242
-6.4796 7.8021 25.7199
-4.8119 7.4981 24.3412
-3.3774 7.1889 23.1694
-2.1473 6.9160 22.1667
-1.0914 6.7046 21.3016
-0.2618 6.5763 20.6165
0.4684 6.5119 20.0097
1.1163 6.5131 19.4715
1.6982 6.5799 18.9945
2.2291 6.7105 18.5741
2.7204 6.9037 18.2088
3.1825 7.1578 17.8982
3.6255 7.4708 17.6432
4.1388 7.9154 17.4156
4.6484 8.4367 17.2764
5.1634 9.0304 17.2341
5.6926 9.6906 17.2988
6.3616 10.5662 17.5365
7.0672 11.5092 17.9737
7.8113 12.4920 18.6358
8.5916 13.4742 19.5445
9.6642 14.6894 21.1488
10.7406 15.6455 23.2205
11.7532 16.1565 25.6930
12.6109 16.0569 28.3967
13.1833 15.2991 30.8977
13.4538 13.9363 33.1074
13.3694 12.0970 34.7935
12.9326 9.9522 35.8158
12.3397 8.1418 36.1205
11.5704 6.4354 35.9751
10.6745 4.9284 35.4447
9.7046 3.6772 34.6231
8.7653 2.7427 33.6673
7.8442 2.0411 32.6010
6.9707 1.5493 31.4770
6.1655 1.2329 30.3361
5.4502 1.0564 29.2197
………………………………….
10.5640 15.2991 22.9618
11.0058 15.6163 23.9464
18
19
21 t=
0
0.0025
0.0050
0.0075
0.0100
0.0226
0.0352
0.0477
0.0603
0.0716
0.0830
0.0943
0.1057
0.1171
0.1284
0.1398
…………….
19.9906
20.0000
x=
25
ans =
Columns 1 through 5
Columns 6 through 10
Columns 11 through 15
Columns 16 through 20
Columns 21 through 25
Columns 1 through 8
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
Columns 9 through 16
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
Columns 17 through 24
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
Column 25
0
1
29
32
33
34
…………
37
38
39
40
41
42
43
44
7. Conclusion:
I therefore conclude that the laboratory experiment number 2 helped us easily navigate ordinary differential
equations using MATLAB. The various and unique functions and code of MATLAB were used to gain a general
solution of an ODE problem. This
experiment allows us to plot the solution of about 20 orbits near the equilibrium solution using the given codes.
MATLAB guides students on familiarizing several approaches solving initial value ordinary equations. It also
presents the user with various tools for modeling linear systems that can be used to solve ordinary differential
equations.
TIP–VPAA–054D
TECHNOLOGICAL INSTITUTE OF THE PHILIPPINES
Revision Status/Date: 0/2009 September 09
RUBRIC FOR LABORATORY PERFORMANCE
1 2 3
I. Laboratory Skills
Manipulative
Members do not demonstrate Members occasionally Members always demonstrate
needed skills. demonstrate needed skills. needed skills.
Skills
Members do not follow safety Members follow safety Members follow safety
Safety Precautions
precautions. precautions most of the time. precautions at all times.
Members do not know their Members have defined Members are on tasks and
tasks and have no defined responsibilities most of the have defined responsibilities at
Cooperative and
responsibilities. Group time. Group conflicts are all times. Group conflicts are
Teamwork
conflicts have to be settled by cooperatively managed most of cooperatively managed at all
the teacher. the time. times.
Ability to do Members require supervision Members require occasional Members do not need to be
independent work by the teacher. supervision by the teacher. supervised by the teacher.
TOTAL SCORE
Other Comments / Observations:
TotalScore
RATING = ( ) x 100%
24
Evaluated by:
_______________________________________