where are constants.

The first thing I did was open Mathimatica and listed to be  Random Integers. By doing this; every time I pressed Shift+Return I would receive a new graph with different traces and determinants.

For the second part of this project we had to find the values for . And graph their respective lines on the graph.

The first one I chose was a spiral. This does not give us any lines to graph. The answer we got was involving  .

Here for this plot we found the values of to be:

H*The right
hand side of the
differential equation*L
F@8t_, y_<D := t + y^2;
H*The time step size*L
deltat = 0.001;
H*Defining the
Euler scheme*L
euler@8t_, y_<D :=
8t + deltat,
y + deltat * F@8t, y<D<;
H*Apply the Euler scheme
successivey starting from
the initial condition*L
output = NestList@
euler, 80, 1<, 1000D;
H*Plot the output*L
A = ListPlot@
output, Joined ® True,
PlotStyle ® 8Red, Thick<D
General::ovfl : Overflow occurred in computation. ‡
0.2 0.4 0.6 0.8
2
4
6
8
10
12
14
ClearAll@output, y, t, deltat, FD
Solve::ifun :
Inverse functions are being used by Solve, so some solutions may not be found; use Reduce for complete
solution information. ‡
Solve::ifun :
Inverse functions are being used by Solve, so some solutions may not be found; use Reduce for complete
solution information. ‡
DSolve@8y¢@tD Š F@t, y@tDD, y@1D Š 2<, y@tD, tD
2 Project 3 problem 1.nb
ClearAll@s, tD;
s = NDSolve@8y’@tD == F@8t, y@tD<D,
y@0D Š 1<, y, 8t, 0, 1.0<D
B = Plot@Evaluate@y@tD . sD,
8t, 0, 1.0<, PlotRange ® All,
PlotStyle -> 8Black, Thick<D
NDSolve::ndsz :
At t == 0.9305643422360891`, step size is effectively zero; singularity or stiff system suspected. ‡
88y ® InterpolatingFunction@880., 0.930564<<, <>D<<
0.2 0.4 0.6 0.8 1.0
-8´1046
-6´1046
-4´1046
-2´1046
Project 3 problem 1.nb 3
Show@8A, B<D
0.2 0.4 0.6
2
4
6
8
10
12
14
4 Project 3 problem 1.nb

For this first project, our objective is to plot various Differential Equations and determine what the plot is actually telling us. This first project was just a series of trial and error along with trying to figure out how to correctly plot the Differential Equations. I worked with Thomas Morris.

Question 1:

a.

This first Differential Equation was not that challenging. To get the first plot, I simply put VectorPlot[{1, 2 x}, {x, 0, 1}, {y, 0, 1}] and received the first plot. I then decided to go ahead and try a different plot to see if it would give me a clearer understanding of what the Differential Equation is doing. I also added a little color to it. As you can see, this stream plot view of the Differential Equation shows a bit more.

As you can see from the plot above, as moves from 0.3 to 0.5 it rapidly increases the value.

b.

Similarly as the previous problem, I used the StreamPlot function on Mathimatica. StreamPlot[{1,2y/x},{x,-1,1},{y,-3,3}] gave me the following plot.

The next problem gave us an interesting plot. at we get a straight line as well as when . But with any other and value we get a rapid curve. From and the curves are somewhat minor compared to the the almost vertical lines when . The same goes for the any value for both and greater than

c.

Here we have another interesting graph. It seems we almost have a straight line diagonally through the graph where some of the curves start. Again in this graph, as decreases from to or increases from to the curves are less intense. Also at  is where some of the lines start and also it is a minimum and a maximum for others. For this plot, I also used the stream plot function;StreamPlot[{1,(x-y)/(x+y)},{x,-1,1},{y,-3,3}].

d.

Here in this plot we have very strong positive curves. But again in this plot, at is either the beginning or the end for some of the curves. Some of the curves follow but then turn upward and change their direction at .

Question 2.

a.

Again, similarly as the other plots, this plot has an apparent beginning and end for some of the curves that separate the two streams. The rest of the curves bend and follow each other, all bending at the same point. This plot was kind of hard to describe.

b.

Again, separates the two streams. This plot almost looks like it has the ripple effect, beginning at and and for each value of and the ripple gets weaker and weaker.

Problem 1: T(x,y)=(x+y,x)

This separates into two equations:

dx/dt=x+Y

dx/dt=x

For this example there are two solutions which will be graphed later.

First I set (x+y,x)=(λx,λy)

This simplifies out into two separate equations of

x+y=λx and x=λy

In order to solve for the value/s of λ I set the two equations equal to zero

(1-λ)x+y=0

xλy=0

Then I used the equation ad-bc=o solve for λ where

a=(1-λ), b=1, c=1 and d=-λ

These values are found by setting the two equations equal to ax+by=0 and cx+dy = 0.

For this example λ=+.6103 and λ=-.6103

Finally,  for solving the system is to plug the final λ value into one of the original equations of

(1-λ)x+y=0

x-λy=0

and  solve for y to get thesolutions for the equation.

the answers are         y=0.618034x and         y=-1.618034x

Here is the code that I wrote to graph the solutions along with the vector field:

[x,y]=meshgrid(-1:1/10:1,-1:1/10:1);
>> u=2*x+y;
>> v=x+y;
>> w=sqrt(u.^2+v.^2);
>> quiver(x,y,u./w,v./w,.5,’.’)
>> hold on
>> f=@(x).618034*x;
>> fplot(f,[-1,1],’r’)
>> hold on
>> f=@(x)-1.61803*x;
>> fplot(f,[-1,1],’g’)
>> hold off
>> hold off

This was the final solution.

Example #2

dx/dt=2x+5y

dy/dt=x-2y

λ=-0.23606 and λ=4.23607

Soutions:

Red: y= -1         Green: y=0.2

Example #3

dx/dt=x+3y

dy/dt=y

λ-1

Solution: Red: y=0

Example #4

dx/dt=2x+2y

dy/dt=2x+y

λ=-0.56155 and λ=3.5616

Solutions:

Green: y= -1.2807x                Red: y= 0.7807x

Example #5

dx/dt=-4x-3y

dy/dt=-2x+4y

λ=√22

Solution: Red: y= -2.8968x

Example #6

dx/dt=2x-2y

dy/dt=2x+y

λ=(3+√-15)/4 and λ=(3-√-15)/4

This differential equation has a non- real solution.

1:  4xydx+(x^2+1)dy=0

First, I subtracted (x^2+1)dy from both sides and got 4xydx=-(x^2+1)dy.

At the same time, I divided both sides by y and -(x^2+1),

which yields (4xydx)/-(x^2+1))=dy/y.

Next, I integrated both sides ∫(4xdx)/(-(x^2+1)=∫dy/y.

After that, I used the U-Substitution method which gave me, -2ln|(x^2+1)| = ln |y| +C.

By raising both sides to the exponent of e, the ln functions disappear and I could then rewrite the functions in terms of y:

y=e^-2ln(x^2+1)+C

By raising both sides to the exponent of e, the ln functions disappear so I could then rewrite the function in terms of y:

y=e^(-2ln(x^2+1))+C

Simplifying it even further I get y=(1/x^2+1)^2+C=(1/(x^2+1)^2)+C

Using dsolve, we get:

>> dsolve(’Dy = -(4*x*y)/(x^2 + 1)’,’x’)

ans =

C6/(x^2 + 1)^2

2: tan(x)dy+2ydx=0

tan(x)dy=-2ydx .

dy/-2t=dx/tan(x).

ln|y|=-2ln|sin(x)|

|y|=C/sin^2(x)

Using dsolve, we get:

>> dsolve(’Dy/y = -2*cot(x)’,’x’)

ans =

C12/sin(x)^2

3: (e^x+1)cos(y)dy+e^x(sin(y)+1)dx=0, y(0)=3

(e^x+1)cos(y)dy=-e^x(sin(y)+1dx

(cos(y)dy)/(sin(y)+1)=(-e^x)/(e^x+1)

ln|sin(y)+1|=ln|e^x+1|-1+C

sin(y+1)=(e^x+1)-1+C

y+1=arcsin(1/e^x+1)+C

y=arcsin(1/e^x+1)-1+C

Next I plugged in 3 for y and 0 for x and found C=4-(π/6)

Using DSolve in Mathematica, we get:

DSolve[(Exp[x]+1)*Cos[y[x]] y’[x] + Exp[x]*(Sin[y[x]]) == 0, y[x], x]

{{y[x] -> -ArcSin[E^C[1]/(1+E^x]}}

10: x(dx/dt)+t=1

x(dx/dt)+t=1

x(dx/dt)=1-t

xdx=(1-t)dt

∫xdx=∫(1-t)dt

1/2(x^2)=t-1/2(t^2)+C

x(t)=±√2t-t^2 +C

Using DSolve in Mathematica, we get:

DSolve[X'[T] == (1 – T)/X[T], X[T], T]

{{X[T] -> -Sqrt[2 T - T^2 + 2 C[1]]}, {X[T] -> Sqrt[

2 T - T^2 + 2 C[1]]}}

12: 2x^2y(dy/dx)+y^2=2

2x^2y(dy/dx)=2-y^2

x^2(dy/dx)=(2-y^2)/(2y)

(x^2)/(dx)=(2-y^2)/(2ydy)

(1/x^2)dx=(2y/(2-y^2))dy

∫(1/x^2)dx=∫((2y)/(2-y^2))dy

U-Substitution:

u=2-y^2

du=-2ydy

-du=2y

-∫du/u=∫x^(-2)dx

-ln|u|=(-1/x)+C

ln|2-y^2|=(1/x)+C

e^(ln|2-y^2|=(e^(1/x))+C

|2-y^2|=e^(1/x)+C

y=±√2-(e^1/x)+C

14: dy/dx-xy^2=2xy

dy/dx=2xy+xy^2

dy/dx=x(2y+y^2)

dy/xdx=2y+y^2

1/xdx=(2y+y^2)/dy

xdx=dy/(2y+y^2)

∫xdx=∫(dy)/(2y+y^2)

1/2x^2=(ln(|y|/|y+2|)/2)

x^2=ln(|y|/|y+2|)

e^x^2=e^(ln(|y|/|y+2|))

e^x^2=|y|/|y+2|

y=(-2e^x^2)/((e^x^2)-1)

]]> http://danielletropeamth212s09.wordpress.com/2009/04/23/fourth-block/feed/ 0 Danielle's Blog http://danielletropeamth212s09.wordpress.com/2009/03/24/third-block/ http://danielletropeamth212s09.wordpress.com/2009/03/24/third-block/#comments Tue, 24 Mar 2009 02:27:55 +0000 Danielle's Blog http://danielletropeamth212s09.wordpress.com/?p=68 ]]>

While addressing a major issue I will use differential equations to model physical or biological phenomena; the nature of the solution curves to a system of coupled non-linear differential equations.

Lorenz Equations

dx/dy=σ(y-x)

dx/dt=x(ρ-x)

dz/dt=xy-βz

Now I created an m file called lorenz_system.m which returns the derivative function as a column vector. I used this same code each time only changing the three variables σ, β, and ρ.

function yprime = lorenz_system (t,y)

yprime = [ σ* (y(2)-y(1)); y(1)*(ρ-y(3))-y(2);y(1)*y(2)-β*y(3) ];

To run this in the command line; I set up the vector of initial condition, the time range, and the number of steps to take, and call “lorenz_system” as an argument to euler_system.m. Below is the code I used.

>> y_init = [ rand(); rand(); rand() ];
>> [ t, y ] = euler_system ( ‘lorenz_system’, [ 0.0, 20.0 ], y_init, 1000 );

To get a plot of the Lorenz attractor I used a built-in package for obtaining approximate numerical solutions to differential equations and systems of differential equations in MATLAB called ode45.

To use the ode 45 for the lorenz system I created two m-files. Following is the code for the first m-file which I saved as g.m.

function xdot = g(t,x)

xdot = zeros(3,1);

σ= 10.0;

ρ = 28.0;

β= 8.0/3.0;

xdot(1) = σ*(x(2)-x(1));

xdot(2) = ρ*x(1)-x(2)-x(1)*x(3);

xdot(3) = x(1)*x(2)-β*x(3);

Below is the code for the second m-file that I saved as lorenz_demo.m

function lorenz_demo(time)

[t,x] = ode45(’g’,[0 time],[1;2;3]);

disp(’press any key to continue …’)

pause

plot3(x(:,1),x(:,2),x(:,3))

print -deps lorenz.eps

This function integrates the Lorenz attractor and from t=0 to t=time.

I then entered “lorenz_demo(200)” at the MATLAB prompt to produce a graphical solution to the Lorenz system of differential equations. The timer ranges from 0 to 200.

1.σ = 10

β = 8/3

ρ = 28

Euler 2-D:

Euler 3-D:

Ode 45:

2.σ = 10

β = 8/3

ρ = 18

Euler 2-D:

Euler 3-D:

Ode 45:

3.σ = 10

β = 8/3

ρ = 8

Euler 2-D:

Euler 3-D:

Ode 45:

To solve Rossler system of equations, I reopened the previous Euler m-file. I saved the following code saved as rossler.m which defines the Rossler system of equations.

function yprime = lorenz_system ( t, y )
yprime = [-y(2)-y(3); y(1)+a*y(2);b+y(3)*(y(1)-c) ];

To call “lorenz_system” as an argument to euler_system.m. I used the code below.

>> y_init = [ rand(); rand(); rand() ];
>> [ t, y ] = euler_system ( ‘lorenz_system’, [ -50.0, 50.0 ], y_init, 10000 );

After getting the solutions yielded by the Euler Method, I used ode 45. I used similar m files to the ones used with the Lorenz system of equations. I made an m-file to define the Rossler differential equations. I changed this m file each time with the different value of a,b, and c.

I created an m-file called rossler_demo.m to solve the rossler system. The following is the code I used:

function rossler_demo(time)

[t,x] = ode45(’gr’,[0 time],[1;2;3]);
disp(’press any key to continue …’)
pause
plot3(x(:,1),x(:,2),x(:,3))
print -deps rossler.eps

I entered “rossler_demo(200)” into the command window to execute the Ode 45.

I used the following code, only altering the values of a,b, and c.

function xdot = gr(t,x)
xdot = zeros(3,1);
a = 0.2;
b = 0.2;
c = 5.7;
xdot(1) = -x(2)-x(3);
xdot(2) = x(1)+ax(2);
xdot(3) = b+x(3)*(x(1)-c);

1.a = 0.2

b = 0.2

c = 5.7

Euler 2-D:

Euler 3-D:

Ode 45:

2.a = 0.1

b = 0.1

c = 4

Euler 2-D:

Euler 3-D:

Ode 45:

3.a = 0.1

b = 0.1

c =12

Euler 2-D:

Euler 3-D:

Ode 45:

4.a = 0.1

b = 0.1

c = 18

Euler 2-D:

Euler 3-D:

Ode 45:

|y_i-y(x_i)|≤Ch

C is a constant value depending on the function and specific interval and h is the step size, as explained in the text.  Things aren’t always constant which in turn cause Eulers method to be inclined to errors. Mathematicians named Carl Runge and Wilhelkm Kutta, set out to find a better way to solve these problems.They came up with what is known as the Runge-Kutta 4th Order Method. They used parabolas and quartics instead of using a bunch of straight lines to make up a solutions curve. This in turn makes for a much more accurate approximation:

|y_i-y(x_i ) |≤Mh^4

M is a constant value depending on the function and specific interval and h is the step size, as explained in the text.

Using the same technique of creating m-files for the Euler method and differential equations. MATLAB has a built in function called “ode 45″ that is used like the Euler m-file.

Problem#1: dy/dx=(x^4)y

The first step is to plot the equation using the Euler method. First a created a file called block2.m :

function f=block2(xn,yn)
%
% The original ode is dy/dx=((x^4)*y)
%
f= (xn.^4).*yn

Another separate “m” file was needed as well as code in the main window of MATLAB. This is both the “m” file that we named euler1.m and the main window code that we used to set up the Euler approach.

function [xout,yout]=euler(fname,xvals,y0,h)
x0=xvals(1);xf=xvals(2);
xn=x0; yn=y0;
xout=xn; yout=yn;
steps=(xf-x0)/h;
for j=1:steps
fn=feval(fname,xn,yn);
xn=xn+h;
yn=yn+h*fn;
xout=[xout;xn];
yout=[yout;yn];
end

The main window code is as follows:

[x,y]=euler1(’Example’,[-1,1],1,.1);

[X,Y]=meshgrid(-4:0.2:4,-4:0.2:4);

DY=(X.^4).*Y;
DX=ones(size(DY));
DW=sqrt(DX.^2+DY.^2);
quiver(X,Y,DX./DW,DY./DW,0.5,’.’);
hold on
plot(x,y)
hold off

Resulting in this graph:

As you can see a straight line with slope of 0 is formed at y=o. The range of the solution has to be so small because once I expanded the bounds of the line the graph either shrank so speedily or grew to fast that the line quickly went out of range and the graphical solution was useless.

After the completion of this graph the Runge-Kutta method was used to see if there was any difference between the two methods. For this solution I had to create another new “m” file, RK.m, and place a new set of code in the main command window.

RK.m

function [xout,yout]=RK(fname, xvals, y0, h)
x0=xvals(1);xf=xvals(2);
xn=x0; yn=y0;
xout=xn; yout=yn;
steps=(xf-x0)/h;
yn=yn’;

for j=1:steps
k1=feval(fname,xn,yn);
k2=feval(fname, xn+(h/2), yn+(h*k1/2));
k3=feval(fname, xn+(h/2), yn+(h*k2/2));
k4=feval(fname, xn+h,yn+h*k3);
ynext=yn+h*(k1+2*k2+2*k3+k4)/6;
xnext=xn+h;
xout=[xout;xnext];
yout=[yout; ynext'];
xn=xnext;
yn=ynext;
end

Command Window Code for Runge-Kutta

>> [x,y]=RK4(’Example1′,[-1,1],1,.1);
>> [X,Y]=meshgrid(-4:0.2:4,-4:0.2:4);
>> DY=(X.^4).*Y;
>> DX=ones(size(DY));
>> DW=sqrt(DX.^2+DY.^2);
>> quiver(X,Y,DX./DW,DY./DW,0.5,’.’);
>> hold on
>> plot(x,y)
>> hold off

Even these two methods look almost exactly the same when the two lines are placed on the same plane there is a much bigger difference than expected. Using this code we were able to compare Euler, RK4, as well as the MATLAB solution to differential equations called ode45.  There is almost no difference between RK4 and ode45.

The final step is to compare all graphical solutions to the numerical solutons using dsolve.

Input: dsolve(’Dy=(x^4)*y,y(1)=1′,’x’)

Output: ans = exp(x^5/5)/exp(1/5)

After getting the equation I told MATLAB to graph the dsolve solution on the same plane as the previous comparison. I chose the color green to represent the dsolve solution.

Command Window code:

>> [x,y]=euler1(’Example’,[-1,1],1,.1);
plot(x,y,’r’)
hold on
[x,y]=RK4(’Example’,[-1,1],1,.1);
plot(x,y,’k’)
hold on
[x,y] = ode45(’Example’,[-1,1],1);
plot(x,y)
hold on
f=@(x) exp(x^5/5)/exp(1/5)
f =
@(x)exp(x^5/5)/exp(1/5)
>> fplot(f,[-1,1],’g’);
>> hold off

There is almost a .05 difference in the y plane between RK4 and Euler through -0.4<x<0.4. To see the slight difference between the two graphical solutions I zoomed in the view. The accuracy of the RK4 is just slightly better.

Problem #2: dy/dx=y+cos(x)

Euler Method:

Runge-Kutta Method:

Comparison:

Comparison using Dsolve:

dsolve(’Dy=y+cos(x),y(0)=0′,’x’)

ans = exp(x)/2 – cos(x)/2 + sin(x)/2

There is not much difference at all between these three solutions. I had to make the solution only from [-1,0] because the solution grew too fast in the positive x direction. The cos(x) is visible in the direction field as you can see the vectors almost trace the shape of a typical cos curve through the point (0,-1).

Problem #3: dy/dx= e^(-y)

Euler:

Runge-Kutta:

Comparison:

Comparison with Dsolve:

dsolve(’Dy=exp(-y),y(0)=2′,’x’)

ans = log(x + exp(2 – 2*pi*i*l)) + 2*pi*i*l [l] [Z_ intersect solve(Re(k) in [-1/2, 1/2), k)]

This graph is surprisingly very accurate.  The line is so close to being a straight line that the Euler method can easily follow the differential equation using its straight lines through the step points. This shows that the only time that a true difference between the methods is noticeable is in a really curvy and loopy differential equation. Since the Euler method is a simpler method to use then for problems such as this it is more that acceptable to use it.

Problem #4: dy/dx=e^(x^2)

Euler:

Runge-Kutta:

Comparison:

This particular differential equation does not have an explicit solution therefore the dsolve code could not be used to help find the answer.

This is another example of how the Euler method can sometimes be an perfectly acceptable method to solve a differential equation with. This line is not as straight as the previous problem but the curve is not abrupt and this allows the Euler method to produce a fairly accurate solution. Because the step size is so small, the graph looks really good.  If I had set the step size to 6 as I had said earlier and the first point was located at x=-3 and the second line was located at x=3 then the Euler method would produce a straight line connecting the two points. For the Runge-Kutta method, the same steps could be given and the result would produce a graph somewhat similar to what is shown here. The answer would be off by a lot in some points although it would be much closer to the actual answer than a straight line.

Problem #5: dy/dx=(x^2)y-(x^2)(y^2)

Euler Method:

Runge-Kutta Method:

Comparison:

This differential equation also does not have an explicit solution and again the dsolve could not me used.  Also in repetition, the Runge-Kutta is almost on top of the solution given by ode45. The linear part of this graph from about -.5<x<1 is portrayed much more accuratly through these two methods. The Euler mothod could not curve as sharply as the other two methods so it entered the linear portion a little too low. You will notice however that the three methods are all exactly the same from about x>2 forming a straight light.

Problem #6: dy/dx=(-y^2)cosx

Euler:

Runge-Kutta:

Comparison:

As you can see in the above example that the Runge-Kutta method definitely varies from the curve of the Euler’s method. What happens here is as the solution goes down the Euler method fails to be as accurate. It uses segments of lines that are not small enough to make a tighter curve.  MATLAB’s dsolve came up with the solution below.

dsolve(’Dy=-y^2*cos(x)’,’x’)

ans =

1/(sin(x)+C1)

dy/dx = xy (#17)

and the given problem

dy/dx = y^2 + t .

First, I will plot a direction field for the first differential equation using MATLAB. Using the text, on page 85, the code used to create the direction field in MATLAB is the following,

[X,Y]= meshgrid(-2*pi:.25:2*pi,-2*pi:.25:2*pi);

DY=X.*Y

DX=ones(size(DY));

DW=sqrt(DX.^2 +DY.^2);

quiver(X,Y,DX./DW,DY./DW,.33,‘.’);

xlabel(‘x’);

ylabel(‘y’);

Which yields this direction field,

In order to obtain the Euler approximation for this equation, I used the following MATLAB code as it was stated in the text.

function [xout,yout]=euler(fname,xvals,y0,h)
x0=xvals(1);xf=xvals(2);
xn=x0;
yn=y0;
xout=xn;
yout=yn;
steps=(xf-x0)/h;
for j=1:steps
fn=feval(fname,xn,yn);
xn=xn+h;
yn=yn+h*fn;
xout=[xout;xn];
yout=[yout;yn];
end

The Euler approximation that MATLAB created is as follows,

The next step was to plot the Euler method over the directional field, which created the following graph,

1. Notice the directional field lines are tangential to the curve. This tells us that the graph produced is a viable solution to this equation.

After completing the first differential equation, the same steps were taken for the second differential equation. The MATLAB code for the directional field for

dy/dx = y^2 + t is the same as the last equation, as follows,

[T,Y]= meshgrid(-2*pi:.25:2*pi,-2*pi:.25:2*pi);

DY=Y.^2+T

DT=ones(size(DY));

DW=sqrt(DT.^2 +DY.^2);

quiver(T,Y,DT./DW,DY./DW,.33,‘.’);

xlabel(‘x’);

ylabel(‘y’);

After getting the directional field for this equation, I used the same general equation for the Euler method as the previous problems. Some changes in the equation were necessary to yield the graph below.

As done in the previous problem, the directional field and Euler method were plotted together.

Once again we notice the directional field lines are tangential to the curve. Now we can conclude that this is another successful solution to the given differential equation. I worked with Paul McDonald on this block.