Apunte Numerico Lab PDF

Universidad de Concepción
Facultad de Ingeniería
Depto. Ingeniería Quimica
APUNTE
DE
CÁLCULO NUMÉRICO
AUTORES
Diego Seiltgens Sorrel

Rodrigo Verdugo Fuentes
1 Apun te d e Cá lcu lo Numérico
TABLA DE CONTENIDOS
Tema 1: Algunos aspectos del MATLAB __________________________________________1
1.1 Comentarios Importantes _____________________________________________________ 1

1.2 Opciones avanzadas de gráficos ________________________________________________ 2
1.3 Algunas reglas prácticas de programación. _______________________________________ 2
1.4 Manejo de archivos en Matlab. _________________________________________________ 2
Tema 2: Sistemas de ecuaciones lineales. __________________________________________4
2.1 Descripción general de los Métodos Directos ________________________________________ 4

2.2 Condicionamiento de una matriz y propagación de errores de redondeo _________________ 5
2.3 Métodos indirectos______________________________________________________________ 6
Tema 3: Mínimos 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 mínimos cuadrados para un problema no lineal ___________________ 11
Ejemplo 3.3: Aplicación de mínimos cuadrados a la circunferencia _______________________ 12
Ejemplo 3.4: Caso de matriz de rango incompleto ____________________________________ 13
Tema 4: Interpolación_________________________________________________________14
Ejemplo 4.1: Comparación entre interpolación y ajuste de mínimos cuadrados ______________ 15

Ejemplo 4.2: Fenómeno de Runge_________________________________________________ 15
Ejemplo 4.3: Aplicación de spline al dibujo de funciones discontinuas ____________________ 16
Ejemplo 4.4: Spline y parametrización de curvas _____________________________________ 17
Ejemplo 4.5: Más acerca del fenómeno de Runge_____________________________________ 18
Tema 5: Integración numérica__________________________________________________20
5.1 Integración usando MatLab _____________________________________________________ 20

5.2 Algoritmos de Integración. ______________________________________________________ 22
Ejemplo 5.1: Exactitud del método de los trapecios en un caso especial. ___________________ 25
Ejemplo 5.2: Exactitud del método de los trapecios en caso especial. _____________________ 26
Tema 6: Ecuaciones no lineales._________________________________________________27
6.1 Métodos numéricos ____________________________________________________________ 27

6.2 Ingreso de sistemas de ecuaciones al Matlab________________________________________ 28
6.3 Solución de ecuaciones mediante los comandos de MatLab ___________________________ 28
Ejemplo 6.1: Hallar todas las raíces de las ecuaciones _________________________________ 29
Ejemplo 6.2: Sistema de ecuaciones no lineales ______________________________________ 31
Ejemplo 6.3: Ajuste de parámetros de una cinética de hidrólisis _________________________ 32
6.4 Algoritmos numéricos para solución 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 Ordinarias._____________________________________37
7.1 Concepto de problema stiff ______________________________________________________ 37

7.2 Solución 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 programación C y ForTran. La

ventaja de este lenguaje es la incorporación de ciertos comandos que facilitan los cálculos, especialmente
en lo referente a matrices. Los comandos fundamentales se encuentran es las guías 1 y 2 del curso.
1.1 Comentarios Importantes
a) Números complejos: MatLab trae incorporado el trabajo con números complejos, y para ello
reconoce la letra i como la unidad imaginaria; ejemplo:
>> a = 1+i;
>> b = -5+2i
Las operaciones con estos números complejos son las siguientes:
Suma: >> e = a+b

>> ans = -4.0000 + 3.0000i
Producto: >> p = a*b

>> ans = -7.0000 + 3.0000i
Racionalización: >> 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
Módulo del complejo: >>abs(a)

>> ans=1.4142
b) Comandos sobre vectores: sea un vector v. Al aplicar:
length(v) : se obtiene el número de componentes del vector.

abs(v) : devuelve un vector formado por el módulo o valor absoluto de sus elementos
max(v) : devuelve el máximo valor de los elementos del vector
min (v) : devuelve el mínimo 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 desviación estándar de un vector
sort(v) : ordena el vector de forma creciente, y devuelve ese vector. Si el vector es complejo, opera
sobre el módulo 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 gráficos
El comando zoom puede manejarse desde la pantalla gráfica con la lupa.

Zoom : interactivo que permite agrandar cierta parte de un gráfico.
Zoom on : enciende el comando zoom
Zoom off : apaga el comando zoom.
Zoom out : lo deja donde estaba
Zoom reset : lo deja en la opción por defecto.
Ginput: permite seleccionar puntos de un gráfico y llevarlos a un vector.
[x,y]=ginput(n) : elige n puntos de un gráfico; 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 gráficos, se puede utilizar la pantalla gráfica viendo en las opciones, o usando
el comando
xlabel(‘nombre del eje x’)
ylabel(‘nombre del eje y’)
title(‘título’)
1.3 Algunas reglas prácticas de programación.
Todos los comandos van en minúsculas. Recordar que MatLab diferencia entre mayúsculas y minúsculas.
El nombre de la función debe ser igual al del archivo .m donde esta se guarda. Dicho nombre debe cumplir
ciertas características:
- El primer carácter 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: Generación y carga de archivos en MatLab.
Para guardar un archivo con extensión 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: Generación 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
después 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 trigonométricas.

- Las matrices que no son cuadradas y representa la identidad, se denominan “matrices de pseudo
identidad”
Comandos de interés:
Clear : limpia la memoria

