Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Apunte Calculo Numerico Lab
Apunte Calculo Numerico Lab
Facultad de Ingeniera
Depto. Ingeniera Quimica
APUNTE
DE
CLCULO NUMRICO
AUTORES
Diego Seiltgens Sorrel
Rodrigo Verdugo Fuentes
TABLA DE CONTENIDOS
1.2
1.3
1.4
Tema 4: Interpolacin_________________________________________________________14
Ejemplo 4.1: Comparacin entre interpolacin y ajuste de mnimos cuadrados ______________ 15
Ejemplo 4.2: Fenmeno de Runge_________________________________________________ 15
Ejemplo 4.3: Aplicacin de spline al dibujo de funciones discontinuas ____________________ 16
Ejemplo 4.4: Spline y parametrizacin de curvas _____________________________________ 17
Ejemplo 4.5: Ms acerca del fenmeno de Runge_____________________________________ 18
Tema 1
Algunos aspectos del MATLAB
El MatLab (Matriz Laboratory) no es muy diferente a los lenguajes de programacin C y ForTran. La
ventaja de este lenguaje es la incorporacin de ciertos comandos que facilitan los clculos, especialmente
en lo referente a matrices. Los comandos fundamentales se encuentran es las guas 1 y 2 del curso.
1.1 Comentarios Importantes
a)
Nmeros complejos: MatLab trae incorporado el trabajo con nmeros complejos, y para ello
reconoce la letra i como la unidad imaginaria; ejemplo:
>> a = 1+i;
>> b = -5+2i
Las operaciones con estos nmeros complejos son las siguientes:
Suma: >> e = a+b
>> ans = -4.0000 + 3.0000i
Producto: >> p = a*b
>> ans = -7.0000 + 3.0000i
Racionalizacin: >> r = a/b
>> ans = -0.1034 + 0.2414i
Argumento normalizado: >>angle (a)
>> ans = 0.7854 (en radianes y en el intervalo [-, ])
Conjugado: >> conj(a)
>> ans = 1-i
Mdulo del complejo: >>abs(a)
>> ans=1.4142
b)
length(v) :
abs(v) :
max(v) :
min (v) :
sum(v) :
prod(v) :
norm(v) :
mean
:
std(v)
:
sort(v) :
c)
det (A)
rank(A)
A
[V,D]= eig(A)
:
:
:
:
trace(A)
devuelve el determinante de A
devuelve el rango de A
devuelve la transpuesta de A
devuelve dos matrices, la matriz D que contiene los valores propios de A, y V, que
contiene los vectores propios de A.
Suma la diagonal. (sirve para calcular norma de matrices)
Para nombrar los ejes de los grficos, se puede utilizar la pantalla grfica viendo en las opciones, o usando
el comando
xlabel(nombre del eje x)
ylabel(nombre del eje y)
title(ttulo)
Observaciones:
-
Comandos de inters:
Clear
Clc
Whos
Dir
Help
:
:
:
:
:
limpia la memoria
limpia la pantalla, es decir las variables siguen existiendo
permite ver las variables y como estn almacenadas en la memoria
permite ver los archivos existentes, donde est situado el Matlab
Ayuda (P.E. >>Help Plot despliega una ventana con informacin en ingls acerca del
comando.)
Tema 2
Sistemas de ecuaciones lineales.
La resolucin del problema Ax=b, donde A es una matriz cuadrada de mm y b un vector de m1, da
origen a la teora de sistemas de ecuaciones. Este problema tendr solucin siempre y cuando la matriz A
tenga inversa, lo que es equivalente a decir que el determinante de la matriz no es cero, o que cero no es
valor propio de A, i.e. todas las filas y columnas de A son linealmente independientes.
Como calcular la matriz inversa A-1, es muy costoso computacionalmente (en MatLab se hace con el
comando inv(A)), se recurren a dos tipos de mtodos, los directos y los indirectos.
-
Mtodos directos: Son aquellos que operando sobre la matriz A, ya sea factorizndola o
intercambiando columnas, permiten encontrar la solucin x.
Mtodos indirectos: Sin alterar la matriz A, se genera una sucesin de vectores X0, X1Xn de
modo que dicha sucesin converja a la solucin del sistema.
LU
Chol.
S.E.L.
Jacobi
Mtodos Indirectos
G.S.
P.C.G
[L,U,P] = lu(A), devuelve la matriz triangular superior L, la matriz triangular inferior U y una matriz
de permutacin P, que fue necesario hacer para que la matriz U quedara triangular inferior. Como
hubo que permutar la matriz A para factorizarla, para resolver el sistema hay que permutar el vector b
y el sistema a resolver es:
(L*U)*x = P*b
-
Cholesky
Consiste en descomponer a en una matriz R de modo que A=R*Rt. Esta factorizacin es ms
restrictiva pues requiere que la matriz A sea una matriz simtrica ( que A=At en el caso de las
matrices reales) y definida positiva (que los valores propios de A sean todos mayores que cero). En
MatLab el comando a usar es:
R= chol (A)
Y el sistema a resolver es:
(R*Rt)*x=b
El problema 3 del laboratorio 3, tiene como objetivo ver como se usan estos comandos y medir los
tiempos de resolucin de los mtodos pre definidos en MatLab, a saber: \, lu, chol y el comando inv. Se
observa que el comando \ es el ms rpido. Le sigue el mtodo de Cholesky, el comando inv y luego lu.
Este orden se debe a que las rutinas predefinidas en el MatLab funcionan ms rpido que los programas.
= A A 1
Tambin se calcula como el menor valor propio de la matriz A. Este valor lo entrega el comando MatLab:
>>u = cond (A)
Si el nmero de condicin para cualquiera de las dos formas es cercano a 1, la matriz est bien
condicionada; de lo contrario, si es mucho mayor a uno, el sistema est mal condicionado.
Esta idea se ve en el problema 4 del laboratorio 3, donde se construye la matriz de Hilbert, que es muy mal
condicionada, perturbndose el vector b en orden de 10-6 y se comparan los valores. La solucin del sistema
perturbado dista mucho de la solucin original, por lo que el sistema es muy mal condicionado.
El problema 5 del laboratorio 4 tiene como objetivos: crear una matriz rala como full y verificarla con el
comando nnz, para mostrar que la matriz est compuesta mayoritariamente de ceros. Luego pasarla a una
matriz sparse y comparar su tiempo de resolucin con una full, para notar que una matriz sparse permite
un ahorro de memoria y de tiempo para solucin.
Adems, ver que las matrices pueden generarse sin pasar primero por matrices full, usando el comando
speye, spdiags (anlogo al comando diags pero hecha sparse) y luego construir la matriz de iteracin para
el mtodo de Jacobi.
Notar que si A es sparse, la generacin de las matrices D con el comando diag, -E con el comando tril y -F
con el comando triu devuelven matrices sparse. La construccin de este sistema est resuelta en el
problema 4 de la guia 3 y puede utilizarse con el algoritmo planteado en el problema 6, cambiando slo la
matriz de iteracin.
mk
x k +1 x k < tol
1 mk
mk =
x k 1 x k
x k x k +1
tol
:
Maxit :
El problema 6, muestra como se usa el gradiente conjugado y compara su uso con el mtodo de Gauss
Seidel.
Tema 3
Mnimos cuadrados
El objetivo de los cuadrados mnimos es encontrar la funcin (x) que ajuste una dispersin de puntos de
la mejor forma posible. Esta forma resulta de la minimizacin de la suma de todos los cuadrados de las
distancias entre la funcin y los puntos que se disponen. Esta funcin puede ser una funcin polinomial o
cualquier otra.
2
i =1
( xi )
yi
(3.1)
3.1 Matriz QR
El caso de los mnimos cuadrados trata acerca del ltimo caso (n < m). Lo que se persigue es encontrar un
vector x tal que la norma de los residuos sea mnima (condicin similar a la anterior, de hecho, de ah
viene la ec 3.1), es decir:
r 2 = b A x 2
(3.2)
EL vector x minimizar el residuo anterior si y slo si r es ortogonal a la imagen de A, es decir:
At r = 0 At (b A x) = 0 At A x = At b
La ltima ecuacin se conoce como sistema de ecuaciones normales y es un sistema cuadrado que tendr
solucin si A es de rango completo, es decir, rango(A)=n. Adems, A es simtrica y definida positiva, por
ende, se podran aplicar los mtodos de resolucin de ecuaciones, como Cholesky, Gauss Seidel y el
gradiente conjugado, pero tambin se sabe que la matriz AtA es muy mal condicionada, por lo que se
prefiere otra solucin: el de utilizar la descomposicin de A en dos matrices: A=QR, donde:
R :
Q :
En virtud de lo anterior:
QQ t = I
qi q j = 1 si i=j
qi q j = 0 si ij
10
At A x = At b
R t Q t (Q R ) x = R t Q t b
Rt I R x = Rt Qt b
R x = Qt b
3.2 Problemas lineales y no lineales.
A veces, los problemas no lineales pueden ser reducidos a lineales mediante un proceso de linealizacin,
que consiste en dejar el modelo pedido como lineal mediante alguna transformacin matemtica. Algunos
casos se vern a continuacin:
Caso 1: Modelo inverso:
y=
a
+ b y = a u + b
x
poniendo
u=
1
x
Este modelo puede transformarse a lineal si se invierte la variable x, con ello el ajuste de mnimos
cuadrados obedece a una recta y los puntos a trabajar ya no son x, sino sus inversos.
Caso 2: Modelo exponencial:
y = A exp(b x ) ln( y ) = ln A + b x
Para un modelo exponencial planteado, el problema puede ser linealizado al aplicar logaritmo, con
ello se genera la ecuacin de una recta, con la salvedad que los puntos y se les debe aplicar el
logaritmo y luego ser usados en la solucin del sistema. La pendiente de la recta da directamente
el valor de b, mientras que el valor de A viene dado por la exponencial del coeficiente.
Caso 3: Modelo potencial:
y = A x b ln( y ) = ln A + b ln x
El modelo potencial se linealiza para un b desconocido (Ojo, como b hay que determinarlo, esto
no es un modelo polinomial!), donde los datos x, y deben pasar a sus respectivos logaritmos.
3.3 Rutinas de MatLab para trabajo con polinomios.
El MatLab permite trabajar con polinomios, incluso encontrar el polinomio que mejor ajuste en el sentido
de los mnimos cuadrados a un conjunto de puntos dados. A continuacin se presentar la forma de
ingresar un polinomio a MatLab y algunos de los comandos ms usados.
n
n 1
Sea el polinomio P( x ) = an x + an 1 x + a 0
11
El polinomio se ingresa a MatLab como un vector fila de la forma: P = [an an-1 a0]
Sea un polinomio P y un conjunto de puntos x:
Y=polyval(P,x) :
r=roots(P)
:
P=poly(r)
:
P=polyfit(x,y,n) :
m=10;
n=5;
A=Aj_Pol(m,n);
B=A*A; % Matriz del sistema normal de ecuaciones
cond_B=cond(B) % Estudio del condicionamiento
[Q,R]=qr(A); % Descomposicin de A en matrizces QyR
err_ort=norm(Q*Q-eye(m+1),inf) % Comprobacin de propiedades de Q
h=1/m;
t=(0:h:1);
b=exp(t);
c=A\b;
tt=0:.01:1;
plot(t,b,o,tt,polyval(c,tt),-,tt,exp(tt),b--)
La primera rutina (Aj_Pol) genera y devuelve una matriz A de mn que deben ser ingresados. Esta matriz
corresponde a la matriz de problemas de mnimos cuadrados, cuando la base elegida es un polinomio de
grado n y los puntos elegidos para construir la funcin que mejor los aproximar son los puntos
equiespaciados en el intervalo [0,1].
La segunda rutina permite estudiar el condicionamiento de la matriz ATA, mostrando que el sistema est
mal condicionado. Luego se muestran las propiedades de la matriz Q.
La ltima parte muestra como se encuentra el polinomio de grado 5 que ajusta a la funcin exp(x), para los
puntos dados. Esto se hace generando la matriz A (ya hecha en la rutina Aj_pol) y resolviendo el sistema
de ecuaciones Ax=b con el comando \ en Matlab. El comando polyval permite evaluar el polinomio c en l
o los puntos tt.
Ejemplo 3.2: Ajuste de mnimos cuadrados para un problema no lineal
A veces, el problema de mnimos cuadrados no puede ser lineal, as que la matriz debe armarse con la
base disponible. En este caso, la base es:
2 t
2 t
B = 1 + e t + cos
+ sin
12
12
12
La matriz resulta de la evaluacin de los puntos x, que contiene el archivo, en cada uno de los elementos
de la base. De esta manera, la rutina para encontrar los coeficientes es:
load CO2 % carga el archivo con los datos
m=length(c); % mide el vector para generar la matriz
alfa=0.0037;
t=(1:m);
M=[ones(m,1) exp(alfa*t) cos(2*pi*t/12) sin(2*pi*t/12)]; % arma la matriz de coeficientes
x=M\c % determina los coeficientes
tt=0:.1:60;
mod=x(1)+x(2)*exp(alfa*tt)+x(3)*cos(2*pi*tt/12)+x(4)*sin(2*pi*tt/12); % evala los puntos en el modelo
plot(t,c,o,tt,mod,-) % compara los puntos del archivo con el modelo encontrado
Obervacin: notar el uso del comando ones para generar la columna de unos que exige la base.
Ejemplo 3.3: Aplicacin de mnimos cuadrados a la circunferencia
En este problema, el propsito es encontrar los parmetros de la ecuacin de la circunferencia que
permiten dibujar los datos dados en el archivo. Como la circunferencia es un problema no lineal, la idea es
buscar alguna manera de adaptarlo para usar la idea de mnimos cuadrados.
Recordar que la ecuacin re arreglada propuesta para la circunferencia es:
2 x i a + 2 y i b + c = x i2 + y i2
As, el sistema de ecuaciones queda claramente definido. Los valores de x e y son conocidos; resta slo
encontrar los valores de a, b, c. La matriz en este caso, se forma como se muestra en la rutina:
load circulo % carga el archivo
m=length(x) % mide el vector
A=[2*x 2*y ones(m,1)]; % se forma la matriz A
b=x.*x+y.*y; % se firma el vector b
p=A\b; % se resuelve el sistema
r=sqrt(p(3)+p(2)^2+p(1)^2) % hecho para encontrar el valor de r
tt=0:0.01:2*pi;
xx=p(1)+r*cos(tt);
yy=p(2)+r*sin(tt); %variables para graficar un crculo
plot(x,y,'x',xx,yy)
Observaciones:
Notar que la generacin del vector b se usa el punto, pues se desea multiplicar cada elemento por si
mismo.
Se usan ecuaciones paramtricas para graficar la circunferencia.
El vector p contiene los 3 coeficientes buscados. Por el orden que fue formada la matriz, el elemento
1 corresponde al valor de a, el elemento 2 al de b y el 3 al de c.
13
sin 2 ( x) + co s 2 ( x) = 1
Debidos a esto, MatLab da un warning acerca de la repeticin de ecuaciones. Se puede eliminar cualquier
columna (recordar que la matriz debe ser de rango completo). Esto se hace en la rutina con el comando
A=A(:,2:3).
load rango
m=length(t);
A=[ones(m,1) cos(pi*t).^2 sin(pi*t).^2 ];
x=A\y;
A=A(:,2:3);
x=A\y;
tt=0:0.01:1;
mod=x(1)*cos(pi*tt).^2+ x(2)*sin(pi*tt).^2
plot(t,y,'o',tt,mod,'-')
14
Tema 4
Interpolacin
Si se tiene un conjunto de puntos, al cual se le desea ajustar una curva, lo lgico y la mnima exigencia
que se le hace a la curva que pretende ajustar a dichos puntos, es que pase por todos ellos. Por lo tanto, la
interpolacin consiste en construir una curva que pase por todos los puntos.
La principal diferencia que existe con los mnimos cuadrados, es que los ltimos buscan un ajuste que
minimiza distancias, pero no necesariamente exige que esta curva pase por los puntos
La interpolacin puede ser de dos formas:
Polinomial: y su caso particular usando polinomios de Legendre
Interpolacin
Spline: funcin cbica por tramos.
-
Polinomial
No se dar mayor detalle en este laboratorio, slo saber que los L(x) son los polinomios de Legendre
asociados a los puntos. (ver su construccin en las diapositivas del curso)
n
P ( x ) = y i L( x )
i =1
Y si se desea contruir un polinomio de interpolacin, se puede usar el comando polyfit del MatLab
(visto en en la seccin anterior), recordando que el grado del polinomio n debe ser igual al nmero de
puntos menos uno (n = m 1).
El comando polyfit entrega un polinomio de la manera: [an an-1 ... a0]
El problema es que estos polinomios pueden comenzar a oscilar si n crece mucho, as que se busca
una solucin diferente para evitar estos problemas (fenmeno de Runge)
-
Spline
El spline es una funcin cbica por tramos, es decir, hace un ajuste polinomial cbico entre dos
puntos. Este ajuste se hace para todos los puntos que se dispongan. La ventaja es que al ser de un
grado 3, no oscila como un polinomio de alto grado.
Para que un polinomio cbico sea una spline, debe cumplir que:
a)
b)
c)
d)
s(x) = q(x)
Continua
Derivable
Suave
:
:
:
:
15
Ejemplo 4.1: Comparacin entre interpolacin y ajuste de mnimos cuadrados (problema 1 c) Lab.5)
El siguiente programa construye los polinomios de ajuste para n = 5 y para n = 10 para la funcin seno.
Primero se generan los puntos (11 puntos) y luego se construyen los dos polinomios de ajuste. Se ve
claramente en la figura 3.1 que el polinomio de grado 10 es de interpolacin, porque pasa por todos los
puntos, mientras que el de 5 no lo hace. EL vector xx es slo un conjunto de puntos que sirve para graficar
los polinomios determinados con el comando polyfit. Para evaluar los puntos se usa el comando polyval,
que funciona de la forma:
>>Y=polyval(P,xx)
Si P es un polinomio y xx un punto o un vector, polyval evala el punto o el vector en el polinomio P,
devolviendo en Y, un punto o vector segn sea el caso.
X= 0:10;
Y= sin(x);
C5=polyfit(x,y,5);
C10=polyfit(x,y,10);
xx=0:0.1:10;
Plot(x,y,x,xx,polyval(C5,xx),, x,y,y,xx,polyval(C10,xx),-)
16
La rutina anterior permite visualizar el conocido fenmeno de Runge. Primero, se determinan los puntos
usados para construir los polinomios de interpolacin, luego se determinan con el comando polyval, los
polinomios de grado 6 (C6) y de grado 10 (C10) para aproximar la funcin.
La figura 3.2 muestra que los polinomios slo aproximan en una regin (al centro) a la funcin pedida. En
los extremos, los polinomios comienzan a oscilar y esta oscilacin se hace cada vez ms fuerte debido al
aumento del grado del polinomio. El polinomio de grado 10 es mucho ms oscilante que el de grado 6.
Esto puede evitarse si se usan splines para interpolar la funcin, como se muestra en la figura 3.3. Esta
curva es mucho mejor aproximada por una spline, adems de tener la ventaja de evitar las oscilaciones
Ejemplo 4.3: Aplicacin de spline al dibujo de funciones discontinuas (problema 2 Lab.5)
Load pieza %cargo el archivo pieza
plot(x1,y1,'x',x2,y2,'+',x3,y3,'.')%dibujo del contorno, aqu veo los limites de los puntos para despus
aproximarlos como spline!!!!
xx1=-1:0.01:0;%estos limites los veo en el dibujo anterior
xx2=0:0.01:0.5;
xx3=-1:0.01:0.5;
plot(x1,y1,'x',x2,y2,'+',x3,y3,'.',xx1,spline(x1,y1,xx1),'',xx2,spline(x2,y2,xx2),'-',xx3,spline(x3,y3,xx3),'-')
%dibujo la pieza con 3 splines
17
La figura 3.4 muestra los puntos que componen la pieza. Se ve que existen esquinas o puntos de
discontinuidad que impiden usar una sola spline para dibujarla, por lo que se deben hacer tres splines para
evitarlos. De cualquier forma, la funcin seguir teniendo sus esquinas, pero ahora est bien representada
por 3 splines en la figura 3.5
Ejemplo 4.4: Spline y parametrizacin de curvas (problema propuesto 2 Lab.5)
Load espiral %cargo el arcivo espiral)
plot(x,y,'x', x,y,'-') %grafico los puntos y se unen con una linea
t=1:length(x);%variable para parametrizar
tt=1:0.1:length(x);%parametrizacin de la curva
plot(x,y,x,spline(t,x,tt),spline(t,y,tt),-)%interpolacin spline de la curva paramtrica
Parametrizacion
de x
Parametrizacion
de y
18
Para dibujar la espiral se necesitan encontrar puntos intermedios x e y que pertenezcan a la espiral. Esto se
hace parametrizando la curva con la variable t. Una vez conocidos estos valores, se puede graficar la
espiral, tal como se muestra en la figura 3.7
Ejemplo 4.5: Ms acerca del fenmeno de Runge (problema propuesto 1 Lab.5)
%rutina para el runge
a=-5;
b=5;
for i=0:10
if i==0
P=polyfit(1,1,0);
else
h=(b-a)/i;
x=a:h:b;
y=1./(1+x.^2);
P=polyfit(x,y,i);
subplot(4,3,i)
xx=-5:0.1:5;
yy=1./(1+xx.^2);
plot(xx,yy,'--',xx,polyval(P,xx),'-')
end
end
La idea de este problema es ver que, a medida que aumentan los puntos usados para construir el polinomio
de interpolacin, mayores son las oscilaciones que el polinomio genera al tratar de aproximar la funcin.
En la figura 3.8 se aprecia que el crecimiento de puntos slo aproxima de buena forma la regin del centro
de la curva, pasado sta, se observan oscilaciones.
Figura 3.8: Fenmeno de Runge
19
La situacin no es tan mala, porque s existen funciones que se aproximan mejor, con ms puntos. La
funcin seno no es una funcin mal comportada. A medida que el grado del polinomio de interpolacin
aumenta, la exactitud se hace cada vez mayor. Si se hace un polinomio de grado 7, la aproximacin es casi
perfecta
Figura 3.9: Funcin seno
20
Tema 5
Integracin numrica
La idea es hallar la integral de una funcin f continua en el intervalo [a,b] donde se pretende integrar.
b
i =1
I = p ( x) f ( x) Ai f ( xi ) + R
La integral se transforma en un producto de un factor por la funcin evaluada en alguna particin del
intervalo. Como este producto no es exacto, hay un resto R.
Trapecio: grado 1 (exacta para una recta)
Mtodos de integracin
A veces es ms cmodo ingresar la funcin como una variable string y una forma es usando el comando
inline. Por ejemplo, para ingresar la funcin exp(-x2)
>>t = inline(exp(-x.^2))
La idea es ingresar la funcin no como archivo, sino como un parmetro y con ello ahorrar memoria. La
desventaja est en que una funcin definida como inline no puede recibir valores que no sean los de la(s)
variable(s) con la(s) que se vaya a trabajar. Por ejemplo, en el caso anterior, slo recibe valores de x.
Una vez ingresada la funcin en MatLab, esta puede evaluarse mediante el siguiente comando:
>>Y=feval(t,x)
Donde t es la funcin ingresada como inline, x un punto o un vector e Y es un nmero o un vector que
resulta de la evaluacin de x en la funcin.
21
quad
quadl (tol=10-6)
Para integrales dobles, utilizar dblquad(funcin, a, b, c, d, tol), donde a y b los intervalos donde est el
rectngulo asociado a la variable x, c y d son los intervalos de integracin de y.
Por ejemplo, una manera de conocer la tolerancia de los comandos utilizados es realizar lo siguiente
(problema 3 del lab. de integracin)
>> q=inline('exp(-x.^2)');
>> e1=quad(q,-1,1)
e1 =
1.49364827606288
>> e2=quad(q,-1,1,1e-6)
e2 =
1.49364827606288
>> s1=quad('sqrt',0,1)
s1 =
0.66665956927202
>> s2=quad('sqrt',0,1,1e-6)
s2 =
0.66665956927202
22
n 1
h
f (a ) + f (b) + f ( xi )
2
i =1
R = n
( b a ) h2 f ''( )
h3
f ''( ) =
12
12
[ a, b ]
x2
dx con 20 subintervalos.
La misma mecnica se sigue tanto para las funciones definidas en la librera, que no es necesario
ingresarlas, como las ingresadas como inline.
El comando format long, permite ver todos los decimales de un nmero. Puede ir tanto en el programa
como en el main de MatLab.
>>format long
>>f=inline(x.^2)
f =
Inline function:
f(x) = x.^2
9.04500000000000
9.01125000000000
9.00281250000000
9.00070312500000
>>g =inline(exp(-x.^2))
g =
Inline function:
g(x) = exp(-x.^2)
1.48873667952733
1.49242159226350
1.49334167387975
1.49357162247796
23
0.38587793674575
0.38619020963221
0.38626832040247
0.38628785076256
0.66050934170682
0.66444659142664
0.66587096567353
0.66638264723897
Esta ltima funcin no necesita ser definida como inline, puesto que ya est definida en la librera del
MatLab. Una funcin que est ya definida, como el logaritmo (log) o la raz cuadrada (sqrt) basta slo con
llamarla entre comillas.
Importante: las funciones definidas son sqrt(x) y log(x), no funciones complejas del tipo sqrt(x+1), esta
ltima debe ser definida como inline.
El programa recibe la funcin y los intervalos de integracin a y b.
5.2.2 Simpson: ejemplo 1b)
I=
n 1
n 1
h
R = n
( b a ) h4 f IV ( )
h5 ( IV )
f ( ) =
90
180
[ a, b ]
Esta regla hace diferencia entre los puntos de integracin pares e impares. El algoritmo resultante es el
siguiente.
function int=simpson(funct,a,b,N)
h=(b-a)/(2*N); % necesario para separar pares de impares.
xp=a+2:2:(2*N-2)*h; % nmeros pares
xi=h+(1:2:2*N-1)*h; % nmeros impares
int=h/3*(feval(funct,a)+feval(funct,b)+2*sum(feval(funct,xp)+2*sum(feval(funct,xi))));
Notar que debido a la divisin de nmeros pares e impares que hace el algoritmo, el paso se parte en 2N y
una vez separados, se aplica el algoritmo sumando las componentes pares e impares por separado,
multiplicando por sus respectivos factores.
Para las mismas integrales, se cambia en el caso 1 a) el comando trap por simpson:
24
Inline function:
f(x) = x.^2
7.78000000000000
6.88250000000000
6.43937500000000
6.21921875000000
Se espera, en este ltimo caso, que la solucin sea exacta, ya que Simpson, entrega soluciones exactas
para polinomios de segundo grado.
El nacimiento de esta frmula es distinto, ya que parte de la idea de que los Ai no se conocen. Para n
puntos de particin el algoritmo es:
I=
b a
ba n
Ai f
( xi + 1) + a
2 i =0
2
La diferencia radica en que los xi ya no son arbitrarios, sino que dependen de los puntos n.
Para mostrar su utilizacin, se mostrar el siguiente ejemplo:
Problema 1: Test 3 09/11/01
Sobre el espacio vectorial de las funciones continuas definidas en el intervalo [a, b] a valores reales, se
define el siguiente producto interior:
b
Haga un programa general en MatLab, llamado testIIc.m que, usando integracin de Gauss con los puntos
dados en la tabla, calcule el producto interior entre dos funciones. El programa deber tener por entrada
los valores de a y b, y por salida el valor del producto interior.
xi
0.861136311594053
0.339981043584856
Ai
0.347854845137455
0.652145154862547
25
Solucin:
Primero se construye un programa genrico para esos valores de la cuadratura (lo ideal sera tener en el
MatLab una tabla para todos los valores de n). El programa resultante es:
function I=gauss(f,a,b)
x=[-0.861136311594053 -0.339981043584856 0.861136311594053 0.339981043584856];
A=[0.347854845137455 0.652145154862547 0.347854845137455 0.652145154862547];
u=(a+b)/2+(b-a)/2*x; % se aplica el cambio de variables
Y=feval(f,u); % se evala la funcin
I=0.5*(b-a)*A*Y'; % se realiza el producto Ai*ui
Luego, las funciones deben ser ingresadas como inline. El resto queda propuesto.
Ejemplo 5.1: Exactitud del mtodo de los trapecios en un caso especial.
f=inline('exp(-x)');
N=10:10:100;
error=[];
for n=N;
integ=trap(f,0,1,n);
error=[error abs(integ-(1-exp(-1)))];
end
loglog(N,error,'o:',N,(1./N).^2,'-')
Esta rutina pretende probar la observacin dada en el enunciado del problema 2. Para establecer que el
error es de orden 2, se grafica el error que sale de la diferencia entre el clculo de la integral con el mtodo
de los trapecios y el valor verdadero, que es conocido. Con ello, se genera una tabla de valores entre N y el
error, almacenada en dos vectores: n y error. El ciclo for es para hacer variar el paso N y obtener los datos
de la integracin. Ahora bien, si se grafica la funcin 1/n2 contra n en un grfico logartmico, la grfica es
una lnea recta de pendiente -2. Si el error fuera de orden 2, la pendiente de un grfico logartmico entre N
y el error, debera tener la misma pendiente, es decir, seran paralelas. En efecto:
26
27
Tema 6
Ecuaciones no lineales.
El objetivo de este tema es resolver ecuaciones y sistemas de ecuaciones no lineales usando tcnicas
numricas y con ayuda del MatLab.
A continuacin se presenta una breve descripcin de los algoritmos clsicos usados para resolver
ecuaciones no lineales tanto en una variable, como en varias variables (sistemas de ecuaciones lineales).
Est basado en el teorema del valor medio, que seala que si la funcin a resolver es continua en el
intervalo de solucin y sea f(a)<f(b). Para cada f(a)<z<f(b) debe existir un x0 que pertenezca al intervalo
de solucin. En particular, si f(a) y f(b) tienen signos opuestos, este x0 debe ser 0. As, conocido un
intervalo donde hay un cero o raz, lo que se hace es partir el intervalo en dos, luego evaluar la funcin en
los puntos extremos del intervalo ya cortado. Si existe un cambio de signo en f(xa)f(xb), implica que hay
una raz en el intervalo y este se vuelve a cortar. As sucesivamente hasta encontrar una raz. La
aproximacin puede obtenerse mediante el grfico de la funcin. Es un mtodo de convergencia lento,
pero siempre converge si el intervalo es adecuado. Se le llama mtodo de convergencia garantizada por
ser lento, pero siempre encuentra la solucin. No depende de la distancia entre la solucin y el valor que
se dio como inicial. Slo sirve para una variable.
Se utiliza cuando es muy difcil conocer la raz de la ecuacin o funcin. Es lo mismo que utilizar Newton
Rapson, pero no se conoce la derivada, pero se necesitan 2 puntos de apoyo al principio, para comenzar a
trabajar. Es extensivo tambin a sistemas de ecuaciones.
28
Los sistemas de ecuaciones pueden componerse como funciones a valores vectoriales, es decir, agrupar las
funciones en una funcin F que es un vector. En virtud de esto, las funciones son ingresadas como
matrices dentro de la plataforma, ya sea como inline o como archivos. Por ejemplo:
Sea el sistema a resolver:
x2 + x y + y2 = 1
y x2 = 0
Este sistema puede agruparse como un vector, para luego ser resuelto con tcnicas que veremos
posteriormente. Considerar para esta agrupacin, el siguiente cambio de variables:
x = x(1) ; y = x(2)
Con ello, la funcin F puede construirse con las dos ecuaciones de la forma:
f x 2 + x y + y 2 1
F = 1 =
y + x2
f2
Notar que las ecuaciones, independiente del nmero de variables que tengan, deben tener la forma
f ( x, y , z , w..) = 0
As, la manera de ingresar el vector en MatLab (con el cambio de variables realizado) es:
f=inline('[x(2)-x(1).^2;x(1).^2+x(2).^2-4]');
permite encontrar soluciones para una ecuacin no lineal (1 variable), se debe correr tantas
veces como races se tengan.
>>fzero(f,x0,tol)
fsolve :
El comando fzero, permite encontrar las races de una ecuacin, para ello, se debe tener una aproximacin
inicial de la solucin, que puede obtenerse mirando un grfico de ella. Su sintaxis es:
29
>>x=fzero(f,x0)
Donde:
x
:
f
:
x0
:
A continuacin se presentan unos ejemplos del uso del comando fzero para la solucin de ecuaciones no
lineales.
Ejemplo 6.1: Hallar todas las races de las ecuaciones
a) x 2 = 2
b) x 3 3 x + 1 = 0
c) cos( x) = x
Caso 1
Se sabe que las races son 2 y 2 . Basta utilizar como aproximacin 1.41 y -1.41 para encontrar las
races. Con ello, la funcin ingresada es:
>> f=inline('x.^2-2')
f =
Inline function:
f(x) = x.^2-2
1.4142
La misma idea debe repetirse para hallar la segunda, usando la correspondiente aproximacin inicial.
Caso 2
Aqu las races ya no son claras, y debe recurrirse a un grfico para poder verlas. Por ende, primero
graficar esta funcin, recordando el comando feval visto en tema anterior y el ingreso de la funcin de la
forma f(x)=0 (ya est en esa forma):
x=-10:0.1:10
f=inline('x^3-3*x+1')
f =
Inline function:
f(x) = x^3-3*x+1
plot(x,feval(f,x))
30
Del grfico, se pueden extraer aproximaciones de races para luego aplicar en conjunto con el comando
fzero. Se debe ejecutar 3 veces, una por cada raz que se tenga.
>> fzero(f,1.4)
ans =
1.5321
>> fzero(f,0)
ans =
0.3473
>> fzero(f,-1.2)
ans =
-1.8794
Caso 3
La idea es la misma, graficar y luego encontrar la raz que se ve en el grfico.
x=-2:0.1:2;
f=inline('cos(x)-x')
f =
Inline function:
f(x) = cos(x)-x
>> plot(x,feval(f,x),x,0)
>> fzero(f,1)
ans =
0.7391
Comentario, el plot (x,0) permite que aparezca el eje x de modo de facilitar la localizacin de la raz
inicial con el grfico.
Para resolver un sistema de ecuaciones no lineales existe un comando en MatLab llamado fsolve. Al igual
que fzero, este comando necesita de una aproximacin inicial, que ya no ser tan fcil de visualizar
grficamente puesto que ya la solucin X no es un nmero, sino un vector de n componentes, segn las
variables que el sistema tenga. Este resuelve el sistema usando el mtodo de mnimos cuadrados
El comando bsicamente funciona de la siguiente manera:
X=fsolve(F,X0)
Donde
X
F
:
:
X0
31
y x2 = 0
x2 + y 2 = 4
La solucin puede obtenerse fcilmente debido a que slo basta despejar una variable en funcin de la
otra. La solucin se har usando el comando fsolve.
Caso 1: Funcin como archivo
Si se desea ingresar una funcin como archivo, se usa el concepto de matrices. Cada funcin se ubica en
una columna como sigue:
function F=experimento(x)
F=[x(2)-x(1).^2;x(1).^2+x(2).^2-4]
X=[1.2496 1.5616];
La idea es la misma. El usar inline o no depender de la necesidad de usuario.
32
[ AGV ]
Kh
=
K h0
KI
Conocidos los datos de K1, K2 y Kh hallar los parmetros que ajustan al modelo.
function F=Lpq2(x)
K0=1.04;
K1=0.48;
K2=0.45;
AGV1=250;
AGV2=500;
F1=K1/K0-(1-AGV1/x(1))^x(2);
F2=K2/K0-(1-AGV2/x(1))^x(2);
F=[F1;F2];
Luego, ejecutar fsolve como se indic antes. En este caso, la solucin inicial se encontr usando
parmetros reportados en bibliografa para sistemas similares.
X0=[1000;0.41];
X=fsolve(lpq2,X0)
El programa que se presentar recibe como parmetros el intervalo donde se desea conocer la solucin, o
un intervalo donde haya una sola raz y la tolerancia deseada para la solucin. Lo que hace el programa es
evaluar la funcin en cada uno de los extremos del intervalo y ver si hay cambio de signo. Si no lo hay, el
intervalo no es adecuado, puesto que no tiene una raz. Luego, verifica si el producto de la evaluacin de
las funciones se anula en cero. Si lo hace, es porque ya ha encontrado una raz y el programa termina. De
lo contrario, parte el intervalo por la mitad y sigue buscando de la misma manera anterior.
33
function raiz=bisec(funct,a,b,tol)
fa=feval(funct,a)
fb=feval(funct,b)
if (fa*fb>0)
error('la funcin tiene el mismo signo en los extremos')
end
while (abs(b-a)>tol)
if (fa*fb==0)
if (fa==0)
raiz=a
else
raiz=b
end
else
raiz=(a+b)/2
fraiz=feval(funct,raiz)
if (fa*fb>0)
a=raiz
fa=fraiz
else
b=raiz
fb=fraiz
end
end
end
Ejercicio propuesto: Bajo las mismas condiciones, verificar los resultados del ejemplo 1 usando el
programa anterior.
6.4.2) Mtodo de Newton Raphson
El algoritmo del mtodo de Newton Rhapson se obtiene de las sucesivas aproximaciones usando la
ecuacin de la recta tangente a la curva en los puntos de aproximacin. Este resulta en:
x k +1 = x k
f ( x)
f '( x)
Para este caso, el mtodo requiere de una aproximacin inicial de la raz, que debe ser suficientemente
buena debido a que este mtodo es muy sensible a dicha aproximacin, la evaluacin de la funcin en el
punto y del conocimiento de la derivada de la funcin. De l, se ve que el algoritmo falla si la derivada de
la funcin se anula, por lo que este es un requisito para que el algoritmo funcione. Si no se tiene certeza de
este hecho, es necesario proteger al programa de situaciones como esta. Esto se ve en la lnea de error
implementada en el programa.
34
El programa, adems de recibir la funcin, debe recibir la funcin derivada y el nmero mximo de
iteraciones. Lo que hace es evaluar la funcin, la derivada y calcular el algoritmo. El criterio de detencin
usado es la variable corr. Esto porque:
corr =
f ( x)
= x k x k +1
f '( x)
El criterio de detencin necesita el valor absoluto del miembro derecho, as que da lo mismo en que orden
se reste. Recordar que el criterio de parada usado es: x k x k +1
function raiz=newton(f,Df,x0,tol,maxit)
k=0;
raiz=x0;
corr=tol+1;
while ((k<maxit) & (abs(corr))>tol)
k=k+1;
xk=raiz;
fxk=feval(f,xk);
Dfxk=feval(Df,xk);
if (Dfxk==0)
error('La derivada de la funcion se anula')
end
corr=fxk/Dfxk;
raiz=xk-corr;
end
if (abs(corr)>tol)
error('Se excedio el numero maximo de iteraciones')
end
El algoritmo es bsicamente el mismo, slo que ahora los xs son vectores, al igual que la funcin y la
derivada ya no es un nmero, sino que corresponde a la matriz jacobiana de la funcin compuesta. A
modo de repaso, la matriz jacobiana se forma como:
f1x
f
2x
J =
f nx
fij
f1 y
f2 y
f ny
f1m
f 2 m
f nm
La derivada de la ecuacin i que conforma el sistema con respecto a la variable j de la cual esta
ecuacin es dependiente.
35
Ahora, el algoritmo falla cuando el determinante de la matriz es nula, es decir, la matriz no es invertible.
Como criterio de detencin usa la variable corr y el argumento es el mismo que el usado para una
variable, slo que ahora ya no se necesita el valor absoluto, sino que la norma, puesto que el sistema es
vectorial.
function raiz=newton2(f,Df,x0,tol,maxit)
k=0;
raiz=x0;
corr=tol+1;
while ((k<=maxit) & (norm(corr,inf)>tol))
k=k+1;
xk=raiz;
fxk=feval(f,xk);
Dfxk=feval(Df,xk);
if norm((Dfxk)<length(Dfxk))
error('La diferencial de la funcion es singular')
end
corr=fxk/Dfxk;
raiz=xk-corr;
end
if (norm(corr,int)>tol)
error('Se excedio el numero maximo de iteraciones')
end
Comentario:
- La jacobiana se ingresa al MatLab de la misma forma que una funcin vectorial, pero slo que
para un sistema de 2 ecuaciones, ya se tendra una jacobiana de 2*2. (ms claro con un ejemplo).
Ejemplo 6.5: Uso del programa Newton Rhapson para sistemas de varias variables
Sea el sistema:
x 2 + xy + y 2 = 1
y = x2
x 2 + xy + y 2 1
F =
y x2
Para ingresar la funcin se utiliza el comando inline. Notar que todas las funciones deben ingresarse de la
forma f ( x, y ) = 0 . La funcin F es una funcin vectorial que se ingresa como un vector de 2*1.
>> f=inline('[x(1).^2+x(1)*x(2)+x(2).^2-1 ; x(2)-x(1).^2]')
f = Inline function:
f(x) = [x(1).^2+x(1)*x(2)+x(2).^2-1 ; x(2)-x(1).^2]
36
2x + y 2 y + x
J = Df =
1
2 x
>> Df=inline('[2*x(1)+x(2) x(1)+2*x(2) ; -2*x(1) 1]')
Df = Inline function:
Df(x) = [2*x(1)+x(2) x(1)+2*x(2) ; -2*x(1) 1]
Luego se ingresan los parmetros requeridos para ejecutar el programa. Para encontrar una aproximacin
inicial, a veces se debe tratar algebraicamente la solucin. Por ejemplo, para este caso, reemplazando la
ecuacin 2 en 1, se tiene un polinomio en x que puede ser resuelto para encontrar la solucin inicial, que
resulta ser igual a la solucin inicial en x. En este caso al parecer no tendra asunto, porque con esto ya se
tendra la solucin. El punto es que no siempre se tienen aproximaciones para soluciones y a veces se
recurre a valores de bibliografa o un promedio entre dos valores donde se sabe que hay una solucin.
>> tol=1e-12;
>> maxit=10;
>> x0=[-1:1];
>> raiz=newton2(f,Df,xo,tol,maxit)
>> P = x 2 + x 3 + x 4 1(= 0 )
A travs del comando roots, se puede encontrar las races para x:
>>roots(P)
37
Tema 7
Ecuaciones Diferenciales Ordinarias.
Un problema stiff es anlogo al concepto de condicionamiento de una matriz, slo que ahora una pequea
perturbacin en la condicin inicial del sistema puede alterar la solucin de la ecuacin diferencial.
Considere el PVI:
y(x,y)=C (x,y)
y(0)=1
Si la solucin del PVI se perturba en =0.01 el problema no ser stiff, si la solucin no sufre mayores
cambios. Si ante esta perturbacin, el sistema sufre cambios notables (reflejados en su estabilidad) el
problema es stiff.
7.2 Solucin de ecuaciones no lineales con el comando ode
Independiente si la situacin es stiff o no stiff, los comandos ode tienen la misma sintaxis, sta es:
Solucin
funcin
>>[t,y]=ode45(t,[t0 tf],[y0],options)
Rango donde se
calcula la solucin
Intervalo de
solucin
Cond. Inicial
38
vector llamado tspan que contiene los puntos deseados, para luego usarlo en lugar del intervalo [t0 tf] en
el comando ode.
7.2.3 Solucin de una ecuacin diferencial de primer orden
Este caso se resuelve mediante la afliccin directa del comando ode. La secuencia de paso se ilustra con el
siguiente ejemplo.
Considerar el PVI:
y(t)=y(t),
y(0)=1
t [0 1.5]
En este caso, la variable z es lo que devuelve la funcin y se ingresa t, que es la variable independiente e y,
que es la variable representada en la EDO.
Paso 2: Aplicar el comando ode segn
39
x' = y
y ' = x
x(0) = 1
x(1) = 0
Es necesario modificar las ecuaciones para que sean de primer orden; esto se hace con un cambio de
variables:
y (2) = x ' = y
y (1) = y ' = x
x(0) = 1
x = y (1)
; es decir,
, con t [0 2]
y (0) = 0
y = y ( 2)
Bajo el mismo principio que rige la formacin de funciones vectoriales, el sistema puede formularse
matricialmente de la forma:
y ' = F (t , y )
y (0) = y0
x
y = ;
y
y y (2)
F (t, y ) = =
;
x y (1)
1
y0 =
0
40
Con ello, el archivo generado es un vector de 2*1, que contiene las dos ecuaciones diferenciales que deben
resolverse simultneamente, para luego aplicar el comando ode.
1
function z=F(t,y)
z=[y(2);-y(1)];
0.8
0.6
0.4
0.2
0
-0.2
-0.4
-0.6
-0.8
-1
-1
-0.8
-0.6
-0.4
-0.2
0.2
0.4
0.6
0.8
m u ''+ b u '+ k u = f
U ( 0 ) = u0
u ' ( 0 ) = v0
Este caso es el ms complejo, pues se debe reducir a un sistema de ecuaciones cuyas componentes sean
todas de primer orden, para luego ingresarlas como sistema (caso 2) y resolver. Para ello, se debe realizar
el cambio de variables visto en el curso de EDO y repasado aqu, cuya base es despejar la ecuacin en
funcin de la variable que tenga el mayor orden de la ecuacin.
Sean:
u (0 ) = 1
v(0 ) = 0
u' ' =
donde
f k u b u'
m
y(1)
y(2)
:
:
posicin
velocidad
function z=Fla(t,y)
m=1.2;
b=0.3;
k=15;
z=[y(2);(-k*(y(1))-b*y(2))/m];
41
1
0.8
0.6
0.4
0.2
0
-0.2
-0.4
-0.6
-0.8
-1
10
20
30
40
50
60
Caso 2: f ( t ) = cos ( t )
0.15
function z=Flb(t,y)
m=1.2;
b=0.3;
k=15;
z=[y(2);(cos(t)-k*(y(1))-b*y(2))/m];
0.1
0.05
-0.05
-0.1
-0.15
-0.2
Caso 3: f ( t ) = cos ( w t )
con w =
function z=Flc(t,y)
m=1.2;
b=0.3;
k=15;
om=sqrt(k/m)
z=[y(2);(cos(om*t)-k*(y(1))-b*y(2))/m];
k
m
10
20
30
40
50
60
42
y (0) = 1
y (t ) = e t + sin(t ) solucin analtica
= 1000
t [0 1]
Para ello, lo primero es ingresar el PVI en el archivo MatLab
function z=f3(t,y)
alfa=1000;
z=alfa*(y-sin(t))+cos(t);
Luego, se ingresa la solucin del PVI (que es conocida) y se ejecuta el comando ode45. Para este caso, el
largo del vector es 1229 y con un error de 0,012. Recordar que Y es un vector columna que se compara
con la solucin evaluada en todos los pasos. Como es un vector, se usa la norma.
exact=inline('exp(-1000*t)+sin(t)');
options=odeset('abstol',1e-3);
[t,y]=ode45('f3',[0 1],1,options);
plot(t,y,'+-')
error=norm(exact(t)-y,inf)
length(t)
Luego, el proceso se repite para el comando ode15s. En este caso el error es de 0,011 y con un largo de
40.
[t,y]=ode15s('f3',[0 1],1,options);
plot(t,y,'+-')
error=norm(exact(t)-y,inf)
length(t)
Lo anterior prueba que el ode15s es bastante ms eficiente en la resolucin del problema stiff, pues usa
menos pasos. El error no es tan relevante, pues cambia muy poco, mantenindose en la tolerancia deseada.
43
Ejercicios Resueltos
Temas 7 y 8
Ejercicio 1
Resolver usando el mtodo de Newton Rhapson el sistema de ecuaciones no lineales
y = e x
y
x = e
Solucin
Primero, reconocer la funcin a valor vectorial y la jacobiana del problema, que en este caso son::
y e x
F =
y
xe
e x
J =
1
e y
Luego, se procede a ingresar las funciones al MatLab como ya se indic. Notar que las funciones estn de
la forma f(x,y)=0
Paso 1
Ingresar funcin
>>G=inline([x(2)-exp(-x(1));x(1)-exp(x(2))])
Paso 2
Encontrar raz aproximada (en este caso es posible hacerlo tratando algebraicamente la
funcin)
ln ( x ) = y ln ( x ) e x
>>f=inline(log(x)-exp(-x));
>>x=-2:0.01:2;
>>plot(x,feval(f,x))
Notar que se necesita la aproximacin x0 compuesta del valor de x e y ingresados en un
vector. Nuevamente, el tratamiento no tiene sentido puesto que resolviendo esa ecuacin no
lineal en x se obtiene de inmediato el valor de y.
Paso 2.1 :
Jacobiana
>>DG=[exp(-x(1)) 1;1 exp(x(2))];
Paso 3
Comentario
Este trabajo puede hacerse tanto en la pantalla como en un archivo de texto, que para los efectos es ms
fcil manejarlo como rutero.
44
Ejercicio 2
y = ex x
( )
y = tan 1 x 2
Graficar para encontrar una solucin inicial. Es necesario darse un intervalo que es
ARBITRARIO.
>>x=-5:0.01:5;
>>plot(x,exp(x-x.^2),x,atan(x.^2))
De la interseccin de las 2 curvas puede verse los puntos donde ambas ecuaciones se
intersectan.
Paso 2
Paso 3
Paso 4
Integrar
>>I=quad(f0,a,b)
Ejercicio 3
La ecuacin de Blasius
f ' (0 ) = 0
f ' ( ) 1 cuando
z
45
Cambio de variables
f = y (1)
f ' = y (1)' = y (2)
f ' ' = y (1)' ' = y (2 )' = y (3)
f f ''
y (1) y (3)
f '''=
y (3)' =
2
2
Paso 1
Ingresar funcin
Function F=edo(t,y)
F=[y(2); y(3);(-y(1)+y(3))/2];
Paso 2
ODE
>>[t,y]=ode45(F,[0 10],[0;0;0.1])
Ejecutar para 0.2 0.5
>>plot(t,y(:,2))
function z=blasius(x)
[t,y]=ode45(F,[0 10],[0;0;x]);
z=y(length(t),2)-1;
>>raiz=fzero(blasius,0.3)
c) Para resolver este caso basta acoplar la ecuacin diferencial que genera el momento de la funcin. sta
se acopla en el archivo ingresado antes, con ello el sistema a resolver es:
y (2)
[t , y ] = y =
y (3)
(2)
46
>>[t,y]=ode45(p4c,[0 0.5],[0;0;0.3320;0])
El momento corresponde a la cuarta columna del vector y:
>>mom=y(length(t),4)
Ejercicio 4
Perfil de temperatura en una aleta rectangular.
En una aleta triangular de un radiador, la distribucin de la temperatura T se rige por la ecuacin
diferencial:
d 2T h
(T Ta ) = 0
dx 2 k
Donde:
Ta
: Temperatura del aire (de 70 [F])
H
: Coeficiente de transferencia de calor entre la aleta y el aire. (2.5 [Btu/(hr*ft2*F)])
K
: Conductividad trmica de la aleta (212 Btu/(hr*ft2*F)])
Para x = 3 [ft] calcular la temperatura T, sabiendo que a x = 1[ft], T = 179 [F] y
Usar cualquier mtodo visto en clases.
2T h
(T Ta ) = 0
x 2 k
h = 2.5 Btu h ft 2 F
h
70 F
k = 212 Btu h ft 2 F
Ta = 70 F
x = 3 ft
T (1) = 179 F
T
x
= 20 F ft
x =1
Paso 1
T = y (1)
T ' = y ' (1) = y (2)
h
h
T ' ' = (T Ta ) = ( y (1) 70)
k
k
x=1
x=3
dT
= 20 [ F / ft ] .
dx
47
Paso 2: Programar
function z=p1((t,y)
Ta=70;
h=2.5;
k=212;
z=[y(2);h/k*(y(1)-Ta)];
Ejercicio 5
Resorte acoplado resuelto mediante el mtodo de Adams Moulton.
Considere el problema mecnico de 2 masas m1 y m2 interconectadas mediante un sistema de resortes
amortiguados como lo indica la figura.
El movimiento de las dos masas est modelado por el siguiente sistema de ecuaciones:
Re escriba el PVI como un sistema de ecuaciones de 4x4. Usando el mtodo implcito de Adams Moulton
de orden 1(Euler implcito), escriba el sistema a programar.
Haga un programa en MatLab que resuelva la parte anterior.
Para un paso h=0.1, m1=1, m2=2, c1=2, c2=3, k1=10, k2=15, evale: x1(2) y x2(4).
48
y(1) = x1
y(2 ) = x1
y (3 ) = x2
y(4 ) = x2
y(1) = y(2 )
y( 2 ) =
1
[ c1 y(2 ) k1 y(1) c2 (y(2 ) y(4 ) ) k2 (y(1) y(3) )]
m
y(3 ) = y(4 )
y( 4 ) =
1
[ c2 (y(4 ) y(3) ) k2 (y(3) y(1) )]
m
y (1) = 2
y (2 ) = 0
y (3) = 1
y (4 ) = 0
b)
0
h ( k1 + k 2 )
m1
hk 2
m2
1
h ( c1 + c 2 )
m1
0
hc 2
m2
0
hk 2
m1
0
hk 2
m2
hc 2 y1, i + 1 y1, i
m1 y 2, i + 1 = y 2, i
1 y 3, i + 1 y 3, i
hc 2 y 4, i + 1 y 4, i
m2
x = b/ A
c) Escribir programa
function f=f(t,y)
global m1,m2,c1,c2,k1,k2
f=[y(2);(-c1*y(2)-k1*y(1)-c2*(y(2)-y(4))-k2*(y(1)-y(3)))/m1;y(4);(-c2*(y(4)-y(2))-k2*(y(3)-y(1)))/m2];
49
Ejercicio 6
Lanzamiento parablico de una pelota de bisbol
La trayectoria de una pelota de bisbol que sale de un punto a un metro de altura se ha modelado por:
h( x) = tg ( ) x 2
9.8
+1
2 v cos 2 ( )
2
0
40
h( x 2 )dx
Solucin
>> f=inline('tan (a).*40-9.8./(2*30.^2.*(cos(a).^2)).*40.^2+1');
>> a=fzero(f,pi/4)
a=
0.1990
b) =0,7
>> f=inline('x.^2');
>> I=quad(f,0,40)
I=
2.1333e+004
50
Ejercicio 7: Problema 8
Interseccin de races.
Se desea encontrar TODOS los puntos de interseccin de las curvas:
x2
y = 1
4
y = 2 ( x 0.9 ) 1
2
La mejor forma para hacerlo es despejar la variable y para despus resolver una ecuacin no lineal en x.
Escriba un programa en MatLab que resuelva el problema.
Indique el nmero de puntos de interseccin en R y todos los puntos de interseccin encontrados.
Solucin
>> f=inline('sqrt(1-(x.^2)/4-2.*(x+0.9).^2+1)');
>> plot(x,feval(f,x))
>> x1=fzero(f,raiz1)
>> x1=fzero(f,raiz2)
roverdug@udec.cl