Apunte Numerico Lab

Universidad de Concepcin
Facultad de Ingeniera
Depto. Ingeniera Quimica

APUNTE
DE
CLCULO NUMRICO

AUTORES

Diego Seiltgens Sorrel
Rodrigo Verdugo Fuentes
1 Apunt e de Cl cul o Numri co
TABLA DE CONTENIDOS

Tema 1: Algunos aspectos del MATLAB __________________________________________1

1.1 Comentarios Importantes _____________________________________________________ 1
1.2 Opciones avanzadas de grficos ________________________________________________ 2
1.3 Algunas reglas prcticas de programacin. _______________________________________ 2
1.4 Manejo de archivos en Matlab. _________________________________________________ 2

Tema 2: Sistemas de ecuaciones lineales. __________________________________________4

2.1 Descripcin general de los Mtodos Directos ________________________________________ 4
2.2 Condicionamiento de una matriz y propagacin de errores de redondeo _________________ 5
2.3 Mtodos indirectos______________________________________________________________ 6

Tema 3: Mnimos cuadrados ____________________________________________________9

3.1 Matriz QR_____________________________________________________________________ 9
3.2 Problemas lineales y no lineales.__________________________________________________ 10
3.3 Rutinas de MatLab para trabajo con polinomios. ___________________________________ 10
Ejemplo 3.1: Propiedades de las matrices Q y R _____________________________________ 11
Ejemplo 3.2: Ajuste de mnimos cuadrados para un problema no lineal ___________________ 11
Ejemplo 3.3: Aplicacin de mnimos cuadrados a la circunferencia _______________________ 12
Ejemplo 3.4: Caso de matriz de rango incompleto ____________________________________ 13

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 5: Integracin numrica__________________________________________________20

5.1 Integracin usando MatLab _____________________________________________________ 20
5.2 Algoritmos de Integracin. ______________________________________________________ 22
Ejemplo 5.1: Exactitud del mtodo de los trapecios en un caso especial. ___________________ 25
Ejemplo 5.2: Exactitud del mtodo de los trapecios en caso especial. _____________________ 26

Tema 6: Ecuaciones no lineales._________________________________________________27

6.1 Mtodos numricos ____________________________________________________________ 27
6.2 Ingreso de sistemas de ecuaciones al Matlab________________________________________ 28
6.3 Solucin de ecuaciones mediante los comandos de MatLab ___________________________ 28
Ejemplo 6.1: Hallar todas las races de las ecuaciones _________________________________ 29
Ejemplo 6.2: Sistema de ecuaciones no lineales ______________________________________ 31
Ejemplo 6.3: Ajuste de parmetros de una cintica de hidrlisis _________________________ 32
6.4 Algoritmos numricos para solucin de sistemas de ecuaciones no lineales ______________ 32
Ejemplo 6.5: Uso del programa Newton Rhapson para sistemas de varias variables __________ 35

Tema 7: Ecuaciones Diferenciales Ordinaria ._____________________________________37 s

7.1 Concepto de problema stiff ______________________________________________________ 37
7.2 Solucin de ecuaciones no lineales con el comando ode _______________________________ 37
Ejemplo 7.1: Problema stiff ______________________________________________________ 42

Ejercicios Resueltos Temas 7 y 8 ________________________________________________43

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) Comandos sobre vectores: sea un vector v. Al aplicar:

length(v) : se obtiene el nmero de componentes del vector.
abs(v) : devuelve un vector formado por el mdulo o valor absoluto de sus elementos
max(v) : devuelve el mximo valor de los elementos del vector
min (v) : devuelve el mnimo valor de los elementos del vector
sum(v) : devuelve la suma de los componentes del vector
prod(v) : devuelve el producto de los componentes de un vector.
norm(v) : norma euclidiana del vector (v)
mean : promedio de las componentes de un vector
std(v) : devuelve la desviacin estndar de un vector
sort(v) : ordena el vector de forma creciente, y devuelve ese vector. Si el vector es complejo, opera
sobre el mdulo del complejo.

c) Comandos sobre matrices:

det (A) : devuelve el determinante de A
rank(A) : devuelve el rango de A
A : devuelve la transpuesta de A
[V,D]= eig(A) : devuelve dos matrices, la matriz D que contiene los valores propios de A, y V, que
contiene los vectores propios de A.
trace(A) : Suma la diagonal. (sirve para calcular norma de matrices)

1.2 Opciones avanzadas de grficos

El comando zoom puede manejarse desde la pantalla grfica con la lupa.
Zoom : interactivo que permite agrandar cierta parte de un grfico.
Zoom on : enciende el comando zoom
Zoom off : apaga el comando zoom.
Zoom out : lo deja donde estaba
Zoom reset : lo deja en la opcin por defecto.

Ginput: permite seleccionar puntos de un grfico y llevarlos a un vector.

[x,y]=ginput(n) : elige n puntos de un grfico; almacena en x la variable independiente y en y la
ordenada.
[x,y]=ginput : selecciona puntos hasta presionar enter.

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)

1.3 Algunas reglas prcticas de programacin.

Todos los comandos van en minsculas. Recordar que MatLab diferencia entre maysculas y minsculas.
El nombre de la funcin debe ser igual al del archivo .m donde esta se guarda. Dicho nombre debe cumplir
ciertas caractersticas:

