Guía de Estudio

Mtodos Numricos
Romina Cardo & lvaro Corvaln

METODOS NUMERICOS GUA DE ESTUDIO

Prrafo Preliminar

Las pginas que siguen intentan servir de gua para el estudio de un primer curso de Mtodos Numricos, en el
sentido clsico de recurrir a linealizar mtodos que tratan generalmente con variables continuas usualmente
discretizadas- (tratando de prestar atencin a las limitaciones inherentes a la representacin numrica de los
mismos).
La implementacin efectiva de los algoritmos est orientada al entorno Matlab, y muchos ejemplos y ejercicios son
planteados (y muchas veces resueltos) en dicho entorno. Sin embargo, su uso fluido, est sobreentendido ya que
este no es un manual de Matlab-, y remitimos a la bibliografa sugerida en el curso y/o a la documentacin propia del
mismo, para cualquier duda o explicacin sobre este.

Mtodos Numricos

Aritmtica de punto flotante

Debido a las dificultades para trabajar con una representacin numrica que abarque a todos los nmeros reales, es
habitual el uso de sistemas en los que se puede representar y operar con sus elementos un subconjunto finito de
IR. Los ms frecuentes son los de aritmtica de punto flotante:
Fijada una base de numeracin b (generalmente b = 2, pero para operar a mano muchas veces daremos ejemplos
con b = 10), se representan exactamente aquellos nmeros cuya expresin con base b es de la forma:
p
m
b a a a x = ... . 0
2 1
con m j b a a
j
,..., 2 para } ,..., 1 , 0 { , 0
1
= , R p r donde r y R son nmeros enteros, 0 = x
(la representacin del 0 se hace aparte). Se pide que 0
1
a para evitar el que haya distintas representaciones de un
mismo nmero (ya que por ejemplo:
5 3 2
10 00023 . 0 10 02300 . 0 10 23000 . 0 23 = = = ; pidiendo 0
1
a solo es vlida
la primera representacin:
2
10 23000 . 0 23 = .

En binario es particularmente elegante, ya que como 0
1
a debe ser 1
1
= a (y m j a a
j j
,..., 2 para , 1 , 0 = = = ), por
lo que el 0.1 inicial se presupone siempre, de modos que slo hace falta guardar en memoria el contenido de m-2
bits para los dgitos 1 0 de
m
a a ,...,
2
, junto a un bit adicional para el signo, y se suelen elegir r y R de modo que
1 2 =
k
r R , de modo que haya
k
2 exponentes posibles para la base 2, y ello se puede guardar entonces con k
bits (sin desperdiciar combinaciones), frecuentemente ) 1 2 ( y 2
1 1
= =
k k
r R , por ejemplo r = -31, R = 32 (y por lo
tanto 32 31 p ). O sea que cualquier nmero de la forma
p
m
a a a x 2 ... . 0
2 1
= con 0
1
a y 2 para } 1 , 0 { > j a
j

se representa con exactamente k m- + 1 bits.

Escribamos algunos de los nmeros de punto flotante con alguna eleccin de b,m,r y R para observar sus
caractersticas: Si b es 10, m es 3, r es -4 y R es 5, podemos representar exactamente los siguientes nmero
positivos (y adems sus opuestos y el 0) a la izquierda en punto flotante, y a la derecha en notacin usual):
7
4
4
4
10 0000001 . 0 : os consecutiv nmeros entre diferencia
0000999 . 0 10 999 . 0
...
0000101 . 0 10 101 . 0
0000100 . 0 10 100 . 0
=
=
=

6
3
3
3
0009990 . 0 10 999 . 0
...
0001010 . 0 10 101 . 0
0001000 . 0 10 100 . 0
=
=
=

Mtodos Numricos

2
1
1
1
99 . 9 10 999 . 0
...
01 . 1 10 101 . 0
1 10 100 . 0
=
=
=

2
5
5
5
10 100 : os consecutiv nmeros entre diferencia
99900 10 999 . 0
...
10100 10 101 . 0
10000 10 100 . 0
=
=
=
=

Notamos que la distancia entre nmeros consecutivos va aumentando cuando aumenta el rango decimal de nmeros
considerados.
Los mil primeros nmeros representables entre el menor nmero positivo representable exactamente:
-llmmoslo min = 0000100 . 0 10 100 . 0
4
=

- y el milsimo: 0001000 . 0 10 100 . 0
3
=

distan uno del otro en
0000001 . 0 (un diezmillonsimo)
Los ltimos mil nmeros representables estn separados de 100 en 100 (10000, 10100, , 99800, 99900).
Precisamente 99900 es el mayor nmero representable. Lllammoslo max = 99900.
Los nmeros entre 0000100 . 0 10 100 . 0
4
=

y 99900 10 999 . 0
5
= se redondean al nmero representable ms
prximo.
De esta manera, en esta aritmtica de punto flotante, si bien, por ejemplo, los nmeros
5
10 745 . 0 74500 = y
2
10 230 . 0 23 = son representables exactamente, no lo es su suma. De hecho, si por abuso de notacin denotamos
con + el resultado en punto flotante de la suma de dos nmeros, entonces 74500 23 74500 = + . En efecto,
realmente es
5
10 74523 . 0 74523 23 74500 = = + , que no es representable exactamente, estando entre
74600 10 746 . 0 y 74500 10 745 . 0
5 5
= = que s son representables. Y el ms cercano a 74523 es el menor de ellos:
74500 10 745 . 0
5
= , y por ello en esta aritmtica de punto flotante es: 74500 23 74500 = + . El menor nmero
positivo que, representable en aritmtica de punto flotante que sumado a 74500 no da como resultado 74500 es 100,
o sea 100 10 100 . 0
2
= . Se dice que 100 es el psilon de mquina de 74500. De hecho es el psilon de mquina de
todos los nmeros representables entre 10000 y 99900.
De anloga manera,
7
10 0000001 . 0

= es el psilon de mquina de 0000100 . 0 10 100 . 0
4
=

y de todos los nmeros
entre 0000100 . 0 10 100 . 0
4
=

y 0000999 . 0 10 999 . 0
4
=

. Por su parte, el psilon de mquina del 1 (y de todos los
nmeros entre
1
10 100 . 0 00 . 1 1 = = y
1
10 999 . 0 99 . 9 = es
1
10 100 . 0 01 . 0 = .
Mtodos Numricos

Los nmeros comprendidos entre min y max se redondean al nmero representable ms prximo: Por ejemplo
7 . 34 10 347 . 0 a redondea se 72 . 34 10 3472 . 0
2 2
= = , y 8 . 34 10 348 . 0 a redondea se 78 . 34 10 3478 . 0
2 2
= = ,
igualmente etc , 34.7499999 34.7499, , 749 . 34 se redondean a 34.7, y en cambio 34.7501, 34.750001, 34.7500001, etc,
se redondean a 34.8. Por simetra, 34.75 se redondea a 34.8 (es decir hacia arriba) as la mitad de los dgitos x
despus del fin de la mantisa representada en este caso 0.347x- se redondean hacia abajo (0,1,2,3,4) y la otra
mitad hacia arriba (5,6,7,8,9).
El error absoluto de redondeo al asignar a un nmero el representable ms prximo depende de en qu rango est,
de modo que si estamos entre 10000 y 99900, podemos cometer un error de redondeo de hasta 50 100
2
1
=
unidades, por ejemplo
5
10 2435 . 0 24350 = se redondea por
5
10 244 . 0 24400 = con un error de 50, que
evidentemente es la mitad del psilon de mquina para el rango de 10000 a 99900.
Por su parte, el error absoluto al redondear
2
10 2435 . 0 35 . 24 = por
2
10 244 . 0 4 . 24 = es 05 . 0 1 . 0
2
1
= que
evidentemente es la mitad del psilon de mquina para el rango de 10.0 a 99.9.
Sin embargo el error relativo es el mismo en ambos casos. Si, para normalizar, calculamos los errores relativos al
menor nmero del rango (10000 en el primer caso, 10.0 en el segundo), este es 0.01
2
1
10
1 . 0
2
1
10000
100
2
1
=
, es decir la
mitad del psilon de mquina del 1. Es decir que el psilon de mquina del 1 es una caracterstica de la aritmtica de
punto flotante considerada, y no depende del rango de valores en que est el nmero a redondear (siempre que est
entre min y max).
Por eso, al psilon de mquina del 1 lo llamamos directamente psilon de mquina (propiamente dicho).
Una operacin que da un resultado mayor que max (o menor que -max), se dice un sobreflujo, y debe indicarse de
alguna manera. En Matlab, por ejemplo, se retorna Inf (por infinito).
Por ejemplo:
>>1.7*10^308+1.7*10^308
ans =
Inf
Una operacin que da un nmero positivo entre min y 0 (o un negativo entre -min y 0) se dice un subflujo. Los
subflujos no siempre son anunciados. En Matlab se devuelve 0 sin ninguna advertencia.
Por ejemplo:
>> 10^-323-0.8*10^-323
ans =
0
En Matlab, las constantes importantes de la aritmtica de punto flotante pueden obtenerse invocando realmax (lo
que llamamos max), realmin (lo que llamamos min), eps (el psilon de mquina propiamente dicho, es decir el
de 1). La funcin eps() da el psilon de mquina de un numero cualquiera.
Ejercicio
Con la aritmtica de punto flotante mencionada arriba calcule:
i) 40+(60+10000)
Mtodos Numricos

ii) (40+60)+10000
Qu conclusiones puede sacar de ello?
Normas vectoriales y matriciales

La mayora de los problemas que somos capaces de tratar numricamente, lo son, total o parcialmente, mediante
linealizacin. Es decir que en algn punto se aproximan por un modelo lineal.

Es por eso que en muchos paquetes numricos se recurre a libreras de algoritmos de lgebra matricial. En particular
Matlab es esencialmente una interfaz para acceder a las libreras LINPACK y EISPACK.

Algunas cuestiones que en lgebra lineal exacta estn definidas con precicn son algo ms borrosas en lgebra
lineal numrica.
Por ejemplo:
A=[1 1+eps;1+eps 1+2*eps]; (donde eps es el psilon de mquina) es una matriz de rango 1, porque las filas de la
matriz son l.i. El determinante de la matriz es:
1 * (1+2*eps)- (1+eps)*(1+eps) = 1+2*eps-1-2*eps-2*eps^2 = -2*eps^2 0.
Pero numricamente: >> (1+eps)*[1 1+eps]-[1+eps 1+2*eps]

ans =