Clc : limpia la pantalla, es decir las variables siguen existiendo
Whos : permite ver las variables y como están 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 información en inglés acerca del
comando.)
Tema 2
Sistemas de ecuaciones lineales.
La resolución del problema Ax=b, donde A es una matriz cuadrada de m×m y b un vector de m×1, da
origen a la teoría de sistemas de ecuaciones. Este problema tendrá solución 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 métodos, los directos y los indirectos.
- Métodos directos: Son aquellos que operando sobre la matriz A, ya sea factorizándola o
intercambiando columnas, permiten encontrar la solución x.
- Métodos indirectos: Sin alterar la matriz A, se genera una sucesión de vectores X0, X1…Xn de
modo que dicha sucesión converja a la solución del sistema.
El cuadro resumen a continuación presenta los métodos iterativos a trabajar:
Gauss
Métodos Directos LU
Chol.
S.E.L.
Jacobi
Métodos Indirectos G.S.
P.C.G
2.1 Descripción general de los Métodos Directos
- Eliminación 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 sustitución sucesiva. Es más barato
computacionalmente que determinar la matriz inversa. Sólo necesita de una matriz no singular.
- Factorización 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 Método de Thomas (ver problema 7 lab 2). También 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
“psicológicamente” 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 descomposición, 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 permutación 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 factorización es más
restrictiva pues requiere que la matriz A sea una matriz simétrica ( 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 resolución de los métodos pre definidos en MatLab, a saber: \, lu, chol y el comando inv. Se
observa que el comando \ es el más rápido. Le sigue el método de Cholesky, el comando inv y luego lu.
Este orden se debe a que las rutinas predefinidas en el MatLab funcionan más rápido que los programas.
2.2 Condicionamiento de una matriz y propagación de errores de redondeo
El condicionamiento de una matriz indica si el sistema propagará errores al utilizar algún método para
resolverlo.
Sea el sistema:
Ax = b
Si el vector b, o la matriz A sufren alguna perturbación 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 pequeña perturbación en b o A, el sistema
es mal condicionado y la solución está sujeta a mucho error.
El índice que permite establecer si una matriz o el sistema está bien o mal condicionado es el ‘número de
condición’, que puede ser calculado como:
µ = A ⋅ A −1
También se calcula como el menor valor propio de la matriz A. Este valor lo entrega el comando MatLab:
>>u = cond (A)
Si el número de condición 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, perturbándose el vector b en orden de 10-6 y se comparan los valores. La solución del sistema
perturbado dista mucho de la solución original, por lo que el sistema es muy mal condicionado.
2.3 Métodos indirectos
Los métodos iterativos son los métodos 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 métodos directos, además de ocupar mucha memoria, perturban el carácter disperso de una matriz,
puesto que la factorización va creando elementos no nulos en posiciones inicialmente nulas. Este
problema se conoce como el problema de llenado, el cual aumenta la propagación de los errores de
redondeo en la solución del sistema, además de encarecer el costo computacional de los métodos.
La idea es generar una sucesión de soluciones Xi de modo que esta sucesión converja a la solución x.
La convergencia de la solución está garantizada por los teoremas vistos en clases. Uno de estos criterios es
que la norma de la matriz de iteración (que no es la misma que la matriz A del sistema) sea menor que
uno. Basta con que una norma cumpla esta condición, para que la sucesión converja a la solución.
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 más económica de trabajar con las matrices dispersas.
La ventaja es que MatLab permite hacer algunas operaciones con matrices sparse sin que éstas pierdan
dicha condición. 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 sería 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 resolución con una full, para notar que una matriz sparse permite
un ahorro de memoria y de tiempo para solución.
Además, ver que las matrices pueden generarse sin pasar primero por matrices full, usando el comando
speye, spdiags (análogo al comando diags pero hecha sparse) y luego construir la matriz de iteración para
el método de Jacobi.
2.3.2 Descripción general de métodos iterativos
2.3.2.1 Método 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 iteración J:

A·x=b
(D – E – F) ·x = b
D·xk+1 = (E + F) ·xk + b
x = D-1(E + F) ·xk + D-1·b
k+1
J es la matriz a la cual se le estudia la convergencia usando el teorema señalado en la sección 2.3 (lo de la
norma). Para calcularla se utiliza la norma infinito, porque ésta es más resistente a los cambios.
Jacobi es un método 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
aii > ∑ aij
i =1
j =!
Notar que si A es sparse, la generación de las matrices D con el comando diag, -E con el comando tril y -F
con el comando triu devuelven matrices sparse. La construcción 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 sólo la
matriz de iteración.
2.3.2.2 Método de Gauss Seidel
Para las matrices D, -E y -F, usadas anteriormente, la matriz de iteración J está elegida de la siguiente
manera:
J = ( D – E)
El método converge cuando la matriz es simétrica y definida positiva.

También vale lo dicho para la matriz con formación sparse. El problema de generar la matriz de iteración
y resolver el sistema de ecuaciones mediante este método está descrito en el problema 6 y usa el test de
detención descrito en la sección siguiente.
Se dice que la convergencia de un método no necesariamente hace la convergencia del otro. Por lo tanto,
si la matriz es definida positiva y es simétrica, no necesariamente el método de Jacobi converge.
2.3.2.3 Test de detención
Los métodos iterativos deben detenerse una vez que se considera que la sucesión converge. En la teoría, la
sucesión converge en el infinito. Como en la práctica no existe, se debe detener la iteración una vez que se
llegue a un grado aceptable de medición, dado por la precisión que se busca. Un test sugerido es el
siguiente:
mk
x k +1 − x k < tol
1 − mk
x k −1 − x k
mk =
x k − x k +1
2.3.2.4 Método del Gradiente Conjugado
El Gradiente Conjugado es un método que depende mucho del número de condicionamiento y requiere
que la matriz sea simétrica y definida positiva.
El gradiente conjugado posee un origen distinto a los anteriores, viene de la minimización de una función
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 características de
simetría y definida positiva.
¿Cómo construir una matriz simétrica y definida positiva?
~ = A T ⋅ A , con A matriz no simétrica.

A
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 : número máximo de iteraciones que se desean.
El problema 6, muestra como se usa el gradiente conjugado y compara su uso con el método de Gauss
Seidel.
Tema 3
Mínimos cuadrados
El objetivo de los cuadrados mínimos es encontrar la función φ(x) que ajuste una dispersión de puntos de
“la mejor forma posible”. Esta forma resulta de la minimización de la suma de todos los cuadrados de las
distancias entre la función y los puntos que se disponen. Esta función puede ser una función polinomial o
cualquier otra.
m 2
∑ϕ
i =1
( xi ) − yi (3.1)
Con m el número de puntos.
El problema se reduce entonces a encontrar una función φ que sea una combinación lineal de las funciones
dadas para ajustar el modelo (por ejemplo, ajustar los puntos a una función polinomial), tal que se cumpla
la condición anterior.
Esto genera el siguiente problema a resolver: Ax=b, con A una matriz rectangular de m filas y n columnas,
con n, el número de elementos de la base que genera a φ.
Recordar los 3 casos:
- n>m : El sistema está sobredeterminado (tenemos más ecuaciones que incógnitas) y la
base sería una combinación lineal (ver el ejemplo propuesto 2 del lab 4).
- n=m : El sistema tiene solución única (caso de interpolación - tema 4-).
- n<m : El sistema tendría infinitas soluciones.
3.1 Matriz QR
El caso de los mínimos 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 mínima (condición 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 sólo 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 ecuación se conoce como sistema de ecuaciones normales y es un sistema cuadrado que tendrá
solución si A es de rango completo, es decir, rango(A)=n. Además, A es simétrica y definida positiva, por
ende, se podrían aplicar los métodos de resolución de ecuaciones, como Cholesky, Gauss Seidel y el
gradiente conjugado, pero también se sabe que la matriz At⋅A es muy mal condicionada, por lo que se
prefiere otra solución: el de utilizar la descomposición de A en dos matrices: A=Q⋅R, donde:
R : Matriz triangular superior no singular. qi ⋅ q j = 1 si i=j

Q : Matriz ortonormal, es decir el producto de dos columnas cumple:
qi ⋅ q j = 0 si i≠j
En virtud de lo anterior:
Q⋅Q t = I
Así, el sistema a resolver se transforma a:
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 linealización,
que consiste en dejar el modelo pedido como lineal mediante alguna transformación matemática. Algunos
casos se verán a continuación:
Caso 1: Modelo inverso:

a 1
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 mínimos
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 ecuación de una recta, con la salvedad que los puntos y se les debe aplicar el
logaritmo y luego ser usados en la solución 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 mínimos cuadrados a un conjunto de puntos dados. A continuación se presentará la forma de
ingresar un polinomio a MatLab y algunos de los comandos más usados.
n −1
Sea el polinomio P( x ) = an x + an −1 x +… a 0
n
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) : 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 raíces del polinomio P.
P=poly(r) : P es un polinomio formado a partir de las raíces 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 mínimos cuadrados al
conjunto de puntos x e y.
Ejemplo 3.1: Propiedades de las matrices Q y R
function A=Aj_Pol(m,n) m=10;

h=1/m; n=5;
t=(0:h:1)'; A=Aj_Pol(m,n);
A=[ones(m+1,1)]; B=A’*A; % Matriz del sistema normal de ecuaciones
for j=1:n cond_B=cond(B) % Estudio del condicionamiento
A=[t.^j A]; [Q,R]=qr(A); % Descomposición de A en matrizces QyR
end err_ort=norm(Q’*Q-eye(m+1),inf) % Comprobación 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 m×n que deben ser ingresados. Esta matriz
corresponde a la matriz de problemas de mínimos cuadrados, cuando la base elegida es un polinomio de
grado n y los puntos elegidos para construir la función que mejor los aproximará son los puntos
equiespaciados en el intervalo [0,1].
La segunda rutina permite estudiar el condicionamiento de la matriz AT⋅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 función 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 mínimos cuadrados para un problema no lineal

A veces, el problema de mínimos 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 ⎠
La matriz resulta de la evaluación 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); % evalúa los puntos en el modelo
plot(t,c,’o’,tt,mod,’-’) % compara los puntos del archivo con el modelo encontrado
Obervación: notar el uso del comando ones para generar la columna de unos que exige la base.
Ejemplo 3.3: Aplicación de mínimos cuadrados a la circunferencia

En este problema, el propósito es encontrar los parámetros de la ecuación 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 mínimos cuadrados.
Recordar que la ecuación 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 sólo
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 círculo
plot(x,y,'x',xx,yy)
Observaciones:
- Notar que la generación del vector b se usa el punto, pues se desea multiplicar cada elemento por si
mismo.
- Se usan ecuaciones paramétricas 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
combinación lineal, pues:
sin 2 ( x) + co s 2 ( x) = 1
Debidos a esto, MatLab da un warning acerca de la repetición 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
Interpolación
Si se tiene un conjunto de puntos, al cual se le desea ajustar una curva, lo lógico y la mínima exigencia
que se le hace a la curva que pretende ajustar a dichos puntos, es que pase por todos ellos. Por lo tanto, la
interpolación consiste en construir una curva que pase por todos los puntos.
La principal diferencia que existe con los mínimos cuadrados, es que los últimos buscan un ajuste que
minimiza distancias, pero no necesariamente exige que esta curva pase por los puntos
La interpolación puede ser de dos formas:
Polinomial: y su caso particular usando polinomios de Legendre
Interpolación
Spline: función cúbica por tramos.
- Polinomial
No se dará mayor detalle en este laboratorio, sólo saber que los L(x) son los polinomios de Legendre
asociados a los puntos. (ver su construcción en las diapositivas del curso)
n
P ( x ) = ∑ y i L( x )
i =1
Y si se desea contruir un polinomio de interpolación, se puede usar el comando polyfit del MatLab
(visto en en la sección anterior), recordando que el grado del polinomio n debe ser igual al número 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 solución diferente para evitar estos problemas (fenómeno de Runge)
- Spline
El spline es una función cúbica por tramos, es decir, hace un ajuste polinomial cúbico 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 cúbico 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 aproximación 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 opción
que posee MatLab.
Ejemplo 4.1: Comparación entre interpolación y ajuste de mínimos cuadrados (problema 1 c) Lab.5)
El siguiente programa construye los polinomios de ajuste para n = 5 y para n = 10 para la función 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 interpolación, porque pasa por todos los
puntos, mientras que el de 5 no lo hace. EL vector xx es sólo 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 evalúa el punto o el vector en el polinomio P,

devolviendo en Y, un punto o vector según 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: comparación de polinomios interpolantes para la función seno
Ejemplo 4.2: Fenómeno de Runge (problema 1 d) Lab.5)
x=-5:5; % puntos dados para determinar el polinomio

y=1./(1+x.^2); % evaluación de los puntos en la función
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 gráfico desaparezca.
plot(x,y,’o‘,xx,yy,’-‘,xx,spline(x,y,xx),’:‘) %fig 3.2
Figura 3.2: Fenómeno de Runge Figura 3.3: aproximación de la función usando spline
La rutina anterior permite visualizar el conocido fenómeno de Runge. Primero, se determinan los puntos
usados para construir los polinomios de interpolación, luego se determinan con el comando polyval, los
polinomios de grado 6 (C6) y de grado 10 (C10) para aproximar la función.
La figura 3.2 muestra que los polinomios sólo aproximan en una región (al centro) a la función pedida. En
los extremos, los polinomios comienzan a oscilar y esta oscilación se hace cada vez más fuerte debido al
aumento del grado del polinomio. El polinomio de grado 10 es mucho más oscilante que el de grado 6.
Esto puede evitarse si se usan splines para interpolar la función, como se muestra en la figura 3.3. Esta
curva es mucho mejor aproximada por una spline, además de tener la ventaja de evitar las oscilaciones
Ejemplo 4.3: Aplicación 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 después
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: gráfico 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 función seguirá teniendo sus esquinas, pero ahora está bien representada
por 3 splines en la figura 3.5
Ejemplo 4.4: Spline y parametrización 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);%parametrización de la curva
plot(x,y,’x’,spline(t,x,tt),spline(t,y,tt),’-‘)%interpolación spline de la curva paramétrica
Parametrizacion Parametrizacion
de x 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: Más acerca del fenómeno de Runge (problema propuesto 1 Lab.5)
%rutina para el runge %rutina para el seno

a=-5; a=0;
b=5; b=2*pi;
for i=0:10 for i=0:10
if i==0 if i==0
P=polyfit(1,1,0); P=polyfit(1,1,0);
else else
h=(b-a)/i; h=(b-a)/i;
x=a:h:b; x=a:h:b;
y=1./(1+x.^2); y=sin(x);
P=polyfit(x,y,i); P=polyfit(x,y,i);
subplot(4,3,i) subplot(4,3,i)
xx=-5:0.1:5; xx=0:0.1:2*pi;
yy=1./(1+xx.^2); yy=sin(xx);
plot(xx,yy,'--',xx,polyval(P,xx),'-') plot(xx,yy,'--',xx,polyval(P,xx),':')
end end
end end
La idea de este problema es ver que, a medida que aumentan los puntos usados para construir el polinomio
de interpolación, mayores son las oscilaciones que el polinomio genera al tratar de aproximar la función.
En la figura 3.8 se aprecia que el crecimiento de puntos sólo aproxima de buena forma la región del centro
de la curva, pasado ésta, se observan oscilaciones.
Figura 3.8: Fenómeno de Runge

La situación no es tan mala, porque sí existen funciones que se aproximan mejor, con más puntos. La
función seno no es una función “mal comportada”. A medida que el grado del polinomio de interpolación
aumenta, la exactitud se hace cada vez mayor. Si se hace un polinomio de grado 7, la aproximación es casi
perfecta
Figura 3.9: Función seno

Tema 5
Integración numérica
La idea es hallar la integral de una función f continua en el intervalo [a,b] donde se pretende integrar.
n
I = ∫ p ( x) ⋅ f ( x) → ∑ Ai ⋅ f ( xi ) + R
b
a
i =1
La integral se transforma en un producto de un factor por la función evaluada en alguna partición del
intervalo. Como este producto no es exacto, hay un resto R.
Trapecio: grado 1 (exacta para una recta)
Métodos de integración Simpson: grado 2 (exacta para una parábola)
Gauss: es exacta hasta un polinomio de grado 2n+1
La integración de Romberg no será tratada en el apunte.
5.1 Integración usando MatLab
5.1.1 Funciones ‘inline’ en MatLab
A veces es más cómodo ingresar la función como una variable string y una forma es usando el comando
inline. Por ejemplo, para ingresar la función exp(-x2)
>>t = inline(‘exp(-x.^2)’)
La idea es ingresar la función no como archivo, sino como un parámetro y con ello ahorrar memoria. La
desventaja está en que una función 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, sólo recibe valores de x.
Una vez ingresada la función en MatLab, esta puede evaluarse mediante el siguiente comando:
>>Y=feval(t,x)
Donde t es la función ingresada como inline, x un punto o un vector e Y es un número o un vector que
resulta de la evaluación de x en la función.
5.1.2 Comando quad para integración.
El comando quad evalúa la función a integrar entre determinados intervalos de integración.
>>I=quad (función, a, b, tol)

quad (tol=10-6)
quad quad8 (tol=10-3)
quadl (tol=10-6)
Para integrales dobles, utilizar dblquad(función, a, b, c, d, tol), donde a y b los intervalos donde está el
rectángulo asociado a la variable x, c y d son los intervalos de integración de y.
Por ejemplo, una manera de conocer la tolerancia de los comandos utilizados es realizar lo siguiente
(problema 3 del lab. de integración)
>> 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
5.2 Algoritmos de Integración.
5.2.1 Trapecios: Ejemplo 1a)
h ⎛ n −1
⎞
I= ⋅ ⎜ f (a ) + f (b) + ∑ f ( xi ) ⎟
2 ⎝ i =1 ⎠
R = −n ⋅
h3
⋅ f ''(θ ) = −
( b − a ) ⋅ h2 ⋅ f ''(θ )
12 12
θ ∈ [ a, b ]
El programa entregado en el laboratorio. 6, corresponde a la programación del método de los trapecios. El

comando sum permite sumar las componentes de un vector – sección 1.1 b) comandos sobre vectores –
generado tras la evaluación del vector x, que corresponde a los nodos de evaluación para x.
Si luego, se escribe:
>>trap(t,0,20)
1
∫e
x2
Lo que resulta entonces es: ⋅dx con 20 subintervalos.
0
La misma mecánica se sigue tanto para las funciones definidas en la librería, que no es necesario
ingresarlas, como las ingresadas como inline.
El comando format long, permite ver todos los decimales de un número. 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
>>x=[trap(f,0,3,10) trap(f,0,3,20) trap(f,0,3,40) trap(f,0,3,80)]
x = 9.04500000000000 9.01125000000000 9.00281250000000 9.00070312500000
>>g =inline(‘exp(-x.^2)’)
g = Inline function:
g(x) = exp(-x.^2)
>>e =[trap(g,-1,1,10) trap(g,-1,1,20) trap(g,-1,1,40) trap(g,-1,1,80)]
e = 1.48873667952733 1.49242159226350 1.49334167387975 1.49357162247796

l=[trap(‘log’,1,2,10) trap(‘log’,1,2,20) trap(‘log’,1,2,40) trap(‘log’,1,2,80)]
l = 0.38587793674575 0.38619020963221 0.38626832040247 0.38628785076256
s=[trap(‘sqrt’,0,1,10) trap(‘sqrt’,0,1,20) trap(‘sqrt’,0,1,40) trap(‘sqrt’,0,1,80)]
s = 0.66050934170682 0.66444659142664 0.66587096567353 0.66638264723897
Esta última función no necesita ser definida como inline, puesto que ya está definida en la librería del
MatLab. Una función que está ya definida, como el logaritmo (log) o la raíz cuadrada (sqrt) basta sólo 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 función y los intervalos de integración a y b.
5.2.2 Simpson: ejemplo 1b)
h ⎛ n −1 n −1
⎞
I= ⋅ ⎜ f (a ) + f (b) + 4 ⋅ ∑ f ( x2i +1 ) + 2 ⋅ ∑ f ( x2i ) ⎟
3 ⎝ i =0 i =1 ⎠
R = −n ⋅
h5 ( IV )
⋅ f (θ ) = −
( b − a ) ⋅ h4 ⋅ f IV (θ )
90 180
θ ∈ [ a, b ]
Esta regla hace diferencia entre los puntos de integración 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; % números pares
xi=h+(1:2:2*N-1)*h; % números 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 división de números pares e impares que hace el algoritmo, el paso se parte en 2⋅N 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:
>>format long
>>f=inline(‘x.^2’)
f(x) = x.^2
>>x=[simpson(f,0,3,10) simpson(f,0,3,20) simpson(f,0,3,40) simpson(f,0,3,80)]
x = 7.78000000000000 6.88250000000000 6.43937500000000 6.21921875000000
Se espera, en este último caso, que la solución sea exacta, ya que Simpson, entrega soluciones exactas
para polinomios de segundo grado.
5.2.3 Cuadratura de Gauss
El nacimiento de esta fórmula es distinto, ya que parte de la idea de que los Ai no se conocen. Para n
puntos de partición el algoritmo es:
b−a ⎛ n ⎛⎛ b − a ⎞ ⎞⎞
I= ⋅ ⎜ ∑ 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 utilización, 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
< f , g >= ∫ f ( x) ⋅ g ( x)dx
a
Haga un programa general en MatLab, llamado testIIc.m que, usando integración 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 Ai
± 0.861136311594053 0.347854845137455
± 0.339981043584856 0.652145154862547
Aplique el programa para calcular:
i) f = < f , f > , donde f ( x ) = sin(45 ⋅ x ) , a =-π y b = π
ii) <sin(7 ⋅ x),x>, donde a=0 y b=2 ⋅ π