- El primer carcter debe ser una letra.
- No debe tener ni acentos ni caracteres especiales como /, *, +, -, \.
- No deben ser nombres reservados, ya sea de funciones definidas en MatLab u otro tipo de
comando.

1.4 Manejo de archivos en Matlab.

Es posible generar un archivo de datos en MatLab, para posteriormente abrirlo en otra rutina o
subprograma. Asimismo, es posible guardar archivos tipo .m como ascii, para ser abierto en otro tipo de
documentos, en particular, en EXCEL.

Caso 1: Generacin y carga de archivos en MatLab.

Para guardar un archivo con extensin tipo .m basta usar el comando save. Considerar la matriz A
en el workspace.

>>save matriz A % guarda la matriz A en un archivo .m llamado matriz
>>load matriz % carga el archivo matriz, y deja la matriz A en la memoria.
>>save matriz B -append % guarda una matriz B en el archivo matriz sin sobre escribir A.

En general, el comando opera de la siguiente forma.
>>save nombre de archivo variable 1 variable 2
>>load nombre de archivo

Si se usa solo el comando save, guarda todas las matrices existentes en la pantalla.

Caso 2: Generacin de archivos desde MatLab para abrir en EXCEL.

El archivo debe guardarse como tipo ascii (caracteres) para poder ser reconocido por otro
programa. Se usa el comando save de la misma forma. Considerar un vector b para el ejercicio.

>>save vector b ascii tabs % guarda el vector b en un archivo tipo ascii llamado vector, que
despus puede ser abierto con EXCEL. El comando tabs permite
respetar las tabulaciones, si las hubiera.

Observaciones:

- MatLab siempre trabaja en radianes, cuando se utilizan funciones trigonomtricas.
- Las matrices que no son cuadradas y representa la identidad, se denominan matrices de pseudo
identidad

Comandos de inters:

Clear : limpia la memoria
Clc : limpia la pantalla, es decir las variables siguen existiendo
Whos : permite ver las variables y como estn almacenadas en la memoria
Dir : permite ver los archivos existentes, donde est situado el Matlab
Help : 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 X
0
, X
1
X
n
de
modo que dicha sucesin converja a la solucin del sistema.

El cuadro resumen a continuacin presenta los mtodos iterativos a trabajar:

Jacobi
Chol.
LU
Gauss
Mtodos Indirectos
Mtodos Directos
P.C.G
G.S.
S.E.L.

2.1 Descripcin general de los Mtodos Directos

- Eliminacin Gaussiana (M.E.G.)
Consiste en hacer operaciones elementales sobre la matriz A de modo de dejar una matriz triangular
inferior (o triangular superior) y luego resolver por sustitucin sucesiva. Es ms barato
computacionalmente que determinar la matriz inversa. Slo necesita de una matriz no singular.

- Factorizacin LU
Consiste en decomponer la matriz A en dos matrices, una matriz triangular superior U y una triangular
inferior L. A partir de esto se genera el Mtodo de Thomas (ver problema 7 lab 2). Tambin requiere
que la matriz sea no singular (determinante distinto de cero.) En MatLab, el comando usado es:
[L,U]= lu(A). Este comando devuelve la matriz L triangular inferior y una matriz U
psicolgicamente triangular superior, puesto que devuelve la matriz sin permutar, en el caso que la
matriz requiera ser permutada. (ver la idea del pivoteo cuando los elementos de la fila pivote son 0).
Con esta descomposicin, el sistema a resolver es:

(L*U)*x=b
[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*R
t
. Esta factorizacin es ms
restrictiva pues requiere que la matriz A sea una matriz simtrica ( que A=A
t
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*R
t
)*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.

2.2 Condicionamiento de una matriz y propagacin de errores de redondeo

El condicionamiento de una matriz indica si el sistema propagar errores al utilizar algn mtodo para
resolverlo.
Sea el sistema:
Ax = b

Si el vector b, o la matriz A sufren alguna perturbacin en sus elementos: la matriz ser bien condicionada
si el resultado obtenido no se altera mayormente con respecto al resultado del sistema inicial. Por el
contrario, si el resultado sufre severos cambios al introducir una pequea perturbacin en b o A, el sistema
es mal condicionado y la solucin est sujeta a mucho error.
El ndice que permite establecer si una matriz o el sistema est bien o mal condicionado es el nmero de
condicin, que puede ser calculado como:

1
A A

=

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.

2.3 Mtodos indirectos

Los mtodos iterativos son los mtodos indirectos. Su nacimiento se debe a la existencia de las matrices
ralas o sparse, la cual tiene en muchas posiciones el cero, que no necesariamente son matrices banda o
tridiagonales. A decir verdad, estas ltimas son un caso especial de una matriz dispersa o rala.
Los mtodos directos, adems de ocupar mucha memoria, perturban el carcter disperso de una matriz,
puesto que la factorizacin va creando elementos no nulos en posiciones inicialmente nulas. Este
problema se conoce como el problema de llenado, el cual aumenta la propagacin de los errores de
redondeo en la solucin del sistema, adems de encarecer el costo computacional de los mtodos.
La idea es generar una sucesin de soluciones X
i
de modo que esta sucesin converja a la solucin x.
La convergencia de la solucin est garantizada por los teoremas vistos en clases. Uno de estos criterios es
que la norma de la matriz de iteracin (que no es la misma que la matriz A del sistema) sea menor que
uno. Basta con que una norma cumpla esta condicin, para que la sucesin converja a la solucin.

2.3.1 Matrices full y sparse.

La matriz almacenada como full, es una matriz que guarda todas las posiciones, incluso los ceros. En
cambio la matriz sparse, almacena la matriz sin las posiciones nulas (no guarda ceros), por lo que se
transforma en una manera ms econmica de trabajar con las matrices dispersas.
La ventaja es que MatLab permite hacer algunas operaciones con matrices sparse sin que stas pierdan
dicha condicin. El comando speye permite crear la matriz identidad pero de manera sparse. Si se desea
pasar una matriz full a una matriz sparse se realiza:

>>A=sparse (M);

Para pasar una matriz sparse a un tipo full, se utiliza el comando:

>>B=full(A);

El conteo de elementos no nulos (distintos de cero) en una matriz, se hace con el comando nnz.

>>H=nnz(A) % donde H sera la cantidad de elementos no nulos que hay en la matriz.

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.

2.3.2 Descripcin general de mtodos iterativos
2.3.2.1 Mtodo de Jacobi

Toma la matriz A y la descompone en tres matrices: D (diagonal principal de A), -E (matriz triangular
inferior) y -F (matriz triangular superior, es decir, desde la diagonal principal para arriba posee
elementos).

A = D E F

Para construir la matriz de iteracin J:
Ax=b
(D E F) x = b
Dx
k+1
= (E + F) x
k
+ b
x
k+1
= D
-1
(E + F) x
k
+ D
-1
b

J

J es la matriz a la cual se le estudia la convergencia usando el teorema sealado en la seccin 2.3 (lo de la
norma). Para calcularla se utiliza la norma infinito, porque sta es ms resistente a los cambios.
Jacobi es un mtodo convergente cuando la matriz es de diagonal dominante. Es decir, que el elemento de
la diagonal principal en valor absoluto, es mayor que la suma de los valores absolutos de los elementos de
la fila correspondiente.

=
=
>
n
j
i
ij ii
a a
!
1

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.

2.3.2.2 Mtodo de Gauss Seidel

Para las matrices D, -E y -F, usadas anteriormente, la matriz de iteracin J est elegida de la siguiente
manera:
J = ( D E)

El mtodo converge cuando la matriz es simtrica y definida positiva.
Tambin vale lo dicho para la matriz con formacin sparse. El problema de generar la matriz de iteracin
y resolver el sistema de ecuaciones mediante este mtodo est descrito en el problema 6 y usa el test de
detencin descrito en la seccin siguiente.
Se dice que la convergencia de un mtodo no necesariamente hace la convergencia del otro. Por lo tanto,
si la matriz es definida positiva y es simtrica, no necesariamente el mtodo de Jacobi converge.

2.3.2.3 Test de detencin

Los mtodos iterativos deben detenerse una vez que se considera que la sucesin converge. En la teora, la
sucesin converge en el infinito. Como en la prctica no existe, se debe detener la iteracin una vez que se
llegue a un grado aceptable de medicin, dado por la precisin que se busca. Un test sugerido es el
siguiente:

1
1
k k k
k
m
x x to
m
+
<
l

1
1
k k
k
k k
x x
m
x x

2.3.2.4 Mtodo del Gradiente Conjugado

El Gradiente Conjugado es un mtodo que depende mucho del nmero de condicionamiento y requiere
que la matriz sea simtrica y definida positiva.
El gradiente conjugado posee un origen distinto a los anteriores, viene de la minimizacin de una funcin
objetivo. El MatLab usa el comando pcg para el gradiente conjugado. En realidad, es un gradiente
conjugado precondicionado, esto se debe a que el gradiente conjugado converge muy lentamente si la
matriz es mal condicionada. A veces se usan precondicionadores (que es lo que hace esta rutina), que
deben elegirse con cuidado, porque el precondicionar una matriz puede alterar sus caractersticas de
simetra y definida positiva.

Cmo construir una matriz simtrica y definida positiva?

A A A
~ T
= , con A matriz no simtrica.

En MatLab el comando que se usa es

>>X=pcg(A,b,tol, maxit)

Donde tol : la tolerancia o el error al cual yo quiero llegar.
Maxit : nmero mximo de iteraciones que se desean.

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
( )
1
i
m
x i
i
y
=

(3.1)
Con m el nmero de puntos.

El problema se reduce entonces a encontrar una funcin que sea una combinacin lineal de las funciones
dadas para ajustar el modelo (por ejemplo, ajustar los puntos a una funcin polinomial), tal que se cumpla
la condicin anterior.
Esto genera el siguiente problema a resolver: Ax=b, con A una matriz rectangular de m filas y n columnas,
con n, el nmero de elementos de la base que genera a .
Recordar los 3 casos:
- n > m : El sistema est sobredeterminado (tenemos ms ecuaciones que incgnitas) y la
base sera una combinacin lineal (ver el ejemplo propuesto 2 del lab 4).
- n = m : El sistema tiene solucin nica (caso de interpolacin - tema 4-).
- n < m : El sistema tendra infinitas soluciones.

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:

2 2
r b A x = (3.2)

EL vector x minimizar el residuo anterior si y slo si r es ortogonal a la imagen de A, es decir:

0 ( ) 0
t t t
A r A b A x A A x A b = = =
t

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 A
t
A 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 : Matriz triangular superior no singular.
1
i j
q q = si i=j
Q : Matriz ortonormal, es decir el producto de dos columnas cumple:

0
i j
q q = si ij

En virtud de lo anterior:
QQ
t
= I

As, el sistema a resolver se transforma a:

( )
t t
t t t t
t t t
t
A A x A b
R Q Q R x R Q b
R I R x R Q b
R x Q 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:
1 a
y b y a u b poniendo u
x 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:

exp( ) ln( ) ln y A b x y 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:

ln( ) ln ln
b
y A x y A b 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.

Sea el polinomio
0
1
( ) 1
n n
x n n
P a x a x a
= + +

El polinomio se ingresa a MatLab como un vector fila de la forma: P = [a
n
a
n-1
a
0
]

Sea un polinomio P y un conjunto de puntos x:

Y=polyval(P,x) : Devuelve un vector Y que contiene los valores que resultan de evaluar x en el
polinomio P.
r=roots(P) : r es un vector que contiene las races del polinomio P.
P=poly(r) : P es un polinomio formado a partir de las races r.
P=polyfit(x,y,n) : si x e y son los puntos que se disponen y n es el grado del polinomio; P es el
polinomio de grado n que mejor ajusta en el sentido de los mnimos cuadrados al
conjunto de puntos x e y.

Ejemplo 3.1: Propiedades de las matrices Q y R

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--)