0 0
Es decir que las filas son numricamente l.d.
Y de hecho el rango de la matriz (numricamente, en Matlab) es 1.
Es entonces necesario poder medir cundo dos vectores o matrices son casi iguales, casi nulas, casi l.d..
Para ello introducimos mtricas mediante normas vectoriales y matriciales.
En
xn nx n
IR IR IR
1 1
estn disponibles las normas p: ( )
p
p
n
p
p
n
a a a a
/ 1
1 1
... ) ,..., ( + + = para < p 1 , y
( )
n n
a a a a ,..., max ) ,..., (
1 1
=
. La norma ms frecuente es la eucldea (o usual), correspondiente a p = 2.

Se puede probar que todas las normas p son comparables entre s (cada una mayora a algn multiplo positivo de
cualquier otra), pero para determinada cuestin una u otra puede ser ms natural. La norma del vector fila o columna
X puede invocarse en Matlab con: norm(X,p) (naturalmente, como p = 2, es la usual, norm(X) es igual que
norm(X,2).

Para las matrices slo se define AX A
p
X
p
1
max
=
= , pero el clculo efectivo en general es difcil (por la maximizacin),
por lo que estn disponibles solamente:
La norma 2: norm(A) norm(A,2).
La norma 1: norm(A,1) que resulta la mayor de las sumas de los valores absolutos de los elementos de las
columnas.
La norma : norm(A,Inf) que resulta la mayor de las sumas de los valores absolutos de los elementos de las filas.
Mtodos Numricos

La norma de Frbenius: norm(A,fro), que consiste en la raz cuadrada de la suma de los cuadrados de todos los
elementos de la matriz.
Mtodos Numricos

Descomposiciones matriciales

A continuacin veremos que, en muchas circunstancias, es posible escribir una matriz como productos de matrices
que, en algn sentido son ms sencillas o ms manejables. E iremos viendo que propiedades de la matriz original
podemos abstraer de ellas y que aplicaciones podemos darle. De hecho, posiblemente ya conozcamos previamente
alguna descomposicin. Por ejemplo, si la matriz cuadrada A, de n x n, tiene n autovectores linealmente
independiente, es posible escribir a A como:
1
* *

= C D C A , donde D es una matriz diagonal, tal que los elementos
de la diagonal satisfacen que
j jj j
C D C A * * = , donde el escalar
jj
D es el j-simo elemento de la diagonal de D y el
vector (columna) es la j-sima columna de C (por lo tanto las columnas de C son una base de autovectores de C).
Recordemos que a pesar de su importancia, la diagonalizacin de una matriz
1
* *

= C D C A (con
|
|
|
|
|
|
|
|
|
|
\
|
|
|
|
|
|
|
|
|
|
\
|
|
|
|
|
|
|
|
|
|
\
|
= . .........
1 n
C
E
V
O
T
U
A
C
E
V
O
T
U
A
C
y
|
|
|
|
|
|
|
|
|
\
|
=
L
A
V
O
T
U
A
D
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
) tiene el inconveniente de que no puede hallarse para todas las matrices cuadradas,
y ni si quiera definirse para las rectangulares.

Como sustituto existe la descomposicin en Valores Singulares (SVD: Singular Value Decomposition):

Dada
nxk
R A ,
nxn
R U ,
nxk
R S y
kxk
R V tales que :

U es ortogonal de nxn (o sea '
1
U U U
t
= =
pues en Matlab la traspuesta es la tilde vertical),

V es ortogonal de kxk (o sea '
1
V V V
t
= =
)
Mtodos Numricos

S es seudodiagonal de nxk (mismo tamao de A) , o sea,
|
|
|
|
|
|
\
|
=
0 . . . 0 0 0 0 0 0
. . . 0 . 0 0 0
. . . 0 0 . 0 0
. 0 0 0 0 0 . 0
0 . . . 0 0 0 0 0 0
11
nn
s
s
S si k>n ,
o,
|
|
|
|
|
|
|
|
|
|
|
|
|
|
\
|
=
0 . . . 0
. .
. .
. .
0 . . . 0
0 0 0 0
0 . 0 0 0
0 0 . 0 0
0 0 0 . 0
0 0 0 0
11
nn
s
s
S si n>k , o
|
|
|
|
|
|
\
|
=
nn
s
s
S
0 0 0 0
0 . 0 0 0
0 0 . 0 0
0 0 0 . 0
0 0 0 0
11
si n=k ; con 0 ....
22 11
s s donde
,..... ,..., ,
22 11 ii
s s s se llaman VALORES SINGULARES, vale que:
' * * V S U A = (o sea
1
* *

V S U ya que
1
'

= V V , de forma anloga a la diagonalizacin).

Proposicin: cond(U)=1 y cond(V)=1 .
(con Matlab el nmero de condicin se calcula con el comando cond, y para U y V es 1 , ya que son matrices ortogonales).

Recordemos que el Nmero de Condicin es el mayor factor por el que se pueden llegar a multiplicar los errores relativos al
aplicarle la matriz a un vector.
>
>
= = =
n k si
s
s
o
k n si
s
s
valor mnimo
valor mximo
S cond A cond
nn
kk
11
11
singular
singular
) ( : ) ( .

Si A es cuadrada, esto coincide con la definicin anterior,
Si A es rectangular, la igualdad anterior ) ( : ) ( S cond A cond = se toma como la definicin de cond(A) (y en cualquier caso,
numricamente siempre se calcula as ).

Practicamos con el Matlab, y abrimos la aplicacin eigshow, poniendo:
>> eigshow (en la ventana de comandos) as abre la aplicacin con la primera matriz de una galera de matrices.
Mtodos Numricos

Observacin: >> eigshow (A) con A una matriz de 2x2 , abre la aplicacin con la matriz que le damos.

Default
eig/svd con xe y perpendiculares siempre, hacemos un click all para que quede
svd/eig as grafica svd
Cuando Ax y Ay tambin son perpendiculares, all tenemos el cambio de base de la svd, y las longitudes de Ax y Ay son
11
s y
22
s
(los valores singulares de la diagonal de S).
Ax y Ay (o viceversa representan la mxima dilatacin o contraccin, y por eso el cociente mide el mayor factor por el
que puede multiplicarse el error relativo al multiplicar por A, y por eso
22
11
) ( : ) (
s
s
S cond A cond = = .
En Matlab el comando svd trabaja como el comandoeig (que da autovectores y autovalores ) recordemos:
>> eig (A) da los Autovalores si A es cuadrada
n
.
.
1
diagonal de D
anlogamente:

>> svd (A) da los Valores Singulares
) (
.
.
11
nn kk
s o s
s
diagonal de S.
Mtodos Numricos

>> [Matriz 1 , Matriz 2]=eig(A) , donde Matriz 1=
|
|
|
\
|

da C= la matriz de autovectores (en columna) , y,
Matriz 2=
|
|
|
|
|
|
\
|
n
0 0 0 0
0 . 0 0 0
0 0 . 0 0
0 0 0 . 0
0 0 0 0
1
da D= matriz de Autovalores.
Anlogamente,
>> [Matriz 1 , Matriz 2 , Matriz 3 ]=svd(A) , donde Matriz 1=
|
|
|
\
|

da
nxn
R U
Matriz 2
|
|
|
|
|
|
|
|
|
|
|
|
|
|
\
|
=
0 . . . 0
. .
. .
. .
0 . . . 0
0 0 0 0
0 . 0 0 0
0 0 . 0 0
0 0 0 . 0
0 0 0 0
11
kk
s
s
o,
|
|
|
|
|
|
\
|
=
0 . . . 0 0 0 0 0 0
. . . 0 . 0 0 0
. . . 0 0 . 0 0
. 0 0 0 0 0 . 0
0 . . . 0 0 0 0 0 0
11
nn
s
s
S da S= matriz de Valores Singulares

Matriz 3 =
kxk
R V .
Planteamos un pequeo ejercicio consistente en tomar una matriz aleatoria de 9x5, hallar la svd y verificar las propiedades.
Su resolucin sera:
>> A=randn(9,5) da una matriz de 9x5 cuyos coeficientes estn elegidos al azar con distribucin normal estndar
>> [U,S,V]= svd (A)
Mtodos Numricos

|
|
|
\
|
= U
|
|
|
\
|
= S
|
|
|
\
|
= V
>> ' *U U
|
|
|
\
|
1 . 0
0 . 0
0 . 1
la matriz identidad de 9x9 !! Y as confirmamos la ortogonalidad de U.
>> ' *V V
|
|
|
\
|
1 . 0
0 . 0
0 . 1
la matriz identidad de 5x5 !! Y as confirmamos la ortogonalidad de V.
>>cond(U)
1 verificamos que U tiene condicin 1

>>cond(V)
1 verificamos que V tiene condicin 1

>>cond(S)
.
>>cond(A)
.
>>S(1,1)/S(5,5)
dan los tres igual!!!! Y as verificamos que
singular
singular
) ( : ) (
valor mnimo
valor mximo
S cond A cond = = .
Mtodos Numricos

-----------------------------------------------------------------------------------------------------------------------------------------------------

Ahora ingresemos una matriz (tipo) A

1.0000 2.0000 4.0000
1.0001 2.0002 4.0003
5.0005 10.0009 20.0020
100.0010 200.0030 400.0040
10.0001 20.0002 40.0005
7.0000 8.0000 9.0000

>> A=[1 2 4;1.0001 2.0002 4.0003;5.0005 10.0009 20.0020;100.001 200.003 400.004;10.0001 20.0002 40.0005;7 8 9]

A =

1.0000 2.0000 4.0000
1.0001 2.0002 4.0003
5.0005 10.0009 20.0020
100.0010 200.0030 400.0040
10.0001 20.0002 40.0005
7.0000 8.0000 9.0000

Y observamos que es de rango completo, poniendo:

>> rank(A)
3
Pero mirndola uno dira que las 5 primeras filas son casi l.d. (linealmente dependientes), es decir, que son casi mltiplos de
la primera, y que en este caso uno puede dar a ojo una matriz A
~
prxima a A, pero de rango 2 :

(
(
(
(
(
(
(
(
=
9 8 7
40 20 10
400 200 100
20 10 5
4 2 1
4 2 1
~
A
En una matriz ms grande eso podra ser til, por ejemplo para comprimir la informacin (A tiene 18 coeficientes, pero para
recordar A
~
slo tengo que guardar 10 nmeros): 1,2,4,1,5,100,10,7,8 y 9 pues:
Mtodos Numricos

|
|
|
|
|
|
|
|
\
|
9 8 7
4 2 1
10 ) 1 (
100 ) 1 (
5 ) 1 (
1 ) 1 (
1
fila
fila
fila
fila
fila

Pero hacerlo a ojo en una matriz ms grande es difcil.

Observemos que:

>> svd (A)
ans =
461.3432
5.3119
0.0002

O sea que:

(
(
(
(
(
(
(
(
=
0 0 0
0 0 0
0 0 0
0002 . 0 0 0
0 3119 . 5 0
0 0 3432 . 461
S

Tambin S de rango 3, de hecho rango(S)=rango(A) siempre!!

Ms an, internamente Matlab calcula el rango de cualquier matriz contando cuntos valores singulares (elementos de la
diagonal de S ) son 0 . (numricamente es mucho ms rpido que verificar independencia lineal de filas o columnas)

Mtodos Numricos

Ahora es fcil encontrar una matriz parecida a S pero de rango 2 :

>> [U,S,V]= svd (A)
>> S(3,3)= 0 pongo en 0 el coeficiente 0.0002 que era despreciable respecto de 3432 . 461 y de 3119 . 5 .

(
(
(
(
(
(
(
(
=
0 0 0
0 0 0
0 0 0
0 0 0
0 3119 . 5 0
0 0 3432 . 461
Scambiada
Entonces:
>> Aaprox=U*Scambiada ' *V queda de rango 2 y lo verificamos haciendo:
>> rank(Aaprox)
2 y es casi igual a A.
Esta idea de mandar a 0 a los elementos de S que sean despreciables y obtener Aaprox haciendo ' * * V S U con la S retocada
sirve para una matriz cualquiera, aunque no sea fcil hacerlo a ojo.
Adems, como las filas y columnas de ceros no aportan nada, slo necesitamos guardar: (si decidimos conservar los primeros
ele valores singulares)
U
~
=primeras ele columnas de U
ll
s s s ,..., ,
22 11
(el cuadradito de S de ele x ele)
V
~
= primeras ele columnas de V
Y de todos modos U
~
(de nxl) * S
~
(delxl)* '
~
V (de lxk)= Aaprox (de nxk) del mismo tamao que A (de nxk) pero de rango l.
Enseguida programaremos una funcin que reciba como entrada A y l, y que devuelva la Aaprox de rango l, y otra funcin que
reciba A y con 1 0 y devuelva l tal que sea el menor tal que: si j>l entonces
11
.s s
jj
< , y lo usaremos para
comprimir imgenes.
********************************************************************************************************
Mtodos Numricos

Primero armamos tres funciones de Matlab:

La primera recibe una matriz A y un nmero 1 0 , y devuelve el ndice del ltimo valor singular (ordenados de mayor a
menor) tal que es mayor o igual que cierto nmero, vemoslo:

function ele=nivel(A, epsilon)
v=svd(A);
j=1;
while( j<=max(size(v)) && v(j)>=epsilon*v(1))
j=j+1;
end
ele=j-1;

Por ejemplo, si A tiene valores singulares:
04 . 0
8 . 0
2 . 1
5
9
14
37
64
nivel(A, 0.1) es 4 ( porque
9
14
37
64
y
son 4 . 6 64 * 1 . 0 = )
Y nivel(A, 0.01) es 7 ( porque
8 . 0
2 . 1
5
9
14
37
64
y
son 64 . 0 64 * 01 . 0 = )

La siguiente funcin calcula la descomposicin SVD pero reducida a una cantidad dada ele de valores singulares:

function [Ur,Sr,Vr]=svdr(A,ele)
[U,S,V]=svd(A);
Ur=U(:,1:ele); % primeras ele columnas de U
Vr=V(:,1:ele); % primeras ele columnas de V
Sr=S(1:ele,1:ele); % primeras ele filas y columnas de S
Mtodos Numricos

La tercera funcin calcula la matriz de rango ele ms prxima a una matriz A:

function Aap=aproxima(A, ele)
[Ur,Sr,Vr]=svdr(A, ele);
Aap=Ur*Sr*Vr';
Y ensayamos el funcionamiento en una matriz tipo:
|
|
|
|
|
|
|
|
\
|

3 11 4 2
1 3 5 7
14 003 . 8 4 2
35 20 01 . 10 5
02 . 70 40 20 10
7 4 2 1
.

Dijimos que lo usaramos para Compresin de Imgenes:

Descargamos del lirweb el archivo con la imagen de prueba: lena.bmp en .. mis documentos\MATLAB

La importamos como una matriz de nmeros reales (por defecto es tipo entero pero svd solo puede usarse con matrices de
tipo real) La instruccindouble transforma los enteros en tipo punto flotante de doble precisin, ponemos:

>>L=double(imread('lena.bmp'));
>>image(uint8(L))
axis equal

(uint8 la vuelve a poner en tipo entero para graficar es necesario-) 16 16.000.0
47 47.000.0 etc.
Uint8 es por tipo entero (int = integer), sin signo u (de unsigned), de 8 bits (de 0 a 1 2 255
8
= ).

En realidad
3 512 512 x x
R L (o sea, que son 3 matrices una para cada color, por ejemplo: la 1era es el rojo ) .
Es R G B por red-green-blue.

Mtodos Numricos

>> copia de L=L;
)
`
0; * ,3) : , L(: de copia = ,3) : , L(: de copia >>

0; * ,2) : , L(: de copia = ,2) : , L(: de copia >>
en copia de L mandamos a 0 las intensidades de verde y azul.
>>image(uint8(copia de L))
axis equal se ve como si tuviramos anteojos rojos.
>>nivel(L(: ,:,1), 0.01) % buscamos cuntos valores singulares son mayores al 1% del mayor en cada color
56
>>nivel(L(: ,:,2), 0.01)
81
>>nivel(L(: ,:,3), 0.01)
106
>>Lap(: ,:,1)=aproxima(L(: ,:,1), 56); %Hicimos la cuenta que resulta que podramos guardar la imagen con nivel de
precisin del 99% usando 30% del tamao de los datos originales.
>>Lap(: ,:,2)=aproxima(L(: ,:,1), 81);
>>Lap(: ,:,3)=aproxima(L(: ,:,1), 106);
>>image(uint8(L))
axis equal
figure(2)
>>image(uint8(Lap))
axis equal %Graficamos las 2 figuras y vemos que se parecen mucho, aunque vistas con el zoom se ve que
se perdi un poco de nitidez

Las descomposiciones matriciales que siguen, en lugar de usarse para analizar A en una base adecuada (como la svd y la
diagonalizacin), se usan para resolver sistemas lineales:

Factorizacin L-U:

Dada
nxn
R A , P y U L, con L triangular inferior , U triangular superior y P de permutaciones tales que P*A=L*U (se
puede mencionar apenas que P y L corresponden a las operaciones al hacer Gauss y U es la triangular).

Entonces un sistema Ax=b se puede resolver as:
Mtodos Numricos

Esquema: Ax=b
PAx=Pb
LUx=Pb
Y llamando w=Ux se resuelve: Lw=Pb (con L triangular inferior) y
obtenido w, resolviendo Ux=w (con U triangular superior) hallamos x.

Entonces proponemos hacer tres funciones:
Una que resuelva sistemas con matriz triangular inferior, la segunda que sigue que resuelva sistemas con matriz triangular
superior, y la tercera que resuelva un sistema cualquiera usando el esquema anterior.

Veamos la primera:

function x=resuelveL(L,c) % para Lx=c
x(1,1)=c(1)/L(1,1);
for j=2:max(size(c))
x(j,1)=(c(j) -L(j,1: j-1)*x(1: j-1 ,1))/L(j,j);
end

********************************************************************************************************
Recordemos que la descomposicin LU nos permite resolver un sistema con matriz cuadrada arbitraria, en un problema de
resolucin de sistemas triangulares mediante: P A=L*U, por lo tanto:
El esquema es: Ax=b
PAx=Pb
LUx=Pb
Y si w es solucin de Lw=Pb (con L triangular inferior) entonces x es solucin de Ux=w (con U triangular superior)
la misma x tal que Ax=b
y reescribiramos la funcin que resuelve con matrices triangulares inferiores:
function x=resuelveL(L,c)
x(1,1)=c(1,1)/L(1,1);
x(j,1)=(c(j) -L(j,1: j-1)*x(1: j-1 ,1))/L(j,j);
end
Ahora podemos usar sta funcin para resolver (tambin) sistemas triangulares superiores :

function x=resuelveU(U,w)
x=flipud(resuelveL(flipud(fliplr(U)),flipud(w)));

Y ahora un sistema cualquiera se resuelve mediante una funcin que aplique el esquema:
Mtodos Numricos

function x=resuelve(A,b)
[L,U,P]=lu(A)
x=resuelveU(U, resuelveL(L,P*b));

La ltima lnea corresponde al esquema de resolucin por LU , y si, como ocurre muchas veces uno resuelve
1
b Ax = ,
2
b Ax = ,
3
b Ax = ,. con distintos .. ,......... , ,
3 2 1
b b b pero la misma A. Entonces vale la pena hacer:
[L,U,P]=lu(A) ; y guardar L,U y P , y para cada
i
b usar la lnea : x=resuelveU(U, resuelveL(L,P*
i
b ));

Ejercicio:

a) Elegir una matriz aleatoria A grande (por ejemplo de 200 x 200 con randn) y un vector b fcil de verificar, por ejemplo:
b=(1:200) o sea:
|
|
|
|
|
|
|
|
|
\
|
=
200
.
.
.
3
2
1
b . Hallar b x A = con las funciones anteriores y verifique (Ax debe dar =b)

b) Comparar el tiempo que demora resolver
1
b Ax = ,.,
20
b Ax = para 20 vectores columnas al azar:
) 1 , 200 ( randn b
j
= (con un ciclo for ) , por un lado resolviendo con stas funciones pero sin guardar L , U y P, y por otro lado,
guardando L, U y P y ejecutando para cada
i
b la instruccin:
>> x=resuelveU(U, resuelveL(L,P*b))

Con

>> Tic
.
>> instrucciones
.
>> toc
Matlab devuelve el tiempo de CPU que demoran las instrucciones entre TIC y TOC.

Observacin: cond(P)=1 y luego cond(P*A)=cond(A)=cond(L*U) cond(L) . cond(U).
Mtodos Numricos

Otra factorizacin que permite resolver sistemas es la Q-R:

Dada
mxn
R A ,
mxm
R Q ortogonal (o sea
t
Q Q =
1
),
mxn
R R triangular superior y
nxn
R P de permutaciones
tales que A*P=Q*R (obsrvese que ahora P multiplica a derecha en LU era a izquierda).

Esto tiene aplicacin para resolver sistemas cuadrados, pero tambin rectangulares (aunque por un rato no nos preocuparemos
por especificar qu significa resolver un sistema que no sea cuadrado).

El esquema ahora sera as: { b x A = . Llamando x=P*z , tenemos
{ b x A = . { b APz = { b QRz = { b Q Rz = ' (
t
Q Q =
1
) luego obtengo z resolviendo el sistema con R
triangular superior, entonces: x=P*z

Ejercicio: Programar la resolucin con qr

El esquema para resolver se puede programar as:

( Observacin: [Q,R,P]=qr(A) es la sintxis de Matlab para hallar la descomposicin QR )

function x=resuelve_con_qr (A,b)
[Q,R,P]=qr(A) ;
z=resuelveU(R,Q *b) ; la misma que ya programamos para sistemas triangulares superiores
x=P*z

Ej: Podemos probarlo con la misma A=randn(200,200) y b=(1:200) de antes.

Observacin:
cond(Q)=1 y cond(P)=1 (por ser respectivamente ortogonal y de permutaciones).

As que cond(A)=cond(R).

Aqu tenemos controlado el nmero de condicin.

Ahora vamos a pensar en qu sentido podemos resolver un sistema no-cuadrado.
Mtodos Numricos

Primer Caso: Ms ecuaciones que incgnitas (sistema sobredeterminado)
Primer Ejemplo Motivador:
Dada una tabla:
k k
y x
y x
y x
y x
y x
. .
. .
3 3
2 2
1 1

Se pide: Hallar la recta c ax y + =
~
tal que la distancia a los puntos de la tabla sea mnima:

.
.
. .
1
. .
. .
1
1
2
1
2
1
|
|
|
|
|
|
\
|
=
|
|
\
|
|
|
|
|
|
|
\
|
k k
y
y
y
c
a
x
x
x
tendra solucin exacta si los puntos estaran alineados
Ax=b
Como en general NO lo estn, el sistema no tiene solucin.
Idealmente sera Ax-b=0 y por lo tanto, 0
2
2
= b Ax . Lo que entendemos como solucin aproximada de cuadrados
mnimos es
|
|
\
|
=
c
a
x tal que 0
2
2
b Ax sea mnima.

Cmo hallamos esa solucin de cuadrados mnimos en general ? mn
2
2
b Ax

( Ntese que esto puede pedirse para un sistema con
mxn
R A con m>n )
-Asociado o no al ejemplo motivador de la recta del mejor ajuste-

Estamos buscando el mnimo de (Ax-b) . (Ax-b) siendo . el producto escalar.
Ahora, seguramente habrn visto en Clculo Avanzado que:
i i i
dx
x dv
x u x v
dx
x du
dx
x v x u d ) (
). ( ) ( .
) ( )) ( ). ( (
+ =
Entonces:
Mtodos Numricos

0 ) ( .
'
. 2
) ).( (
2
)) ).( ((
= =

=

b Ax
A de i fila o
A de i columna
dx
b Ax b Ax d
dx
b Ax b Ax d
i i
si es mnimo debe ser 0
) (
=
i
dx
d

y debe ser 2. A * (Ax-b)=0 A * Ax-Ab=0 A * Ax=Ab
Entonces hay que resolver un sistema (que es cuadrado!!)

Entonces, si A * A tiene rango completo, una primera manera de resolver el problema es usar los mtodos que tenamos para
resolver sistemas cuadrados para resolver A * Ax=A * b.

Ejercicio:
Con la tabla
2 . 615 1 . 20
1 . 328 . 5 . 10
8 . 161 . 1 . 5
5 . 95 8 . 2
0 . 54 5 . 1
3 . 16 21 . 0
y x

a) Hallar la recta de cuadrados mnimos
b) Graficar la recta x/ ymc=ax+c con a y c hallados antes , y junto con los puntos de la tabla para ver si es verosmil.
c) Hallar la diferencia (en norma 2) entre la recta y los puntos :
2
y y
mc

********************************************************************************************************

Mtodos Numricos

Recordemos que si tenemos un sistema sobredeterminado: Ax=b con
mxn
R A , con m>n (ms ecuaciones que
incgnitas) y A de rango completo, entonces la solucin (aproximada) de cuadrados mnimos ( o sea,
1 nx
R x /
2
b Ax sea
mnima), coincide con la solucin exacta del sistema compatible determinado: A * A*x=A * b.

Evidentemente, si Ax=b es determinado, la solucin de cuadrados mnimos coincide con la solucin exacta ( ya que es
0
2
= b Ax que claramente es mnima).

Dijimos que hay varias formas entonces de hallar la solucin:

Con la funcin resuelve (que habamos programado usando la descomposicin LU ).

function x=resuelve(A,b)
[L,U,P]=lu(A);
w=resuelveL(L,P*b);
x=resuelveU(U,w);

function x=resuelveL(L,c)
x(1,1)=c(1,1)/L(1,1);
x(j,1)=(c(j,1)-L(j,1:j-1)*x(1:j-1,1))/L(j,j);
end

function x=resuelveU(U,c)
x=flipud(resuelveL(flipud(fliplr(U)),flipud(c)));

Con la funcin resuelve qr (que habamos programado usando la descomposicin QR )

( Observacin: [Q,R,P]=qr(A) es la sintxis de Matlab para hallar la descomposicin QR )

function x=resuelve_con_qr (A,b)
[Q,R,P]=qr(A) ;
z=resuelveU(R,Q *b) ; la misma que ya programamos para sistemas triangulares superiores
x=P*z

Mtodos Numricos

Observando que A * A*x=A * b tiene a A * A cuadrada e inversible (porque A es de rango completo y tambin lo son
a A ,y, A * A ) y entonces b A A A x '* * ) '* (
1
= .

En general habamos desaconsejado resolver sistemas Ax=b haciendo b A x *
1
= , aunque existiera
1
A , ya que el clculo de
la inversa es costoso ) (
3
N O en lugar de ) (
2
N O para el mtodo de Gauss o sea, con LU-.
Pero A * A es simtrica y definida positiva y existen algoritmos ) (
2
N O para hallar la inversa (por ejemplo con Cholesky,
aunque no lo mencionaremos).
Adems ' * ) '* (
1
A A A

tiene inters en s misma. Es la pseudoinversa ( o inversa de Moore-Penrose) y , aunque A es rectangular
y no tiene inversa, al menos resulta inversa a izquierda. En efecto:
nxn
Id A A A A =
* ] ' * ) '* [(
1
. (recordemos que rg(A)=n
ya que , como el producto matricial es asociativo es
nxn
Id A A A A A A A A = =

) '* ( * ) '* ( * ] ' * ) '* [(
1 1
.

En Matlab hay una funcin especfica para hallar la pseudoinversa: pinv( ) (es decir, pinv(A)*A=Id )
Ejemplo, probemos una en Matlab:

>> A=[2 6 2;-3 -8 0;4 9 2]
A =
2 6 2
-3 -8 0
4 9 2

>> pinv(A)
ans =
-1.1429 0.4286 1.1429
0.4286 -0.2857 -0.4286
0.3571 0.4286 0.1429

>> pinv(A)*A
ans =
1.0000 -0.0000 -0.0000
0.0000 1.0000 0.0000
-0.0000 -0.0000 1.0000

Entonces tenemos al menos 4 formas de calcular la solucin de cuadrados mnimos, y las ensayamos para una
matriz grande, donde se notara la eficiencia de las funciones ( y comparamos tiempos en Matlab con Tic Toc ):

>> A=randn(1000,1000);

Mtodos Numricos

>> b=randn(1000,1);

>> tic
x=resuelve(A*A,A*b);
toc
0.3 seg

>> tic
x=resuelve qr(A*A,A*b);
toc
1.3 seg

>> tic
x=inv(A*A)*A*b;
toc
0.9 seg
>> tic
x=pinv(A)*b;
toc
18 seg

Si bien la ltima es la ms corta de escribir es la menos eficiente.

Si tuviramos que resolver 100 sistemas de ste tamao, con la funcin resuelve demoramos 30 seg , y, con pinv demoramos
como media hora!!!!!!!!!!

Despus resolvemos el ejemplo que haba quedado pendiente:

Ej: Con la tabla
2 . 615 1 . 20
1 . 328 . 5 . 10
8 . 161 . 1 . 5
5 . 95 8 . 2
0 . 54 5 . 1
3 . 16 21 . 0
y x

Mtodos Numricos

a) Hallar la recta de cuadrados mnimos
b) Graficar la recta x/ ymc=ax+b con a y b hallados antes y junto con los puntos de la tabla para ver si es verosmil.
c) Hallar la diferencia (en norma 2) entre la recta y los puntos :
2
y y
mc

Solucin:

>> x=[0.21;1.5;2.8;5.1;10.5;20.1]
x =

0.2100
1.5000
2.8000
5.1000
10.5000
20.1000

>> y=[16.3;54.0;95.5;161.8;328.1;615.2]

y =

16.3000
54.0000
95.5000
161.8000
328.1000
615.2000
>> A=[x ones(6,1)]

A =

0.2100 1.0000
1.5000 1.0000
2.8000 1.0000
5.1000 1.0000
10.5000 1.0000
20.1000 1.0000

>> ab=resuelve(A'*A,A'*y)
Mtodos Numricos

ab =

30.1514
9.7523

>> ymc=ab(1)*x+ab(2)
o
>> yapr=ab(1)*x+ab(2)

ymc =
o
yapr=

16.0841
54.9793
94.1761
163.5242
326.3416
615.7947

>> plot(x,y, ' o ',x,ymc)
o
>> plot(x,y,' o ',x,yapr)

Pues:

.
.
. .
1
. .
. .
1
1
6
2
1
6
2
1
|
|
|
|
|
|
\
|
=
|
|
\
|
|
|
|
|
|
|
\
|
y
y
y
c
a
x
x
x
con
|
|
\
|
c
a
solucin de cuadrados mnimos
Mtodos Numricos

0 5 10 15 20 25
0
100
200
300
400
500
600
700

>> norm(ymc-y)
o
>> norm(yapr-y)

ans =

3.0294

>> norm(ymc-y)/norm(y) (para calcular el error relativo)

-------------------------------------------------------------------------------------------------------------------------------------------------------

Si los datos tienen un aspecto no lineal

(por ejemplo:

) a pesar de que es posible ajustar un modelo lineal, no parece muy adecuado.

Mtodos Numricos

Los criterios ms importantes son la disposicin de los puntos y lo que sepamos tericamente acerca del modelo.

Veamos:

Ejercicio:

3 . 753 10
4 . 464 9
8 . 266 8
4 . 140 7
4 . 66 6
9 . 30 5
9 . 18 4
2 . 20 3
2 . 27 2
0 . 32 1
6 . 32 0
2 . 28 1
8 . 18 2
7 . 8 3
2 . 2 4
y x

Esto lo generamos con : >> x=(-4:10)';
>> y=0.1*x.^4-3*x.^2+2*x+33+0.5*randn(size(x));
>> y=round(10*y)/10
(pero no se lo decimos!!!!)

Y se pide:
a) Ajustar un modelo lineal ax+b por cuadrados mnimos.
b) Ajustar un modelo cuadrtico c bx ax + +
2
por cuadrados mnimos.
c) Ajustar un modelo cbico d cx bx ax + + +
2 3
d) Ajustar un modelo de orden 6, o sea, g fx ex dx cx bx ax + + + + + +
2 3 4 5 6
e) En cada caso calcular los errores relativos. Graficar en todos los casos.
Resolvemos:
Mtodos Numricos

>> x=(-4:10)';
>> x
x =
-4
-3
-2
-1
0
1
2
3
4
5
6
7
8
9
10
>> y=0.1*x.^4-3*x.^2+2*x+33+0.5*randn(size(x))
y = 2.4001
8.4450
19.0078
28.4560
33.6451
32.4343
27.1954
19.4988
18.5901
30.4216
65.7980
140.2287
266.0718
464.8076
752.5975
>> y=round(10*y)/10
y =
2.4000
8.4000
19.0000
28.5000
33.6000
Mtodos Numricos

32.4000
27.2000
19.5000
18.6000
30.4000
65.8000
140.2000
266.1000
464.8000
752.6000
>> A=[x ones(size(x))]
A =
-4 1
-3 1
-2 1
-1 1
0 1
1 1
2 1
3 1
4 1
5 1
6 1
7 1
8 1
9 1
10 1
>> clin=resuelve(A'*A,A'*y)

clin =

34.8432
22.7704
>> ylin=clin(1)*x+clin(2)

ylin =

-116.6025
-81.7593
-46.9161
-12.0729
Mtodos Numricos

22.7704
57.6136
92.4568
127.3000
162.1432
196.9864
231.8296
266.6729
301.5161
336.3593
371.2025

>> norm(ylin-y)

ans =

547.7645
>> norm(y)
ans =
939.7123

>> norm(ylin-y)/norm(y)

ans =

0.5829 (o sea, da 0.58 - o sea un 58% inadmisible !!!!)

>> plot(x,y,'.',x,ylin)
Mtodos Numricos

-4 -2 0 2 4 6 8 10
-200
-100
0
100
200
300
400
500
600
700
800

Ahora Cuadrtico!

>> A=[x.^2 A] es lo mismo que >> A=[ x.^2 x ones(size(x))]
pero lo marcado ya estaba en A, as que abreviamos insertando slo la columna faltante.
A =
16 -4 1
9 -3 1
4 -2 1
1 -1 1
0 0 1
1 1 1
4 2 1
9 3 1
16 4 1
25 5 1
36 6 1
49 7 1
64 8 1
81 9 1
100 10 1

>> ccuad=resuelve(A'*A,A'*y)

ccuad =
Mtodos Numricos

7.1278
-7.9235
-46.1316
>> ycuad=polyval(ccuad,x) esto equivale a y=ccuad(1)*x^2+ccuad(2)*x+ccuad(3); pero est claro que con grados de
polinomios mayores es cada vez ms largo de escribir. La funcinpolyval(a,x) hace esa
tarea. Si : ] , ,......, , [
1 2 1 +
=
k k
a a a a a entonces poyval(a,x) equivale a :
] * ...... 1 ^ * ^ *
1 2 1 +
+ + + +
k k
a x a k x a k x a .
OJO! Hay que completar los coeficientes si hiciera falta!
ycuad =

99.6071
41.7890
-1.7734
-31.0803
-46.1316
-46.9273
-33.4675
-5.7520
36.2190
92.4455
162.9277
247.6654
346.6587
459.9076
587.4121

>> norm(ycuad)
ans =
890.2821

>> norm(y)
ans =
939.7123

>> norm(ycuad-y)
ans =
300.7606

Mtodos Numricos

>> norm(ycuad-y)/norm(y)
ans =
0.3201 notemos que todava es como 0.32

>> plot(x,y,'.',x,ycuad)

-4 -2 0 2 4 6 8 10
-100
0
100
200
300
400
500
600
700
800

Ahora va la Cbica!

>> A=[x.^3 A]
A =
-64 16 -4 1
-27 9 -3 1
-8 4 -2 1
-1 1 -1 1
0 0 0 1
1 1 1 1
8 4 2 1
27 9 3 1
64 16 4 1
125 25 5 1
216 36 6 1
343 49 7 1
512 64 8 1
729 81 9 1
1000 100 10 1

>> ccubi=resuelve(A'*A,A'*y)
Mtodos Numricos

ccubi =
1.2033
-3.7018
-15.6246
41.9493

>> ycubi=polyval(ccubi,x)
ycubi =
-31.7923
23.0177
48.7648
52.6688
41.9493
23.8262
5.5192
-5.7520
-2.7677
21.6920
74.8468
163.9164
296.1205
478.6789
718.8114

>> norm(ycubi)
ans =
935.7046
>> norm(y)
ans =
939.7123

>> norm(ycubi-y)
ans =
86.6951

>> norm(ycubi-y)/norm(y)
ans =
0.0923 o sea, 0.09 un 9 % inadmisible!!!

Mtodos Numricos

>> plot(x,y,'.',x,ycubi)
-4 -2 0 2 4 6 8 10
-100
0
100
200
300
400
500
600
700
800

Ahora va la Sexta!

>> A=[x.^6 x.^5 x.^4 A]
A =
4096 -1024 256 -64 16 -4 1
729 -243 81 -27 9 -3 1
64 -32 16 -8 4 -2 1
1 -1 1 -1 1 -1 1
0 0 0 0 0 0 1
1 1 1 1 1 1 1
64 32 16 8 4 2 1
729 243 81 27 9 3 1
4096 1024 256 64 16 4 1
15625 3125 625 125 25 5 1
46656 7776 1296 216 36 6 1
117649 16807 2401 343 49 7 1
262144 32768 4096 512 64 8 1
531441 59049 6561 729 81 9 1
1000000 100000 10000 1000 100 10 1
>> csex=resuelve(A'*A,A'*y)
csex =
-0.0000
Mtodos Numricos

0.0005
0.0995
-0.0073
-3.0243
1.9814
33.4549
>> ysex=polyval(csex,x)

ysex =
2.3953
8.3948
19.0260
28.5553
33.4549
32.5047
26.8684
20.1420
18.3749
30.0643
66.1224
139.8164
266.6814
464.4064
752.6926

>> norm(ysex)
ans =
939.7115

>> norm(y)
ans =
939.7123

>> norm(ysex-y)
ans =
1.2141

>> norm(ysex-y)/norm(y)

Mtodos Numricos

ans =
0.0013

Ahora con grado 6 s da un valor chico menos de 1/10 , del 1% !!!!!!!!-

>> plot(x,y,'.',x,ysex)
-4 -2 0 2 4 6 8 10
0
100
200
300
400
500
600
700
800

La de grado 6 aproxima bien!! :

Veamos los coeficientes:
csex =
-0.0000
0.0005
0.0995
-0.0073
-3.0243
1.9814
33.4549
Vemos que los coeficientes de mayor orden son casi 0. Eso sugiere que quizs con un polinomio de menor grado (entre 4 y 5)
quizs tambin hubiera ajustado bien:
>> A=A(:,3:end) todas la filas, desde la columna 3 en adelante (x^4) (x^3 x^2 x ones)
Mtodos Numricos

A =
256 -64 16 -4 1
81 -27 9 -3 1
16 -8 4 -2 1
1 -1 1 -1 1
0 0 0 0 1
1 1 1 1 1
16 8 4 2 1
81 27 9 3 1
256 64 16 4 1
625 125 25 5 1
1296 216 36 6 1
2401 343 49 7 1
4096 512 64 8 1
6561 729 81 9 1
10000 1000 100 10 1
>> ccuart=resuelve(A'*A,A'*y)
ccuart =
0.0994
0.0102
-3.0343
1.8457
33.4613

>> ycuart=polyval(ccuart,x)
ycuart =
2.3302
8.3938
19.1420
28.6705
33.4613
32.3824
26.6881
20.0188
18.4013
30.2482
66.3588
139.9181
266.4977
464.0550
752.9340

>> norm(ycuart)
ans =
Mtodos Numricos

939.7113

>> norm(y)
ans =
939.7123

>> norm(ycuart-y)
ans =
1.3725
>> norm(ycuart-y)/norm(y)
ans =
0.0015 0.015 casi tan bueno como grado 6 . Pero con dos parmetros menos!!!!!!!!!!!

>> plot(x,y,'.',x,ycuart) tambin grficamente ajusta bien!!!!1
-4 -2 0 2 4 6 8 10
0
100
200
300
400
500
600
700
800

------------------------------------------------------------------------------------------------------------------------------------------------------

Mtodos Numricos

Hay casos donde un modelo no polinmico parece ms adecuado.
Ejercicio:
7 . 11 10
62 . 7 9
46 . 6 8
3 . 8 7
03 . 11 6
04 . 10 5
9 . 6 4
5 . 2 3
35 . 0 2
41 . 1 1
1 . 4 0
4 . 4 1
65 . 1 2
8 . 2 3
64 . 5 4

y x

Uno puede probar grado 6 (u otro) y ve que el ajuste es mediocre.
Parece una sinusoide montada en una lineal!!!!
Planteamos a cos(x)+b sen(x) + cx+d
>> x=(-4:10)';
>> y=[-5.64; -2.8;1.65;4.4;4.1;1.41;0.35;2.5;6.9;10.4;11.03;8.3;6.46;7.62;11.7];
y =
-5.6400
-2.8000
1.6500
4.4000
4.1000
1.4100
0.3500
2.5000
Mtodos Numricos

6.9000
10.4000
11.0300
8.3000
6.4600
7.6200
11.7000

>> A=[cos(x) sin(x) x ones(size(x))];
A =
-0.6536 0.7568 -4.0000 1.0000
-0.9900 -0.1411 -3.0000 1.0000
-0.4161 -0.9093 -2.0000 1.0000
0.5403 -0.8415 -1.0000 1.0000
1.0000 0 0 1.0000
0.5403 0.8415 1.0000 1.0000
-0.4161 0.9093 2.0000 1.0000
-0.9900 0.1411 3.0000 1.0000
-0.6536 -0.7568 4.0000 1.0000
0.2837 -0.9589 5.0000 1.0000
0.9602 -0.2794 6.0000 1.0000
0.7539 0.6570 7.0000 1.0000
-0.1455 0.9894 8.0000 1.0000
-0.9111 0.4121 9.0000 1.0000
-0.8391 -0.5440 10.0000 1.0000

>> coef=resuelve(A'*A,A'*y)

coef =

2.1099
-3.0265
0.9953
1.9011

>> yap=coef(1)*cos(x)+coef(2)*sin(x)+coef(3)*x+coef(4); (aqu no sirve poyval !!!!!)

yap =
-5.7495
Mtodos Numricos

-2.7464
1.7845
4.5925
4.0110
1.4896
0.2616
2.3709
6.7934
10.3780
10.7441
8.4701
6.5618
7.6887
11.7297

>> norm(yap-y)/norm(y)
ans =
0.0192 (vemos que aproxima bastante bien!!!)

>> plot(x,y,'.',x,yap)
-4 -2 0 2 4 6 8 10
-6
-4
-2
0
2
4
6
8
10
12

Ejercicio propuesto:
Programar una funcin: function coef=polcm(x,y,m) que reciba vectores x e y , y un
0
N n ,
Mtodos Numricos

y que devuelva el polinomio de orden n que mejor ajuste por cuadrados mnimos.
********************************************************************************************************

Habamos dejado como ejercicio programar una funcin polcm: function coef=polcm(x,y,m) que reciba como entradas
vectores x e y , y un
0
N n , y que devuelva los coeficientes del polinomio de mejor ajuste por cuadrados mnimos, de
orden n.

La funcin quedara, por ejemplo, as:
Function coef=polcm(x,y,n)
If size(x,2)==1
x=x % si x llega a estar en fila lo pone en columna.
end
If size(y,2)==2 % idem para y
y=y
end
A=[ones(size(x))];
For k=1:n
A=[x.^k A];
End
Coef=resuelve(A*A,A*y);

Podemos probarlo, por ejemplo, para buscar un polinomio de orden n que aproxime bien el seno en un intervalo. Por ejemplo
en un perodo.

Ejercicio:

Sean x=linspace(0,2*pi,100); (un perodo)
y=sin(x);
Hallar el polinomio (de cuadrados mnimos) de menor orden que aproxime a y en los puntos de abscisa x, con error relativo
menor o igual a 0.01 ( el 1 % ).
Graficar y experimentar qu pasa con grados muchos ms grandes.

Solucin:

>> x=linspace(0,2*pi,100);
>> y=sin(x);
n=-1;
err_rel=1;
Mtodos Numricos

while (err_rel>0.01)
n=n+1;
coef=polcm(x,y,n);
yapr=polyval(x,y,n);
err_rel=norm(yapr-y)/norm(y);
if n==99
break
end
end

----------------------------------------------------------------------------------------------------------------------------------------------
No probamos an, pero seguramente debe conseguirse con un polinomio de orden <10. (tipo n=8 o algo as).

Vale la pena ver que para grados grandes el polinomio se hace inestable (en general) y no vale la pena.

Graficar:

>>plot(x,y,' o ',x,yapr)

Y probar, por ejemplo, con n=40, 60, 99
------------------------------------------------------------------------------------------por ac sern las 8:30 hs??????
En general, hasta aqu, vimos como ajustar modelos de la forma: ) ( ........ ) (
1 1
x a x a y
k k
+ + =

NOTA: Si ) (
1
x =x.^(k-1), ) (
2
x =x.^(k-2),, 1
k
, quedan los polinomios, pero recordemos que tambin vimos antes
un caso con y=a*cos(x)+b*sin(x)+c*x+d , aqu: ) (
1
x =cos(x) ; ) (
2
x =sin(x) ; ) (
3
x =x ; 1 ) (
4
x .

Pero tambin es posible, si es inversible, ajustar un modelo:
) ( ........ ) ( ) ( )) ( ........ ) ( (
1 1
1
1 1
x a x a y x a x a y
k k k k
+ + = + + =

Entonces se renombra: ) (
1
y z

= , ) ( ........ ) (
1 1
x a x a z
k k
+ + = , se usa cuadrados mnimos y luego se halla
) (z y = .

Ejemplo Tpico:

Ajustar un modelo exponencial
x
ka y = a los datos:
Mtodos Numricos

8 . 1592 2
1 . 803 . 5 . 1
1 . 398 . 1
6 . 99 0
9 . 24 1
3 . 6 2
y x

Solucin:
>> x=[-2;-1;0;1;1.5;2];
>> y=[6.3;24.9;49.6;398.5;803.1;1592.8];
>> z=log(y);
>> AB=polcm(x,z,1);
>>ak=exp(AB);
>>yap=ak(2)*ak(1).^x;
>>plot(x,y,' o ',x,yap)
>>norm(yap-y)/norm(y);
Observacin: z=log(k)+log(a)*x
z=A*x+B con A=log(a) y B=log(k)
|
|
\
|
=
|
|
\
|
k
a
B
A
exp
Otro Caso No Lineal es el de las Aproximaciones de Pad:

La idea es conseguir
) (
) (
x Q
x P
y un modelo racional.

Muchas veces es necesario, ya que si hay polos incluso aunque no estn en la recta real, si estn cerca de ella - , la
convergencia de los polinomios es lenta. (Por Ejemplo:
2
1
1
x
y
+
= ).
Adems las funciones racionales aparecen frecuentemente al analizar ecuaciones diferenciales o ecuaciones en diferencias
(recurrencias) que se obtienen habitualmente como funciones de transferencia al analizar el sistema (transformar la ecuacin)
con la transformada Z (ecuaciones en diferencias) o con la transformada de Laplace (ecuaciones diferenciales ordinarias).
Es habitual al considerar circuitos, control de procesos, etc.

En general, se puede normalizar (sacando un factor comn adecuado) para que el trmino constante del denominador sea 1.

Mtodos Numricos

) ( ) ( ) ( ) ( .
) ( 1
) (
x yR x P y x P x R y y
x R
x P
y = = +
+
= y hay que averiguar los coeficientes de P(x) y R(x).
Observacin:
El orden del aproximante se nota ) / ( n N (gr(P)/gr(Q))

Ejercicio:

Dado

10
9
8
7
6
.
.
.
.
.
.
7
8
9
10
y x

Esto lo generamos con : >> x=(-10:10)'; % size(x)=21
>> y=(2*x+1)./(x.^2+1)+0.05*randn(21,1);
>> y=round(100*y)/100; (pero sin decirlo)

Se pide:
a) Ajustar un aproximante de Pad (1/2) (4 parmetros) y hallar el error relativo.
b) Buscar el orden del polinomio de menor grado que tiene un error relativo similar.
c) Graficar ambas.

Solucin:
Mtodos Numricos

Debe ser y dxy y cx b ax b ax y dxy y cx
dx cx
b ax
y = + + = + +
+ +
+
=
2 2
2
1

Corresponde a : ( ) ) ( 1
2
y
d
c
b
a
xy y x x =
|
|
|
|
|
\
|

Entonces ponemos:

>> x=(-10:10)'; % size(x)=21
>> y=[los valores de la tabla];
>> ab_c_d=resuelve(A*A,A*b);
>> ypade=( ab_c_d(1)*x+ ab_c_d(2)./( ab_c_d(3)*x.^2+ ab_c_d(4)*x+1);
>>err_rel=norm(ypade-y)/norm(y);
>>plot(x,y,' o ',x,ypade)
>>err_pol=>>err_rel+1;
>>n=-1;
>>while(err_pol > err_rel)
n=n+1;
coef=polcm(x,y,n);
ypol=polyval(coef,x);
err_rel=norm(ypol-y)/morm(y);
end
>>n % para ver que orden qued
>>plot(x,y,' o ',x,ypol,x,ypade)

----------------------------------------------------------------------------------------------------------------------hasta aqu 9:15 aprox

Una aplicacin posible de los polinomios de cuadrados mnimos es la
Integracin Aproximada:

Si tenemos una funcin no integrable fcilmente ( o no integrable en absoluto) con los mtodos usuales de integracin, una
opcin es aproximarla por polinomios (globalmente o por tramos) y luego integrar las polinmicas:

Recordemos que: :
|
\
|
+ + + + +
+

+
= + + + +

0
2
.........
1
0
2
1 1
1
) ...... (
0
1
1
1
1
x a x
a
x
n
a
x
n
a
n
n
n
n
dx a x a x a x a
b
a
b
a
n
n
n
n
y hacemos :
Mtodos Numricos

Con los coeficientes: [ 0 , ,
2
, ,......... ,
1
0
1 1
a
a
x
n
a
n
a
n n
+
] , polyval(coeficientes,b)- polyval(coeficientes,a)=Integral buscada
y agregamos el 0 al final para completar el polinomio que es primitiva del original
Luego:

dx x P dx x f x P x f ) ( ) ( ) ( ) ( y sta ltima es fcil.

Ejercicio:

a) Programar una funcin que calcule la integral de un polinomio cuyos coeficientes estn en el vector p , entre los lmites a y b.
( a la funcin llammosla : integrapol )
b) Probarla para integrar aproximadamente (usar el mismo grado que en el 1er ejercicio en que aproximamos sin(x) en
[0,2 ]) :
0
) sin( dx x (ac podemos chequear fcilmente)
c) Probarlo para

2
1
2
2
dx e
x
(n=7)

Solucin:

La funcin quedara, por ejemplo, as:
Function I=integrapol(p,a,b)
n=max(size(p))-1;
coef prim=[coef./((n+1):-1:1 0)];
I=polyval(coef prim,b)- polyval(coef prim,a); ;

>> x=linspace(0,pi,50);
>> y=sin(x);
>> p=polcm(x,y,8); % es 8 o lo que haya salido en el ejercicio 1
>> Iseno=integrapol(p,0,pi)
>>x=linspace(1,2,20); % elijo partir en 20 puntos
>>y=exp(-(x.^2)/2);
>>q=polcm(x,y,7)
>> integrapol(q,r,2)

********************************************************************************************************

Mtodos Numricos

Mencionamos que las Aproximaciones de Pad no tienen un desempeo mucho mejor para errores aleatorios sobre datos
que se aproximen bien por Polinmicas, pero en cambio son muy tiles para funciones que tengan asntotas horizontales, que
son especialmente incmodas para la interpolacin polinmica (debido a que los polinomios no tienen tales asntotas).

Ejemplo: arctan(x) , Si ponemos :

>> x=-20:0.1:20;
>> y=atan(x);
>> plot(x,y)
-20 -15 -10 -5 0 5 10 15 20
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2

Podemos ver que las aproximaciones por polinomios de cuadrados mnimos, incluso para polinomios de cuadrados mnimos de
grado grande, son malas. Por ejemplo:

>>coef=polcm(x,y,30);
>> yp=polyval(coef,x);
>>plot(x,y, '.' ,x,yp)

-20 -15 -10 -5 0 5 10 15 20
-2.5
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
2.5

O mejor:
>> plot(x,y,'o',x,yp)
Mtodos Numricos

-20 -15 -10 -5 0 5 10 15 20
-2.5
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
2.5

La razn es evidente, ya que los nicos polinomios que son constantes en algn intervalo son los de grado cero.
As, si f es casi constante en un intervalo, la nica forma para los polinomios de no alejarse mucho de f, es ir oscilando
alrededor de f, lo que impone muchos puntos crticos, lo que requiere agrandar mucho el grado.
En cambio con Pad, uno puede obtener aproximaciones muy aceptables con grado de P y Q (
) ( 1
) (
x Q
x P
y
+
) no muy grandes.
Por lo que s, Matlab no tiene funciones con aproximaciones de Pad, como s tiene: polyfit (es similar a polcm) y polyval
(para evaluarla).

Programemos: (ya q ser cmodo tenerlas a mano)

Hagamos 2 funciones, una para calcular los coeficientes y otra para evaluarla:

function [cp,cq]=apPade(x,y,n,m) % busca los coeficientes de p y q para y=p/(1+q) con q(0)=0, gr(p)n , gr(q)=m
A=zeros(max(size(x)),n+1+m);
if size(x,1)==1
x=x';
end
if size(y,1)==1
y=y';
end
for k=1:n+1
A(:,k)=x.^(n+1-k);
end
for k=n+2:n+1+m
A(:,k)=-(x.^(m+n+2-k)).*y;
end
coef=resuelve(A'*A,A'*y); %tienen q estar a mano las funciones: resuelve, resuelveU y resuelveL
cp=coef(1:n+1);
cq=[coef(n+2:end);1];
Mtodos Numricos

function y=padeval(cp,cq,x)
y=polyval(cp,x)./polyval(cq,x)

Entonces si ponemos, Por Ejemplo: (para el mismo ejemplo de antes)
>>[cp,cq]=apPade(x,y,7,6);
>>ypa=padeval(cp,cq,x);
>> plot(x,y,'o',x,ypa) % debe andar bastante bien.
-20 -15 -10 -5 0 5 10 15 20
-2
-1.5
-1
-0.5
0
0.5
1
1.5
2
muy bien!
Ahora veamos un poco la INTEGRACION NUMERICA:

La clave ser que:
+ + + + + +
+
= + + + + +
+
0
1 2 3
.........
1
) ..... (
0 2 1 3 2 1 1
0
1
1
2
2
1
1
x
a
x
a
x
a
x
k
a
x
k
a
dx a x a x a x a x a
k k k k k
k
k
k completamos
para usar luego polyval

Entonces si tenemos una tabla tipo x|y , y si elegimos n, la siguiente funcin calcula el polinomio de cuadrados mnimos de
orden n, e integra el polinomio, como aproximacin a la integral de y=f(x).

function Int=integra(x,y,n)
coef=polcm(x,y,n);
coefprimit=[coef./(n+1):-1:1;0];
Int=poyval(coefprimit,max(x))-polyval(coefprimit,min(x)) % ponemos max(x) y min(x) en lugar de x(end) y x(1) por si x est
desordenado.

La probamos con algn ejemplo:

>> x=linspace(0,pi,100);
>> y=sin(x);
Mtodos Numricos

>> Int=integra(x,y,7)
ans
2.0000 % coincide con
2 ) sin(
0
=
dx x

Pero las funciones que se portan mal con los polinomios, tienen problemas de convergencia:

>> x=-20:0.1:20;
>> y=atan(x);
>> integra(x,y,7)
13,.
>> integra(x,y,15)
14,.
>> integra(x,y,40)
15,0700
>> integra(x,y,41)
15,0100 % error en la segunda cifra
>> integra(x,y,140)
15,038
>> integra(x,y,141)
15,0720

O sea, NO parece converger!!!!!, los errores por arriba ms o menos se cancelan, pero la precisin es pobre, y no resulta un
mtodo muy fiable!!.

Una forma de salvar ese problema es, en lugar de usar un solo polinomio en todo el dominio, vamos aproximando de a tramos
por polinomios (de grado pequeo).

Esta idea est implcita en la Sumas de Riemann: (constante de a tramos, o sea, polinomios de grado cero)

O suplantando los rectngulos de antes, por TRAPECIOS (lineal de a tramos, o sea, polinomios de grado 1)
Mtodos Numricos

CUADRTICAS (Regla de Simpson) P polinomio de grado 2 que aproxima a f en [a,b]

Etc,.. en general las frmulas correspondientes se llaman: de Newton-Cotes.

Recapitulando, el procedimiento requiere:
Mn Cuadrados de polinomio del orden

intervalo - sub cada en tomados puntos
particin la de elementos
derecho borde
izquierdo borde
funcin la
k
m
n
b
a
f

Si la funcin no existe en Matlab, hay que crearla. Por ejemplo:
2
2
1
) (
) (
x
x sen
x f
+
=
Hay varias maneras:

function y=fun(x)
y=sin(x.^2)./(1+x.^2);

o en lnea de comandos: >>fun=@(x) sin(x.^2)./(1+x.^2);

(o se puede usar @(x) sin(x.^2)./(1+x.^2) en la llamada a la funcin)

La funcin que hace Newton-Cotes sera:
Mtodos Numricos

function Int=integraF(f,a,b,n,m,k)
Int=0;
parti=linspace(a,b,n+1);
for j=1:n
x=linspace(parti(j), parti(j+1),m);
y=f(x);
Int=Int+integra(x,y,k)
end

Observacin:

La particin y la sub-particin es equi-espaciada. Podra evitarse esto pero, por lo general, no cambia gran cosa.

Ejemplos:

>>Int=integraF(@sin,o,pi,15,5,2)
2.0000
>>Int=integraF(@ sin(x.^2)./(1+x.^2),-1,1,20,8,3)

notemos que esta funcin NO admite primitiva por sustitucin o partes

>>Int=integraF(@ atan,-20,20,200,20,7) el mismo de antes!! Pero ahora s converge!!!

Ejercicio:

Hallar la probabilidad de que , en una poblacin de media 170 cm y desviacin estndar 6 cm (con distribucin normal), una
persona mida entre 140 cm y 200 cm.

Resolucin:

>>f=@(x) (1/(sqrt(2.pi)*6))*exp(-((x-170).^2)/2*6);
>>integraF(f,140,200,100,8,3) % elijo una particin de 100 intervalos, 8 puntos en cada intervalo, y cbicas en cada intervalo

********************************************************************************************************
Mtodos Numricos

Hasta aqu hemos considerado sistemas lineales que, matricialmente, se pueden plantear como:
b AX =
con
m n
IR A

, y
1
n
IR b .

Podemos asumir, eventualmente considerando un sistema equivalente adecuado que estamos en el caso de que
{ } m n A rg , max ) ( = .
Asumiendo dicha hiptesis, el caso con n=m es m n A rg = = ) ( , y el sistema es determinado, situacin que ya
estudiamos, por ejemplo, cuando vimos la descomposicin LU.

El caso con n>m es el de los sistemas sobredeterminados. Con n m A rg < = ) ( el sistema por lo general no tiene solucin,
y llambamos solucin de cuadrados mnimos a aquel
1
m
IR X tal que b AX sea mnima. Dicha solucin de
cuadrados mnimos se encontraba, por ejemplo, como b A A A X )
'
)
'
((
1
= , siendo
'
A la matriz traspuesta de A. Debido
a que m A rg = ) ( resulta que
m m
IR A A

'
es de rango completo, m, y por ello est definida su inversa, y la matriz
'
)
'
(
1
A A A

que resulta una pseudo-inversa a izquierda de A, es decir: I A A A A =
)
'
)
'
((
1
, donde I es la identidad
de m m .

Ahora nos toca considerar el caso con m>n, con m n A rg < = ) ( . En este caso, si existe
1
m
IR X tal que b AX =
resulta que hay infinitos elementos en el conjunto: } : {
1
b AX IR X C
m
= =

, ya que si
1
m
IR h cumple
0 = Ah , y si b AX = entonces b h X A = + ) ( , y el conjunto } 0 : { = = Ah h
o
C
) (A Nu = tiene dimensin 0 > n m , y por lo tanto
o
C tiene infinitos elementos, y tambin los tiene C. Por ello el
sistema se dice subdeterminado, y se trata de elegir entre las infinitas soluciones (los elementos de C), alguna que sea
preferible por alguna razn.
Mtodos Numricos

Una de las elecciones ms frecuentes consiste en elegir la solucin de mnima norma al cuadrado. Esto es lo que entenderemos
como solucin de cuadrados mnimos para un sistema subdeterminado.
Es decir: buscamos } : {
1
b AX IR X C
o
X
m
= =

tal que
2
2
X
o
X para todo C X .

A continuacin veremos que dicha solucin de cuadrados mnimos del sistema sub-determinado puede hallarse como
b AA A
o
X ) )
'
(
'
(
1
= . Ntese que como m n A rg < = ) ( es
n n
IR AA

'
con n AA rg = )
'
( de modo que
1
)
'
(

AA est bien definido, y la matriz obtenida como
n m
IR AA A

) )
'
(
'
(
1
resulta ser una pseudo-inversa a
derecha de A, esto es que: I AA A A =
) )
'
(
'
(
1
, donde I es la identidad de n n .

A continuacin esbozamos la idea que permite proponer a b AA A
o
X ) )
'
(
'
(
1
= como la solucin buscada.

El problema puede verse como un problema de extremos de minimizacin de X , o equivalentemente de
2
X de un
mltiplo positivo de ello, sujeto a las condiciones de ligadura correspondientes a que
} : {
1
b AX IR X C X
m
= =

. Esto lo podemos interpretar entonces como el problema de hallar un mnimo para la
funcin X X X F
'
2
1
) ( = sujeto a las condiciones de ligadura:
=
=
n n
b X A
b X A
...
1 1
, siendo
m
IR X

1 '
el vector traspuesto
de X y por lo tanto
2
'
X X X = , y siendo
i
A
la i-sima fila de A.

De esta manera el problema se puede encarar mediante la bsqueda de n multiplicadores de Lagrange para la funcin F. O sea
consideramos:
Mtodos Numricos

) ( ... ) (
'
2
1
) , (
1 1 1 n n n
b X A b X A X X X G = con
1
n
IR .
Un extremo de la funcin auxiliar G requiere que se anulen las derivadas parciales respecto de las componentes de X y de
, es decir que (derivando en cada caso):

0
'
...
1 1
= = =
|
\
|

i
i
X
ni n i i
X A A A G
i
X

0 = = |
\
|

j
b X A G
j
j

De las m primeras ecuaciones (las de las derivadas respecto de las coordenadas de X ) obtenemos:
'
A X = , y
reemplazando as X en las n ecuaciones de las derivadas respecto de las
j
se obtiene 0
'
=
j
b A A
j
para j=1n. Es
decir que resulta:
b AA =
'
. Como
'
AA tiene inversa (por ser cuadrada de rango completo) resulta que b AA
1
)
'
(

= . Y volviendo a
reemplazar en
'
A X = obtenemos como nico posible extremo: b AA A
1
)
'
(
'
. Denotmoslo
o
X . O sea:
b AA A
o
X ) )
'
(
'
(
1
=
No es difcil convencerse que
o
X cumple lo pedido. Por una parte se tiene que
b b AA AA b AA A A
o
AX = = =
1 1
)
'
)(
'
( ) )
'
(
'
( , o sea b
o
AX = .
Por otra parte, est claro que si } : {
1
b AX IR X C X
m
= =

es 0 ) ( =
o
X X A , por lo que
o
X X es
ortogonal a las filas de A(puestas en columna, para interpretar el producto matricial como producto interno en
1 m
IR

).

Mtodos Numricos

Por otra parte llamando b AA r
1
)
'
(

= resulta que r A
o
X
'
= , o sea resulta que
'
...
'
1
1
|
\
|
|
\
|
+ + =
n
A r A r
o
X
n
de
modo que W
o
X X + = con
o
X generado por las filas de A (puestas luego en columna), y W es ortogonal a ellas (y por
lo tanto es ortogonal a X. De all resulta que
2
2
2
W
o
X X + = de donde resulta que
) (
2
1
2
1
) (
2
2
o
X F
o
X X X F = = , de donde realmente nuestro punto crtico es un mnimo global de F para el
conjunto C.

La misma funcin pinv(), de matlab, que proporcionaba la inversa a izquierda de una matriz
m n
IR A

de rango completo
con n m A rg < = ) ( , es decir: ( )
'
)
'
(
1
A A A A pinv

= , tambin nos da en el caso de que m n A rg < = ) ( una
inversa a derecha, es decir que en este caso:
( )
1
)
'
(
'
= AA A A pinv . Por ejemplo:
>> A=[1 2 4;3 5 11]

A =

1 2 4
3 5 11

>> A_1=pinv(A)

A_1 =

Mtodos Numricos

-2.6667 1.0000
4.1667 -1.5000
-1.1667 0.5000

>> A*A_1

ans =

1.0000 -0.0000
-0.0000 1.0000

>> % Efectivamente conseguimos ahora una inversa a derecha.
>> % Ntese que ahora, con n=2<3=m es pinv(A)=A'*(A*A')^-1
>> A'*(A*A')^-1

ans =

-2.6667 1.0000
4.1667 -1.5000
-1.1667 0.5000

Mtodos Numricos

Ejercicio:
i) Para la matriz dada anteriormente
|
|
\
|
=
11 5 3
4 2 1
A , y para el vector columna
|
|
\
|
=
8
3
b , hallar dos soluciones distintas
para el sistema b AX = , y calcular sus normas.
ii) Hallar la solucin de mnima norma
o
X de b AX = y verificar que su norma es menor o igual a la de las otras soluciones
halladas.

Resolucin:
Como tenemos 3-2=1 variable ms que el numero de ecuaciones podemos proponer un valor para una de ellas y obtener, a
partir de ella, las otras dos.
Si
|
|
|
\
|
=
z
y
x
X y ponemos x = 3 queda:
1*3+2*y+3*z = 3
3*3+5*y+11*z = 8
Es decir:
2*y+3*z = 0
5*y+11*z = -1
De donde se obtiene y = 2, z = -1, es decir
|
|
|
|
\
|
=
1
2
3
X , verificamos:
>> X=[3;2;-1]

Mtodos Numricos

X =
3
2
-1
>> A*X
ans =
3
8
De la misma manera, ponemos, por ejemplo: x = 1, y obtenemos como nueva solucin:
|
|
|
|
\
|
=
0
1
1
X
>> A*[1;1;0]
ans =
3
8
OK.
Ahora calculamos las normas:
>> norm([3;2;-1])
ans =
3.7417
>> norm([1;1;0])
ans =1.4142
Mtodos Numricos

Si bien esta solucin tiene una norma que parece bastante chica podemos mejorarlo. Busquemos la solucin de mnima norma
para el sistema subdeterminado, b AX = , como explicamos antes:
>> b=[3;8]
b =
3
8
>> Xo=pinv(A)*b
Xo =
0.0000
0.5000
0.5000
>> norm(Xo)
ans =
0.7071
Ntese que Xo tiene la mitad de la norma de la solucin hallada anteriormente.

Exponencial de Una Matriz
Para matrices cuadradas se pueden definir las potencias, con exponente en INo, de la matriz por
4 43 4 42 1
veces k
A A A
k
A = ... si kIN
y I A =
0
(la identidad del tamao de A)
Como tambin est definido el producto por un escalar, podemos definir polinomios en las matrices cuadradas.
Mtodos Numricos

Por ejemplo, si 3 2
3
4
5
2 ) ( + + + = x x x x p , se define I A A A A p 3 2 4 2 ) (
3 5
+ + + = , de donde se obtiene
una aplicacin de los polinomios con escalares en IR ( en C), en las matrices cuadradas del tamao de A que preserva sumas,
productos de potencias de A y productos por escalares (un morfismo).
Cmo adems tenemos definida una norma podemos hacer an ms. La norma nos permite definir una nocin de convergencia
en
m n
IR A

:
Dada una sucesin de matrices { }
IN
A
k
k

, decimos que
m n
IR M

es el lmite de { }
IN
A
k
k

, o que
M
k
A
k
=

lim si y slo si 0 lim =

M
k
A
k
. Este ltimo es un lmite de una sucesin de nmeros reales, y por lo
tanto est bien definido.
Obs: Como todas las normas matriciales son comparables entre s podemos suponer que trabajamos con la norma 2.
Consideramos ahora en el caso de matrices cuadradas, para una matriz
n n
IR A

, la sucesin de matrices: { }
IN
S
k
k

dada por ) (A p S
k k
= , donde
j
k
j
j
k
x x p

=
=
0
!
1
) ( . Es decir
=
=
k
j
j
j
k
A S
0
!
1
.
Se puede demostrar que { }
IN
A p
k
k

) ( es una sucesin convergente de nmeros reales, y que a consecuencia de ello
{ }
IN
S
k
k

converge, es decir que existe el
k
S
k
lim , y denotamos tal lmite:

=

=
0
!
1
lim
j
j
j
k
k
A S .
En el anillo de los nmeros complejos con la norma usual existe el lmite

= =

=
0
!
1
0
!
1
lim
j
j
j
k
j
j
j
k
z z y se define a dicho
lmite como la exponencial compleja:
=
=
0
!
1
j
j
j
z
z
e , y dicha exponencial tiene, entre otras propiedades las siguientes:

w
e
z
e
w z
e =
+

1
0
= e
Si IR t ,
t z
e
tz
e ) ( =
Mtodos Numricos

Es entonces natural, para
n n
IR A

, definir
=
=
0
!
1
j
j
j
A
A
e , y se obtienen de manera totalmente anloga las
siguientes propiedades:
Si A y B conmutan, es decir AB=BA , entonces
B
e
A
e
B A
e =
+

nula. matriz la es donde , O I
O
e =
Si IR t ,
t A
e
tA
e ) ( =

Ejercicio
Como ejercicio podemos tratar de evaluar aproximadamente la exponencial de una matriz en Matlab efectuando sumas
parciales de la serie mencionada, detenindonos cuando el trmino siguiente es numricamente nulo, es decir si:
)
0
!
1
(
1
)! 1 (
1
1
)! 1 (
1
1
)! 1 (
1
+
+
+
+
=
+
+
k
j
j
j
eps
k
k
k
k
k
k
A A A A donde )
0
!
1
(
=
k
j
j
j
eps A es el Epsilon de
mquina de la suma parcial. Comprese el resultado con alguna matriz cuadrada usando la funcin de Matlab expm que
evala la exponencial matricial.
Resolucin:
Programamos la siguiente funcin
function eA=exp_matricial(A)
eA=eye(size(A));
k=1;
siguiente=A;
acota=norm(A);
while(acota>eps(eA))
eA=eA+siguiente;
k=k+1;
siguiente=siguiente*A/k;
acota=acota*norm(A)/k;
end
Mtodos Numricos

Ntese que en lugar de dividir por los factoriales conviene ir dividiendo por cada factor de los mismos y multiplicando por A o su
norma para posponer posibles sobreflujos o subflujos.
Verificamos su funcionamiento con una matriz aleatoria de 3 por 3:
>> A=rand(3,3)
A =
0.8147 0.9134 0.2785
0.9058 0.6324 0.5469
0.1270 0.0975 0.9575

>> eA=exp_matricial(A)

eA =

3.2881 2.2290 1.3802
2.2617 2.8712 1.7128
0.4615 0.3910 2.7554
>> expm(A)
ans =
3.2881 2.2290 1.3802
2.2617 2.8712 1.7128
0.4615 0.3910 2.7554

Obtenemos lo mismo que con expm (en general usaremos esta funcin ya existente en Matlab).
Mtodos Numricos

Observacin importante
No se debe confundir la exponencial matricial que se obtiene con expm- con la funcin exp aplicada a una matriz que
sencillamente da la exponencial de cada entrada:
>> expm(A)
ans =
3.2881 2.2290 1.3802
2.2617 2.8712 1.7128
0.4615 0.3910 2.7554
>> exp(A)
ans =
2.2586 2.4927 1.3211
2.4739 1.8820 1.7279
1.1354 1.1025 2.6052
Se ve que difieren claramente. Adems, por ejemplo:
>> exp([1 2 3;0 1 2])
ans =
2.7183 7.3891 20.0855
1.0000 2.7183 7.3891
>> expm([1 2 3;0 1 2])
??? Error using ==> mtimes
Inner matrix dimensions must agree.
Esto es porque la exponencial matricial slo tiene sentido para matrices cuadradas a diferencia de la exponencial coordenada a
coordenada obtenida con exp-.

Mtodos Numricos

Una de las aplicaciones importantes de la exponencial matricial, es que, como la funcin exponencial en una variable, nos
permite obtener solucin para ecuaciones diferenciales lineales a coeficientes constantes.

Se puede verificar a partir de la definicin de derivada de una funcin de variable escalar que: Si IR t ,
tA
Ae
dt
tA
e d
=
) (

Entonces si buscamos
n
t X IR IR : ) ( tal que AX X = las funciones de la forma
tA
ke t X = ) ( con IR k
resultan solucin.
Asimismo el problema de valor inicial:
=
=
o
X t X
AX X
o
) (
resulta ser
tA
e
o
X t X = ) (

Lo anterior corresponde a ecuaciones homogneas.
Hay distintas formas de acceder a las soluciones del caso no homogneo.
Por ejemplo se puede verificar que:
tA
e ds s B
sA
e
o
X t X
t
t

+ = ) ) ( ( ) (
0
resulta solucin de:
=
+ =
o
X t X
B AX X
o
) (

Ms adelante veremos de estimar numricamente las integrales.
Ntese que si A y J son matrices semejantes, es decir L J L A . .
1
= donde L es una matriz inversible entonces
L
J
e L
A
e
1
= . Esto es claro a partir de la definicin de la exponencial como sumas de mltiplos de potencias de la matriz,
Mtodos Numricos

y del hecho de que L
k
J L L J J J L A A A
k
A . . . ... . . ...
1 1
= = = , y entonces
L
J
e L L J L L J L A
A
e
j
j
j
j
j
j
j
j
j
1
0
!
1
1
0
1
!
1
0
!
1
) (

=
= = = =

Si entonces A es diagonalizable podemos estudiar y analizar cualitativamente las soluciones de las ecuaciones diferenciales
mencionadas arriba con matriz A, de manera ms sencilla teniendo en cuenta los autovalores y autovectores de A.
********************************************************************************************************
Mtodos Numricos

RESOLUCION de ECUACIONES NO-LINEALES: (1ra Parte: CASO ESCALAR)

Nos interesa ahora resolver ecuaciones no-lineales. Empezamos viendo el caso de una variable:

Si tenemos una ecuacin f(x)=g(x) suele ser cmodo escribirla de alguna manera equivalente pero ms sencilla para
pensarla en trminos de algunos resultados. Algunas formas seran:

H(x)=0 (por ejemplo: con H(x)=f(x)-g(x) ) , o,
T(x)=x (por ejemplo: con T(x)= f(x)-g(x)+x ,o, T(X)=
) (
) (
x g
x f x
si g no se anula ).
En el 1er caso, la bsqueda de soluciones de la ecuacin coincide con la bsqueda de ceros de la funcin H(x).

En el 2do caso, las soluciones de la ecuacin son puntos fijos de la funcin T.

Los primeros mtodos que vemos, aprovechan ideas para buscar ceros.
El primero de ellos se basa en un Teorema muy conocido que recordamos:

TEOREMA de BOLZANO: Si H es contnua en [a,b] y si H(a)>0 y H(b)<0, o , si H(a)<0 y H(b)>0 , o sea H(a).H(b)<0
Entonces existe ) , ( b a c tal que H(c)=0.

Observacin: La condicin de que los valores H(a) y H(b) sean uno positivo y uno negativo, en trminos de
programa, se puede chequear fcilmente de una sola vez, verificando que H(a).H(b)<0.

El mtodo basado en el teorema de Bolzano, se llama Mtodo de BISECCION, y consiste en ir precisando la
ubicacin de alguna raz de H, por el procedimiento de partir el intervalo en partes iguales y observar en cul de
ellas es posible volver a aplicar el teorema.

Por Ejemplo:
---------------------------------------

Paso n: Intervalo [a,b] estimacin de la raz:
2
0
b a
x
+
=
Paso n+1 : Evalo H(
0
x ). Tenemos tres posibilidades:
1) el signo (H(
0
x ))=signo (H(a))
2) el signo (H(
0
x ))=signo (H(b))
3) H(
0
x )=0

Si H(
0
x )=0 devolvemos como solucin
0
x y terminamos ah.
Mtodos Numricos

Si el signo (H(
0
x ))=signo (H(a)) entonces puedo aplicar el teorema de Bolzano en el intervalo [
0
x ,b].

Entonces renombramos a=
0
x , y vuelvo al paso n.
Si el signo (H(
0
x ))=signo (H(b)) entonces puedo aplicar el teorema de Bolzano en el intervalo [a,
0
x ].

Entonces renombramos b=
0
x , y vuelvo al paso n.
En cada paso la longitud del intervalo se divide por 2 (salvo cuando hallamos justo la raz), por lo que se gana en
cada caso un dgito binario en cada paso. (o 0,30103 dgitos decimales en cada paso- es decir 1 decimal cada
3 o 4 pasos-). Por ello se dice que es un mtodo de orden 1.

Una cuestin pendiente consiste en decidir cundo detenernos. Algunas posibilidades son:
1) Despus de cierta cantidad N de pasos prefijada.
2) Cuando el intervalo es menor (en longitud) que cierto 0 > prefijado.
3) Cuando < ) (
0
x H para cierto 0 > prefijado.
4) Combinando condiciones tipo y .

Las dos primeras son esencialmente lo mismo, ya que a y b estn dados y despus de N pasos la longitud del
intervalo est completamente determinada por a,b y N: longitud
N
a b
2
= , o sea fijar N equivale a fijar

N
a b
2
= .
Entonces podemos proponer pasar como criterios de corte:
1) Fijar (achicar las abscisas)
2) Fijar (achicar las ordenadas)
3) Pedir que, por ejemplo,
2 2
+ sea pequeo (as forzamos a que ambos y sean pequeos).

El criterio de la puede dar soluciones mediocres si la pendiente es grande cerca de la raz:

Despus de cuatro pasos (
0
x ,
1
x ,
2
x ,
3
x ) ---------------------------------------------------------------
H(
3
x ) est lejos de 0 (e incluso H(
2
x )<H(
3
x ) )

El criterio de las puede dar una solucin lejana y la correcta si la pendiente es chica cerca de la raz:

(En una de esas ya par en
0
x porque < ) (
0
x H ) -------------------------------------------------
Pero la raz correcta c est bastante lejos.

Proponemos entonces usar el criterio mixto (pedir que < +
2 2
)) ( ( ) (
medio
x H Intervalo longitud , para cierto 0 > .
Mtodos Numricos

Entonces proponemos programar el mtodo y probarlo:

Ejercicio:

a) Programar el mtodo de Biseccin: poniendo como encabezado de la funcin: function sol=biseccin (H,a,b,alfa).

b) Probarlo hallando alguna raz de :

i) 2 6 3 9
2 3
+ = + x x x (solucin verdadera para verificar
3
2
= x )

ii) cos(x)=x

----------------------------------------------------------------------------------------------------------------------hasta aqu sern 8:30 aprox

Solucin:
a)

function sol=biseccion (H,a,b,alfa)
if H(a)*H(b)>=0
error (H(a) y H(b) deben ser una >0 y otra <0 ) ;
end
sol=(a+b)/2 ;
while ( sqrt(H(sol)^2+(abs(b-a))^2) >=alfa )
if H(sol)==0
return;
elseif sign(H(sol))= =sign(H(a))
a=sol;
else
b=sol;
end
sol=(a+b)/2;
end

b)

i)
>> H=@(x) 9*x.^3+3*x-6*x.^2-2 (o sea, H(x)= 2 6 3 9
2 3
+ x x x ) con @ puedo poner una function en el prompt de
Matlab

Mtodos Numricos

>> H(0)
ans=-2
>> H(1)
ans=4 (luego podemos usar biseccin!!!!)
>> sol=biseccion(H,0,1, 0.000001 )
sol=0.66667

ii)

>> G=@(x) cos(x)-x
>> G(0)
ans=1
>> G(pi/2)
ans=-1.57. (luego podemos usar biseccin!!!!)
>> solu=biseccion(G,0,pi/2, 0.00000001 ) por ejemplo!!!
solu=. (algn nmero)
>> G(solu) (verif)
0 ( o un nmero x
grande numero
10 (tipo
10
10
) )

Ventajas y Desventajas del Mtodo de Biseccin:

Ventajas: Slo requiere continuidad.
Converge siempre si se cumplen las hiptesis. (en teora)

Desventajas: Slo encuentra races asociadas a un cambio de signo.
(no puede hallar una raz por ej de multiplicidad 2 , as -------------------------- )
Converge relativamente lento (orden 1, como mencionramos).
No se puede generalizar a varias variables.
-------------------------------------------------------------------------------------------------------------------------------------------------
A continuacin propondremos otros mtodos. Veamos primero la idea geomtrica:

Una posibilidad es: aproximar localmente por funciones a las que se le sepa encontrar los ceros (v.g.: lineales), y
tomar dichos ceros (de las lineales) como aproximaciones sucesivas. El primer mtodo es debido a Evangelista
Torricelli (el mismo del barmetro), pero Newton lo us en un caso particular y Raphson lo generaliz y se conoce
como el Mtodo de Newton-Raphson.

El Mtodo de Newton-Raphson puede entenderse fcilmente con ste esquema:

Una raz es un x tal que H(x)=0.
Mtodos Numricos

En general se parte de una cierta estimacin de la raz de H, y se busca la siguiente, hallando donde 0 ) (
~
= x H ,
siendo H
~
=la funcin lineal cuyo grfico es la recta tangente a H en la estimacin anterior:

Es decir,
1 + n
x es tal que 0 ) (
~
1
=
+ n
x H , o sea, ) ( ) ).( ( ' 0
1 n n n n
x H x x x H + =
+
.
O sea, despejando:
) ( '
) (
1
n
n
n n
x H
x H
x x =
+
(paso iterativo)
OBSERVACIONES:
Es claro que ste mtodo tiene requerimientos bastante ms restrictivos:

Tiene que existir H, adems de H.
Adems debe poder pasarse explcitamente H, ya que MATLAB NO HALLA derivadas en forma simblica.
Hay que partir de una suposicin razonable de la raz, para que adems 0 ' H en cierto intervalo donde iteremos.

( Si H se anula el paso iterativo podra no aplicarse). ------------------------------------------

Adems, se ve que si estamos en otra colina (ms all de un punto crtico), el mtodo puede llevarnos a alejarnos de la raz.

Tambin es preferible que NO haya cambios de concavidad ---------------------------------------------

Por otra parte, en general el mtodo converge rpido (en caso de que converja).
En dicha situacin es de orden 2.
2
, : k x c x c con correcta raz la es c si k
n n
= (con k que slo depende de f en cierto intervalo alrededor
de c).
(Sale que:
2
0 0 0 0
) ).( ( ' ' ) ).( ( ' ) ( ) ( x x H x x x H x H x H + + = , (el desarrollo de Taylor)
siendo los dos 1eros sumandos ) ).( ( ' ) ( ) (
~
0 0 0
x x x H x H x H + = lo que nos da las aproximaciones lineales).

Si c es una raz doble (o de mayor multiplicidad) tambin converge --------------------------------------------

Aunque el orden vuelve a ser 1 en este caso. (Si se sabe el orden, se puede modificar el mtodo para que vuelva a ser de orden
2)

Puede generalizarse para resolver ecuaciones vectoriales; o sistemas de ecuaciones no-lineales de varias incgnitas.

Proponemos ahora programar el mtodo de Newton-Raphson (N-R) para el caso escalar, y usarlo en algn ejemplo.

Mtodos Numricos

Como converge rpido, lo usual es pararlo despus de cierta cantidad fija de iteraciones (8, 10, 12, por ejemplo. Por
ejemplo, si parto de una estimacin distante aproximadamente
2
1
del valor absoluto de la solucin, en 25 pasos
estaremos en el orden del psilon de mquina de ese nmero).

Otras alternativas son parar cuando < ) (
n
x H para cierto 0 > , o cuando <
+ n n
x x
1
para cierto 0 > .

Aqu implementamos la versin con n iteraciones (si uno quiere, se puede tomar el valor de la raz que devuelva el
mtodo y si uno no est satisfecho con ) (sol H o con )
) ( '
) (
(
) ( '
) (
sol H
sol H
sol sol
sol H
sol H
= , siendo
) ( '
) (
sol H
sol H
sol la
iteracin siguiente, entonces se puede volver a ejecutar Newton-Raphson con algunas iteraciones ms (total, nunca
van a ser muchos los intentos) ).

Solucin: Aqu va la funcin:

function sol=NR_escalar (H,Hprima,
0
x ,n)
sol=
0
x ;
for k=1:n
sol=sol-H(sol) / Hprima(sol) ;
end

Ejemplo: (tambin se pueden probar con los ejemplos usados para biseccin)

Observacin: = +
)) 1 ln(ln( lim
2
0
x
x
, y , 0 lim
0
=
x
x
. Por otra parte: + = +
+
)) 1 ln(ln( lim
2
x
x
, y , =
+
x
x
lim .

Hallar una solucin de x x = + )) 1 ln(ln(
2
.
Entonces buscamos ceros de x x x H + + = )) 1 ln(ln( ) (
2
.
Vemos que la solucin no debe andar lejos de 1
0
= x , y, 1
) 1 ).( 1 ln(
2
1 2 .
1
1
) 1 ln(
1
) ( '
2 2 2 2
+
+ +
= +
+ +
=
x x
x
x
x x
x H .
Entonces:
>> H=@(x) log(log(1+x.^2))+x ; (en Matlab ln es log, y
10
log es log10 , tambin est disponible
2
log es log2 )
>> Hprima=@(x) 2*x./(log(1+x.^2)* (1+x.^2))+1 ;
>> solaprox=NR_escalar (H,Hprima, 1,10) (o sea,
0
x =1 y n=10 ) y verificamos
>> H(solaprox)
0,.. (debe dar casi 0)
********************************************************************************************************
Mtodos Numricos

Comentamos que uno de los inconvenientes del Mtodo de Newton-Raphson (N-R) es que se debe disponer explcitamente de
la derivada de la funcin. Si dicha derivada es trabajosa de calcular o de evaluar, o si directamente no sabemos como hallarla-
por ejemplo si los valores de la funcin pueden calcularse en forma explcita pero quizs no los de la derivada, Por ejemplo:

Sea x e de solucin H H
x
= =

) ( : a , uno supone que H vara en forma suave con , pero no conocemos una
frmula para ) ( H , pero s podemos hallar ) ( H para cada usando algn tipo de mtodo,

en ese caso nos gustara poder aplicar un mtodo semejante al de Newton-Raphson (N-R) pero sin tener que disponer de la
derivada.

Un posible mtodo en ese sentido es el Mtodo de la SECANTE:

METODO de la SECANTE:

La idea es similar al de N-R, pero se parte de dos aproximaciones iniciales y la aproximacin que sigue consiste en aquel punto
donde se anule H
~
(en lugar de H ), donde ) ( ) .(
) ( ) (
) (
~
1
1
1
n n n
n n
n n
x H x x
x x
x H x H
x H +
, en lugar de
) ( ) ).( ( ' ) (
~
n n n
x H x x x H x H + = .

O sea que:
1
1
1
) ( ) (
) (
=
n n
n n
n
n n
x x
x H x H
x H
x x . (En N-R era
) ( '
) (
1
n
n
n n
x H
x H
x x =
+
).
Grficamente: Veamos las dos primeras iteraciones del Mtodo de la Secante:

A partir de
0
x y
1
x se halla
2
x , en el paso siguiente me olvido de
0
x , y
1
x pasa a jugar el papel de
0
x y
2
x el papel de
1
x , y
repito.

Como en N-R, cortamos despus de un nmero de iteraciones que pasamos como parmetro. A continuacin lo programamos:
Mtodos Numricos

function sol=secante(H,x0,x1,n)
sol=x1;
for k=1:n
sol=x1-H(x1)*(x1-x0)/(H(x1)-H(x0));
x0=x1;
x1=sol;
end
Lo probamos, por ejemplo en cos(x)=x (o sea, cos(x)-x=0).

>> H=@(x) cos(x)-x
H =
@(x) cos(x)-x
>> sol=secante(H,2.1,2,8)
sol =
0.7391
>> H(sol)
ans =
0 la encontramos con tanta precisin como permite el Matlab!

Observacin: Si ponemos:

>> sol=secante(H,2.1,2,12)
Warning: Divide by zero.
> In secante at 4
sol =
NaN obtenemos NaN (Not a Number)

Esto indica que hubo una operacin indefinida, en este caso es un
0
0
, pues cuando el mtodo converge a la raz- y
generalmente lo hace rpido- puede suceder que = =
1 0
x x raz de H, y entonces el denominador
0 1
0 1
) ( ) (
x x
x H x H
es
0
0
.
En N-R:
) ( '
1
n
x H
no tena problemas si
n
x = raz de H, si la raz es simple.

Como reflexin nos queda que en el Mtodo de la SECANTE no conviene pasarnos de rosca con las iteraciones (en general
converge con pocas, y si da: NaN entonces repetirlo con menos iteraciones).

Mtodos Numricos

Comentario sobre las operaciones con (Inf) y/o con indeterminaciones en Matlab:

Generalmente MATLAB respeta las definiciones usuales, pero no siempre. Algunas cuestiones que podran sorprendernos:

0
1
es Inf , y,
0
1
es -Inf (o sea que 0 es
+
0 ),
0
0
es NaN, 0*Inf es NaN, Inf-Inf es NaN,

Inf
Inf
es NaN, y 1^Inf es NaN.

Pero 0^0 es 1 y tambin: Inf^0 es 1.

Adems: log(Inf) es Inf, y log(0) es Inf, pero log(-1) es 0+pi*i , y as por ejemplo: log(-2)=ln(2)+pi*i , y , sqrt(-1)es o+1*i.

Acerca de la Velocidad de Convergencia de un Mtodo:

Se denomina ORDEN de un Mtodo a lo siguiente:

Si las aproximaciones dadas por cierto mtodo:
1
x ,
2
x ,.,
n
x ,
1 + n
x ,.. , raz de H, entonces en general existe q tal
que
) 1 (
1
O
x
x
q
n
n
=
(es decir, k
x
x
q
n
n
n
=
1
lim , para
0 >
R k ).
Equivalentemente se puede pedir : ) 1 (
) (
) (
1
O
x H
x H
q
n
n
=
+
.
El orden q es 2 para N-R
El orden q es 1 para BISECCION.
El orden q es ...... 61 , 1
2
5 1
+
para SECANTE.
Estor valores pueden hallarse tericamente, o estimarlos numricamente como en la bsqueda de Exponente Hlder:

) log( . log ) log( .
1 1
+
+ + n n
q
n n
x q k x x k x , entonces dividiendo por ) log(
n
x obtenemos:

q
x
k
x
x
n n
n
+
+
) log(
) log(
) log(
) log(
1

ya que 0
) log(
) log(

n
n
x
k
. (o anlogamente: q
x H
x H
n
n
n

+
) ) ( log(
)) ( log(
1
)

Mtodos Numricos

Recordemos la funcin NR_1:

function sol=NR_1(H,Hprima,x0,n) % Hprima=la derivada de H
sol=x0; % es la primera estimacion de sol=la solucion
for k=1:n % n = numero de iteraciones
sol=sol-H(sol)/Hprima(sol);
end

Por ejemplo:

>> H=@(x) cos(x)-x
H =
@(x) cos(x)-x
>> Hprima=@(x) -sin(x)-1
Hprima =
@(x) -sin(x)-1
>> c=NR_1(H,Hprima,6,20)
c =
0.7391

>> for k=0:9
F(k+1)=norm((log(abs(NR_1(H,Hprima,6,k+1))-c))/(log(abs(NR_1(H,Hprima,6,k))-c)));
end
>> miro. 2.5100 2.2130 2.0912 (tiende a 2) Inf (cuando da Inf el mtodo termina)

O tambin:

>> for k=0:9
W(k+1)=norm((log(H(NR_1(H,Hprima,6,k+1))))/(log(H(NR_1(H,Hprima,6,k)))));
end
>>miro.. 2.1268 2.0996 y
>> W(10)

ans =

Inf el mtodo termin!

Mtodos Numricos

Veamos otro ejemplo: para la SECANTE:

>> for k=0:11
U(k+1)=norm(log(abs(secante(H,6.5,6.4,k+1)-c)))/(log(abs(secante(H,6.5,6.4,k)-c)))));
end
>> miro. 1.8100 1.7130 1.6993 (tiende a ...... 61 , 1
2
5 1
+
) Inf (cuando da Inf el mtodo termina)

Volviendo al Mtodo de la SECANTE, lo que hacemos es aproximar la derivada de H en
n
x por un cociente incremental lateral
(de qu lado depende de la posicin de
1 n
x respecto de
n
x ).

Una alternativa mixta sera usar una derivada aproximada. En este caso, una estimacin ms estable de la derivada se puede
obtener promediando cocientes incrementales a izquierda y derecha. Armamos la siguiente funcin:

function Hprima_x=derivaprox(H,x,epsi)
Hprima_x=(H(x+epsi)-H(x-epsi))/(2*epsi ); %corresponde a estimar a ) ( '
2
) ( ) (
x H
x H x H

Con esta otra funcin podemos armar un N-R con derivada numrica:

function sol=NR_1_ap(H,x0,n,epsi)
if nargin==3
epsi=0.001; % si no se pasa el parmetro epsi , se toma por defecto 0.001
end
sol=x0;
for k=1:n
sol=sol-H(sol)/derivaprox(H,sol,epsi);
end

Mtodos Numricos

Caso MULTIVARIADO:

Queramos ahora resolver sistemas no-lineales de n ecuaciones y n incgnitas.

=
=
=
=
=
=
0 ) , ,......... , (
.......... .......... ..........
0 ) , ,......... , (
0 ) , ,......... , (
) , ,......... , ( ) , ,......... , (
........ .......... .......... .......... ..........
) , ,......... , ( ) , ,......... , (
) , ,......... , ( ) , ,......... , (
2 1
2 1 2
2 1 1
2 1 2 1
2 1 2 2 1 2
2 1 1 2 1 1
n n
n
n
n n n n
n n
n n
x x x h
x x x h
x x x h
x x x g x x x f
x x x g x x x f
x x x g x x x f
, donde
i i i
g f h =

Es decir que lo podemos escribir en forma vectorial como:

Hallar X para
n n
R R H : tal que H(X)=0, (o sea, ] 0 .....; ;......... 0 ; 0 [ ]) ; ;......... ; ([
2 1
=
n
x x x H
r
)
Resulta cmodo pensarlo en columnas, y buscar
(
(
(
(
(
(
=
|
|
|
|
|
|
\
|
(
(
(
(
(
(
(
(
(
(
(
(
=
0
.
.
.
0
.
.
.
/
.
.
.
1 1
n n
x
x
H
x
x
X .
Proponemos generalizar N-R, pero en su versin aproximada.

Ntese que, incluso aunque las derivadas sean fciles de calcular, por ejemplo,
5 5
: R R H , las derivadas a programar
son 25!, y puede ser muy pesado de programarlas a mano. En cambio, podemos hallarlas numricamente usando H, sin dar
explcitamente ninguna frmula para
j
i
x
H
.
Por otra parte, notemos que el paso iterativo de N-R era:
) ( '
) (
1
n
n
n n
x H
x H
x x =
+
).
Esto tambin se puede escribir como: ) ( * )) ( ' (
1
1 n n n n
x H x H x x

+
= .
Escrito as se puede generalizar a ms variables poniendo ) ( * )) ( (
1
1 n n n n
x H x JH x x

+
= donde ) ( JH es la matriz
Jacobiana de H en cada punto. Programamos su clculo aproximado:

Mtodos Numricos

En cada columna de
|
|
|
|
|
|
|
|
|
|
|
\
|
=
. . ) ( . ) (
. . . . .
. . . . .
. . . . .
. . ) ( . ) (
. . ) ( . ) (
) (
1
2
1
2
1
1
1
x
x
H
x
x
H
x
x
H
x
x
H
x
x
H
x
x
H
x JH
j
n n
j
j
estn las derivadas respecto de 1 variable por vez, entonces:
2 / ))
0
.
1
.
0
( )
0
.
1
.
0
( ( ) (
|
|
|
|
|
|
\
|
+
|
|
|
|
|
|
\
|
+ =
x H x H H
x
j
, donde
|
|
|
|
|
|
\
|
0
.
1
.
0
es la j-sima columna de la matriz identidad
nxn
I .
Y entonces programamos:

function J=JACOB_APROX(H,X,epsi)
I=eye(max(size(X)));
for k=1:max(size(X)) % derivo en cada columna
J(:,k)=(H(X+epsi*I(:,k))-H(X-epsi*I(:,k)))/(2*epsi);
end

Y ahora programamos NR-MULTIVARIADO:

function sol=NR_MULTI(H,x0,n,epsi)
if nargin==3
epsi=0.001;
end
sol=x0;
for k=1:n
sol=sol-inv(JACOB_APROX(H,sol,epsi))*H(sol);
end

Mtodos Numricos

Veamos un Ejemplo:

Hallar alguna solucin de:
= +
=
0 6
0 1 ) cos(
2
2 1
2 1
x x
x x

(una solucin es (2,2), pero vamos a hacer como que no lo sabemos y la buscamos con NR_MULTI).
Lo armamos vectorialmente (como antes), H es:
(
+

=
|
|
\
|
(
6
1 ) cos(
2
2 1
2 1
2
1
x x
x x
x
x
H , y ponemos:
>> H=@(x) [cos(x(1)-x(2))-1; x(1)+x(2)^2-6]
>> H([2.5 1.8]) % calculamos H
|
|
\
|
(
8 . 1
5 . 2

ans =
-0.2352
-0.2600 no est lejos de
(
0
0

Buscamos con NR_MULTI:

>> NR_MULTI(H,[2.5;1.8],10,0.0001)
ans =
2.0005
1.9999 (
(
2
2
la verdadera solucin)

En realidad, tal como lo programamos NR_MULTI tambin funciona en 1 variable:

>> H=@(x) cos(x)-x
H =
@(x) cos(x)-x
>> NR_MULTI(H,1,8,0.01)
ans =
0.7391 (la solucin de cos(x)=x !!)

********************************************************************************************************
Mtodos Numricos

Recordemos que habamos programado un mtodo N-R multivariado que permite buscar soluciones de ecuaciones
vectoriales (o sistemas de ecuaciones) de
n n
R R
.

Copiamos por las dudas (alguno habr faltado) las funciones JACOB-APROX y NR-MULTI:

function J=JACOB_APROX(H,X,epsi)
I=eye(max(size(X)));
for k=1:max(size(X))
J(:,k)=(H(X+epsi*I(:,k))-H(X-epsi*I(:,k)))/(2*epsi);
end

function sol=NR_MULTI(H,x0,n,epsi)
if nargin==3
epsi=0.001;
end
sol=x0;
for k=1:n
sol=sol-inv(JACOB_APROX(H,sol,epsi))*H(sol);
end

Planteamos entonces el siguiente ejercicio:

Ejercicio:

Halle, si es posible, algn extremo de la funcin
R R F
3
:
dada por
6 2 2 ) ( ) , , (
2 2 2 2
+ + + + + = x yz z y sen z y x z y x F
cerca del
(
(
(
15 . 0
1 . 0
2 . 1
.
Probar que F debe anularse.

Solucin:

Llamo H= ] 2 ) cos( ) ( 2 2 ; 2 ) cos( ) ( 2 2 ; 2 2 [ ) , , , ( y z y z y sen z z z y z y sen y x z y x F + + + + = y
busco ceros de H:
Mtodos Numricos

>> H=@(X)
)] 2 ( * 2 )) 3 ( ) 2 ( cos( * )) 3 ( ) 2 ( sin( * 2
) 3 ( * 2 ); 3 ( * 2 )) 3 ( ) 2 ( cos( * )) 3 ( ) 2 ( sin( * 2 ) 2 ( * 2 ; 2 ) 1 ( * 2 [
X X X X X
X X X X X X X X
+
+ +

>> PUNTO_CRITICO=NR_MULTI(H,[1.2;0.1;0.15],12) (debera dar:
|
|
|
\
|
0
0
1
aprox.)

Presentamos por ltimo un mtodo que puede aplicarse en contextos an ms generales (por ejemplo: espacios
mtricos), aunque, claro, requiere ms condiciones (o ms restrictivas). Pero incluso N-R se puede ver como caso
particular. Se basa en el siguiente teorema:

TEOREMA del PUNTO FIJO de BANACH: (o de la Aplicacin Contractiva)

Sea U un espacio mtrico (lase
n
R ), y sea T una aplicacin de U en U, o sea, U U T : tal que ) 1 , 0 ( c , o sea,
0<c<1 / d(T(u),T(v)) d(u,v) (esto es una aplicacin contractiva) con d la funcin distancia en U,
entonces U p ! / T(p)=p.

Adems, partiendo de U x
0
cualquiera, vale que p x T
n
n
=
+
) ( lim
0
) (
donde T T T T
n
o o o .....
) (
= (n veces).

Si tenemos una determinada ecuacin ) ( ) (

= X g X f (escalar o vectorial) que podemos escribir como ) (

= x T x , y si T resulta
ser contractiva, entonces podemos estimar la solucin haciendo:
) ( ., ),........ ( ), ( ,
1 2 0 1 0
solucin X x T x x T x x = = .

Ntese que en realidad necesitamos que valga, no en general, sino para un
0
x bien elegido.

Si 1 0 0 .........
0 1 2 1
2
1 1
< < < < < <

+
c porque x x c x x c x x c x x
n
n
n n n n n n

Entonces para n grande es
n n
x x
+1
y como
1
) (
+
=
n n
x x T luego ) (
n n
x T x (casi un punto fijo)

En particular, si en N-R ponemos
) ( '
) (
) (
x H
x H
x x T = , vale que
) ( '
) (
) ( '
) (
) ( ) ( ) (
1
1
1
1
1
1 1 1 1
+
+
+
+
+
+ + + +
= = =
n
n
n
n
n
n n n n n
x H
x H
x
x H
x H
x x x T x T x T .

Entonces si (y ste si es la restriccin) podemos escribir f(x)=g(x) como x=T(x) para T contrada, el mtodo sale con sta
funcin:
Mtodos Numricos

function sol=PUNTO_FIJO(T,x0,n) % si no se da n, se hace hasta que se halla el punto fijo
if nargin==2
sol=x0;
x1=T(x0);
while ((norm(x1-sol))>0)
temp=sol;
sol=T(x1);
x1=temp;
end
end
sol=x0;
for k=1:n
sol=T(sol);
end
----------------------------------------------------------------------------------------------------------------------hasta aqu 9:15 aprox
Veamos un ejemplo:

Busquemos una solucin de cos(x)=x.

Directamente aqu es T(x)=cos(x) y sabemos por cuestiones generales (ver un grfico de cos(x) y x) que debe haber
una solucin entre 0 y 1 aproximadamente.

All T(x)=sen(x) y ) ( ) ( '
) ( ) (
sen c T
v u
v T u T
= =
por el Teo de Lagrange, y en [0,1] es ) ( sen < ) 1 ( sen <1.

Entonces T contrae con c< ) 1 ( sen .

Entonces partimos de, por ejemplo: 3 . 0
0
= x

>> sol=PUNTO_FIJO(@cos, 0.3, 20)

sol=0.7391

------------------------------------------------------------------------------------------------------------------------------------

Mtodos Numricos

Soluciones numricas de ecuaciones diferenciales.
En ste caso las ecuaciones diferenciales pueden ser no-lineales y de R en
n
R ; pero en principio, s, van a ser de 1er
orden. Las de orden n se pueden reescribir como si fueran de 1er orden (con ms variables), haciendo un cambio de variables
estndar:
..... ..........
) ( ' '
) ( '
) (
3
2
1
t x x
t x x
t x x
=
=
=
, (lo que los fsicos llamaran: Representacin en el espacio de fases).
El problema de valores iniciales se puede escribir como:
(ms adelante veremos cmo adaptarlo a problemas de contorno)

Hallar
n
R R X : /
=
=
0 0
) (
)) ( , ( ) ( '
.) . . (
X t X
t X t f t X
I V P
Ntese que, en principio, esto podra escribirse como:
+ =
t
t
X ds s X s f t X
0
0
) ( , ( ) ( ; verifica que
|
|
\
|
=
=
0 0
) (
)) ( , ( ) ( '
X t X
t X t f t X
. Y siendo
+ =
t
t
X ds s X s f t X T
0
0
) ( , ( )) ( ( , lo que
resulta: X(t)=T(X(t)), o sea que hallar X(t) es hallar un punto fijo de un espacio adecuado (de funciones), y de hecho la
demostracin del Teorema de Picard de Existencia y Unicidad de las soluciones, se basa en el Teorema de Punto Fijo de Banach.

La bsqueda numrica de las soluciones, sin embargo, se suele hacer usando otras ideas.

El mtodo ms rstico, pero que inspira a otros mejores, es el de EULER. La idea es la siguiente:

Dibujemos las distintas soluciones paralelas a la de nuestro P.V.I. con distintos valores iniciales:

Se trata de seguir la pista a la solucin, aproximando en cada punto por la tangente.
(depende de la curvatura, uno se va aproximando por debajo o por arriba de la verdadera solucin)

Descargamos un programita muy fcil de usar:

http://math.rice.edu/~dfield/
For use with version 7.7 of MATLAB.
dfield8.m New December 10, 2009.
>> dfield8
Mtodos Numricos

-2 0 2 4 6 8 10
-4
-3
-2
-1
0
1
2
3
4
t
x
x ' = x
2
- t

Interpretamos X(t)=X(t)^2-t

---------------------------------------------------------------------------------------------------------------------------------------------------
El mtodo lo que hace en cada paso temporal, es estimar:

X(t+h)=X(t)+X(t).h como X(t)= f(t,X(t)),
X(t+h)=X(t)+f(t,X(t)).h

Hagamos una 1era versin:

function [ t , X ]=euler(f,t0,X0,tfinal,h)
pasos=1+floor((tfinal-t0) / h);
Mtodos Numricos

t=linspace(t0,tfinal,pasos);
h_efectivo=t(2)-t(1) ; X(1)=X0 ;
for k=2:pasos
X(k)=X(k-1)+f(t(k-1), X(k-1)) * h_efectivo;
end

Ejemplo:

Hallar X tal que
=
=
1 ) 0 (
) ( ) ( '
X
t X t X
en [0,2] (solucin: X(t)=
t
e )

>> [ t , X ]=euler(@(t,X)X,0,1,2,0.001);

>> plot(t,X)
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
1
2
3
4
5
6
7
8

>> X(end)
ans =

7.3817
2
e

----------------------------------------------------------------------------------------------------------------------------------------------

Mtodos Numricos

>> H=@(X) [2*X(1)-2;2*X(2)+2*sin(X(2)-X(3))*cos(X(2)-X(3))+2*X(3);2*X(3)+2*sin(X(2)-X(3))*cos(X(2)-X(3))+2*X(2)]

H =

@(X)[2*X(1)-2;2*X(2)+2*sin(X(2)-X(3))*cos(X(2)-X(3))+2*X(3);2*X(3)+2*sin(X(2)-X(3))*cos(X(2)-X(3))+2*X(2)]

>> TO_CRITICO=NR_MULTI(H,[1.2;0.1;0.15],12)

>> H=@(X) [cos(X)-X]

H =

@(X)[cos(X)-X]

>> TO_CRITICO=NR_MULTI(H,0,12)

TO_CRITICO =

0.7391

>> H=@(X) [2*X(1)-2;2*X(2)+2*sin(X(2)-X(3))*cos(X(2)-X(3))+2*X(3);2*X(3)-2*sin(X(2)-X(3))*cos(X(2)-X(3))+2*X(2)]

H =

@(X)[2*X(1)-2;2*X(2)+2*sin(X(2)-X(3))*cos(X(2)-X(3))+2*X(3);2*X(3)-2*sin(X(2)-X(3))*cos(X(2)-X(3))+2*X(2)]

>> TO_CRITICO=NR_MULTI(H,[1.2;0.1;0.15],12)

TO_CRITICO =

1.0000
-0.0000
0.0000

>> norm([0.5 -0.25;-0.25 0])

ans =

0.6036

>> G=@(X) [0.5*X(1)+0.1*X(1)^5-0.25*X(2);0.125*X(2)^4-0.25*X(1)]
Mtodos Numricos

G =

@(X)[0.5*X(1)+0.1*X(1)^5-0.25*X(2);0.125*X(2)^4-0.25*X(1)]

>> G([0;0])

ans =

0
0

>> G=@(X) [0.5*X(1)+0.25*X(1)^4-0.25*X(2);0.125*X(2)^4-0.25*X(1)]

G =

@(X)[0.5*X(1)+0.25*X(1)^4-0.25*X(2);0.125*X(2)^4-0.25*X(1)]

>> G=@(X) [0.5*X(1)+0.25*X(1)^2-0.25*X(2);0.125*X(2)^4-0.25*X(1)]

G =

@(X)[0.5*X(1)+0.25*X(1)^2-0.25*X(2);0.125*X(2)^4-0.25*X(1)]

>> T=@(X) [-0.5+0.25*X(1)^2-0.25*X(2);0.125*(X(2)+1)^4-0.25*X(1)+0.25]

T =

@(X)[-0.5+0.25*X(1)^2-0.25*X(2);0.125*(X(2)+1)^4-0.25*X(1)+0.25]

>> T([1;-1])

ans =

0
0

>> T=@(X) [0.5+0.25*X(1)^2-0.25*X(2);0.125*(X(2)+1)^4-0.25*X(1)-0.75]

Mtodos Numricos

T =

@(X)[0.5+0.25*X(1)^2-0.25*X(2);0.125*(X(2)+1)^4-0.25*X(1)-0.75]

>> T([1;-1])

ans =

1
-1

>> sol=PUNTO_FIJO(T,[0.5;-0.5],12)

sol =

0.9991
-0.9996

>> sol=PUNTO_FIJO(T,[0.1;-0.1],12)
sol =

0.9986
-0.9994

>> sol=PUNTO_FIJO(T,[0.1;-0.1],20)
sol =

1.0000
-1.0000

********************************************************************************************************
Mtodos Numricos

Sigamos con soluciones numricas de Ecuaciones Diferenciales:

Programamos el Mtodo de EULER que mencionamos antes:
Idea: Queremos hallar X solucin de
=
=
0 0
) (
)) ( , ( ) ( '
x t x
t x t f t x

........ .
! 3
) ( ' ' '
.
2
) ( ' '
). ( ' ) ( ) (
3 0 2 0
0 0 0
+ + + + = + h
t x
h
t x
h t x t x h t x
Si h es chico ( 0 h ) entonces h h h << ..... ,......... ,
3 2
y descartamos los trminos de orden 2,3,.
Quedndonos: h t x t x h t x ). ( ' ) ( ) (
0 0 0
+ + y como )) ( , ( ) ( ' t x t f t x = , obtenemos: h t x t f t x h t x )). ( , ( ) ( ) (
0 0 0 0
+ +
Llamamos: ) 1 ( t al
0
t y ) 1 ( x a
0
x
) 2 ( t es h t +
0
y ) 2 ( x a h x t f x + + )) 1 ( ), 1 ( ( ) 1 (
) 3 ( t es h t 2
0
+ y ) 3 ( x a h x t f x + + ) 2 ( ), 2 ( ( ) 2 ( , etc.
Si 5 . 0 = h :

function [ t , X ]=euler(f,t0,X0,tfinal,h) %donde t=[t(1),t(2),,t(k)]es una particin del intervalo[t0,tfinal]donde estimo la
solucin, y la matriz x=[(x1),(x2),..]tiene en cada columna el vector posicin en tiempo ti
pasos=1+floor(abs(tfinal-t0) / h);
hutil=t(2)-t(1) ; % t es siempre igual ***
X(:,1)=X0 ;
for k=2:pasos
X(:,k)=X(:,k-1)+f(t(k-1), X(k-1)) * hutil;
end
*** si entre t0 y tfinal h no cabe una cantidad exacta de veces, tomo un hutil h pero un poquito ms chico. Por ejemplo:
En [0,pi] con h=0.01 hago[pi-0]/0.01=314.1592 tomo 314+1=315 sub-intervalos (de longitud pi/315=0.0099. 0.01

Mtodos Numricos

Lo probamos primero con una ecuacin cuya solucin conocemos:
=
=
1 ) 0 (
'
x
x x
cuya solucin es
t
e t x = ) ( .
Probamos en el intervalo [0,2] con distintos pasos h, por ejemplo 0.01, 0.001, 0.0001

>> f=@(t,x) x % aunque f dependa slo de x hay que dar las dos variables de entrada (para poder evaluar f(t,x(t)))
f =
@(t,x) x
>> [t,x]=euler(f,0,1,2,0.01);
>> x(end)
ans =
7.3160
>> exp(2)
ans =
7.3891
>> [t,x]=euler(f,0,1,2,0.001);
>> x(end)
ans =
7.3817 % etc, cuando 0 h la solucin va mejorando
Pero cada vez hace falta dar ms pasos al achicar el h, y el mtodo cada vez tarda ms!!
-----------------------------------------------------------------------------------------------------------------------------------------------
Tambin resolvimos antes con el programita dfield8.m
=
=
4 . 1 ) 2 (
) ( ) ( '
2
x
t t x t x
en [-2,-1.5]
Esta vez no sabemos que frmula tendra la solucin exacta.
Pero podemos indirectamente si est convergiendo probando dos pasos distintos: por ejemplo: h , y, h/2 , y si las dos
soluciones difieren poco damos por buena la solucin aproximada:

>> f=@(t,x) x.^2-t
f =
@(t,x) x.^2-t
>> [t,x]=euler(f,-2,1.4,-1.5,0.001);
>> x(end)
ans =
14.5270
>> [t,x]=euler(f,-2,1.4,-1.5,0.0005);
>> x(end)
ans =
14.7409 estn cerca
Mtodos Numricos

Tambin podemos resolver alguna con
n
R R X : con n>1.
Por Ejemplo: Hallemos
3
: R R X con
|
|
|
\
|
=
) (
) (
) (
) (
t z
t y
t x
t X tal que
|
|
|
\
|
=
|
|
|
\
|
=
2 . 0
5 . 0
5 . 0
) 0 (
) (
) (
) (
* ) cos( ) ( '
2
2
2
X
t z
t y
t x
t t x
en [0,4], donde la solucin
es una trayectoria en el espacio.

>> f=@(t,x) cos(t).*[x(1).^2, x(2).^2, x(3).^2]
f =
@(t,x) cos(t)*[x(1).^2, x(2).^2, x(3).^2]
>> [t,X]=euler(f,0,[0.5;-0.5;0.2],4,0.001);
>> plot3(X(1,:),X(2,:),X(3,:))
0.2
0.4
0.6
0.8
1
-1
-0.8
-0.6
-0.4
-0.2
0.16
0.18
0.2
0.22
0.24
0.26

---------------------------------------------------------------------------------------------------------------------------------------
Tambin podemos resolver ecuaciones de orden n: ) ( ) ( ). ( .......... ). (
) 1 ( ) (
t q t x t p x t a x
n n
= + + +

Hacemos la representacin en el espacio de fases:
) 1 (
2
1
.
.
.
'
=
=
=
n
n
x x
x x
x x
entonces X=
|
|
|
|
|
|
|
|
\
|

=
|
|
|
|
|
|
|
|
\
|
=
|
|
|
|
|
|
|
|
\
|
n
n
n
ax px t q
x
x
x
x
x
x
x
x
........ ) (
.
.
.
.
.
.
' '
'
'
.
.
.
'
'
1
3
2
) (
2
1

Por Ejemplo: (Oscilador armnico no-lineal y forzado)

Mtodos Numricos

=
=
=
5 . 0 ) 0 ( '
2 ) 0 (
) 2 cos( ) ( )
3
( ) ( ' ). sin( 2 ) ( ' '
x
x
t t x
t
t x t t x
en [0 , 3] con paso h=0.001 . Entonces:
X=
|
|
\
|
=
|
|
\
|
+ +
=
|
|
\
|
=
|
|
\
|
=
|
|
\
|
=
|
|
\
|
5 . 0
2
) 0 (
) sin( 2 )
3
( ) 2 cos(
'
) 0 ( '
) 0 (
) 0 (
' '
'
'
'
2 1
2
2
1
x
x t x
t
t
x
x
x
x
X
x
x
X
x
x
x
x

>> f=@(t,x) [x(2); cos(2*t)+(t/3)*x(1)+2*sin(t)*x(2)]
f =
@(t,x) [x(2); cos(2*t)+(t/3)*x(1)+2*sin(t)*x(2)]
>> [t,X]=euler(f,0,[2;-0.5],3,0.001);
>> plot(t,X(1,:)) (x era
1
x , la 1er fila de X)
0 0.5 1 1.5 2 2.5 3
0
2
4
6
8
10
12
t
x

>> plot(X(1,:), X(2,:)) (es la solucin vista en el plano de fases)
0 2 4 6 8 10 12
-2
0
2
4
6
8
10
12
14
16
18
x
x
'

Si en cierto tramo las curvas solucin tienen una concavidad de signo fijo, Euler sobrevala o subevala de forma recurrente.

Mtodos Numricos

Una forma de compensar es, en lugar de usar la tangente en
k
t , o sea: X(:,k)=X(:,k-1)+f(t(k-1),X(:,k-1))* t ;
en vez de ello, tratar de usar la tangente que debera haber en la llegada, para que, retrocediendo, regresemos
correctamente al punto inicial, es decir, Cul es X(:,k) de modo que X(:,k)= X(:,k-1)+f(t(k),X(:,k))* t ?
El problema es que X(:,k) est IMPLCITO (aparece en ambos lados de la ecuacin)

Esto puede verse como un problema de punto fijo, tomando T(X(:,k))= X(:,k) donde
T(X(:,k))=X(:,k-1)+f(t(k),X(:,k))* t .

En ese contexto: t k X k t f k X k t f k X T k X T = )) (:,
~
), ( ( )) (:, ), ( ( )) (:, (
~
)) (:, (
Y para t suficientemente chico se puede hacer de T un operador de contraccin si f cumple una condicin de
Lipschitz en la segunda variable. De esta manera, usando el Principio del Punto Fijo de Banach, la idea es partir de
un X(:,k) estimado (de hecho la aproximacin de Euler) e ir iterando hasta aproximarnos al X(:,k) implcito.

En la prctica fijamos un valor de tolerancia, y cuando dos iteraciones distan entre s menos que dicho valor de
tolerancia, aceptamos el X(:,k) y pasamos a k+1:

function [t,X]=eulerimp(f,t0,X0,tfinal,h,tol)
if nargin==5
tol=0.001;
end
pasos=floor(abs(tfinal-t0)/h)+1;
X(:,1)=X0;
hutil=t(2)-t(1);
for k=2:pasos
temp1=X(:,k-1)+F(t(k-1),X(:,k-1))*hutil;
temp2=X(:,k-1)+F(t(k),temp1)*hutil;
while abs(temp2-temp1)>=tol
temp1=temp2;
temp2=X(:,k-1)+F(t(k),temp2)*hutil;
end
X(:,k)=temp2;
end

En general la estimacin con eulerimp aproxima la solucin correcta cometiendo errores contrarios a los de Euler
Por Ejemplo:
Miremos el que ya hicimos:
=
=
1 ) 0 (
'
x
x x
cuya solucin es
t
e t x = ) ( , para ] 2 , 0 [ t .
Mtodos Numricos

>> f=@(t,x) x
f =
@(t,x) x
>> [tr,xr]=euler(f,0,1,2,0.01);
>> xr(end)
ans =
7.3160 (el verdadero valor es ......... 3891 . 7
2
e )
>> [tk,xk]=eulerimp(f,0,1,2,0.01); (dejamos la tolerancia por default 0.001) 389 . 7
2
= e
ans =
7.4623

Esto sugiere que promediar los resultados de ambos mtodos ser mejor que cualquiera de ellos por separado:

Euler Combinado:

function [t,X]=eulercomb(f,t0,X0,T,h,tol)
if nargin==5
tol=0.001;
end
[te,Xe]=euler(f,t0,X0,T,h);
[ti,Xi]=eulerimp(f,t0,X0,T,h,tol);
t=(te+ti)/2;
X=(Xe+Xi)/2;

Si ponemos en el prompt:
>> f=@(t,x) x
f =
@(t,x) x
>> [t,x]=eulercomb(f,0,1,2,0.01);
>> x(end)
ans =
7.3891

Mejor que con Eulerimp y que con Euler!!
********************************************************************************************************

Mtodos Numricos

Antes mencionamos que combinando los Mtodos de Euler y de Euler implcito (con Eulercomb) los resultados eran
probablemente (casi siempre) mejores que con cada mtodo por separado.

Podemos testear sta caracterstica viendo cundo es necesario achicar el paso para que dos aproximaciones con
pasos distintos disten entre s en menos de un prefijado. (Aunque no conozcamos la solucin exacta).

Ejemplo:
Sea el problema de segundo orden:
=
=
= +
1 ) 0 ( '
0 ) 0 (
4 6 9 ' . . 3 ' '
2
x
x
t x x t x
en [0 , 1.5]

a) Buscar solucin aproximada con Euler para h=0.1 ,
2
1 . 0
,
4
1 . 0
,
8
1 . 0
, . Hasta que las soluciones con
N
2
1 . 0
y
1
2
1 . 0
+ N
en x(1.5) (es decir en x(end)) disten en menos de 0.001.

b) Idem con Euler imp
c) Idem con Euler comb
d) Comparar qu potencia de N se requiri con cada mtodo para que las aproximaciones con
N
2
1 . 0
y
1
2
1 . 0
+ N
disten en menos
de 001 . 0 = .

Solucin:
Hacemos la representacin (el cambio de coordenadas, para transformarlo en un problema de 1er orden):
X=
|
|
\
|
=
|
|
\
|
+
=
|
|
\
|
=
|
|
\
|
1
0
) 0 (
4 2 .^ * 6 * * 3 * 9
'
'
2 1
2
2
1
x
t x t x
x
x
x
x
x
x
en [0 , 1.5]
Se puede hacer la bsqueda automticamente:

>> f=@(t,X) [X(2) ; 9*X(1)-3*t.*X(2)+6*t.^2-4 ]
>> h=0.1;
>> [tl ,xl ]=euler(f,0,[0;1],1.5,h);
>> [tl2 ,xl2 ]=euler(f,0,[0;1],1.5,h/2);
>> n=1;
>> while(abs(xl(end)-xl2(end))>0.001)
n=n+1;
Mtodos Numricos

h=h/2;
tl = tl2 ;
xl = xl2 ;
[tl2 ,xl2 ]= euler(f,0,[0;1],1.5,h/2);
end
>>n
n =
3
>> xl(end)
ans =
1.7501

Para los otros mtodos se copian las mismas lneas cambiando Euler por eulerimp y Euler por eulercomb.

>> f=@(t,X) [X(2) ; 9*X(1)-3*t.*X(2)+6*t.^2-4 ]
>> h=0.1;
>> [tl ,xl ]=eulerimp(f,0,[0;1],1.5,h);
>> [tl2 ,xl2 ]=eulerimp(f,0,[0;1],1.5,h/2);
>> n=1;
n=n+1;
h=h/2;
tl = tl2 ;
xl = xl2 ;
[tl2 ,xl2 ]= eulerimp(f,0,[0;1],1.5,h/2);
end
>>n
n =
5

>> f=@(t,X) [X(2) ; 9*X(1)-3*t.*X(2)+6*t.^2-4 ]
>> h=0.1;
>> [tl ,xl ]=eulercomb(f,0,[0;1],1.5,h);
>> [tl2 ,xl2 ]=eulercomb(f,0,[0;1],1.5,h/2);
>> n=1;
n=n+1;
h=h/2;
tl = tl2 ;
xl = xl2 ;
Mtodos Numricos

[tl2 ,xl2 ]= eulercomb(f,0,[0;1],1.5,h/2);
end
>>n
n =
4
-------------------------------------------------------------------------------------------------------------------------------------------------
Comentamos ahora que el problema bsico
=
=
0 0
) (
) , ( '
x t x
x t f x
de Euler es que como estima:

43 42 1
3 2 1
curvatura la desprecia
k
x t f
k k k
t
c x
t t x t x t x
k k
2
) , (
1 1
.
2
) ( ' '
. ) ( ' ) ( ) (
1 1
+ + =

con
k
c entre
1 k
t y
k
t (Lagrange)
por

t x t f t x t x
k k k k
+ =

). , ( ) ( ) (
1 1 1

Una va de solucin es lo que hicimos con Euler combinado, tratando de compensar la curvatura por el lado contrario.

Otra idea, que adems admite luego generalizaciones ms agudas an, es tratar de representar el trmino ( )
2
.
2
) ( ' '
t
c x
k

de alguna manera.

Si ponemos:

4 4 4 4 4 4 4 3 4 4 4 4 4 4 4 2 1
4 4 4 4 4 4 4 3 4 4 4 4 4 4 4 2 1
4 4 4 8 4 4 4 7 6
4 4 4 3 4 4 4 2 1
43 42 1
2
1
1 1
1
1
.
2
) ( ' '
). .
2
) ( ' '
(
.
2
) ( ' '
2
) ( ' ) ( '
1 1
) (
~
1
) (
~
) (
1 1 1
.
2
)) , ( ) , ( , (
. ) , ( ) ( ) (
t
c x
t t
x
t
x t x t x
k k
euler t x
t k t k
euler de paso t x
t x
k k k k
t
x t f x t f x t f
t x t f t x t x
k k
k
k k
k
k
=
=

=

+
+ + =

Entonces, llamando ) , (
1 1 1
=
k k
x t f m =pendiente de Euler, y,
= )
~
, (
2
euler x t f m
k k
pendiente (estimada en el punto de llegada)de Euler

t
m
t
m
t m t x t
m m
t m t x t x
k k k
+ + =
+ + =

2 2
) (
2
) (
) ( ) (
1 2
1 1
1 2
1 1
, o sea,
Mtodos Numricos

t
m m
t x t x
k k

+
+ =
2
) (
) ( ) (
2 1
1
Este es el mtodo de RUNGE-KUTTA (de orden 2)
(este promedio de las pendientes hace un promedio similar al de Euler combinado). Adems lo hace localmente, de modo que
posiblemente corrige antes de que los errores locales se aumenten de manera crtica.

En general la idea de los mtodos de RUNGE-KUTTA de orden n es combinar pendientes en distintos puntos para estimar
trminos hasta el orden n del desarrollo de Taylor de la solucin.

-----------------------------------------------------------------------------------------------------------
Programemos en Matlab:

function [t,X]=RK2(F,t0,X0,T,h) % function [t,X]=RK2(f,t0,X0,tfinal,h)
pasos=ceil(abs(T-t0)/h); % pasos=floor(abs(tfinal-t0)/h)+1;
t=linspace(t0,T,pasos); % t=linspace(t0,tfinal,pasos);
X(:,1)=X0; % hutil=t(2)-t(1);
hutil=t(2)-t(1); % X(:,1)=X0;
for k=2:pasos
m1=F(t(k-1),X(:,k-1));
m2=F(t(k),X(:,k-1)+m1*hutil);
X(:,k)=X(:,k-1)+((m1+m2)/2)*hutil;
end

Ejercicio:
Probar con RK2 el h de la forma
N
2
1 . 0
tal que la solucin con
N
h
2
y
1
2
+ N
h
disten en tfinal=1.5 en menos de 0.001 como
hicimos con Euler, Eulerimp y Eulercomb en el mismo problema de antes:
=
=
= +
1 ) 0 ( '
0 ) 0 (
4 6 9 ' . . 3 ' '
2
x
x
t x x t x
en [0 , 1.5]
Solucin:
Idem antes:
>> f=@(t,X) [X(2) ; 9*X(1)-3*t.*X(2)+6*t.^2-4 ]
>> h=0.1;
>> [tl ,xl ]=RK2(f,0,[0;1],1.5,h);
>> [tl2 ,xl2 ]=euler(f,0,[0;1],1.5,h/2);
>> n=1;
Mtodos Numricos

n=n+1;
h=h/2;
tl = tl2 ;
xl = xl2 ;
[tl2 ,xl2 ]= RK2(f,0,[0;1],1.5,h/2);
end
>>n
n =
4

No vamos a programar cada mtodo de RUNGE-KUTTA, pero proponemos uno ms como ejercicio:

RK4:

Dado
1 1
,
k k
x t hacer: t h =
Entonces, llamando ) , (
1 1 1
=
k k
x t f m ; es la de Euler
); 2 / * , 2 / (
1 1 1 2
h m x h t f m
k k
+ + =

); 2 / * , 2 / (
2 1 1 3
h m x h t f m
k k
+ + =

); * , (
3 1 4
h m x h t f m
k k
+ + =

function [t,X]=RK4(F,t0,X0,T,h) % function [t,X]=RK2(f,t0,X0,tfinal,h)
pasos=ceil(abs(T-t0)/h); % pasos=floor(abs(tfinal-t0)/h)+1;
t=linspace(t0,T,pasos); % t=linspace(t0,tfinal,pasos);
hutil=t(2)-t(1);
X(:,1)=X0;
for k=2:pasos
m1=F(t(k-1),X(:,k-1));
m2=F(t(k),X(:,k-1)+m1*hutil);
X(:,k)=X(:,k-1)+((m1+2*m2+2*m3+m4)/6)*hutil;

Se hace un promedio ponderado de 6 pendientes (pesan ms las del medio), para estimar los trminos de Taylor
(hasta orden 4) t
m m m m
x
k

+ + +
+ ).
6
2 2
(
4 3 2 1

Mtodos Numricos

Ejemplo:

Probar las soluciones de
4
2
) (
RK
RK
Eulercomb y Eulerimp too Euler
para Hallar X tal que
=
=
1 ) 0 (
) ( ) ( '
X
t X t X
en [0,2] con
todos el mismo paso h=0.01, para poder compararlos (solucin: X(t)=
t
e )
Comparando en cada caso X(end) con
2
e 7.3817

f=@(t,x) x
[te,Xe]=euler(f,0,1,2,0.01);
[tim,Xim]=eulerimp(f,0,1,2,0.01);
[tc,Xc]=eulercomb(f,0,1,2,0.01);
[tr2,Xr2]=RK2(f,0,1,2,0.01);
[tr4,Xr4]=RK4(f,0,1,2,0.01);
abs(Xe(end)-exp(2))
abs(Xim(end)-exp(2))
abs(Xc(end)-exp(2))
abs(Xr2(end)-exp(2))
abs(Xr4(end)-exp(2))

----------------------------------------------------------------------------------------------------------------
Contar el ode45 del Matlab:
Example
[t,y]=ode45(@vdp1,[0 20],[2 0]);
plot(t,y(:,1));

0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
1
2
3
4
5
6
7
8

Mtodos Numricos

********************************************************************************************************
Mtodos Numricos

Antes programamos los algoritmos de RUNGE-KUTTA de orden 2 (RK2) y RUNGE-KUTTA de orden 4 (RK4).
(ambas funciones se encuentran en el lirweb de la materia )

Planteamos el siguiente problema:
Hallar
2
: R R X tal que
|
|
\
|
=
2
1
x
x
X con
|
|
\
|
=
|
|
\
|
=
|
|
\
|
=
5 . 0
5 . 0
) 0 ( '
1
1
) 0 (
* ). * 10 cos( * 2 ' '
1
2
x
x
x
x
t x
en [0 , 3].
Hallar la solucin con RK2 y con RK4 con paso h=0.1. Si el error relativo de uno respecto del otro (en norma de Frbenius) fuera
> 0.001 entonces achicar el h y repetir. El error relativo mencionado sera
4
4 2
RK
RK RK
X
X X
.
Solucin:
Hay que llamar
|
|
|
|
|
\
|
=
'
'
2
1
2
1
x
x
x
x
W entonces
|
|
|
|
|
\
|
=
|
|
|
|
|
\
|
=
1
2
4
3
2
1
2
1
* ) * 10 cos( * 2
) ( * ) * 10 cos( * 2
' '
' '
'
'
'
w t
w t
w
w
x
x
x
x
W
Queda
|
|
|
|
|
\
|
=
|
|
|
|
|
\
|
=
5 . 0
5 . 0
1
1
) 0 (
* ) * 10 cos( * 2
) ( * ) * 10 cos( * 2
'
1
2
4
3
W
w t
w t
w
w
W

>> f=@(t,W) [W(3) ; W(4);2*cos(10*t)*[-W(2);W(1)] ];

>> h=0.1;
>> f=@(t,W) [W(3) ; W(4);2*cos(10*t)*[-W(2);W(1)] ];
>> [tR2,WR2]=RK2(f,0,[1;-1;-0.5;0.5],3,h);
>> [tR4,WR4]=RK4(f,0,[1;-1;-0.5;0.5],3,h);
>> XR2=WR2(1:2,:);
>> XR4=WR4(1:2,:);
Mtodos Numricos

>> norm(XR2-XR4,'fro')/norm(XR4,'fro')
ans =
0.2240 da ms de 0.001, entonces repetimos con h=0.01:

>> h=0.01;
>> [tR2,WR2]=RK2(f,0,[1;-1;-0.5;0.5],3,h);
>> [tR4,WR4]=RK4(f,0,[1;-1;-0.5;0.5],3,h);
>> XR2=WR2(1:2,:);
>> XR4=WR4(1:2,:);
ans =

>> h=0.001;
>> [tR2,WR2]=RK2(f,0,[1;-1;-0.5;0.5],3,h);
>> [tR4,WR4]=RK4(f,0,[1;-1;-0.5;0.5],3,h);
>> XR2=WR2(1:2,:);
>> XR4=WR4(1:2,:);
ans =

>> h=0.0001;
>> [tR2,WR2]=RK2(f,0,[1;-1;-0.5;0.5],3,h);
>> [tR4,WR4]=RK4(f,0,[1;-1;-0.5;0.5],3,h);
>> XR2=WR2(1:2,:);
>> XR4=WR4(1:2,:);
ans =
2.3425e-004 ahora s

Esta idea de realizar la cuenta con dos mtodos distintos y considerar que la solucin es aceptable si las soluciones
no difieren mucho puede sistematizarse. (De hecho los solvers de MATLAB comparan 2 mtodos para decidir el h).

Podemos programarlo as:

Mtodos Numricos

function [t,X]=RK24(F,t0,X0,tfinal,h,tol)
if nargin==4
h=abs(tfinal-t0)/100;
tol=0.01;
end
if nargin==5
tol=0.01;
end
[t2,X2]=RK2(F,t0,X0,tfinal,h);
while((norm(X2-X4), 'fro' )/(norm(X4), 'fro')) >tol)
h=h/2;
end
t=t4;
X=X4;

Podemos probarlo, Po Ejemplo, con:
=
=
1 ) 0 (
'
x
x x
cuya solucin es
t
e t x = ) ( , en el intervalo [0,2].

>> f=@(t,x) x
f =
@(t,x) x
>> [t,X]=RK24(f,0,1,2,0.1,0.01);
>> X(end)
ans =
7.3890
>> exp(2)
ans =
7.3891
----------------------------------------------------------------------------------------------------------

Ahora planteamos un problema que tiene una ecuacin sencilla pero requiere un gran esfuerzo de clculo para algunos valores
del parmetro:
Mtodos Numricos

=
=
) 0 (
'
3 2
x
x x x
con 0 en ]
2
, 0 [
.

Est asociado a la ignicin de un combustible concentrado (por ejemplo un fsforo) con x=radio de la llama.
Al principio la llama es pequea, en un momento se alcanza un valor crtico de ignicin, y la llama crece hasta alcanzar una
nueva estabilidad. El grfico tiene una pinta de escaln tanto ms empinada cuanto menor sea (como vemos debajo).

Observacin:
3 2
x x indica que las estabilidades se alcanzan cuando se anulan (en 0 y 1) la componente
2
x (proporcional a
la superficie de la llama) y
3
x (proporcional al volumen).

>> f=@(t,x) x.^2-x.^3
f =
@(t,x) x.^2-x.^3

>> delta=0.01;
>> [t,X]=RK24(f,0,delta,2/delta,0.1,0.01);
>> plot(t,X,'o')
0 20 40 60 80 100 120 140 160 180 200
0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1
delta=0.01

>> delta=0.001;
>> [t,X]=RK24(f,0,delta,2/delta,0.1,0.01);
>> plot(t,X,'o')
Mtodos Numricos

0 200 400 600 800 1000 1200 1400 1600 1800 2000
0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1
delta=0.001

>> delta=0.0001;
>> [t,X]=RK24(f,0,delta,2/delta,1,0.01); OJO!! hace falta agrandar el paso porque el intervalo es muy largo 2/delta=20000
>> plot(t,X,'o')
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
x 10
4
0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1
delta=0.0001 y Paso=1

Pero con delta=0.00001 se cuelga, porque hace falta achicar tanto el paso que hacen falta muchos sub-intervalos!! Hagamos:
>> delta=0.00001;
>> [t,X]=RK4(f,0,delta,2/delta,1,0.01); OJO!!! No con RK24 para que no se cuelgue!!!!
>> plot(t,X,'o') da (despus de largo rato) una respuesta, pero la respuesta requiere 200000 puntos!!
Mtodos Numricos

0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
x 10
5
0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1
delta=0.00001 Paso=1 con RK4

Una alternativa es usar un mtodo que no use el mismo paso siempre, sino que lo achique, o agrande segn haga falta!
A continuacin veremos y programaremos el Mtodo de BOGACKI-SHAMPINE (BS23), (el 23 hace alusin a que compara en
cada paso) un mtodo de orden 2 y de orden 3, y modifica el paso si no se cumple cierto criterio.

********************************************************************************************************
Mtodos Numricos

Recin planteamos un problema que tiene una ecuacin sencilla pero requiere para algunos valores del parmetro,
un gran esfuerzo de clculo:

=
=
) 0 (
'
3 2
x
x x x
0 en [0 ,
2
]

Est asociado a la ignicin de combustible concentrado (por ejemplo: un fsforo), con x=radio de la llama.
Al principio la llama es pequea, en un momento se alcanza un valor crtico de ignicin y la llama crece hasta
alcanzar una nueva estabilidad. El grfico tiene una pinta de escaln, tanto ms empinada cuanto menor sea el .

Observacin:
3 2
x x indica que las estabilidades se alcanzan cuando se anulan (en 0 y 1) la componente
2
x
(proporcional a la superficie de la llama) y
3
x (proporcional al volumen).

Con RK4 (no con RK24 q se cuelga!), despus d largo rato, el Matlab da una respuesta pero sta requiere de 200000 puntos!!

Una alternativa es usar un mtodo que no use el mismo paso siempre, sino que lo achique, o agrande segn haga
falta. Presentamos (y empezamos a programar) el Mtodo de Bogacki-Shampine : BS23 (el 23 hace alusin a que
compara en cada paso) un mtodo de orden 2 y uno de orden 3, y achica el paso si no se cumple cierto criterio.

Escribamos el algoritmo de BS23, que tambin est en la pgina web de la materia (lirweb):

function [t,X]=BS23(f,t0,X0,tf,h,tol)
if nargin==4
h=abs(tf-t0)/100;
tol=0.001;
end
if nargin==5
tol=0.001;
end
k=2;
err=tol+1;
BANDERA=0;
t(1)=t0;
X(:,1)=X0;
hutil=h;
h1=hutil;
while(BANDERA==0)
hutil=min(h1,abs(tf-t(k-1)));
h1=hutil;
while(err>tol)
Mtodos Numricos

hutil=h1;
s1=f(t(k-1),X(:,k-1));
s2=f(t(k-1)+hutil/2,X(:,k-1)+s1*hutil/2);
s3=f(t(k-1)+hutil*(3/4),X(:,k-1)+s2*hutil*(3/4));
temp1=X(:,k-1)+hutil*(2*s1+3*s2+4*s3)/9;
s4=f(t(k-1)+hutil,temp1);
err=((6*s2+8*s3-5*s1-9*s4)/72)*hutil;
h1=hutil*0.7;
%pause
end
t(k)=t(k-1)+hutil;
X(:,k)=temp1;
%pause
%h1=min(h1*4,h);
h1=min(h1*2,10*h);
if t(k)==tf
BANDERA=1;
end
err=tol+1;
k=k+1;
end

--------------------------------------------------------------------------------------------------------
Y tomamos el mismo problema:

>> f=@(t,x) x.^2- x.^3
>> delta=0.00001;
>> [t,x ]=BS23(f ,0 ,delta ,2/delta ,2, 0.0000001);
>> plot(t,x,' o ')
>> size(t) % necesita del orden de la sexta parte de los puntos q RK4 (y RK24 se colgaba)
35000 (aprox) esperando un poquiito
>> delta=0.0001;
>>[t,x ]=BS23(f ,0 ,delta ,2/delta ,20, 0.001);
>> plot( t, x,' o ')
Mtodos Numricos

0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
x 10
5
0
0.2
0.4
0.6
0.8
1
1.2
1.4

Idem (casi inmediatamente) En los casos razonables es ms rpido!!!

Con programas del matlab:
>> ode23s(f,[0 2/delta],delta)
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
x 10
5
0
0.2
0.4
0.6
0.8
1
1.2
1.4

>> ode45(f,[0 2/delta],delta)
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
x 10
5
0
0.2
0.4
0.6
0.8
1
1.2
1.4

----------------------------------------------------------------------------------------------------.

Queremos plantear a continuacin otro tipo de ecuacin diferencial:
Mtodos Numricos

Ejemplo: (tipo oscilador armnico)
Hallar R x ] 2 , 0 [ : tal que
=
=
= +
3 ) 2 (
2 ) 0 (
) * 2 sin( ) ( ) ( ' . * ) cos( * 2 ) ( ' '
x
x
t t x t x t t x
. Este es un Problema de CONTORNO.

Solucin:

Tenemos datos en ambos bordes del intervalo [0,2], pero no podemos usar directamente ninguno de los mtodos
que vimos, ya que si ponemos: haciendo la representacin (el cambio de coordenadas):

|
|
\
|
=
|
|
\
|
+
=
|
|
\
|
+
=
|
|
\
|
=
|
|
\
|
=
|
|
\
|
=
! ! ! ! !
?
?
) 0 (
) 2 ( * ) cos( * 2 ) 1 ( ) * 2 sin(
) 2 (
'
) cos( 2 ) 2 sin( ' '
'
'
:
'
2 1
2
2
1
inicial velocidad la conocemos no X
X t X t
X
X
x t x t
x
x
x
X
queda problema el
x
x
x
x
X
3 ) 2 )( 1 ( = = t X

Cmo podemos encararlo?

Una idea natural es probar: Es decir, ensayo un valor supuesto para V(0) (la velocidad inicial) y fijarse cuan cerca
(o lejos) estamos de que X(2)=3

>> f=@(t,X) [X(2) ; sin(2*t)-X(1)+2*cos(t)*X(2) ]
>> V=0.5; % como 1er conjetura, como la pendiente d la recta por (0,2) y (2,3) es 0.5 pruebo apuntar derecho
>> [t ,X ]=RK24(f,0,[2;0.5],2,0.01);
>> X(end) Supuestamente no va a dar 3 justo.
ans =
-1.9871

Se propone ir probando otros valores de V, hasta obtener resultados que mejoren la puntera.
De hecho a sta bsqueda se la llama SHOOTING.

Podemos probar un poquito a mano y luego tratar de programar una forma ms sistemtica (por ejemplo probando
con distintos v entre -10 y 10 cada 0.1 (con un ciclo for) y luego refinando).

-----------------------------------------------------------------------------------------------------------
>>k=1;
>> for v=-10: 0.5 :10
[t ,X ]=RK24(f,0,[2;V],2,0.01);
Valfin(k)=X(1,end)
Mtodos Numricos

K=k+1;
end
>> plot(Valfin)
Y localizamos cul es el k para el que Valfin est ms cerca de 3 y guardamos ese V.

Una forma ms sistemtica consistira en plantearlo como un problema de bsqueda de soluciones de una ecuacin
(aunque en realidad lo anterior no se descarta, ya que haba que tener una idea previa de por dnde hallar la
solucin) y resolverlo con Newton-Raphson, o Biseccin, u otro mtodo.
Por ejemplo, programamos:
function xf=valorfinal(v)
f=@(t,X) [X(2) ; sin(2*t)-X(1)+2*cos(t)*X(2) ]
[t,X]=RK24(f,0,[2;V],2,0.01);
xf=X(end)

y a partir del v que tenamos de la bsqueda anterior (pongmosle v=1.2), resolvemos:
>>sol=NR_MULTI(@valorfinal,1.2,8)
1.2341 (pongmosle)
>>[t,X]=RK24(f,0,[2;sol],2,0.01);
>>X(1,end)
ans= 3.0000
>>plot(t,x) % la solucin del Problema de Contorno
>> [t ,X ]=RK24(f,0,[2;sol],2,0.01);
>> X(1,end)
ans =
3.0000
>> plot(t,X(1,:))
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
2
2.5
3
3.5

********************************************************************************************************
Mtodos Numricos

Planteamos otro problema de contorno:
Ejercicio:
Hallar
|
|
|
|
|
\
|
=
) (
) (
) (
) ( , ] 3 , 0 [ :
3
2
1
1 3
t X
t X
t X
t X R X
x
tal que
|
|
|
|
|
\
|
=
=
=
=
0 ) 3 (
5 . 1 ) 3 (
1 ) 0 (
2
) ( ) (
) (
) (
) (
3
2
1 3
1
2
X
X
X
t X t X
t X
t X t
t X

Resolucin:
Creamos una funcin H que reciba como entrada valores a y b, de modo que asignando
=
=
=
b X
X
a X
) 0 (
1 ) 0 (
) 0 (
3
2
1
resuelva el problema de
valores iniciales con dichos datos, y que para la X solucin del mismo devuelva como valor de H el vector columna:
|
|
|
\
|
|
|
\
|

=
) 3 (
5 . 1 ) 3 (
3
2
X
X
b
a
H de manera que si
|
|
\
|
|
|
\
|
=
0
0
b
a
H entonces
=
=
0 ) 3 (
5 . 1 ) 3 (
3
2
X
X
-y como tambin pedimos
1 ) 0 (
2
= X entonces tendremos la solucin del problema de contorno.
Para la solucin usemos, por ejemplo RK4. Entonces programamos:

function valH=H(v) %v=(a;b), o sea v(1)=a y v(2)=b
f=@(t,X) [t*X(2) ; X(1); X(3)-X(1) ];
[t,X]=RK4(f,0,[v(1);1;v(2)],3,0.01);
valH=[X(2,end)-1.5;X(3,end)];

Y disparamos algunos valores de prueba.
>> H([0.2;0.4])
ans =

13.1237
-21.4529
Mtodos Numricos

>> H([0.3;-2])

ans =

14.6929
-73.8748

>> H([-0.9;0.001])

ans =

-4.1367
16.9160

Este ltimo parece un punto de partida adecuado para buscar una solucin, es decir hallando donde H(0)=(0;0).
Usemos de nuevo NR_MULTI

>>sol=NR_MULTI(@H, [-0.9;0.001],10)

sol =

-0.6364
-0.2878

Verifiquemos:

>> H(sol)

ans =

1.0e-015 *

-0.2220
0.5516
Muy aceptable (casi [0;0])

Calculemos la solucin y veamos que cumple lo pedido:
>> f=@(t,X) [t*X(2) ; X(1); X(3)-X(1) ];
[t,X]=RK4(f,0,[sol(1);1;sol(2)],3,0.01);
Mtodos Numricos

>> X(:,1)

ans =

-0.6364
1.0000
-0.2878

>> X(:,end)

ans =

2.3915
1.5000
0.0000

Y se ve que cumple las condiciones de contorno:
0 ) 3 (
5 . 1 ) 3 (
1 ) 0 (
2
3
2
=
=
=
X
X
X

Problema de Eventos

Llamamos as a aquellos problemas donde se busca la solucin de una ecuacin diferencial en un intervalo [to,T], donde to est
dado, y el T corresponde a un tiempo a determinar donde ocurre que la solucin, en tiempo T, satisface alguna condicin
dependiendo de X(T) y las derivadas de X en T (all sucedeun cierto evento).

Podemos, por lo general, tambin plantear dicho problema como una bsqueda de ceros de una funcin univariada o
multivariada-.

A continuacin vemos un ejemplo:
Mtodos Numricos

Consideremos el siguiente Problema de Eventos:

Cierto mvil de masa 1 responde a la siguiente ley de movimiento:

=
=
= +
0 ) 0 ( '
1 ) 0 (
1 ' ' . ) ' (
2
y
y
y y y

Halle T>0 tal que la energa cintica ) ) ' .( 1 .
2
1
. .
2
1
(
2 2
y velocidad masa = del mismo sea
4
1
(en unidades
2
] [ ]. [ v m ).
O sea, las que sean unidades de masa por las que sean las de velocidad al cuadrado, o sea que resolviendo
numricamente como si no hubiera unidades.

Resolucin Numrica:

Planteamos:
=
=
=
0 ) 0 ( '
1 ) 0 (
) ' ( 1
' '
2
y
y
y
y
y
con
|
|
|
\
|
=
|
|
\
|
=
|
|
\
|
=
|
|
\
|
=
1
2
2
2
2
1
) ( 1
' '
'
'
'
y
y
y
y
y
Y
y
y
y
y
Y , o sea,
|
|
\
|
=
|
|
|
\
|
=
0
1
) 0 (
2 ).^ ( 1
'
1
2
2
Y
y
y
y
Y

Y armamos una funcin que para cada T calcule la energa cintica en T:

function ec=G(T)
f=@(t,Y) [Y(2) ; (1-Y(2).^2)/Y(1) ];
[t,Y]=ode45(f,[0 T],[1;0]);
ec=(Y(end,2)).^2*0.5
T=0.5210
Y en lnea de comandos planteamos la solucin de G(T) -
4
1
= 0

>> Gmenos1_4=@(T) G(T)-0.25
>> T=NR_MULTI(Gmenos1_4,0.5,12);
>> 1.0000

En este caso, en realidad puede confirmarse que este valor es correcto, resolviendo la ecuacin:

Mtodos Numricos

1 ' ' . ) ' (
2
= + y y y equivale a : + = + = = + = = q t k t y
q
t k
t y
k t
y
k t y y y y . 2
2
.
2 2
)'
2
( ' . 1 )' ' . (
2 2
2 2 2

2 2 2 2 2
) ( ) ( k q k t y k q k t y + = + = sup y>0.
Con y(0)=1=q
Y=
2 2
1 ) ( k k t
k t
+

Y(0)=0=
1
k
k=0
( ) ( ) 1 1 1 2
2
1
1 4
1
1 2
1
'
2
1
1
) ( '
1
) ( ' 1 ) (
2 2 2
2
2
2
2
2
2
2
2
2
2
= = + = =
+
=
+
=
+
=
+
= + = t t t t
t
t
t
t
y
t
t
t y
t
t
t y t t y

pues t>o.
-----------------------------------------------------------------------------------------------.

Ahora vamos a considerar brevemente otro tema acerca del Anlisis de Frecuencias de una serie de datos.

La cuestin puede tratarse a partir del caso continuo con ventajas e inconvenientes-, pero en esta ocasin
preferiremos verlo directamente para series de datos discretos, que podemos ver como secuencias de mediciones
temporales (series de tiempo) y lo que queremos es medir la contribucin de las diferentes frecuencias a los valores
de la serie.

Dada una serie temporal: ) ..., ,......... , (
1 1 0 N
x x x (es decir x(n)=
n
x con n=0,1,,N-1)
La idea es escribirla como:
=
1
0
2
. ) (
N
f
f
N
n
if
X e n x
con
=
= =
1
0
2
) (
) ( . .
1
N
t
N
t
if
f f
t x e
N
X X

La igualdad anterior vale porque el producto escalar:
dn e e X e e X e n x
N
N
n
il
N
n
if
f
N
n
il
N
n
if
f
N
n
il

>= < >= <
0
2 2 2 2 2
.
2
1
. , ), (

con ) , ( .
2
1
0
2 2
l f dn e e
N
N
n
il
N
n
if

la Delta de Kronecker , ya que:
si f l = es 1 .
2 2
=

N
t
il
N
t
if
e e

con

2 .
0
2 2
=

dn e e
N
N
n
il
N
n
if

si f l queda 0 por la periodicidad de .
2
N
k
i
e

Mtodos Numricos

Luego:
f
N
n
il
X e n x >= <
2
), (

Recapitulando:
=
1
0
2
.
N
f
N
n
if
f
e X x
es la descomposicin de x en la b. o. n.
F f
N
n
if
e
)
`
2
donde F es el conjunto
de frecuencias representables.

Para que valga la representacin, debemos tener un conjunto de N frecuencias, que en realidad son simtricas
respecto del 0 (para una seal real), es decir f en ]
2
,
2
[
N N
(pero por periodicidad podemos asumir f en [0,N-1],
- y en realidad las distintas son de 0 a
2
N
).
Esto es equivalente a no exceder la Frecuencia de Nyquist, - para estimar lo que ocurre con frecuencia de 1
segundo hace falta realizar muestreo al menos cada medio segundo-.
Recordemos
=
=
1
0
2
. .
1
N
t
t
N
t
if
f
x e
N
X

Si n=0
=
=
1
0
0
.
1
N
t
t
x
N
X (el promedio de
t
x ) constante en arg=0

Si n=1
=
=
1
0
2
1
. .
1
N
t
t
N
t
i
x e
N
X

Etctera.
Para cada f se gira
N
t
if
e
2
y se mira la proyeccin (que es mxima cuando
t
x da los conjugados girando a la misma
velocidad y sentido opuesto).

Esto requerira ) ( ) . (
2
N O N N O = con distintas velocidades angulares.

Pero hay una forma ms aguda de hacerlo:

Mirar la contribucin de los promedios como frecuencia N (en lugar de 0). ( Si N es entero 1
0 2
2
= =
i
N
N
i
e e

)

Mtodos Numricos

Luego mirar la frecuencia
2
N
, luego
4
N
,., etc. Con ellas, y usando la periodicidad para cada intervalo
frecuencial, slo hace falta ver las contribuciones de frecuencias N ,
2
N
,
4
N
,
8
N
,, 1 (y las dems se
deducen de estas).

Esto requiere (si
k
N 2 = ) los datos para
N=
k
2 ,
1
2
2
=
k
N
,
2
2
4
=
k
N
,.,
1
2
)
2
(
=
Nyquist
N
N
= k datos (por N) y k N =
2
log .

Luego con N N k N
2
log . . = datos reconstruimos la descomposicin frecuencial.

Este esquema, que permite calcularla con un algoritmo ) ( ) log . (
2
2
N O N N O << se llama TRANSFORMADA
RAPIDA de FOURIER (FFT) por Fast Fourier Transform.

(Si 000 . 000 . 000 . 1000 10 10 2
12 2 6 20
= = N N y 000 . 000 . 20 log .
2
N N )

Hay varias sutilezas y rebusques cuando
k
N 2 , en los que no entraremos.

Usaremos las funciones fft (y su inversa: ifft) de MATLAB.

Una observacin til es que si la serie no es estacionaria (si tiene tendencias de mayor orden que 0 lineales (o de
mayor orden an)-) la representacin en frecuencias converge lentamente porque tienen componentes en cada
frecuencia- , y la representacin discreta adolece por lo general de aliasing (superposicin de frecuencias).
Por ello es til extraer previamente (si corresponde) las tendencias lineales (eventualmente otras, pero las lineales
son, por mucho, las ms usuales). Ello puede hacerse hallando el polinomio de cuadrados mnimos de orden 1, y
restndoselo a la seal.

Un par de ejemplos:

-----------------------------------------------------------------------------------------------------------

1ro) Una en que sea estacionaria: (verificacin ver que polyfit(x,1) tiene 1er coeficiente 0 (la pendiente))

Podemos bajarla de la pgina, pero la construmos previamente con, por ejemplo:

>> t=0:255;
>> x=2*exp(2*pi*i*5*t/255)+2*exp(-2*pi*i*5*t/255)-3*exp(2*19*i*pi*t/255)-3*exp(-2*pi*19*i*t/255)+randn(size(t));
Mtodos Numricos

>> plot(t,x)
>> X=fft(x);
>> plot(abs (X))

Habr solo dos frecuencias dominantes.
Podemos eliminar el ruido anulando las frecuencias menores.

>> M=max(abs(X));
>> XL=X;
>> for k=1:max(size(XL))
if abs(XL(k))<0.1*M % es el 10% del maximo
XL(k)=0;
end
end
>> plot(XL)
>> XL=abs(ifft(XL));
>> plot(XL)

-------------------------------------------------------------------------------------

Ejercicio: Hacer lo mismo con otra seal: x= lo mismo + 0.01*t.
Retirar primero la parte lineal (gurdese en xlin ) con polyfit .
Solucin:

>> plot(x)
>> xlin=polyval(polyfit(x,1),t);
>>xestacionaria=x-xlin;
>>plot(xestacionaria)
>> X=fft(x);
>> plot(X)
>> M=max(abs(X));
>>XL=X;
>> for k=1:max(size(XL))
if abs(XL(k))<0.1*M % es el 10% del maximo
XL(k)=0;
end
end
>> plot(XL)
>> plot(abs(XL))
>> plot(t,x,t,xL)
Mtodos Numricos

>> xestacionaria=abs(ifft(XL));
>> xlimpia=xestacionariaL+xlin
>> plot(xlimpia)
----------------------------------------------------------------------------------------------------------------
0 50 100 150 200 250 300
-15
-10
-5
0
5
10
15
0 50 100 150 200 250 300
0
100
200
300
400
500
600
700
800

0 50 100 150 200 250 300
-15
-10
-5
0
5
10
15

Comparamos la serie y su limpiada.. MUY ACEPTABLE
0 50 100 150 200 250 300
-15
-10
-5
0
5
10
15
0 50 100 150 200 250 300
-15
-10
-5
0
5
10
15

Guía de Estudio

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

Guía de Estudio

Transféré par

Droits d'auteur :

Formats disponibles

Mtodos Numricos

Romina Cardo & lvaro Corvaln

. La norma ms frecuente es la eucldea (o usual), correspondiente a p = 2.

pues en Matlab la traspuesta es la tilde vertical),

0; * ,3) : , L(: de copia = ,3) : , L(: de copia >>

Mn Cuadrados de polinomio del orden

= , o sea fijar N equivale a fijar

por el Teo de Lagrange, y en [0,1] es ) ( sen < ) 1 ( sen <1.

Vous aimerez peut-être aussi