Solución:
Primero se construye un programa genérico para esos valores de la cuadratura (lo ideal sería 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 evalúa la función
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 método 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 observación 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 cálculo de la integral con el método
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 integración. Ahora bien, si se grafica la función 1/n2 contra n en un gráfico logarítmico, la gráfica es
una línea recta de pendiente -2. Si el error fuera de orden 2, la pendiente de un gráfico logarítmico entre N
y el error, debería tener la misma pendiente, es decir, serían paralelas. En efecto:
log f(N) = -2⋅log(N), para la función n vs 1/n2.
log(ε) = -2⋅log(N)+b, se ve en el gráfico obtenido
y como h=1/N
error =C/N 2 = C⋅h 2, con C=10 b

Ejemplo 5.2: Exactitud del método de los trapecios en caso especial.

La idea es la misma que la del problema anterior, sólo 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 mínimos cuadrados.
g=inline('sqrt(x)');
N=10:10:100;
error=[]; log f(N) = -2⋅log(N) para la función n vs 1/n2
for n=N;
integ=trap(g,0,1,n);
error=[error abs(integ-2/3)]; log(ε) = -alpha⋅log(N)+b
end
loglog(N,error,'o:',N,(1./N).^2,'-') y como h=1/N
m=length(N);
A=[ones(m,1) -log(N)']; error =C/N alpha = C⋅h alpha con C=10 b
b=log(error)';
z=A\b; Se obtiene un orden de 1.4811
Alpha=z(2)
figure
loglog(N,error,'o:',N,(1./N).^Alpha,'-')
Tema 6
Ecuaciones no lineales.
El objetivo de este tema es resolver ecuaciones y sistemas de ecuaciones no lineales usando técnicas
numéricas y con ayuda del MatLab.
6.1 Métodos numéricos
A continuación se presenta una breve descripción de los algoritmos clásicos usados para resolver
ecuaciones no lineales tanto en una variable, como en varias variables (sistemas de ecuaciones lineales).
6.1.1 Método de la bisección
Está basado en el teorema del valor medio, que señala que si la función a resolver es continua en el
intervalo de solución y sea f(a)<f(b). Para cada f(a)<z<f(b) debe existir un x0 que pertenezca al intervalo
de solución. 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 raíz, lo que se hace es partir el intervalo en dos, luego evaluar la función en
los puntos extremos del intervalo ya cortado. Si existe un cambio de signo en f(xa)⋅f(xb), implica que hay
una raíz en el intervalo y este se vuelve a cortar. Así sucesivamente hasta encontrar una raíz. La
aproximación puede obtenerse mediante el gráfico de la función. Es un método de convergencia lento,
pero siempre converge si el intervalo es adecuado. Se le llama método de convergencia garantizada por
ser lento, pero siempre encuentra la solución. No depende de la distancia entre la solución y el valor que
se dio como inicial. Sólo sirve para una variable.
6.1.2 Método de Newton Raphson
Es de convergencia rápida y asegurada, consiste en lo siguiente: conocida la derivada de una función, se

puede trazar la recta tangente a un punto dado (conocer una estimación de la solución), llegando a un
punto cercano a la solución, para luego trazar otra tangente en el nuevo punto y encontrar un nuevo x que
se acerca aún más a la solución. Método iterativo, más utilizado. Puede extenderse para 2 o más variables,
pero es sumamente sensible a la aproximación inicial.
6.1.3 Método de la secante
Se utiliza cuando es muy difícil conocer la raíz de la ecuación o función. 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 también 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 función 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 técnicas que veremos
posteriormente. Considerar para esta agrupación, el siguiente cambio de variables:
x = x(1) ; y = x(2)
Con ello, la función F puede construirse con las dos ecuaciones de la forma:
⎡ f ⎤ ⎡ x 2 + x ⋅ y + y 2 − 1⎤
F = ⎢ 1⎥ = ⎢ ⎥
⎣ f2 ⎦ ⎣ y + x2 ⎦
Notar que las ecuaciones, independiente del número 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]');
6.3 Solución de ecuaciones mediante los comandos de MatLab
MatLab tiene dos comandos para resolver ecuaciones no lineales:
fzero : permite encontrar soluciones para una ecuación no lineal (1 variable), se debe correr tantas
veces como raíces 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 raíces de una ecuación, para ello, se debe tener una aproximación
inicial de la solución, que puede obtenerse mirando un gráfico de ella. Su sintaxis es:
>>x=fzero(‘f’,x0)
Donde:
x : Solución de la ecuación no lineal.
f : Función a resolver. Puede ser un objeto inline o un archivo.
x0 : Solución aproximada inicial
A continuación se presentan unos ejemplos del uso del comando fzero para la solución de ecuaciones no
lineales.
Ejemplo 6.1: Hallar todas las raíces de las ecuaciones
a) x 2 = 2
b) x 3 − 3 x + 1 = 0
c) cos( x) = x
Caso 1
Se sabe que las raíces son 2 y − 2 . Basta utilizar como aproximación 1.41 y -1.41 para encontrar las
raíces. Con ello, la función ingresada es:
>> f=inline('x.^2-2')
f(x) = x.^2-2
%Y la ejecución del comando fzero para la raíz positiva es:
>> fzero(f,1.4)
ans = 1.4142
La misma idea debe repetirse para hallar la segunda, usando la correspondiente aproximación inicial.
Caso 2
Aquí las raíces ya no son claras, y debe recurrirse a un gráfico para poder verlas. Por ende, primero
graficar esta función, recordando el comando feval visto en tema anterior y el ingreso de la función de la
forma f(x)=0 (ya está en esa forma):
x=-10:0.1:10
f=inline('x^3-3*x+1')
f(x) = x^3-3*x+1
plot(x,feval(f,x))
Del gráfico, se pueden extraer aproximaciones de raíces para luego aplicar en conjunto con el comando
fzero. Se debe ejecutar 3 veces, una por cada raíz 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 raíz que se ve en el gráfico.
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 localización de la raíz
inicial con el gráfico.
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 aproximación inicial, que ya no será tan fácil de visualizar
gráficamente puesto que ya la solución X no es un número, sino un vector de n componentes, según las
variables que el sistema tenga. Este resuelve el sistema usando el método de mínimos cuadrados
El comando básicamente funciona de la siguiente manera:
X=fsolve(‘F’,X0)
Donde
X : Solución del sistema de ecuaciones no lineales.