function A=Aj_Pol(m,n)
h=1/m;
t=(0:h:1)';
A=[ones(m+1,1)];
for j=1:n
A=[t.^j A];
end

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 A
T
A, 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 2
1 cos sin
12 12
t
t t
B e

= + + +

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 2
2 2
i i i i
x a y b c x y + + = +

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.

Ejemplo 3.4: Caso de matriz de rango incompleto
El problema se resuelve igual que todos. La salvedad es que, claramente la base elegida es una
combinacin lineal, pues:

2 2
sin ( ) cos ( ) 1 x x + =

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,'-')

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
i
i
x L y x P
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
... a
0
]
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) s(x) = q(x) : que la spline pase por los puntos.
b) Continua : no tenga cortes o esquinas.
c) Derivable : su derivada por la izquierda y por la derecha deben ser iguales.
d) Suave : la segunda derivada es por la izquierda y por la derecha la misma.

El comando yy=spline(x;y,xx), devuelve la aproximacin spline del conjunto de datos x, y
evaluados en xx. Es la rutina usada en MatLab para construir una spline. Como se ve, no se ingresan
los valores de la segunda derivada, necesarios para resolver el sistema de ecuaciones para encontrar
los coeficientes. Esto es porque es una spline natural, es decir, dichos valores son 0, siendo la opcin
que posee MatLab.

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),-)

Figura 3.1: comparacin de polinomios interpolantes para la funcin seno

Ejemplo 4.2: Fenmeno de Runge (problema 1 d) Lab.5)

x=-5:5; % puntos dados para determinar el polinomio
y=1./(1+x.^2); % evaluacin de los puntos en la funcin
C6=polyfit(x,y,6); % polinomio de grado 6
C10=polyfit(x,y,10); % polinomio de grado 10
xx=-5:0.1:5;
yy=1./(1+xx.^2); % puntos para graficar la funcion
plot(x,y,o,xx,yy,:,xx,polyval(C6,xx),--,xx,polyval(C10,xx),-) % fig 3.1
figure % crea otra figura en blanco, para luego volver a graficar sin que el anterior grfico desaparezca.
plot(x,y,o,xx,yy,-,xx,spline(x,y,xx),:) %fig 3.2
Figura 3.2: Fenmeno de Runge Figura 3.3: aproximacin de la funcin usando spline

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

Figura 3.4: grfico del contorno Figura 3.5: dibujo de la pieza

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

Figura 3.6: dibujo de los puntos Figura 3.7: dibujo de la espiral

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
%rutina para el seno
a=0;
b=2*pi;
for i=0:10
if i==0
P=polyfit(1,1,0);
else
h=(b-a)/i;
x=a:h:b;
y=sin(x);
P=polyfit(x,y,i);
subplot(4,3,i)
xx=0:0.1:2*pi;
yy=sin(xx);
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

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

Tema 5
Integracin numrica

La idea es hallar la integral de una funcin f continua en el intervalo [a,b] donde se pretende integrar.

1
( ) ( ) ( )
n
b
i i
a
i
I p x f x A f x
=
= +
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)
Simpson: grado 2 (exacta para una parbola)
Gauss: es exacta hasta un polinomio de grado 2n+1
Mtodos de integracin

La integracin de Romberg no ser tratada en el apunte.

5.1 Integracin usando MatLab
5.1.1 Funciones inline en MatLab

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(-x
2
)

>>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.

5.1.2 Comando quad para integracin.

El comando quad evala la funcin a integrar entre determinados intervalos de integracin.

>>I=quad (funcin, a, b, tol)
quad (tol=10
-6
)
quad8 (tol=10
-3
)
quadl (tol=10
-6
)
quad

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=i nl i ne( ' exp( - x. ^2) ' ) ;
>> e1=quad( q, - 1, 1)

e1 =

1. 49364827606288

>> e2=quad( q, - 1, 1, 1e- 6)

e2 =

1. 49364827606288

>> s1=quad( ' sqr t ' , 0, 1)

s1 =

0. 66665956927202

>> s2=quad( ' sqr t ' , 0, 1, 1e- 6)

s2 =

0. 66665956927202

5.2 Algoritmos de Integracin.
5.2.1 Trapecios: Ejemplo 1a)

( )
[ ]
1
1
3
2
( ) ( ) ( )
2
''( ) ''( )
12 12
,
n
i
i
h
I f a f b f x
b a h
R n f h f
a b

=

= + +

= =

El programa entregado en el laboratorio. 6, corresponde a la programacin del mtodo de los trapecios. El
comando sum permite sumar las componentes de un vector seccin 1.1 b) comandos sobre vectores
generado tras la evaluacin del vector x, que corresponde a los nodos de evaluacin para x.

Si luego, se escribe:

>>trap(t,0,20)

Lo que resulta entonces es: con 20 subintervalos. dx e
x

1
0
2
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.

>>f or mat l ong

>>f =i nl i ne( x. ^2 )

f = I nl i ne f unct i on:
f ( x) = x. ^2

>>x=[ t r ap( f , 0, 3, 10) t r ap( f , 0, 3, 20) t r ap( f , 0, 3, 40) t r ap( f , 0, 3, 80) ]

x = 9. 04500000000000 9. 01125000000000 9. 00281250000000 9. 00070312500000

>>g =i nl i ne( exp( - x. ^2) )

g = I nl i ne f unct i on:
g( x) = exp( - x. ^2)

>>e =[ t r ap( g, - 1, 1, 10) t r ap( g, - 1, 1, 20) t r ap( g, - 1, 1, 40) t r ap( g, - 1, 1, 80) ]

e = 1. 48873667952733 1. 49242159226350 1. 49334167387975 1. 49357162247796

l =[ t r ap( l og , 1, 2, 10) t r ap( l og , 1, 2, 20) t r ap( l og , 1, 2, 40) t r ap( l og , 1, 2, 80) ]

l = 0. 38587793674575 0. 38619020963221 0. 38626832040247 0. 38628785076256

s=[ t r ap( sqr t , 0, 1, 10) t r ap( sqr t , 0, 1, 20) t r ap( sqr t , 0, 1, 40) t r ap( sqr t , 0, 1, 80) ]

s = 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)

( )
[ ]
1 1
2 1 2
0 1
5
( ) 4
( ) ( ) 4 ( ) 2 ( )
3
( ) ( )
90 180
,
n n
i i
i i
IV IV
h
I f a f b f x f x
b a h
R n f h f
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:

>>f or mat l ong
>>f =i nl i ne( x. ^2 )

f ( x) = x. ^2

>>x=[ si mpson( f , 0, 3, 10) si mpson( f , 0, 3, 20) si mpson( f , 0, 3, 40) si mpson( f , 0, 3, 80) ]

x = 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.

5.2.3 Cuadratura de Gauss

El nacimiento de esta frmula es distinto, ya que parte de la idea de que los A
i
no se conocen. Para n
puntos de particin el algoritmo es:

( )
0
1
2 2
n
i i
i
b a b a
I A f x
=

= + +

)

La diferencia radica en que los x
i
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
a
f g f x g x < >=
dx

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.

x
i
A
i
0.861136311594053 0.347854845137455
0.339981043584856 0.652145154862547

Aplique el programa para calcular:

i) , f f f = < > , donde ( ) sin(45 ) f x = x , a =- y b =

ii) <sin(7 x),x>, donde a=0 y b=2

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/n
2
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:

log f(N) = -2log(N), para la funcin n vs 1/n
2
.

log() = -2log(N)+b, se ve en el grfico obtenido

y como h=1/N

error =C/N
2
= Ch
2
, con C=10
b

Ejemplo 5.2: Exactitud del mtodo de los trapecios en caso especial.
La idea es la misma que la del problema anterior, slo que esta vez el orden no es 2, sino que un poco
menor, la idea es determinarlo usando la misma idea: linealizar y resolver por mnimos cuadrados.

g=inline('sqrt(x)');
N=10:10:100;
error=[];
for n=N;
integ=trap(g,0,1,n);
error=[error abs(integ-2/3)];
end
loglog(N,error,'o:',N,(1./N).^2,'-')
m=length(N);
A=[ones(m,1) -log(N)'];
b=log(error)';
z=A\b;
Alpha=z(2)
figure
loglog(N,error,'o:',N,(1./N).^Alpha,'-')

log f(N) = -2log(N) para la funcin n vs 1/n
2

log() = -alphalog(N)+b

y como h=1/N

error =C/N
alpha
= Ch
alpha
con C=10
b

Se obtiene un orden de 1.4811

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.

6.1 Mtodos numricos

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).

6.1.1 Mtodo de la biseccin

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.

6.1.2 Mtodo de Newton Raphson

Es de convergencia rpida y asegurada, consiste en lo siguiente: conocida la derivada de una funcin, se
puede trazar la recta tangente a un punto dado (conocer una estimacin de la solucin), llegando a un
punto cercano a la solucin, para luego trazar otra tangente en el nuevo punto y encontrar un nuevo x que
se acerca an ms a la solucin. Mtodo iterativo, ms utilizado. Puede extenderse para 2 o ms variables,
pero es sumamente sensible a la aproximacin inicial.

6.1.3 Mtodo de la secante

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.

6.2 Ingreso de sistemas de ecuaciones al Matlab

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:
2 2
2
1
0
x x y y
y x
+ + =
=

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:

2 2
1
2
2
1 f x x y y
F
f y x
+ +
= =

+

Notar que las ecuaciones, independiente del nmero de variables que tengan, deben tener la forma
( , , , ..) 0 f x y z w =

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]');

6.3 Solucin de ecuaciones mediante los comandos de MatLab

MatLab tiene dos comandos para resolver ecuaciones no lineales:

fzero : permite encontrar soluciones para una ecuacin no lineal (1 variable), se debe correr tantas
veces como races se tengan.

>>fzero(f,x0,tol)

fsolve : resuelve sistemas de ecuaciones.

6.3.1 Modo de utilizar comando fzero

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:

>>x=fzero(f,x0)

Donde:
x : Solucin de la ecuacin no lineal.
f : Funcin a resolver. Puede ser un objeto inline o un archivo.
x0 : Solucin aproximada inicial

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

2
3
) 2
) 3 1
) cos( )
a x
b x x
c x x
=
+ =
=
0

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 =i nl i ne( ' x. ^2- 2' )

f ( x) = x. ^2- 2

%Y l a ej ecuci n del comando f zer o par a l a r a z posi t i va es:

>> f zer o( f , 1. 4)

ans = 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 =i nl i ne( ' x^3- 3*x+1' )

f ( x) = x^3- 3*x+1

pl ot ( x, f eval ( f , x) )

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.

>> f zer o( f , 1. 4)

ans = 1. 5321

>> f zer o( f , 0)

ans = 0. 3473

>> f zer o( 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 =i nl i ne( ' cos( x) - x' )

f =

I nl i ne f unct i on:
f ( x) = cos( x) - x
>> pl ot ( x, f eval ( f , x) , x, 0)
>> f zer o( 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.

6.3.2 Uso del comando fsolve

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 : Solucin del sistema de ecuaciones no lineales.
F : Funcin a valores vectoriales compuesta de todas las ecuaciones que componen el
sistema. Puede ser un objeto inline o un archivo.
X0 : Solucin aproximada inicial del sistema.

Ejemplo 6.2: Sistema de ecuaciones no lineales

Sea el siguiente sistema de ecuaciones (Laboratorio 7 - 25/05/01):

2
2 2
0
4
y x
x y
=
+ =

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]

En este caso x(1)=x y x(2)=y

Como se ve, la primera funcin se ubica en la primera columna de la matriz y en la segunda se ubica la
otra. En este caso, x es un vector de dos componentes, que en su primer elemento tiene la aproximacin
para x, y en la segunda para la variable y, pues as fueron definidas las incgnitas.
Luego, se usa el comando fsolve de la siguiente manera (puede ser en pantalla o en un archivo diferente):

>>X=fsolve(experimento,X0)

Con X0 la solucin inicial:

X0=[1.41,1.41]

La respuesta corresponde a:

X=[1.2496 1.5616];

Caso 2: funcin como inline
>>F=inline('[x(2)-x(1)^2;x(1)^2+x(2)^2-4]')
>>X= fsolve(F,[1.41,1.41], optimset('fsolve'))
Optimization terminated successfully:
First-order optimality is less than options.TolFun.

X=[1.2496 1.5616];

La idea es la misma. El usar inline o no depender de la necesidad de usuario.
Ejemplo 6.3: Ajuste de parmetros de una cintica de hidrlisis
El modelo de Levenspiel permite aproximar una cintica de hidrlisis:
[ ]
0
1
h
h I
AGV
K
K K

=

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)

6.4 Algoritmos numricos para solucin de sistemas de ecuaciones no lineales
6.4.1 Mtodo de la biseccin

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.

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:

1
( )
'( )
k k
f x
x x
f x
+
=

Este algoritmo base se analizar para dos casos:

Caso 1: Caso de una sola variable:

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.
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:

1
( )
'( )
k k
f x
corr x x
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:
1 k k
x x
+

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

Caso 2: Caso de varias variables

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:

1 1 1
2 2 2
x y m
x y m
nx ny nm
f f f
f f f
J
f f f

=

f
ij

: La derivada de la ecuacin i que conforma el sistema con respecto a la variable j de la cual esta
ecuacin es dependiente.

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:
2 2
2
2 2
2
1
1
x xy y
y x
x xy y
F
y x
+ + =
=
+ +
=

Para ingresar la funcin se utiliza el comando inline. Notar que todas las funciones deben ingresarse de la
forma . La funcin F es una funcin vectorial que se ingresa como un vector de 2*1. ( , ) 0 f x y =
>> 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]


Luego se ingresa la derivada. Para este caso, la matriz jacobiana es:

2 2
2 1
x y y x
J Df
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)

El reemplazo de la ecuacin 2 en 1 resulta:

( ) 0 1
4 3 2
= + + = >> x x x P

A travs del comando roots, se puede encontrar las races para x:

>>roots(P)

Tema 7
Ecuaciones Diferenciales Ordinarias.

La plataforma MatLab trae incorporados comandos para la resolucin de ecuaciones diferenciales,
llamados ode. En la gua 9 aparecen listados los comandos para resolver ecuaciones diferenciales tanto
stiff como no stiff. La desventaja de los comandos ode es que slo pueden ser usados para la resolucin de
ecuaciones de primer oden. Esto da origen a 3 casos que se estudiarn ms adelante.

7.1 Concepto de problema stiff

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:

> > [ t , y ] = o d e 4 5 ( t , [ t 0 t f ] , [ y 0 ] , o p t i o n s )
Rango donde se
calcula la solucin
Solucin funcin
Intervalo de
solucin
Cond. Inicial

El mtodo trabaja con tolerancia por defecto:

- Tolerancia relativa 1E-3
- Tolerancia absoluta 1E-6

Estos valores pueden cambiarse con el comando options. Definiendo:

>>options =odeset(reltol1e-6,abstol,1e-8)

Los valores pueden cambiarse a los deseados. Este comando tiene ms opciones que pueden ser
cambiadas.
Estos mtodos son en general de paso variable, lo cual hace que la solucin se conozca en puntos a lo
mejor no deseados. Si se quiere conocer la solucin en ciertos puntos del intervalo, se puede definir un
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), t [0 1.5]
y(0)=1

Paso 1: Hacer un archivo donde se almacene la ecuacin diferencial:

function z=f(t,y)
z =y

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

>> [t,y]=ode45('f',[0 1.5],1);
>> plot(t,y)

Para cambiar opciones:

>> options=odeset('abstol',1e-6,'reltol',1e-4);
>> tspan=0: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

Caso 2: Sistema de ecuaciones de primer orden.

Sea el sistema de ecuaciones diferenciales:

' (0)
' (1)
x y x
y x x
1
0
= =
= =

Es necesario modificar las ecuaciones para que sean de primer orden; esto se hace con un cambio de
variables:

(2) ' (0) 1
(1) ' (0) 0
y x y x
y y x y
= = =
= = =
; es decir,
) 2 (
) 1 (
y y
y x
=
=
, con t [0 2]

Bajo el mismo principio que rige la formacin de funciones vectoriales, el sistema puede formularse
matricialmente de la forma:

( )
( )
0
0
, '
y y
y t F y
=
=
( )
0
(2) 1
; , ;
(1) 0
x y y
y F t y y
y x y

= = =

=

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 -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
0.2
0.4
0.6
0.8
1

function z=F(t,y)
z=[y(2);-y(1)];

>> [t,y]=ode45('F',[0 2*pi],[1;0]);
>> plot(y(:,1),y(:,2))

Caso 3: Una ecuacin diferencial de orden superior, sea el PVI:

( )
( )
0
0
'' '
0
' 0
m u b u k u f
U u
u v
+ + =
=
=

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:
(1) (1) ' ' (2)
(2) ' (1) '' '' (3)
u y y u y
y y u y
= = =
= = =

Para los valores de k=15 kg/s
2
; m=1.2 kg; b= 0.3kg/s.

Caso 1: Resorte soltado del reposo y a 1 m de la posicin de equilibrio

( )
( )
m
u b u k f
u
v
u
'
' '
0 0
1 0

=
=
=

function z=Fla(t,y)
m=1.2;
b=0.3;
k=15;
z=[y(2);(-k*(y(1))-b*y(2))/m];
donde y(1) : posicin
y(2) : velocidad


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];
>> [t,y]=ode45('Flb',[0 60],[0;0]);
>> plot(t,y(:,1))
0 10 20 30 40 50 60
-0.2
-0.15
-0.1
-0.05
0
0.05
0.1
0.15

0 10 20 30 40 50 60
-1
-0.8
-0.6
-0.4
-0.2
0
0.2
0.4
0.6
0.8
1

Caso 2: ( ) ( ) cos f t t =

Caso 3:

( ) ( ) cos f t w t con =
k
w
m
=

>> [t,y]=ode45('Fla',[0 60],[1;0]);
>> plot(t,y(:,1))

function z=Flc(t,y)
m=1.2;
b=0.3;
k=15;
(k/m)
(cos(om*t)-k*(y(1))-b*y(2))/m];
om=sqrt
z=[y(2);
>> [t,y]=ode45('Flc',[0 60],[0;0]);
(t,y(:,1)) >> plot
Ejemplo 7.1: Problema stiff
La idea del problema es comparar la eficiencia de los comandos ode45 y ode15s en la solucin del
siguiente problema stiff:
( ) ( ) ( ) ' sin cos
(0) 1
( ) sin( ) solucin analtica
1000
[0 1]
t
y y t t
y
y t e t
t

= +
=
= +
=

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.

Ejercicios Resueltos
Temas 7 y 8

Ejercicio 1
Resolver usando el mtodo de Newton Rhapson el sistema de ecuaciones no lineales

x
y
y e
x e
=

=

Solucin
Primero, reconocer la funcin a valor vectorial y la jacobiana del problema, que en este caso son::

1
1
x x
y y
y e e
F J
x e e

= =

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)

( ) ( )
x
e x y x

= ln ln

>>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 : Utilizar Newton Raphson

>>raiz=newton(G,DG,x0,tol,maxit)

Con esto se tiene las raices, a saber: X=[1.31;0.27]

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.
Ejercicio 2
Calcular el rea encerrada por
( )
2 1
2
x tan y
e y
x x
=
=

Paso 1 : 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 : Definir f0, que es la funcin objetivo a resolver

