Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Resolucion de EDs Con Mathcad y Matlab
Resolucion de EDs Con Mathcad y Matlab
odesolve(x,b,step)
rkfixed(y,x1,x2,npoints,D)
Sistemas Alisados
Bulstoer(y,x1,x2,npoints,D)
Sistemas Stiff
Stiffb(y,x1,x2,npoints,D,J)
Stiffr(y,x1,x2,npoints,D,J)
Rkadapt(y,x1,x2,npoints,D)
bulstoer(y,x1,x2,acc,D,kmax,s)
rkadapt(y,x1,x2,acc,D,kmax,s)
stiffb(y,x1,x2,acc,D,J,kmax,s)
stiffr(y,x1,x2,acc,D,J,kmax,s)
bvalfit(v1,v2,x1,x2,xf,D,load1,load2,score)
sbval(v,x1,x2,D,load,score)
relax(a,b,c,d,e,f,u,rjac)
multigrid(M,ncycle)
Argumentos:
x es la variable de integración. x debe ser real.
b es el punto terminal del intervalo de integración. b debe ser real.
step (opcional) es el número de pasos usados internamente cuando se
calcula la solución.
y Odesolve( x 150)
2
1.465
1
y( x)
0
- 0.698
- 1
0 2 4 6 8 10
0 x 10
Given
d2
4 f ( t) f ( t) t f ( 0) 4 f ( 5) 13.5
2
dt
f Odesolve( t 5)
30
20
f ( t)
10
0 1 2 3 4 5 6
t
----------------------------------------------------------------------------------------------------
Utilización de Matlab para resolución de Ecuaciones Diferenciales
Ejemplos:
ans = exp(-a*t)*C1
x = exp(-a*s)
y=
[ sin(t)]
[ -sin(t)]
S.f = exp(t)*cos(t)+2*exp(t)*sin(t)
S.g = -exp(t)*sin(t)+2*exp(t)*cos(t)
Y = dsolve('Dy = y^2*(1-y)')
Y=
t+1/y-log(y)+log(-1+y)+C1=0
Como se ve en esta lista, hay métodos para resolver E.D.O. stiff y no stiff. Además hay
métodos de orden bajo, medio, alto y variable.
Todos ellos tienen una sintaxis semejante. Por ejemplo, para resolver el P.V.I.
en el intervalo [to, tf ] mediante el comando ode45 en su opción más sencilla, debe
ejecutarse:
[t,y]=ode45(’f’,[to tf],yo);
donde:
• f es el nombre de la función f(t, y) (típicamente definida mediante un programa
function en un archivo f.m);
• to y tf son los extremos del intervalo donde se desea conocer la solución;
• yo es el valor de la solución en to (es decir el valor de la condición inicial y(to) = yo);
• t devuelve los valores de la variable independiente t donde el método calcula el valor
de la solución;
• y devuelve los valores de la solución en cada uno de los puntos t.
Estos comandos no requieren como dato un paso de integración h pues todos ellos
determinan de manera automática en cada paso k, el tamaño del paso de integración
hk necesario para mantener los errores por debajo de una tolerancia determinada. Los
valores de t que entrega corresponden a los puntos
tk = tk−1 + hk, k = 1, 2, . . . , en los que el comando necesitó calcular el valor de y(tk).
Si se desea conocer la solución para ciertos valores de t, puede
alternativamente ejecutarse:
[t,y]=ode45(’f’,tspan,yo);
options=odeset(’RelTol’,1e-6,’AbsTol’,1.e-8);
[t,y]=ode45(’f’,[to tf],yo,options);
y ejecutarse:
[t,y]=ode45(’f’,[0 1.5],1);
plot(t,y,t,exp(t),'o')
Así se obtiene la siguiente gráfica:
options=odeset('AbsTol',1.e-6);
tspan=0:.1:1.5;
[t,y]=ode45('f',tspan,1,options);
error=exp(t)-y
error =
1.0e-006 *
0
-0.0003
-0.0248
-0.0448
-0.0076
-0.0415
-0.0694
-0.0200
-0.0669
-0.1056
-0.0402
-0.1048
-0.1586
-0.0721
-0.1612
-0.0989
La salida que se presenta indica que los errores son efectivamente menores en
valor absoluto a 10E−6.
La resolución de P.V.I. para sistemas de E.D.O. se realiza mediante los
mismos comandos. En tal caso, f(t,y) debe ser una función a valores vectoriales
(es decir un vector columna de funciones) e y un vector columna de variables
de la misma dimensión. Además, la condición inicial yo también debe ser un
vector columna de la misma dimensión.
Por lo tanto los puntos (x(t), y(t)) solución de este sistema de E.D.O, describen
la circunferencia unitaria.
Este sistema escrito vectorialmente resulta:
function Z=F(t,Y)
Z=[Y(2);-Y(1)];
Los siguientes comandos resuelven este P.V.I. en el intervalo [0, 2] y grafican
la curva (x(t), y(t)), para 0 < t< 2, que se obtiene:
[t,Y]=ode45('f',[0 2*pi],[1;0]);
plot(Y(:,1),Y(:,2));
Así se obtiene la siguiente gráfica:
Supongamos que deseamos resolver y plotear la solución de la siguiente
ecuación diferencial de segundo orden
eqn2='D2y+8*Dy+2*y=cos(x)';
inits2 = 'y(0)=0, Dy(0)=1';
y=dsolve(eqn2,inits2,'x')
y =
1/65*cos(x)+8/65*sin(x)+(-1/130+53/1820*14ˆ(1/2))*exp((-4+14ˆ(1/2))*x)
-1/1820*(53+14ˆ(1/2))*14ˆ(1/2)*exp(-(4+14ˆ(1/2))*x)
x=0:0.1:1;
z=eval(vectorize(y));
plot(x,z)
Given
y Odesolve( x 150)
2
1.465
1
y( x)
0
- 0.698
- 1
0 2 4 6 8 10
0 x 10
inits=’x(0)=1,y(0)=2,z(0)=3’;
[x,y,z]=dsolve(’Dx=x+2*y-z’,’Dy=x+z’,’Dz=4*x-4*y+5*z’,inits)
x =
-5/2*exp(3*t)-5/2*exp(t)+6*exp(2*t)
y =
5/2*exp(3*t)+5/2*exp(t)-3*exp(2*t)
z =
10*exp(3*t)+5*exp(t)-12*exp(2*t)
t=linspace(0,.5,25);
xx=eval(vectorize(x));
yy=eval(vectorize(y));
zz=eval(vectorize(z));
plot(t, xx, t, yy, t, zz)
Búsqueda de soluciones numéricas
xvalues=0:.1:.5;
[x,y]=ode45(f,xvalues,1)
x =
0
0.1000
0.2000
0.3000
0.4000
0.5000
y =
1.0000
1.1111
1.2500
1.4286
1.6667
2.0000
donde los valores por defecto son RelTol = 0,001 y AbsTol = 0.000001.
Como un ejemplo de cuándo puede ser que desee cambiar estos valores,
observamos que si yk llega a ser grande, entonces al error ek se le permitirá
crecer bastante. En este caso, aumentar el valor de RelTol. Para la ecuación
y' = xy2 + y, con y (0) = 1, los valores de y llegan a ser muy grandes cuando x
se acerca a 1. De hecho, con las tolerancias de error por defecto, nos
encontramos con que el comando
xspan = [0,.5];
y0 = 1;
[x,y]=ode23(@firstode,xspan,y0);
plot(x,y)
Sistemas de EDs
Observe que x se almacena como x(1), y como x(2), y z como x(3). Además,
xprime es un vector columna, como se desprende de la coma después de la
primera aparición de x(2). Si en la ventana de comandos, escribimos
x0=[-8 8 27];
tspan=[0,20];
[t,x]=ode45(@lorenz1,tspan,x0);
plot(x(:,1),x(:,3))
y =
exp((-4+14^(1/2))*x)*(53/1820*14^(1/2)-1/130)+exp(-(4+14^(1/2))*x)*(-
53/1820*14^(1/2)-1/130)+1/65*cos(x)+8/65*sin(x)
x=0:0.01:1;
z = eval(vectorize(y));
plot(x,z)
Se ejecuta:
x0=[0 1]; % condiciones iniciales
tspan=[0,1]; % intervalo
[x,y]=ode45(@ee,tspan,x0);
plot(x,y(:,1))
Transformadas de Laplace
syms t;
laplace(t^2)
ans =
2/s^3
syms s;
ilaplace(1/(1+s))
ans =
exp(-t)
Problemas de contorno
function res=bc(y0,y1)
%BC: Evaluates the residue of the boundary condition
res=[y0(1);y1(1)-10];
sol=bvpinit(linspace(0,1,25),[0 1]);
sol=bvp4c(@bvpexample,@bc,sol);
sol.x
ans =
Columns 1 through 9
0 0.0417 0.0833 0.1250 0.1667 0.2083 0.2500 0.2917 0.3333
Columns 10 through 18
0.3750 0.4167 0.4583 0.5000 0.5417 0.5833 0.6250 0.6667 0.7083
Columns 19 through 25
0.7500 0.7917 0.8333 0.8750 0.9167 0.9583 1.0000
sol.y
ans =
Columns 1 through 9
0 0.0950 0.2022 0.3230 0.4587 0.6108 0.7808 0.9706 1.1821
2.1410 2.4220 2.7315 3.0721 3.4467 3.8584 4.3106 4.8072 5.3521
Columns 10 through 18
1.4173 1.6787 1.9686 2.2899 2.6455 3.0386 3.4728 3.9521 4.4805
5.9497 6.6050 7.3230 8.1096 8.9710 9.9138 10.9455 12.0742 13.3084
Columns 19 through 25
5.0627 5.7037 6.4090 7.1845 8.0367 8.9726 9.9999
14.6578 16.1327 17.7443 19.5049 21.4277 23.5274 25.8196
Métodos Numéricos
Método de Euler
donde c (x0, x0). Observando desde nuestra ecuación que y′(x0) = f(x0, y(x0)),
tenemos
Una vez más, tenemos desde nuestra ecuación que y'(x 1) = f(x1, y(x1)), y así
Si eliminamos el término
donde el valor y(x1) requerido aquí puede ser aproximado por el valor de (6.2).
Más generalmente, para cualquier k = 1, 2, ..., n - 1 se puede aproximar y(x k+1)
de la relación
donde y(xk) se conocerán a partir del cálculo anterior. Al igual que con los
métodos numéricos de la integración, es habitual en la práctica de tomar la
partición en subintervalos de igual anchura,
Si decimos que los valores de y0, y1, ..., yn denotan nuestras aproximaciones
para y en los puntos x0, x1, ..., xn (es decir, y0 = y(x0), y1 ≈ y(x1), etc), entonces
podemos aproximar y(x) sobre la partición de P calculando iterativamente
(6.3)
Ahora tenemos el punto (x1, y1) = (.1,), y podemos utilizar esto y (6.3) para
calcular
Ahora tenemos (x2, y2) = (0.2, 3.1725), y podemos utilizar esto para calcular
Podemos implementar este archivo con el siguiente código, que crea la figura
6.1.
f=inline('sin(x*y)');
[x,y]=euler1(f,0,1,pi,10);
plot(x,y)
Con x=0.01
[x,y]=euler1(f,0,1,pi,100);
plot(x,y)
• Resolutores Multipaso
d2 d
y( x) 3 y( x) 7 y( x) 4 x
2 dx
dx
contiene una segunda derivada la cual puede ser escrita como una primera
derivada:
d2 d d
2
y( x) y( x)
dx dx dx
define dos funciones como:
d
y0 ( x) y( x) y1 ( x) y0 ( x)
dx
d
y0 ( x) y1 ( x)
dx
d
y1 ( x) 4 x 7 y0 ( x) 3 y1 ( x)
dx
Argumentos:
y debe ser o bien un vector de n valores inicales u un valor inicial
único.
x1, x2 son puntos extremos del intervalo sobre el cual la
solución a las ecuaciones diferenciales será evaluada. Los valores
iniciales en y son los valores en x1.
npoints es el número de puntos más allá del punto inicial para el
cual la solución es aproximada. Esto controla el número de filas
(1 + npoints) en la matriz retornada por rkfixed.
D es una función vector-valued n-element conteniendo las
primeras derivadas de las funciones desconocidas.
Notas:
rkfixed usa el método Runge-Kutta method de cuarto orden para
resolver una ecuación diferencial de primer orden.
Se puede usar rkfixed para resolver una ecuación diferencial así
también como un sistema de ecuaciones diferenciales.
Uso de la función rkfixed
Para sistemas de ecuaciones diferenciales o por una que no es lineal en el
término derivada de más alto orden, use rkfixed.
El ejemplo de abajo muestra cómo usar rkfixed para evaluar la solución de
una ecuación diferencial de segundo orden a puntos igualmente espaciados.
y( 0) 1 y'( 0) 3
1
y <- define las condiciones iniciales
3
y1 <- primera derivada
D( t y)
y1 2 y0 <- segunda derivada
Z rkfixed( y 0 0.5 400 D) <- Evalua solución en 400 puntos entre 0 y 0.5
0 1 2
0 0 1 3
1 1.25·10 -3 1.004 2.999
2 2.5·10 -3 1.007 2.998
3 3.75·10 -3 1.011 2.996
4 5·10 -3 1.015 2.995
5 6.25·10 -3 1.019 2.994
6 7.5·10 -3 1.022 2.993
Z 7 8.75·10 -3 1.026 2.992
8 0.01 1.03 2.99
9 0.011 1.034 2.989
10 0.013 1.037 2.988
11 0.014 1.041 2.987
12 0.015 1.045 2.986
13 0.016 1.049 2.985
14 0.018 1.052 2.984
15 0.019 1.056 2.982
Retorna una matriz en la cual: (1) la primera columna contiene los puntos
en los cuales es evaluada la solución y (2) las columnas remanente contiene
los valores correspondientes de la solución y sus primeras n-1 derivadas.
Argumentos:
y debe ser o bien un vector de n valores inicales o un escalar.
x1, x2 son puntos extremos del intervalo sobre el cual la solución
a las ecuaciones diferenciales será evaluada. Los valores iniciales
en y son los valores en x1.
npoints es el número de puntos más allá del punto inicial para el
cual la solución es aproximada. Esto controla el número de filas
(1 + npoints) en la matriz retornada por rkfixed.
D es una función vector-valued n-element conteniendo las
primeras derivadas de las funciones desconocidas.
Notes:
A diferencia de rkfixed la cual integra en pasos de igual tamaño para
alcanzar una solución, Rkadapt examina cuán rápido una solución
está cambiando y adapta su tamaño de paso acordemente. Rkadapt
usará tamaños de paso no uniformes unternamente cuando resuelve
la ecuación diferencial, pero retornará la solución en puntos
igualmente espaciados.
Sistemas Alisados (Smooth systems)
Argumentos:
0
P Bulstoer 0 T N D n 0 1 N
0
1.384
4
P1 n
P2 n
4
1.384
0 1 2 3 4 5 6
0 P0 n 6
theta
derivative of theta
Sistemas Stiff
Stiffb(y, x1, x2, npoints, D, J)
Stiffr(Y, x1, x2, npoints, D, J)
Cada una de estas funciones retorna una matriz en la cual: (1) la primera
columna contiene los puntos en los cuales es evaluada la solución y (2) las
columnas remanentes contienen los valores correspondientes de la solución
y sus primeras n-1 derivadas.
Argumentos:
Y( 0) 1
( K1) t t
Y( t) e e
( K1) t 7 7 7
Y( t) e t 10 10 10 0.001
1
0.905
Y ( t) 0.5
0
6 6 6 6
0 2 10 4 10 6 10 8 10
7 t 5
110 10
( K1) t t
Y( t) e e t 0.01 0.02 5
1
0.99
Y ( t) 0.5
3
6.73810
0 1 2 3 4 5
0.01 t 5
La región corta de cambio rápido es la capa frontera, la curva de variación
lenta es conocida como la solución estado estacionario. Este
comportamiento es típico de problemas stiff.
Ejemplo:
y para x < 0
Solve y'' donde y(-1)=1 e y(1)=2
y para x > 0
y1
D ( x y) xf 0 <- punto de dictontinuidad
( x 0) y0 ( x 0) y0
v10 1 < - valor de intento para y(-1)
1 < - y(-1)
load1( x1 v1)
v10 < - valor de intento para y(-1)
2 < - y(1)
load2( x2 v2)
v20 < - valor de intento para y(1)
bvalfit(v1, v2, x1, x2, xf, D, load1, load2, score) Retorna un vector
conteniendo aquellos valores iniciales dejados sin especificar en x1.
Argumentos:
Argumentos:
Ecuación de Poisson
Argumentos:
R 32 M R R 1
3
4 4
MR R 2 M R R 2
8 2
i 0 32 k 0 32
ai k 1 b a d a c a e 4 a
vi k 0 f M
S1 relax( a b c d e f v 0.95)
S1
Argumentos:
R 32 MR R 0 M R R 1
3
4 4
M R 3 R 2 M R R 2
8 2
4 4
S multigridM
( 2)
S
$$$$$$$$$$$$$$$$$$$$$$$$
MATLAB contiene dos funciones para calcular soluciones numérica de
ecuaciones diferenciales ordinarias; "ode23" y "ode45".
A continuación se describen los argumentos de los comandos MATLAB ODE.
[x,y] = ode23('función',a,b,inicial)
Esta instrucción regresa un conjunto de coordenadas "x" y "y" que representan
a la función y=f(x), los valores se calculan a través de métodos Runge-Kuta de
segundo y tercer orden.
El nombre "función", define una función que representa a una ecuación
diferencial ordinaria, ODE23 proporciona los valores de la ecuación diferencial
y'=g(x,y).
Los valores "a" y "b" especifican los extremos del intervalo en el cual se desea
evaluar a la función y=f(x).
El valor inicial y = f(a) especifica el valor de la función en el extremo izquierdo
del intervalo [a,b].
[x,y] = ode45('función',a,b,inicial)
Esta instrucción regresa un conjunto de coordenadas "x" y "y" que representan
a la función y=f(x), los valores se calculan a través de métodos Runge-Kuta de
cuarto y quinto orden.
El nombre "función", define una función que representa a una ecuación
diferencial ordinaria, ODE45 proporciona los valores de la ecuación diferencial
y'=g(x,y).
Los valores "a" y "b" especifican los extremos del intervalo en el cual se desea
evaluar a la función y=f(x).
El valor inicial y = f(a) especifica el valor de la función en el extremo izquierdo
del intervalo [a,b].
Las instrucciones "ODE23" y "ODE45" contienen dos parámetros adicionales.
Se usa un quinto parámetro para especificar una tolerancia relacionada con el
tamaño del paso; las tolerancias por omisión son 0.001 para ODE23 y
0.000001 para ODE45.
Existe un sexto parámetro que sirve para solicitar que la función exhiba
resultados intermedios, es decir, que realice rastreo; el valor por omisión "0"
indica que no se desean rastrear los resultados.
Como ilustración de la función ODE de MATLAB, se presentan los pasos para
calcular soluciones numéricas de ecuaciones diferenciales, las siguientes
instrucciones MATLAB definen las funciones requeridas para evaluar la
ecuación diferencial deseada.
Se graban las siguientes instrucciones con su editor ASCII favorito, en lo
particular yo uso el "editeur", si Ud. desea usarlo también, esta disponible en la
siguiente URL;
http://proton.ucting.udg.mx/shareware/editeur/editeur.zip
function dy = g1(x,y)
%
% g1
% esta función evalúa una ODE
% ecuación diferencial de primer grado
%
dy = 3*x.^2;
El siguiente paso consiste en grabar este archivo como "g1.m", sobre algún
subdirectorio de trabajo valido para el MATLAB, las siguientes instrucciones
resuelven g(x,y) dentro del intervalo [2,4] con condición inicial 0.5 para y=f(2).
% Determinar la Solución de la EDO
%
% dy = 3*x.^2;
%
[t,y] = ode23('g1',[2,4],0.5);
plot(t,y,'o'),...
title('Solución de la Ecuación dy = 3*x.^2'),...
xlabel('Tiempo'),ylabel('y = f(t)'),grid
Sobre el subdirectorio de trabajo valido se graba este archivo como "mat1.m" y
se escribe mat1, generándose la siguiente solución gráfica.
Mathcad.pdf
Las dos funciones más fáciles de usar, Odesolve y Pdesolve, son usadas
dentro de Solve Blocks. Hay muchas otras funciones que ayudan a relover
sistemas de ecuaciones diferenciales, incluyendo Adams, AdamsBDF, BDF,
Bulstoes, bvalfit, Jacob, multigrid, numol, Radau, relax, Rkadapt, rkfixed, sbval,
statespace, Stiffb y Stiffr.
-----
dsolve - Symbolic solution of ordinary differential equations
Syntax
dsolve('eq1','eq2',...,'cond1','cond2',...,'v')
dsolve(...,'IgnoreAnalyticConstraints',value)
Descripción
You can specify initial and boundary conditions by equations like y(a) = b or
Dy(a) = b, where y is a dependent variable and a and b are constants. If the
number of the specified initial conditions is less than the number of dependent
variables, the resulting solutions contain the arbitrary constants C1, C2,....
Ejemplo:
>> dsolve('D2y=-3*y','y(0)=1')
ans =
C1*sin(3^(1/2)*t)+cos(3^(1/2)*t)
* Para varias ecuaciones y una única salida, dsolve retorna una estructura
conteniendo las soluciones.
Examples
dsolve('Dx = -a*x')
ans =
C2/exp(a*t)
dsolve('Df = f + sin(t)')
ans =
C4*exp(t) - sin(t)/2 - cos(t)/2
ans =
1
-1
cosh(C7 + s*i)
cosh(C11 - s*i)
ans =
b*exp(a*t)
ans =
(1/exp(a*t*i))/2 + exp(a*t*i)/2
z =
x: [1x1 sym]
y: [1x1 sym]
z.x
ans =
C20*cos(t) + C19*sin(t)
z.y
ans =
C19*cos(t) - C20*sin(t)
By default, the solver applies the set of purely algebraic simplifications that are
not correct in general, but that can result in simple and practical solutions:
y = dsolve('Dy=1+y^2','y(0)=1')
y =
tan(pi/4 + t)
To obtain complete and generally correct solutions, set the value of the option
IgnoreAnalyticConstraints to none:
y = dsolve('Dy=1+y^2','y(0)=1',...
'IgnoreAnalyticConstraints','none')
y =
piecewise([C29 in Z_, tan(pi/4 + t + pi*C29)])
The algebraic simplifications also allow you to obtain solutions for the equations
that the solver cannot compute when it uses strict mathematical rules:
dsolve('Dv=19.6*v-0.00196*v^2','v(0)=1')
ans =
10000/(exp(log(9999) - (98*t)/5) + 1)
versus
dsolve('Dv=19.6*v-0.00196*v^2','v(0)=1',...
'IgnoreAnalyticConstraints','none')
Diagnostics
If dsolve cannot find an analytic solution for an equation, it prints the warning: