Documente Academic
Documente Profesional
Documente Cultură
ECUACIONES DIFERENCIALES
CAPITULO VI
Introduccin.
dy d 2 y
dny
F ( x, , 2 ,..., n ) 0
dx dx
dx
Ley Fsica
EDO
Solucin
dv
c
g v
dt
m
Analtica
gm
c m t
v
1 e
c
Numrica
vi 1 vi g vi t
m
Mtodos
3. Mtodos
4. Mtodos
5. Mtodos
2.
mltipaso o de continuacin.
predictor corrector.
explcitos.
implcitos.
Solucin
numrica
Aproximacin
por funciones
Polinomios ortogonales
Series de Fourier
Funciones ortogonales
Mtodo de
diferencias
(step by step)
Metodo de Euler
Metodo de Runge-Kuta
...
...
dy
y ' f ( x, y )
dx
y ( x0 ) y0
y ( x' ) ?
PROBLEMAS DE VALORES
INICIALES
Dada una EDO de orden n un
problema con condiciones iniciales es:
dy d 2 y
dny
F ( x, , 2 ,..., n ) 0
dx dx
dx
y ( x a ) c1
dy ( x a )
c2
dx
.
.
dy n 1 ( x a)
cn
dx
PROBLEMAS DE VALORES DE
FRONTERA
El orden mnimo de la ecuacin
diferencial para un problema de
valores de frontera es dos:
dy d 2 y
F ( x , y , , 2 ) 0
dx dx
y ( x a) c1
y ( x b) c 2
y= y
Solucin
y(t) = c exp(t)
Como verificar la
solucin ?
Valor de frontera
y = z
z = -y
Solucin
y(t) = A sin(t+a)
z(t) = A cos(t+a)
y(0)=0
y()=0 muchas soluciones
y = a y
y(t) = c exp(at)
y = -y
Solucin
y(t) = c exp(-t)
Estable
a>0
y = y
Solucin
y(t) = c exp(t)
PROBLEMAS DE VALOR
INICIAL
Los mtodos numricos que estudiaremos se podrn aplicar a
una ecuacin o a sistemas de ecuaciones diferenciales:
C.I.
d
y (t ) f (t , y )
dt
y (t0 ) y0
Tiempo
t [t0 , t f ]
EDO
PROBLEMAS DE n-simo
ORDEN
Se podrn aplicar a problemas de n-simo orden con condicin
inicial, de la forma:
y1 =
y2 =
y3 =
...
yn =
y
y
y
y
(n-1)
= dn-1/ dt
n-1
PROBLEMAS DE n-simo
ORDEN
Derivando miembro a miembro cada una de
estas ltimas ecuaciones con respecto a t, se
obtiene el sistema equivalente:
y1
y2
y3
...
y n
= y = y2
= y = y3
= y = y4
= f(t,y1,y2,y3,....,yn)
Condicin inicial
y1(t0)=y1,0 , y2(t0)=y2,0 , ..., yn(t0)=yn,0
d2
(t ) sin( ) 0
2
dt
d
(t0 ) 1; (t0 ) 1
dt
t [0,10]
y1 =
y2 =
y1 = y2
y2 = = -sin()
Condiciones iniciales: y1(0) = 1, y2(0) = 1
MTODOS DE EULER
dy
y ' f ( x, y ), y ( x0 ) y0
dx
se debe integrar la ecuacin diferencial en el intervalo
yi 1 yi f ( xi , yi )h
yi hy 'i
Mtodo
yEuler
de
yi+1 = yi + f(xi, yi)h
Predicho
Error
Verdadero
y = pendiente = f(xi,yi)
t
xi
Tamao de paso, h
xi+1
EJEMPLO
Con el mtodo de Euler integre numricamente
la ecuacin
Yi
Yi solucin exacta
0.0
1.000 000
1.000 000
0.1
1.050 000
1.055 409
0.2
1.110 638
1.123 596
0.3
1.184 649
1.208 459
0.4
1.275 870
1.315 789
0.5
1.389 819
1.454 545
Programa mtodo de
Euler
function [t,y] = euler_1(fun,ti,tmax,h,ci)
% METODO DE EULER
% fun: funcin programada
% ti : tiempo inicial
% tmax : tiempo final
% h : intervalo de tiempo
% ci : condiciones iniciales
for n=1:length(ci)
Y(n,1) = ci(n);%condicion inicial
end
T(1) = ti; %tiempo inicial
fin=(tmax-ti)/h;
for n=1:fin
Y(:,n+1)=Y(:,n)+h*feval(fun,T(n),Y(:,n));
T(n+1)=T(n)+h;
end
t=T'; y=Y';
plot(t,y)
EJEMPLO:EDO de orden 1
C.I.
d
y (t ) y (t ) 5e t sin(5t )
dt
y (0) 1
Tiempo
t [0,3]
EDO
X = Xn+1
Y = Yn + h f(Xn, Yn)
34
yi' 1 f ti 1 , yi01
yi =f(ti, yi)
ti+1
ti
y'
f ti , yi f ti 1 , y 0i 1
t
Predictor
ti
ti+1
Corrector35
2.
y i 1 y i xi , y i , h h
Donde
a1 k1 a2 k2 .......... .......... an kn
k1 f xi , y i
k2 f xi p1 h, y i q11 k1 h
k3 f xi p2 h, y i q21 k1 h q22 k2 h
.
kn f xi pn-1 h, y i qn-1,1 k1 h qn-1,2 k2 h .......... .. qn-1,n-1 kn-1 h
a1 k1 a1 f xi , y i
k1 f xi , y i
k2 f xi p1 h, y i q11 k1 h
f xi , y i 2
y i 1 y i f xi , y i h
h
2!
f
f 2
yi1 yi a1 f xi, yi a2 f xi, yi h a2 p1 a2 f xi, yi q11 h ....
x
y
y
dx 2!
x
a1 a2 1 , a2 p1
1
2
a2 q11
1
1
y q11
2 a2
2 a2
Entonces: a1 = , p1 = 1 y q11 = 1.
Reemplazando, obtendremos la ecuacin:
a1 1 - a2 , p1
y i 1 y i a1 k1 a2 k2 h
donde:
1
2
1
1
y i 1 y i k1 k2 h
2
2
k1 f xi , y i
-kpendiente
en el inicio del intervalo
2 f xi h, y i k1 h
k1
k2 - pendiente al final del mismo.
y i 1 y i a1 k1 a2 k2 a3 k 3 h
y i 1 y i
donde:
k1 f xi , y i
k2
k3
1
k1 4 k2 k3 h
6
1
1
f xi h, y i k1 h
2
2
f xi h, y i k1 h 2 k2 h
1
y i 1 y i k1 2 k2 2 k3 k4 h
6
k1 f xi , y i
k2
k3
k4
1
1
f xi h, y i k1 h
2
2
1
1
f xi h, y i k2 h
2
2
f xi h, y i k3 h
k1 h f (x 0 ,y0 )
h
k1
k 2 h f (x0 , y0 )
2
2
h
k2
k3 h f (x 0 , y0 )
2
2
k 4 h f (x0 h, y0 k3 )
1
K0 (k1 2k 2 2k 3 k4 )
6
y entonces se toma:
y1 y0 K0
k1 h f (x1 , y1 )
h
k1
k 2 h f (x1 , y1 )
2
2
h
k2
k3 h f (x1 , y1 )
2
2
k 4 h f (x1 h, y1 k3 )
1
K0 (k1 2k 2 2k 3 k4 )
6
y2 y1 K0
k1 h f (x n 1 , yn 1 )
h
k1
k 2 h f (xn 1 , yn 1 )
2
2
h
k2
k3 h f (x n 1 ,y n 1 )
2
2
k 4 h f (xn 1 h, yn 1 k3 )
1
K0 (k1 2k 2 2k 3 k4 )
6
yn yn 1 K0
dy
2x y ; y(0) 1
dx
h = 0.2:
x1 x 0 h 0 0.2 0.2
k1 h f (x 0 ,y0 )
0.2 (2 0 1) 0.2
h
k1
k 2 h f (x0 , y0 )
0.2 f (0 0.1, 1 0.1)
2
2
k 2 0.2 2 0.11.1 0.26
h
k2
k3 h f (x 0 , y0 )
2
2
y1 y0 K0 1.2642
x2 x1 h 0.2 0.2 0.4
k1 h f (x1 , y1 ) 0.2 (2 0.2 1.2642) 0.33284
h
k
k 2 h f (x1 , y1 1 ) 0.2 f (0.3, 1.43062) 0.40612
2
2
h
k2
k3 h f (x1 , y1 )
2
2
dy
x 2 y2
dx
h = 0.1:
; y(0) 1
x1 x 0 h 0 0.1 0.1
k 4 h f (x1 h, y1 k3 )
1
K0 (k1 2k 2 2k 3 k4 ) 0.1415621
6
y2 y1 K0 1.2531
Ejemplo
Usar el mtodo de Runge-Kutta para aproximar
Y(0.5) dada la siguiente ecuacin diferencial:
Solucin:
Condiciones iniciales
Xn
0.1
1.01005
0.2
1.04081
0.3
1.09417
0.4
1.17351
0.5
1.28403
Yn
1
Ejemplo
Usar el mtodo de Runge-Kutta para
aproximar y(2.2) dada la ecuacin
diferencial:
Solucin
Tomamos h=0.1 y llegaremos a la aproximacin en dos
pasos. Con esta aclaracin, tenemos los siguientes
datos:
Primera Iteracin:
Segunda Iteracin:
APLICANDO MATLAB
ODE45: Nonstiff Explicit Runge-Kutta pair, order 4 and 5
[T,Y] = ODE45(ODEFUN,TSPAN,Y0)
TSPAN = [T0 TFINAL] integrates the m system of differential
equations y' = f(t,y) from time T0 to TFINAL with initial
conditions Y0.
Function ODEFUN(T,Y) must return a column vector
corresponding to f(t,y).
To obtain solutions at specific times T0,T1,...,TFINAL (all
increasing or all decreasing), use TSPAN = [T0 T1 ... TFINAL].
APLICANDO MATLAB
% Solucin de la funcin myf
tspan = [0 3]; %Intervalo de la variable independiente
yzero = 1; %Condicion inicial
ode45('myf',tspan,yzero) % solucin con grafico
[t,y] = ode45('myf',tspan,yzero); % solucin con datos
plot(t,y,'r*--') % grafico de la solucin
xlabel t, ylabel y(t)
% Solucion exacta
ye = exp(-t).*cos(5*t);
hold on
line(t,ye)
d2
(t ) sin( ) 0
2
dt
d
(t0 ) 1; (t0 ) 1
dt
t [0,10]
y1 =
y2 =
y 1 = y 2
y2 = = -sin() = -sin(y1)
Condiciones iniciales: y1(0) = 1, y2(0) = 1
FUNCION EN MATLAB
function yprime = pend(t,y)
yprime = [y(2); -sin(y(1))];
Ejemplo:
% Solucin de la funcion pend
tspan = [0 10]; % %Intervalo de la variable independiente
yazero = [1; 1]; % condiciones iniciales a
ybzero = [-5;2]; % condiciones iniciales b
yczero = [5; -2];% condiciones iniciales c
[ta,ya] = ode45('pend',tspan,yazero); % solucion con CI a
[tb,yb] = ode45('pend',tspan,ybzero); % solucion con CI b
[tc,yc] = ode45('pend',tspan,yczero); % solucion con CI c
plot(ta,ya) % grafico de la solucion con CI a
plot(tb,yb) % grafico de la solucion con CI b
plot(tc,yc) % grafico de la solucion con CI c
y i 1 y i
1
7 k1 32 k3 12 k4 32 k5 7 k6 h
90
k1 f xi , y i
1
1
k2 f xi h, y i k1 h
4
4
1
1
1
k3 f xi h, y i k1 h k2 h
4 que el de
8 cuarto orden,
8 pero es
preciso
mucho mayor la complejidad adicional y el esfuerzo
Este mtodo es mas
computacional.
1
1
k4 f xi h, y i k2 h k3 h
2
2
3
3
3
k5 f xi h, y i
k1 h
k4 h
4
16
16
3
2
12
12
8
k6 f xi h, y i k1 h k2 h
k3 h
k4 h k5 h
7
7
7
7
7
d ny
dy
d
y
d
y
f x, y,
,
,......,
2
n 1
dx
dx n
dx
dx
dx
dx
d2y
dy 2
y3
2
dx
dx
.
yn
Entonces
d ny
dx n
dy n 1
dx
dy n
f x, y1 , y 2 , y 3 ,......, y n
dx
dx
dx
dy
d y
y3 2
dx
dx 2
n
dy
d y
yn n 1
dx
dx n
dy n
f x, y1 , y 2 , y 3 ,......, y n
dx
y2
y1 a y a 0
dy
y2 a
a 1
dx
d 2 y1
y3 a
a 2
dx 2
d n-1y
. yn a
a n 1
dx n-1
n condiciones iniciales
y ' x v x
Entonces:
v ' x u x
y ' x v x
y '' x v ' x u x
y '' ' x v '' x u' x
Condiciones iniciales en x = 0:
y(0) 4; v(0) 1
u(0) 2
dy1
f1 x , y1 , y 2 ,......... ..., y n
dx
dy 2
f2 x , y1 , y 2 ,......... ..., y n
dx
.
.
dy n
fn x , y1 , y 2 ,......... ..., y n
dx
dy1
- 0.5 y1
dx
dy 2
4 - 0.3 y 2 - 0.1 y1
dx
dy1
f1 ( 0 , 4, 6) - 0.5 4 - 2
dx
dy 2
f2 ( 0 , 4, 6) 4 - 0.3 6 - 0.1 4 1.8
dx
dy 2
f2 ( 0.5 , 3, 6.9) 4 - 0.3 6.9 - 0.1 3 1.63
dx
4.000000
6.000000
0.5
3.000000
6.900000
1.0
2.250000
7.715000
1.5
1.687500
8.445250
2.0
1.265625
9.094870
Sistemas de EDO
Sistema
EDO
C.I.
Tiempo
d
y1 (t ) y2 (t ) y3 (t )
dt
d
y2 (t ) y1 (t ) ay2 (t )
dt
d
y3 (t ) b y3 (t )( y1 (t ) c)
dt
y1 (0) 1; y2 (0) 1; y3 (0) 1;
t [0,100]
FUNCIN EN MATLAB
function yprime = rossler(t,y)
% ROSSLER: Rossler system
a=0.2; b=0.2; c=2.5;
yprime = [-y(2)-y(3); y(1)+a*y(2);
b+y(3)*(y(1)-c)];
APLICANDO MATLAB
% Solucin de la funcin Rossler
tspan = [0,100]; % Intervalo de la variable independiente
yzero = [1;1;1]; % Condicin inicial
ode45('rossler',tspan,yzero); % solucion con grafico
[t,y] = ode45('rossler',tspan,yzero); % solucin con datos
plot(t,y(:,1)) % Grafico solucin de y1
plot(t,y(:,1),t,y(:,2)) % Grafico solucin de y1,y2
plot(t,y(:,1),t,y(:,2),t,y(:,3)) % grafico de la solucin de y1,y2,y3
plot3(y(:,1),y(:,2),y(:,3)) % grafico de la solucin
OTROS MTODOS
Runge-Kutta-Fehlberg Paso adaptativo: METODO DE
PASO VARIABLE
Mtodos de Adams-Bashforth: METODOS MULTIPASOS
EXPLCITOS
Mtodos Adams-Moulton: METODOS MULTIPASOS
IMPLCITOS
METODOS PREDICTOR-CORRECTOR
APLICANDO MATLAB
ode45 is based on an explicit Runge-Kutta (4,5) formula, the
Dormand-Prince pair.
ode23 is an implementation of an explicit Runge-Kutta (2,3) pair
of Bogacki and Shampine.
ode113 is a variable order Adams-Bashforth-Moulton PECE
solver. It is a multistep solver.
ode15s is a variable order solver based on the numerical
differentiation formulas, NDFs. (also known as Gear's method) is
a multistep solver
APLICANDO MATLAB
APLICANDO MATLAB
ODE23: Nonstiff
ODE45: Nonstiff
APLICANDO MATLAB
PROBLEMAS
DE VALORES
DE FRONTERA
PROBLEMAS DE VALORES DE
FRONTERA
dy d 2 y
F ( x , y , , 2 ) 0
dx dx
y ( x a ) c1
y ( x b) c 2
ODE CONDICIONES
FRONTERA
Ejemplos:
u ' ' 4200 x 5 3000 x 4
u (0) 0 , u (1) 0
0 x 1
u1 ( x) y ( x)
u2 ( x) y ' ( x)
a x b
u 2 ' f ( x, y , y ' )
y (a )
u1 (a )
u 2 (a ) ? u1 (b)
y (b)
u2 (a ) k 4
u2 (a ) k3
u2 (a ) k 2
u2 (a ) k1
u1 (b) e1
Ejemplo 1
u ' ' 4200 x 5 3000 x 4
0 x 1
u (0) 0
u (1) 0
y1 u
y2 u '
y1 ' u ' y2
u (0) 0
y1 (0) 0
u (1) 0
y2 (0) ?
u (1) 0
Ejemplo 1 MATLAB
function yprima = frontera_1(x,y)
yprima=[y(2);4200*x^5-300*x^4];
*************************************
xspan = [0 1]; %Intervalo de la variable independiente
yzero = [0 0]; %Condicion inicial
%yzero = [0 -90]; %Condicion inicial
[x,y] = ode45('frontera_1',xspan,yzero);
plot(x,y(:,1)) % grafico de la solucion
y(length(x),1)
Ejemplo 2
1
u ' ' 32 2 x 3 u u '
8
u (1) 17
1 x 3
u (3) 14.33
y1 u
y2 u '
u (1) 17
u (3) 14.33
y1 ' u ' y2
1
y2 ' u ' ' 32 2 x 3 y1 y2
8
y1 (1) 17
y2 (1) ?
u (3) 14.33
Ejemplo 2 MATLAB
function yprima = frontera_2(x,y)
yprima=[y(2);1/8*(32+2*x^3-y(1)*y(2)];
*************************************
xspan = [1 3]; % Intervalo de la variable independiente
yzero = [17 0]; % Condicin inicial
%yzero = [17 -14]; % Condicin inicial
[x,y] = ode45('frontera_2',xspan,yzero);
plot(x,y(:,1)) % grafico de la solucin
y(length(x),1)
METODO DE DIFERENCIAS
FINITAS
y ( xi 1 )
y ( xi )
wi 1
wi
y ( xi 1 )
y (b)
wi 1
y (a )
x a
xi 1
xi
xi 1
x b
METODO DE DIFERENCIAS
FINITAS: CASO LINEAL
METODO DE DIFERENCIAS
FINITAS: CASO LINEAL
METODO DE DIFERENCIAS
FINITAS: CASO LINEAL
METODO DE DIFERENCIAS
FINITAS: CASO NO LINEAL
SISTEMA NO-LINEAL
MATLAB: bvp4c
El comando esta diseado para resolver problemas de
condiciones de frontera de ecuaciones diferenciales ordinarias
de la forma:
y' f ( x , y )
donde x es la variable independiente, y es la variable
dependiente, y y representa dy/dx. Con las siguientes
condiciones de frontera en el intervala [a , b]:
g ( y (a ) , y (b) ) 0
MATLAB: bvp4c
bvp4c usa el mtodo de diferencias finitas con la frmula de
Lobatto IIIa (3-etapas).
Este mtodo produce una solucin continua, no
uniformemente espaciada, de cuarto orden de precisin,
mediante la tcnica de COLOCACIN.
Esta tcnica usa una malla de puntos para subdividir el
intervalo de integracin. Se halla una solucin resolviendo un
sistema global de ecuaciones algebraicas resultantes de las
condiciones de frontera y las condiciones impuestas por el
mtodo de colocacin en cada subintervalo.
Se determina si el error obtenido satisface el critero de
tolerancia, si no, se adapta la malla y se repite el proceso.
MATLAB: bvp4c
La sintaxis de bvp4c es:
sol = bvp4c(odefun, bcfun, solinit)
odefun: Funcin que representa la EDO que se desea
solucionar (similar que para los comandos ODE**).
dydx = odefun(x,y) donde x es un escalar, dydx y y son
vectores columna.
bcfun: Esta funcin debe retornar una funcin residual que
debe ser cero en las condiciones de frontera.
res = bcfun(ya,yb) donde ya y yb son vectores columna
representando las fronteras izquirda y(a) y derecha y(b)
res es un vector columna del residual que satisface las
condiciones de frontera.
MATLAB: bvpinit
solinit: Funcin donde se especifican los puntos iniciales de la
malla y una aproximacin inicial de la solucin en estos puntos.
solinit debe tener una estructura especfica para ser utilizada
en el comando bvp4c por lo que MATLAB tiene el comando
bvpinit para obtener la estructura exigida.
solinit = bvpinit(x,yinicial)
x es un vector que especifica una malla inicial. Para el intervalo
[a,b], se debe especificar x(1) como a y x(end) como b. La
funcin bvp4c obtiene una malla final en la solucin.
MATLAB: bvpinit
yinicial es la aproximacin inicial de la solucin. Puede ser un
vector o una funcin:
Vector: Para cada componente de la solucin bvpinit asume
el correspondiente elemento del vector como un valor
constante para todos los puntos de la malla. Es decir, y(i) es
una aproximacin inicial constante para la componente ith of
the solution y(i,:) en todos los puntos x de la malla.
Funcin: Para cada punto de la malla, la funcin debe
devolver un vector cuyos elementos son aproximaciones de las
correspondientes componentes de la solucin. La funcin debe
ser de la forma: y = guess(x)
donde x son los puntos de la malla y y es un vector con
longitud igual al nmero de componentes de la solucin. O sea,
si se usa la funcin @guess, bvpinit la llama para todas las
componentes de la solucin, y(:,j) = guess(x(j)), en cada
punto de la malla j
ARGUMENTOS DE SALIDA
El comando produce una estructura sol (que puede tener cualquier
nombre) con las siguientes caractersticas:
sol.x: Almacena los nodos de la malla seleccionado por bvp4c
sol.y: Aproxima el valor de y(x) en los nodos de la malla.
sol.yp: Aproxima el valor de y(x) en los nodos de la malla.
sol.parameters: Estima el valor de los parmetros desconocidos,
si es el caso, obtenidos en el clculo.
La funcin bvpval usa la estructura de salida de sol para evaluara
la solucin numrica en cualquier punto del intervalo [a , b].
OPCIONES
La estructura del comando permite considerar los siguientes
argumentos opcionales:
options: Es el cuarto argumento:
sol = bvp4c(odefun,bcfun,solinit,options)
Cambia las propiedades que tiene el mtodo por defecto
(tolerancia, iteraciones, ). Estos cambios se realizan utilizando
las funciones de Matlab bvpset y bvpget (utilizar la ayuda de
MATLAB help para ver ms detalles de estas funciones).
ARGUMENTOS CONOCIDOS
p1,p2... Son parmetros conocidos que se pueden pasar entre las
diferentes funciones del comando (odefun y bcfun).
sol = bvp4c(odefun, bcfun, solinit, options, p1, p2...)
Si no se cambian los opciones se debe colocar [].
sol = bvp4c(odefun, bcfun, solinit, [], p1, p2...)
En la funcin odefun la lista de argumentos conocidos se debe
colocar despus de x , y
dydx = odefun(x,y,p1,p2,...)
En la funcin bcfun la lista de argumentos conocidos se debe
colocar despus de ya, yb
res = bcfun(ya,yb,p1,p2,...)
ARGUMENTOS
DESCONOCIDOS
Ejemplo 1
u ' ' 4200 x 5 3000 x 4
0 x 1
u (0) 0
u (1) 0
y1 u
y2 u '
y1 ' y2
u (0) 0
y1 (0) 0
u (1) 0
y1 (1 ) 0
Ejemplo 1 MATLAB
function solucion=ecuacion1_bvp
inicial = bvpinit(linspace(0,1,20), [0 0])
solucion = bvp4c(@frontera_1, @f1_bc, inicial);
plot(solucion.x,solucion.y(1,:))
%-----------------------------------------------------function res = f1_bc(ya,yb)
res = [ya(1);yb(1)];
%----------------------------------------------------function yprima = frontera_1(x,y)
yprima=[y(2);4200*x^5-300*x^4];
Ejemplo 1 COMPARACION
function solucion=ecuacion1_bvp
inicial = bvpinit(linspace(0,1,20), [0 0])
solucion = bvp4c('frontera_1', @f1_bc, inicial);
plot(solucion.x,solucion.y(1,:))
%-----------------------------------------------------function res = f1_bc(ya,yb)
res = [ya(1);yb(1)];
%------------------------------------------------------xspan = [0 1]; % Intervalo de la variable
independiente
yzero = [0 -90]; % Condicion inicial
[x,y] = ode45('frontera_1',xspan,yzero); % solucin
con datos
hold on;
plot(x,y(:,1),'r') % grafico de la solucin
Ejemplo 2 MATLAB
1
u ' ' 32 2 x u u '
1 x 3
8
3
u (1) 17
u (3) 14.33
y1 u
y1 ' y2
u (1) 17
1
y2 ' 32 2 x 3 y1 y2
8
y1 (1) 17
u (3) 14.33
y1 (3) 14.33
y2 u '
Ejemplo 2 MATLAB
function solucion=ecuacion2_bvp
inicial = bvpinit(linspace(1,3,20), [0 0])
solucion = bvp4c('frontera_2', @f2_bc, inicial);
plot(solucion.x,solucion.y(1,:))
%-----------------------------------------------------function res = f2_bc(ya,yb)
res = [ya(1)-17;yb(1)-14.33];
%------------------------------------------------------function yprima = frontera_2(x,y)
yprima=[y(2);1/8*(32+2*x^3-y(1)*y(2)];