F : Función a valores vectoriales compuesta de todas las ecuaciones que componen el
sistema. Puede ser un objeto inline o un archivo.
X0 : Solución aproximada inicial del sistema.
Ejemplo 6.2: Sistema de ecuaciones no lineales
Sea el siguiente sistema de ecuaciones (Laboratorio 7 - 25/05/01):
y − x2 = 0
x2 + y 2 = 4
La solución puede obtenerse fácilmente debido a que sólo basta despejar una variable en función de la
otra. La solución se hará usando el comando fsolve.
Caso 1: Función como archivo
Si se desea ingresar una función como archivo, se usa el concepto de matrices. Cada función 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 función 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 aproximación
para x, y en la segunda para la variable y, pues así fueron definidas las incógnitas.
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 solución inicial:
X0=[1.41,1.41]
La respuesta corresponde a:
X=[1.2496 1.5616];
Caso 2: función 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 parámetros de una cinética de hidrólisis

El modelo de Levenspiel permite aproximar una cinética de hidrólisis:
γ
Kh ⎛ [ AGV ] ⎞
= 1 − ⎜ ⎟
K h0 ⎝ KI ⎠
Conocidos los datos de K1, K2 y Kh hallar los parámetros 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 solución inicial se encontró usando
parámetros reportados en bibliografía para sistemas similares.
X0=[1000;0.41];
X=fsolve(‘lpq2’,X0)
6.4 Algoritmos numéricos para solución de sistemas de ecuaciones no lineales
6.4.1 Método de la bisección
El programa que se presentará recibe como parámetros el intervalo donde se desea conocer la solución, o
un intervalo donde haya una sola raíz y la tolerancia deseada para la solución. Lo que hace el programa es
evaluar la función 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 raíz. Luego, verifica si el producto de la evaluación de
las funciones se anula en cero. Si lo hace, es porque ya ha encontrado una raíz 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 función 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) Método de Newton Raphson
El algoritmo del método de Newton Rhapson se obtiene de las sucesivas aproximaciones usando la
ecuación de la recta tangente a la curva en los puntos de aproximación. Este resulta en:
f ( x)
x k +1 = x k −
f '( x)
Este algoritmo base se analizará para dos casos:
Caso 1: Caso de una sola variable:
Para este caso, el método requiere de una aproximación inicial de la raíz, que debe ser suficientemente
buena debido a que este método es muy sensible a dicha aproximación, la evaluación de la función en el
punto y del conocimiento de la derivada de la función. De él, se ve que el algoritmo falla si la derivada de
la función 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 línea de error
implementada en el programa.
El programa, además de recibir la función, debe recibir la función derivada y el número máximo de
iteraciones. Lo que hace es evaluar la función, la derivada y calcular el algoritmo. El criterio de detención
usado es la variable corr. Esto porque:
f ( x)
corr = = x k − x k +1
f '( x)
El criterio de detención 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
Caso 2: Caso de varias variables
El algoritmo es básicamente el mismo, sólo que ahora los x’s son vectores, al igual que la función y la
derivada ya no es un número, sino que corresponde a la matriz jacobiana de la función compuesta. A
modo de repaso, la matriz jacobiana se forma como:
⎡ f1x f1 y f1m ⎤
⎢f f2 y f 2 m ⎥⎥
⎢ 2x
⎢ ⎥
J =⎢ ⎥
⎢ ⎥
⎢ ⎥
⎢ ⎥
⎢⎣ f nx f ny f nm ⎥⎦
fij : La derivada de la ecuación i que conforma el sistema con respecto a la variable j de la cual esta
ecuación es dependiente.
Ahora, el algoritmo falla cuando el determinante de la matriz es nula, es decir, la matriz no es invertible.
Como criterio de detención usa la variable corr y el argumento es el mismo que el usado para una
variable, sólo 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 función vectorial, pero sólo que
para un sistema de 2 ecuaciones, ya se tendría una jacobiana de 2*2. (más 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 función se utiliza el comando inline. Notar que todas las funciones deben ingresarse de la
forma f ( x, y ) = 0 . La función F es una función 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(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:
⎡2x + y 2 y + x⎤
J = Df = ⎢
⎣ −2 x 1 ⎥⎦
>> 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 parámetros requeridos para ejecutar el programa. Para encontrar una aproximación
inicial, a veces se debe tratar algebraicamente la solución. Por ejemplo, para este caso, reemplazando la
ecuación 2 en 1, se tiene un polinomio en x que puede ser resuelto para encontrar la solución inicial, que
resulta ser igual a la solución inicial en x. En este caso al parecer no tendría asunto, porque con esto ya se
tendría la solución. El punto es que no siempre se tienen aproximaciones para soluciones y a veces se
recurre a valores de bibliografía o un promedio entre dos valores donde se sabe que hay una solución.
>> tol=1e-12;
>> maxit=10;
>> x0=[-1:1];
>> raiz=newton2(f,Df,xo,tol,maxit)
El reemplazo de la ecuación 2 en 1 resulta:
>> P = x 2 + x 3 + x 4 − 1(= 0 )
A través del comando roots, se puede encontrar las raíces para x:
>>roots(P)
Tema 7
Ecuaciones Diferenciales Ordinarias.
La plataforma MatLab trae incorporados comandos para la resolución de ecuaciones diferenciales,

llamados ode. En la guía 9 aparecen listados los comandos para resolver ecuaciones diferenciales tanto
stiff como no stiff. La desventaja de los comandos ode es que sólo pueden ser usados para la resolución de
ecuaciones de primer oden. Esto da origen a 3 casos que se estudiarán más adelante.
7.1 Concepto de problema stiff
Un problema stiff es análogo al concepto de condicionamiento de una matriz, sólo que ahora una pequeña
perturbación en la condición inicial del sistema puede alterar la solución de la ecuación diferencial.
Considere el PVI:
y’(x,y)=C (x,y)
y(0)=1
Si la solución del PVI se perturba en δ=0.01 el problema no será stiff, si la solución no sufre mayores
cambios. Si ante esta perturbación, el sistema sufre cambios notables (reflejados en su estabilidad) el
problema es stiff.
7.2 Solución de ecuaciones no lineales con el comando ode
Independiente si la situación es stiff o no stiff, los comandos ode tienen la misma sintaxis, ésta es:
Solución función
>>[t,y]=ode45(‘t’,[t0 tf],[y0],options)
Intervalo de
Rango donde se solución Cond. Inicial
calcula la solución
El método trabaja con tolerancia por defecto:
- Tolerancia relativa 1E-3

- Tolerancia absoluta 1E-6
Estos valores pueden cambiarse con el comando options. Definiendo:
>>options =odeset(‘reltol’1e-6,’abstol’,1e-8)
Los valores pueden cambiarse a los deseados. Este comando tiene más opciones que pueden ser
cambiadas.
Estos métodos son en general de paso variable, lo cual hace que la solución se conozca en puntos a lo
mejor no deseados. Si se quiere conocer la solución 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 Solución de una ecuación diferencial de primer orden
Este caso se resuelve mediante la aflicción 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 ecuación diferencial:
function z=f(t,y)
z =y
En este caso, la variable z es lo que devuelve la función 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 según
>> [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:
x' = y x(0) = 1
y ' = −x 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 x(0) = 1 x = y (1)

; es decir, , con t ∈ [0 2π]
y (1) = y ' = − x y (0) = 0 y = y ( 2)
Bajo el mismo principio que rige la formación de funciones vectoriales, el sistema puede formularse
matricialmente de la forma:
y ' = F (t , y ) ⎛ x⎞ ⎛ y ⎞ ⎛ y (2) ⎞ ⎛1⎞

y = ⎜ ⎟; F (t, y ) = ⎜ ⎟ = ⎜ ⎟; y0 = ⎜ ⎟
y (0) = y0 ⎝ y⎠ ⎝ − x ⎠ ⎝ − y (1) ⎠ ⎝ 0⎠
Con ello, el archivo generado es un vector de 2*1, que contiene las dos ecuaciones diferenciales que deben
resolverse simultáneamente, para luego aplicar el comando ode.
function z=F(t,y) 0.8
z=[y(2);-y(1)]; 0.6
0.4
0.2
-0.2
>> [t,y]=ode45('F',[0 2*pi],[1;0]);
>> plot(y(:,1),y(:,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
Caso 3: Una ecuación diferencial de orden superior, sea el PVI:
m ⋅ u ''+ b ⋅ u '+ k ⋅ u = f
U ( 0 ) = u0
u ' ( 0 ) = v0
Este caso es el más 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 ecuación en
función de la variable que tenga el mayor orden de la ecuación.
Sean:
u = y (1) ⇒ y (1) ' = u ' = y (2)
y (2) ' = y (1) '' = u '' = y (3)
Para los valores de k=15 kg/s2; m=1.2 kg; b= 0.3kg/s.
Caso 1: Resorte soltado del reposo y a 1 m de la posición de equilibrio
u (0 ) = 1
v(0 ) = 0
f − k ⋅ u − b ⋅ u'
u' ' =
m
donde y(1) : posición function z=Fla(t,y)

m=1.2;
y(2) : velocidad
b=0.3;
k=15;
z=[y(2);(-k*(y(1))-b*y(2))/m];
>> [t,y]=ode45('Fla',[0 60],[1;0]);

>> plot(t,y(:,1))
0.8
0.6
0.4
0.2
-0.2
-0.4
-0.6
-0.8
-1
0 10 20 30 40 50 60
Caso 2: f ( t ) = cos ( t )
0.15
function z=Flb(t,y)
m=1.2; 0.1
b=0.3;
0.05
k=15;
z=[y(2);(cos(t)-k*(y(1))-b*y(2))/m]; 0
-0.05
-0.1
>> [t,y]=ode45('Flb',[0 60],[0;0]);

>> plot(t,y(:,1)) -0.15
-0.2
0 10 20 30 40 50 60
k
Caso 3: f ( t ) = cos ( w ⋅ t ) con w =
m
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];
>> [t,y]=ode45('Flc',[0 60],[0;0]);

>> plot(t,y(:,1))
Ejemplo 7.1: Problema stiff

La idea del problema es comparar la eficiencia de los comandos ode45 y ode15s en la solución del
siguiente problema stiff:
y ' = α ( y − sin ( t ) ) + cos ( t )
y (0) = 1
y (t ) = e −α t + sin(t ) → solución analítica
α = 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 solución 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 solución 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 más eficiente en la resolución del problema stiff, pues usa
menos pasos. El error no es tan relevante, pues cambia muy poco, manteniéndose en la tolerancia deseada.
Ejercicios Resueltos
Temas 7 y 8
Ejercicio 1
Resolver usando el método de Newton Rhapson el sistema de ecuaciones no lineales
⎡ y = e− x ⎤
⎢ y ⎥
⎣x = e ⎦
Solución
Primero, reconocer la función a valor vectorial y la jacobiana del problema, que en este caso son::
⎡ y − e− x ⎤ ⎡e− x 1 ⎤
F =⎢ y ⎥
J =⎢ ⎥
⎣ x−e ⎦ ⎣1 −e y ⎦
Luego, se procede a ingresar las funciones al MatLab como ya se indicó. Notar que las funciones están de
la forma f(x,y)=0
Paso 1 : Ingresar función
>>G=inline(‘[x(2)-exp(-x(1));x(1)-exp(x(2))]’)
Paso 2 : Encontrar raíz aproximada (en este caso es posible hacerlo tratando algebraicamente la
función)
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 aproximación x0 compuesta del valor de x e y ingresados en un

vector. Nuevamente, el tratamiento no tiene sentido puesto que resolviendo esa ecuación 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 raçices, 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 más
fácil manejarlo como rutero.
Ejercicio 2
2
y = ex− x
Calcular el área encerrada por
( )
y = tan −1 x 2
Paso 1 : Graficar para encontrar una solución 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 intersección de las 2 curvas puede verse los puntos donde ambas ecuaciones se
intersectan.
Paso 2 : Definir f0, que es la función objetivo a resolver
>>f0=inline(‘exp(x-x.^2)-atan(x.^2)’;
La función objetivo está pensada en la idea de que el área será la función “grande” menos la
“chica” (cálculo 1-2)
Paso 3 : Encontrar raíces basándose en las aproximaciones encontradas antes.
>>a=fzero(f0,0.5)
>>b=fzero(f0,1)
0,5 y 1 salen de mirar el gráfico.
Paso 4 : Integrar
>>I=quad(f0,a,b)
Ejercicio 3
La ecuación de Blasius
2 f ' '+ f ⋅ f ' ' = 0 (η )

f (0 ) = 0
f ' (0 ) = 0
f ' (η ) → 1 cuando η → ∞
z : función dada al ODE, puede ser vector o escalar.

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 función
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 ecuación diferencial que genera el momento de la función. Ésta
se acopla en el archivo ingresado antes, con ello el sistema a resolver es:
θ ' (η ) = f ' (η )[1 − f ' (η )]

⎛ y (1) ⎞
⎜ ⎟
⎜ y (2)⎟
[t , y ] = y = ⎜ ⎟
y (3)
⎜ ⎟
⎜θ (2)⎟
⎝ ⎠
En MatLab, la implementación 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 raíz 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 distribución de la temperatura T se rige por la ecuación
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 térmica de la aleta (212 Btu/(hr*ft2*F)])
dT
Para x = 3 [ft] calcular la temperatura T, sabiendo que a x = 1[ft], T = 179 [F] y = 20 [ F / ft ] .
dx
Usar cualquier método visto en clases.
∂ 2T h
− (T − Ta ) = 0 h
∂x 2 k
70 °F
h = 2.5 Btu h⋅ ft 2 ⋅° F
k = 212 Btu h⋅ ft 2 ⋅° F
Ta = 70° F
k
x = 3 ft
T (1) = 179° F
∂T
= 20 ° F ft x=1 x=3
∂x x =1
Paso 1
T = y (1)
T ' = y ' (1) = y (2)
T ' ' = (T − Ta ) = ( y (1) − 70)

h h
k k
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 método de Adams Moulton.
Considere el problema mecánico 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 método implícito de Adams Moulton
de orden 1(Euler implícito), 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, evalúe: x1(2) y x2(4).
a) Realizar cambio de variables
y(1) = x1 y (3 ) = x2
• •
y(2 ) = x1 y(4 ) = x2
• •
y(1) = y(2 )
1
[− c1 y(2 ) − k1 y(1) − c2 (y(2 ) − y(4 ) ) − k2 (y(1) − y(3) )]
•
y( 2 ) =
m
•
y(3 ) = y(4 )
y( 4 ) =
1
m
[− c2 (y(4 ) − y(3) ) − k2 (y(3) − y(1) )]
y (1) = 2 y (3) = 1
y (2 ) = 0 y (4 ) = 0
b)
⎡ 0 1 0 0 ⎤
⎢ ⎥
⎢ h ( k1 + k 2 ) h ( c1 + c 2 ) hk 2 hc 2 ⎥ ⎡ y1, i + 1 ⎤ ⎡ y1, i ⎤
− − ⎢ ⎥ ⎢ ⎥
⎢ m1 m1 m1 m1 ⎥ ⋅ ⎢ y 2, i + 1⎥ = ⎢ y 2, i ⎥
⎢ 0 0 0 1 ⎥⎥ ⎢ y 3, i + 1⎥ ⎢ y 3, i ⎥
⎢ ⎢ ⎥ ⎢ ⎥
⎢ hk 2 hc 2 hk 2 hc 2 ⎥ ⎣ y 4, i + 1⎦ ⎣ y 4, i ⎦
⎢ − − ⎥
⎣ m2 m2 m2 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];
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 parabólico de una pelota de béisbol
La trayectoria de una pelota de béisbol que sale de un punto a un metro de altura se ha modelado por:
9.8
h( x) = tg (α ) ⋅ x 2 − +1
2 ⋅ v ⋅ cos 2 (α )
2
0
donde v0 es la rapidez inicial de salida y α es el ángulo de salida inicial.

Para v0 =[30 m/s], encontrar α de modo que, a 40 m de la base de lanzamiento, la pelota toque el suelo.
40
Para α=0.7, evalúe por el método más conveniente: I = ∫0
h( x 2 )dx
Solución
>> 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
Intersección de raíces.
Se desea encontrar TODOS los puntos de intersección de las curvas:
x2
y = 2 ( x − 0.9 ) − 1
2
y = 1− e
4
La mejor forma para hacerlo es despejar la variable y para después resolver una ecuación no lineal en x.
Escriba un programa en MatLab que resuelva el problema.
Indique el número de puntos de intersección en R y todos los puntos de intersección encontrados.
Solución
>> 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)
Creado: Noviembre 2004 – Revisión, Abril de 2005
diego.seiltgens@vtr.net roverdug@udec.cl

Apunte Numerico Lab PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Apunte Numerico Lab PDF

Cargado por

Copyright:

Formatos disponibles

Universidad de Concepción

Diego Seiltgens Sorrel

Tema 1: Algunos aspectos del MATLAB __________________________________________1

1.1 Comentarios Importantes _____________________________________________________ 1

Tema 2: Sistemas de ecuaciones lineales. __________________________________________4

2.1 Descripción general de los Métodos Directos ________________________________________ 4

Tema 3: Mínimos cuadrados ____________________________________________________9

3.1 Matriz QR_____________________________________________________________________ 9

Ejemplo 4.1: Comparación entre interpolación y ajuste de mínimos cuadrados ______________ 15

Tema 5: Integración numérica__________________________________________________20

5.1 Integración usando MatLab _____________________________________________________ 20

Tema 6: Ecuaciones no lineales._________________________________________________27

6.1 Métodos numéricos ____________________________________________________________ 27

Tema 7: Ecuaciones Diferenciales Ordinarias._____________________________________37

7.1 Concepto de problema stiff ______________________________________________________ 37

Ejercicios Resueltos Temas 7 y 8 ________________________________________________43

El MatLab (Matriz Laboratory) no es muy diferente a los lenguajes de programación C y ForTran. La

1.1 Comentarios Importantes

Las operaciones con estos números complejos son las siguientes:

Suma: >> e = a+b

Producto: >> p = a*b

Racionalización: >> r = a/b

Argumento normalizado: >>angle (a)

Conjugado: >> conj(a)

Módulo del complejo: >>abs(a)

b) Comandos sobre vectores: sea un vector v. Al aplicar:

length(v) : se obtiene el número de componentes del vector.

c) Comandos sobre matrices:

det (A) : devuelve el determinante de A

1.2 Opciones avanzadas de gráficos

El comando zoom puede manejarse desde la pantalla gráfica con la lupa.

Ginput: permite seleccionar puntos de un gráfico y llevarlos a un vector.

[x,y]=ginput(n) : elige n puntos de un gráfico; almacena en x la variable independiente y en y la

1.3 Algunas reglas prácticas de programación.

- El primer carácter debe ser una letra.

1.4 Manejo de archivos en Matlab.

Caso 1: Generación y carga de archivos en MatLab.

>>save matriz A % guarda la matriz A en un archivo .m llamado matriz

En general, el comando opera de la siguiente forma.

Caso 2: Generación de archivos desde MatLab para abrir en EXCEL.

- MatLab siempre trabaja en radianes, cuando se utilizan funciones trigonométricas.

Clear : limpia la memoria

El cuadro resumen a continuación presenta los métodos iterativos a trabajar:

Métodos Indirectos G.S.

2.1 Descripción general de los Métodos Directos

- Eliminación Gaussiana (M.E.G.)

Y el sistema a resolver es: (R*Rt)*x=b

2.2 Condicionamiento de una matriz y propagación de errores de redondeo

>>u = cond (A)

2.3 Métodos indirectos

2.3.1 Matrices full y sparse.

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

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

2.3.2 Descripción general de métodos iterativos

2.3.2.1 Método de Jacobi

Para construir la matriz de iteración J:

2.3.2.2 Método de Gauss Seidel

El método converge cuando la matriz es simétrica y definida positiva.

2.3.2.3 Test de detención

2.3.2.4 Método del Gradiente Conjugado

¿Cómo construir una matriz simétrica y definida positiva?

~ = A T ⋅ A , con A matriz no simétrica.

En MatLab el comando que se usa es

Y el sistema a resolver es: (RRt)x=b