>>f0=inline(exp(x-x.^2)-atan(x.^2);

La funcin objetivo est pensada en la idea de que el rea ser la funcin grande menos la
chica (clculo 1-2)

Paso 3 : Encontrar races basndose en las aproximaciones encontradas antes.

>>a=fzero(f0,0.5)
>>b=fzero(f0,1)

0,5 y 1 salen de mirar el grfico.

Paso 4 : Integrar

>>I=quad(f0,a,b)

Ejercicio 3
La ecuacin de Blasius

( )
( )
( )
( )
=
=
= +

cuando 1 '
0 0 '
0 0
0 ' ' ' ' 2
f
f
f
f f f

z : funcin dada al ODE, puede ser vector o escalar.

Cambio de variables

( )
( ) ( )
( ) ( ) ( )
( )
( ) ( )
2
3 1
' 3
2
' '
' ' '
3 ' 2 ' ' 1 ' '
2 ' 1 '
1
y y
y
f f
f
y y y f
y y f
y f
=
= = =
= =
=

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:

( ) ( ) ( ) [ ]
[ ]
( )
( )
( )
( )
= =
=
2
3
2
1
,
' 1 ' '

y
y
y
y y t
f f

En MatLab, la implementacin del archivo es como sigue:

function Z=p4c(t,y)
Z=[y(2); y(3);(-y(1)+y(3))/2;y(2)*(1-y(2))];
Luego, se resuelve el sistema con el valor de la raz ya calculado en el punto anterior

>>[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:
( )
2
2
0
a
d T h
T T
dx k
=

Donde:
T
a
: Temperatura del aire (de 70 [F])
H : Coeficiente de transferencia de calor entre la aleta y el aire. (2.5 [Btu/(hr*ft
2
*F)])
K : Conductividad trmica de la aleta (212 Btu/(hr*ft
2
*F)])

Para x = 3 [ft] calcular la temperatura T, sabiendo que a x = 1[ft], T = 179 [F] y 20 [ / ]
dT
F ft
dx
= .
Usar cualquier mtodo visto en clases.

x=1 x=3
k
h
70 F

( )
( )
ft
F
x
a
F ft h
Btu
F ft h
Btu
a
x
T
F T
ft x
F T
k
h
T T
k
h
x
T
=

=
=
=
=
=
=
=
20
179 1
3
70
212
5 . 2
0
1
2
2
2
2

Paso 1

( )
( ) ( )
( ) ( ) ( ) 70 1 ' '
2 1 ' '
1
= =
= =
=
y
k
h
T T
k
h
T
y y T
y T
a

Paso 2: Programar

function z=p1((t,y)
Ta=70;
h=2.5;
k=212;
z=[y(2);h/k*(y(1)-Ta)];

Paso 3: Aplicar ode

>> [t,y]=ode45('p1',[1 3],[179;20]);
>> T=y(length(y),1)

T =

221.8961

Ejercicio 5
Resorte acoplado resuelto mediante el mtodo de Adams Moulton.
Considere el problema mecnico de 2 masas m
1
y m
2
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).

a) Realizar cambio de variables

( )
( )
( )
( )
( ) ( )
( ) ( ) ( ) ( ) ( )
( )
( ) ( )
( ) [ ]
( ) ( )
( ) ( ) ( )
( )
( ) ( )
( ) [ ]
( )
( )
( )
( ) 0 4
1 3
0 2
2 1
1
1
1 3 2 3 4 2 4
4 3
3 1 2 4 2 2 1 1 2 1 2
2 1
2 4
2
3
1 2
1 1
=
=
=
=
=
=
=
=
=
=
=
=

y
y
y
y
y y k y y c
m
y
y y
y y k y y c y k y c
m
y
y y
x y
x y
x y
x y

b)
( ) ( )
0 1 0 0
1, 1 1,
1 2 1 2 2 2
2, 1 2,
1 1 1 1
3, 1 3, 0 0 0 1
4, 1 4, 2 2 2 2
2 2 2 2
/
y i y i
h k k h c c hk hc
y i y i
m m m m
y i y i
y i y i hk hc hk hc
m m m m
x b A

+
+ +

+

=

+

+

=

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];
c) Escribir programa

function [t,y]=ad_mult(t0,tf,h,y0)
global m1,m2,c1,c2,k1,k2
x(:,1)=y0;
t=t0:h:tf;
A=[1 -h 0 0;h*(k1+k2)/m1 1+(c1+c2)*h/m1 -h*k2/m1 -h*c2/m1; 0 0 1 -h; -hk2/m2 -h*c2/m2
h*k2/m2 1+h*c2/m2];
n=length(t);
for i=1:n-1
y(:,i+1)=A\y(:,i);
end

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:

2
2 2
0
9.8
( ) ( ) 1
2 cos ( )
h x tg x
v
=

+

donde v
0
es la rapidez inicial de salida y es el ngulo de salida inicial.
Para v
0
=[30 m/s], encontrar de modo que, a 40 m de la base de lanzamiento, la pelota toque el suelo.
Para =0.7, evale por el mtodo ms conveniente:
40
2
0
( ) I h x 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

Ejercicio 7: Problema 8
Interseccin de races.
Se desea encontrar TODOS los puntos de interseccin de las curvas:

( )
2
2
1 2 0.
4
x
y e y x = = 9 1

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

Creado: Noviembre 2004 Revisin, Abril de 2005

diego.seiltgens@vtr.net roverdug@udec.cl
>> 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)

Apunte Numerico Lab

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Apunte Numerico Lab

Transféré par

Droits d'auteur :

Formats disponibles

Universidad de Concepcin

Vous aimerez peut-être aussi