X - CEIUCAWeb
Anuncio
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Párrafo Preliminar
Las páginas que siguen intentan servir de guía para el estudio de un primer curso de Métodos Numéricos, en el
sentido clásico de recurrir a linealizar métodos que tratan generalmente con variables continuas –usualmente
discretizadas- (tratando de prestar atención a las limitaciones inherentes a la representación numérica de los
mismos).
La implementación 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 bibliografía sugerida en el curso y/o a la documentación propia del
mismo, para cualquier duda o explicación sobre este.
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Aritmética de punto flotante
Debido a las dificultades para trabajar con una representación numérica que abarque a todos los números reales, es
habitual el uso de sistemas en los que se puede representar –y operar con sus elementos– un subconjunto finito de
IR. Los más frecuentes son los de aritmética de punto flotante:
Fijada una base de numeración b (generalmente b = 2, pero para operar a mano muchas veces daremos ejemplos
con b = 10), se representan exactamente aquellos números cuya expresión con base b es de la forma:
x = ±0.a1 a 2 ...a m ⋅ b p con a1 ≠ 0, a j ∈ {0,1,..., b} para j = 2,..., m , r ≤ p ≤ R donde r y R son números enteros, ó x = 0
(la representación del 0 se hace aparte). Se pide que a1 ≠ 0 para evitar el que haya distintas representaciones de un
mismo número (ya que por ejemplo: 23 = 0.23000 ⋅ 10 2 = 0.02300 ⋅ 10 3 = 0.00023 ⋅ 10 5 ; pidiendo a1 ≠ 0 solo es válida
la primera representación: 23 = 0.23000 ⋅ 10 2 .
En binario es particularmente elegante, ya que como a1 ≠ 0 debe ser a1 = 1 (y a j = 0, ó a j = 1, para j = 2,..., m ), por
lo que el “0.1” inicial se presupone siempre, de modos que sólo hace falta guardar en memoria el contenido de m-2
bits para los dígitos 1 ó 0 de a 2 ,..., a m , junto a un bit adicional para el signo, y se suelen elegir r y R de modo que
R − r = 2 k − 1 , de modo que haya 2 k exponentes posibles para la base 2, y ello se puede guardar entonces con k
bits (sin desperdiciar combinaciones), frecuentemente R = 2 k −1 y r = −(2 k −1 − 1) , por ejemplo r = -31, R = 32 (y por lo
tanto − 31 ≤ p ≤ 32 ). O sea que cualquier número de la forma x = ±0.a1 a 2 ...a m ⋅ 2 p con a1 ≠ 0 y a j ∈ {0,1} para j > 2
se representa con exactamente m-1 + k bits.
Escribamos algunos de los números de punto flotante con alguna elección de b,m,r y R para observar sus
características: Si b es 10, m es 3, r es -4 y R es 5, podemos representar exactamente los siguientes número
positivos (y además sus opuestos y el 0) –a la izquierda en punto flotante, y a la derecha en notación usual):
0.100 ⋅10 −4 = 0.0000100
0.101 ⋅10 −4 = 0.0000101
−7
diferencia entre números consecutivos : 0.0000001 = 10
...
−4
0.999 ⋅10 = 0.0000999
0.100 ⋅10 −3 = 0.0001000
0.101 ⋅10 −3 = 0.0001010
−6
diferencia entre números consecutivos : 0.000001 = 10
...
−3
0.999 ⋅10 = 0.0009990
…
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
…
0.101 ⋅101 = 1.01
−2
diferencia entre números consecutivos : 0.01 = 10
...
1
0.999 ⋅10 = 9.99
0.100 ⋅101 = 1
…
…
0.100 ⋅10 5 = 10000
0.101 ⋅10 5 = 10100
2
diferencia entre números consecutivos : 100 = 10
...
5
0.999 ⋅10 = 99900
Notamos que la distancia entre números consecutivos va aumentando cuando aumenta el rango decimal de números
considerados.
Los mil primeros números representables –entre el menor número positivo representable exactamente:
-llámémoslo “min” = 0.100 ⋅10 −4 = 0.0000100 - y el milésimo: 0.100 ⋅ 10 −3 = 0.0001000 distan uno del otro en
0.0000001 (un diezmillonésimo)
Los últimos mil números representables están separados de 100 en 100 (10000, 10100, …, 99800, 99900).
Precisamente 99900 es el mayor número representable. Lllamémoslo “max” = 99900.
Los números entre 0.100 ⋅10 −4 = 0.0000100 y 0.999 ⋅105 = 99900 se redondean al número representable más
próximo.
De esta manera, en esta aritmética de punto flotante, si bien, por ejemplo, los números 74500 = 0.745 ⋅ 10 5 y
23 = 0.230 ⋅ 10 2 son representables exactamente, no lo es su suma. De hecho, si por abuso de notación denotamos
con + el resultado en punto flotante de la suma de dos números, entonces “ 74500 + 23 = 74500 ”. En efecto,
realmente es 74500 + 23 = 74523 = 0.74523 ⋅ 10 5 , que no es representable exactamente, estando entre
0.745 ⋅ 10 5 = 74500 y 0.746 ⋅ 10 5 = 74600 que sí son representables. Y el más cercano a 74523 es el menor de ellos:
0.745 ⋅ 10 5 = 74500 , y por ello en esta aritmética de punto flotante es: “ 74500 + 23 = 74500 ”. El menor número
positivo que, representable en aritmética de punto flotante que sumado a 74500 no da como resultado 74500 es 100,
o sea 0.100 ⋅ 10 2 = 100 . Se dice que 100 es el épsilon de máquina de 74500. De hecho es el épsilon de máquina de
todos los números representables entre 10000 y 99900.
De análoga manera, 0.0000001 = 10 −7 es el épsilon de máquina de 0.100 ⋅10 −4 = 0.0000100 y de todos los números
entre 0.100 ⋅10 −4 = 0.0000100 y 0.999 ⋅ 10 −4 = 0.0000999 . Por su parte, el épsilon de máquina del 1 (y de todos los
números entre 1 = 1.00 = 0.100 ⋅ 101 y 9.99 = 0.999 ⋅ 101 es 0.01 = 0.100 ⋅ 101 .
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Los números comprendidos entre “min” y “max” se redondean al número representable más próximo: Por ejemplo
0.3472 ⋅ 10 2 = 34.72 se redondea a 0.347 ⋅ 10 2 = 34.7 , y 0.3478 ⋅ 10 2 = 34.78 se redondea a 0.348 ⋅ 10 2 = 34.8 ,
igualmente 34.749, 34.7499, 34.7499999, etc se redondean a 34.7, y en cambio 34.7501, 34.750001, 34.7500001, etc,
se redondean a 34.8. Por simetría, 34.75 se redondea a 34.8 (es decir hacia arriba) –así la mitad de los dígitos x
después 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 número el representable más próximo depende de en qué rango está,
de modo que si estamos entre 10000 y 99900, podemos cometer un error de redondeo de hasta
1
⋅ 100 = 50
2
unidades, por ejemplo 24350 = 0.2435 ⋅ 10 5 se redondea por 24400 = 0.244 ⋅ 10 5 con un error de 50, que
evidentemente es la mitad del épsilon de máquina para el rango de 10000 a 99900.
Por su parte, el error absoluto al redondear 24.35 = 0.2435 ⋅ 10 2 por 24.4 = 0.244 ⋅ 10 2 es
1
⋅ 0.1 = 0.05 que
2
evidentemente es la mitad del épsilon de máquina 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
1
1
⋅ 100
⋅ 0.1
1
2
2
menor número del rango (10000 en el primer caso, 10.0 en el segundo), este es
=
= 0.01 , es decir la
10000
10
2
mitad del épsilon de máquina del 1. Es decir que el épsilon de máquina del 1 es una característica de la aritmética de
punto flotante considerada, y no depende del rango de valores en que esté el número a redondear (siempre que esté
entre “min” y “max”).
Por eso, al épsilon de máquina del 1 lo llamamos directamente épsilon de máquina (propiamente dicho).
Una operación 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 operación que da un número 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 aritmética de punto flotante pueden obtenerse invocando “realmax” (lo
que llamamos “max”), “realmin” (lo que llamamos “min”), eps (el épsilon de máquina propiamente dicho, es decir el
de 1). La función eps() da el épsilon de máquina de un numero cualquiera.
Ejercicio
Con la aritmética de punto flotante mencionada arriba calcule:
i)
40+(60+10000)
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
ii)
(40+60)+10000
¿Qué conclusiones puede sacar de ello?
Normas vectoriales y matriciales
La mayoría de los problemas que somos capaces de tratar numéricamente, lo son, total o parcialmente, mediante
linealización. Es decir que en algún punto se aproximan por un modelo lineal.
Es por eso que en muchos paquetes numéricos se recurre a librerías de algoritmos de álgebra matricial. En particular
Matlab es esencialmente una interfaz para acceder a las librerías LINPACK y EISPACK.
Algunas cuestiones que en álgebra lineal exacta están definidas con precicón son algo más borrosas en álgebra
lineal numérica.
Por ejemplo:
A=[1 1+eps;1+eps 1+2*eps]; (donde eps es el épsilon de máquina) 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 numéricamente: >> (1+eps)*[1 1+eps]-[1+eps 1+2*eps]
ans =
0 0
Es decir que las filas son numéricamente l.d.
Y de hecho el rango de la matriz (numéricamente, en Matlab) es 1.
Es entonces necesario poder medir cuándo dos vectores o matrices son “casi iguales”, “casi nulas”, “casi l.d.”.
Para ello introducimos métricas mediante normas vectoriales y matriciales.
En IR n ≅ IR nx1 ≅ IR 1xn están disponibles las normas p: ( a1 ,..., a n )
(a1 ,..., a n )
∞
p
(
p
= a1 + ... + a n
)
p 1/ p
para 1 ≤ p < ∞ , y
= max( a1 ,..., a n ) . La norma más frecuente es la euclídea (o usual), correspondiente a p = 2.
Se puede probar que todas las normas p son comparables entre sí (cada una mayora a algún multiplo positivo de
cualquier otra), pero para determinada cuestión una u otra puede ser más 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 sólo se define A
p
= max AX , pero el cálculo efectivo en general es difícil (por la maximización),
X
p
=1
por lo que están 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.
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
La norma de Fröbenius: norm(A,’fro’), que consiste en la raíz cuadrada de la suma de los cuadrados de todos los
elementos de la matriz.
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Descomposiciones matriciales
A continuación veremos que, en muchas circunstancias, es posible escribir una matriz como productos de matrices
que, en algún sentido son más sencillas o más 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 descomposición. Por ejemplo, si la matriz cuadrada A, de n x n, tiene n autovectores linealmente
independiente, es posible escribir a A como: A = C * D * C −1 , donde D es una matriz diagonal, tal que los elementos
de la diagonal satisfacen que A * C j = D jj * C j , donde el escalar D jj 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 diagonalización de una matriz A = C * D * C −1
y
A 0
0 U
0 0
D =0 0
0 0
0 0
0 0
0 0 0
0 0 0
T 0 0
0 O 0
0 0 V
0 0 0
0 0 0
0
0
0
0
0
A
0
0
0
0
0
0
0
L
A
A
U
U
T
T
(con C = O ......... O .
V
V
E
E
C n
C 1
) 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 descomposición en Valores Singulares (SVD: Singular Value Decomposition):
Dada A ∈ R nxk , ∃ U ∈ R nxn , S ∈ R nxk y V ∈ R kxk tales que :
• U es ortogonal de nxn (o sea U −1 = U t = U ' pues en Matlab la traspuesta es la tilde vertical),
• V es ortogonal de kxk (o sea V −1 = V t = V ' )
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
• S es seudodiagonal de nxk
o,
s11
0
0
0
0
S =
0
.
.
.
0
0
.
0
0
0
.
0
0
.
0
0
.
0
0
0
.
0
.
.
.
.
s11
0
(mismo tamaño de A) , o sea, S = 0
0
0
0
0
0
s11 0
0
0 .
s nn
si n>k ,
o
S = 0 0
0
0 0
.
0 0
.
.
0
s11 , s 22 ,..., sii ,..... se llaman VALORES SINGULARES,
• A = U * S * V ' (o sea U * S * V
−1
ya que V ' = V
0 0 0
0
0 0
.
0 0
0
0 0
0 . 0
0 0 .
0
0
.
.
0 0 0 s nn
0
0 0 0
. 0 0
0 . 0
0 0 s nn
.
.
.
.
.
.
.
.
0 0
0
.
. si k>n ,
.
0
0 0
si n=k ; con s11 ≥ s 22 ≥ .... ≥ 0
donde
vale que:
−1
, de forma análoga a la diagonalización).
Proposición: cond(U)=1 y cond(V)=1 .
(con Matlab el número de condición se calcula con el comando “cond”, y para U y V es 1 , ya que son matrices ortogonales).
Recordemos que el Número de Condición es el mayor factor por el que se pueden llegar a multiplicar los errores relativos al
aplicarle la matriz a un vector.
s11
si n > k
s kk
máximo valor singular
cond ( A) := cond ( S ) =
o
=
mínimo valor singular s11
si k > n
s nn
.
Si A es cuadrada, esto coincide con la definición anterior,
Si A es rectangular, la igualdad anterior cond ( A) := cond ( S ) se toma como la definición de cond(A) (y en cualquier caso,
numéricamente siempre se calcula así ).
Practicamos con el Matlab, y abrimos la aplicación “eigshow”, poniendo:
>> eigshow (en la ventana de comandos) así abre la aplicación con la primera matriz de una galería de matrices.
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Observación:
>> eigshow (A)
con A una matriz de 2x2 , abre la aplicación 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 también son perpendiculares, allí tenemos el cambio de base de la svd, y las longitudes de Ax y Ay son s11 y s 22
(los valores singulares de la diagonal de S).
Ax
y
Ay (o viceversa representan la máxima dilatación o contracción, y por eso el cociente mide el mayor factor por el
que puede multiplicarse el error relativo al multiplicar por A, y por eso cond ( A) := cond ( S ) =
s11
.
s 22
En Matlab el comando “svd” trabaja como el comando”eig” (que da autovectores y autovalores ) recordemos:
>> eig (A)
da los Autovalores si A es cuadrada
λ1
.
.
diagonal de D
λn
análogamente:
>> svd (A)
da los Valores Singulares
s11
.
diagonal de S.
.
s kk (o s nn )
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
• • •
>> [Matriz 1 , Matriz 2]=eig(A) , donde Matriz 1= • • •
• • •
λ1
0
Matriz 2= 0
0
0
da C= la matriz de autovectores (en columna) , y,
0
0
0 . 0 0 da D= matriz de Autovalores.
0 0 . 0
0 0 0 λn
0 0 0
. 0 0
Análogamente,
• • •
>> [Matriz 1 , Matriz 2 , Matriz 3 ]=svd(A) , donde Matriz 1= • • • da U ∈ R nxn
• • •
s11 0 0 0 0
0 . 0 0 0
0 0 . 0 0
s11 0 0 0 0 0 0 . . . 0
0 0 0 . 0
.
0 . 0 0 0 0 0
0 0 0 0 s
kk
Matriz 2 =
o, S = 0 0 . 0 0
. .
. da S= matriz de Valores Singulares
0 . . . 0
0
0
0
.
0
.
.
.
.
0 0 0 0 s
.
0 0 . . . 0
nn
.
.
.
.
0 . . . 0
Matriz 3 = V ∈ R kxk .
Planteamos un pequeño ejercicio consistente en tomar una matriz aleatoria de 9x5, hallar la svd y verificar las propiedades.
Su resolución sería:
>> A=randn(9,5)
>> [U,S,V]= svd (A)
da una matriz de 9x5 cuyos coeficientes están elegidos al azar con distribución normal estándar
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
U =
S =
V =
>> U *U '
1 . 0
0 . 0 la matriz identidad de 9x9 ¡!! Y así confirmamos la ortogonalidad de U.
0 . 1
>> V *V '
1 . 0
0 . 0 la matriz identidad de 5x5 ¡!! Y así confirmamos la ortogonalidad de V.
0 . 1
>>cond(U)
1
verificamos que U tiene condición 1
>>cond(V)
1
verificamos que V tiene condición 1
>>cond(S)
……….
>>cond(A)
……….
>>S(1,1)/S(5,5)
…………
dan los tres igual!!!! Y así verificamos que cond ( A) := cond ( S ) =
máximo valor singular
.
mínimo valor singular
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
Ahora ingresemos una matriz (tipo) A
1.0000
1.0001
5.0005
100.0010
10.0001
7.0000
2.0000 4.0000
2.0002 4.0003
10.0009 20.0020
200.0030 400.0040
20.0002 40.0005
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 mirándola uno diría que las 5 primeras filas son “casi” l.d. (linealmente dependientes), es decir, que son “casi” múltiplos de
~
la primera, y que en este caso uno puede dar “a ojo” una matriz A próxima a A , pero de rango 2 :
2
4
1
1
2
4
10 20
~ 5
A=
100 200 400
10 20 40
8
9
7
En una matriz más grande eso podría ser útil, por ejemplo para comprimir la información (A tiene 18 coeficientes, pero para
~
recordar A sólo tengo que guardar 10 números): 1,2,4,1,5,100,10,7,8 y 9 pues:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
fila1
1 2 4
( fila1) × 1
( fila1) × 5
( fila1) × 100
( fila1) × 10
7 8 9
Pero hacerlo a ojo en una matriz más grande es difícil.
Observemos que:
>> svd (A)
ans =
461.3432
5.3119
0.0002
O sea que:
0
0
461.3432
0
5.3119
0
0
0
0.0002
S=
0
0
0
0
0
0
0
0
0
También S de rango 3, de hecho rango(S)=rango(A) siempre!!
Más aún, internamente Matlab calcula el rango de cualquier matriz contando cuántos valores singulares (elementos de la
diagonal de S ) son ≠ 0 . (numéricamente es mucho más rápido que verificar independencia lineal de filas o columnas)
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Ahora es fácil encontrar una matriz “parecida” a S pero de rango 2 :
>> [U,S,V]= svd (A)
pongo en 0 el coeficiente 0.0002 que era “despreciable” respecto de 461.3432 y de 5.3119 .
>> S(3,3)= 0
0
461.3432
0
5.3119
0
0
Scambiada =
0
0
0
0
0
0
Entonces:
>> Aaprox=U*Scambiada *V '
0
0
0
0
0
0
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 U * S * V ' con la S retocada
sirve para una matriz cualquiera, aunque no sea fácil hacerlo “a ojo”.
Además, como las filas y columnas de ceros no aportan nada, sólo necesitamos guardar: (si decidimos conservar los primeros
“ele” valores singulares)
~
U =primeras “ele” columnas de U
s11 , s 22 ,..., sll (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 tamaño que A (de nxk) pero de rango l.
Enseguida programaremos una función que reciba como entrada A y l, y que devuelva la Aaprox de rango l, y otra función que
reciba A y ε con 0 ≤ ε ≤ 1 y devuelva l tal que sea el menor tal que: si j>l entonces s jj < ε .s11 , y lo usaremos para
comprimir imágenes.
********************************************************************************************************
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Primero armamos tres funciones de Matlab:
La primera recibe una matriz A y un número 0 ≤ ε ≤ 1 , y devuelve el índice del último valor singular (ordenados de mayor a
menor) tal que es mayor o igual que cierto número, veámoslo:
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;
64
37
64
14
37
9
⇒ nivel(A, 0.1) es 4 ( porque
son ≥ 0.1 * 64 = 6.4 )
Por ejemplo, si A tiene valores singulares:
14 y
5
9
1.2
0.8
0.04
64
37
14
Y nivel(A, 0.01) es 7 ( porque
son ≥ 0.01 * 64 = 0.64 )
9
5
1.2
y 0.8
La siguiente función calcula la descomposición 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);
Vr=V(:,1:ele);
Sr=S(1:ele,1:ele);
% primeras ele columnas de U
% primeras ele columnas de V
% primeras ele filas y columnas de S
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
La tercera función calcula la matriz de rango “ele” más próxima a una matriz A:
function Aap=aproxima(A, ele)
[Ur,Sr,Vr]=svdr(A, ele);
Aap=Ur*Sr*Vr';
2
4
7
1
20
40
70.02
10
5 10.01
20
35
.
Y ensayamos el funcionamiento en una matriz tipo:
− 2 − 4 − 8.003 − 14
7
5
3
1
2
4
3
− 11
Dijimos que lo usaríamos para Compresión de Imágenes:
• Descargamos del lirweb el archivo con la imagen de prueba: lena.bmp en ….. mis documentos\MATLAB
• La importamos como una matriz de números reales (por defecto es tipo entero pero svd solo puede usarse con matrices de
tipo real) La instrucción”double” transforma los enteros en tipo punto flotante de doble precisión, 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 255 = 2 − 1 ).
8
En realidad L ∈ R 512 x 512 x 3 (o sea, que son 3 matrices
Es R G B por red‐green‐blue.
una para cada color, por ejemplo: la 1era es el rojo ) .
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
>> copia de L=L;
>> copia de L(: , : ,2) = copia de L(: , : ,2) * 0;
en copia de L mandamos a 0 las intensidades de verde y azul.
>> copia de L(: , : ,3) = copia de L(: , : ,3) * 0;
>>image(uint8(copia de L))
axis equal
se ve como si tuviéramos anteojos rojos.
>>nivel(L(: ,:,1), 0.01)
% buscamos cuántos 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 podríamos guardar la imagen con nivel de
precisión del 99% usando ≅ 30% del tamaño 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
diagonalización), se usan para resolver sistemas lineales:
Factorización L‐U:
Dada A ∈ R nxn , ∃ L, U y P 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í:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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 descomposición LU nos permite resolver un sistema con matriz cuadrada arbitraria, en un problema de
resolución de sistemas triangulares mediante: P ∗ A=L*U, por lo tanto:
El esquema es:
Ax=b ⇔
PAx=Pb ⇔
LUx=Pb
Y si w es solución de Lw=Pb (con L triangular inferior) entonces x es solución de Ux=w (con U triangular superior)
la misma x tal que Ax=b
y reescribiríamos la función que resuelve con matrices triangulares inferiores:
function x=resuelveL(L,c)
x(1,1)=c(1,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
Ahora podemos usar ésta función para resolver (también) 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 función que aplique el esquema:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
function x=resuelve(A,b)
[L,U,P]=lu(A)
x=resuelveU(U, resuelveL(L,P*b));
La última línea corresponde al esquema de resolución por LU , y si, como ocurre muchas veces uno resuelve Ax = b1 ,
Ax = b2 , Ax = b3 ,…………………. con distintos b1 , b2 , b3 ,........... pero la misma A. Entonces vale la pena hacer:
[L,U,P]=lu(A) ; y guardar L,U y P , y para cada bi usar la línea : x=resuelveU(U, resuelveL(L,P* bi ));
Ejercicio:
a) Elegir una matriz aleatoria A grande (por ejemplo de 200 x 200 con randn) y un vector b fácil de verificar, por ejemplo:
1
2
3
b=(1:200)’ o sea: b = . . Hallar A ∗ x = b con las funciones anteriores y verifique (Ax debe dar =b)
.
.
200
b) Comparar el tiempo que demora resolver Ax = b1 ,…………., Ax = b20 para 20 vectores columnas al azar:
b j = randn(200,1) (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 bi la instrucción:
>> 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.
Observación: cond(P)=1 y luego cond(P*A)=cond(A)=cond(L*U) ≤ cond(L) . cond(U).
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Otra factorización que permite resolver sistemas es la Q‐R:
Dada A ∈ R mxn , ∃ Q ∈ R mxm ortogonal (o sea Q −1 = Q t ), R ∈ R mxn triangular superior y P ∈ R nxn de permutaciones
tales que A*P=Q*R (obsérvese que ahora P multiplica a derecha – en LU era a izquierda).
Esto tiene aplicación para resolver sistemas cuadrados, pero también rectangulares (aunque por un rato no nos preocuparemos
por especificar qué significa “resolver” un sistema que no sea cuadrado).
{A ∗ x = b . Llamando x=P*z , tenemos
⇔ {APz = b ⇔ {QRz = b ⇔ {Rz = Q' ∗ b ( Q −1 = Q t ) luego obtengo z resolviendo el sistema con R
El esquema ahora sería así:
∴
{A.x = b
triangular superior, entonces:
Ejercicio:
x=P*z
Programar la resolución con qr
El esquema para resolver se puede programar así:
( Observación:
[Q,R,P]=qr(A) es la sintáxis de Matlab para hallar la descomposición QR )
function
x=resuelve_con_qr (A,b)
[Q,R,P]=qr(A) ;
z=resuelveU(R,Q’ *b) ;
x=P*z
la misma que ya programamos para sistemas triangulares superiores
Ej: Podemos probarlo con la misma A=randn(200,200) y b=(1:200)’ de antes.
Observación:
cond(Q)=1 y cond(P)=1 (por ser respectivamente ortogonal y de permutaciones).
Así que cond(A)=cond(R).
Aquí tenemos controlado el número de condición.
Ahora vamos a pensar en qué sentido podemos resolver un sistema no‐cuadrado.
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Primer Caso: Más ecuaciones que incógnitas (sistema sobredeterminado)
Primer Ejemplo Motivador:
x
x1
x2
x3
.
.
xk
y
y1
y2
Dada una tabla:
y3
.
.
yk
y = ax + c tal que la distancia a los puntos de la tabla sea mínima:
Se pide:
Hallar la recta ~
x1 1
x 2 1
. . .
. .
x k 1
y1
y2
a
= . . tendría solución exacta si los puntos estarían alineados
c
.
yk
Ax=b
Como en general NO lo están, el sistema no tiene solución.
Idealmente sería Ax‐b=0 y por lo tanto, Ax − b
a
mínimos ” es x = tal que
c
Ax − b
2
2
2
2
= 0 . Lo que entendemos como solución aproximada “de cuadrados
≥ 0 sea mínima.
¿Cómo hallamos esa solución de cuadrados mínimos en general ?
mín Ax − b
( Nótese que esto puede pedirse para un sistema con A ∈ R mxn con m>n )
‐Asociado o no al ejemplo motivador de la recta del mejor ajuste‐
Estamos buscando el mínimo de (Ax‐b) . (Ax‐b) siendo “.” el producto escalar.
Ahora, seguramente habrán visto en Cálculo Avanzado que:
d (u ( x).v( x)) du ( x)
dv( x)
.v( x) + u ( x).
=
dxi
dxi
dxi
Entonces:
2
2
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
columna i de A
d( )
d (( Ax − b).( Ax − b))
d ( Ax − b).( Ax − b)
=2
= 2.
. ( Ax − b) = 0 si es mínimo debe ser
=0
o fila i de A'
dxi
dxi
dxi
y debe ser 2. A’ * (Ax‐b)=0 ⇔ A’ * Ax‐A’b=0 ⇔ A’ * Ax=A’b
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 métodos que teníamos para
resolver sistemas cuadrados para resolver A’ * Ax=A’ * b.
Ejercicio:
Con la tabla
x
y
0.21 16.3
1.5
54.0
2.8 95.5
5.1. 161.8
10.5. 328.1
20.1 615.2
a) Hallar la recta de cuadrados mínimos
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 verosímil.
c) Hallar la diferencia (en norma 2) entre la recta y los puntos :
y mc − y
2
********************************************************************************************************
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Recordemos que si tenemos un sistema sobredeterminado:
Ax=b con A ∈ R mxn , con m>n (más ecuaciones que
incógnitas) y A de rango completo, entonces la solución (aproximada) de cuadrados mínimos ( o sea, x ∈ R nx1 / Ax − b
mínima), coincide con la solución exacta del sistema compatible determinado: A’ * A*x=A’ * b.
Evidentemente, si Ax=b es determinado, la solución de cuadrados mínimos coincide con la solución exacta ( ya que es
Ax − b
2
= 0 que claramente es mínima).
Dijimos que hay varias formas entonces de hallar la solución:
• Con la función “resuelve” (que habíamos programado usando la descomposición 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);
for j=2:max(size(c))
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 función “resuelve qr” (que habíamos programado usando la descomposición QR )
( Observación:
[Q,R,P]=qr(A) es la sintáxis de Matlab para hallar la descomposición QR )
function
x=resuelve_con_qr (A,b)
[Q,R,P]=qr(A) ;
z=resuelveU(R,Q’ *b) ;
x=P*z
la misma que ya programamos para sistemas triangulares superiores
2
sea
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
• Observando que A’ * A*x=A’ * b tiene a A’ * A cuadrada e inversible (porque A es de rango completo y ∴ también lo son
a A’ ,y,
A’ * A ) y entonces x = ( A'*A) −1 * A'*b .
En general habíamos desaconsejado resolver sistemas Ax=b haciendo x = A −1 * b , aunque existiera A−1 , ya que el cálculo de
la inversa es costoso O ( N 3 ) en lugar de O ( N 2 ) para el método de Gauss – o sea, con LU‐.
Pero A’ * A es simétrica y definida positiva y ∴ existen algoritmos O ( N 2 ) para hallar la inversa (por ejemplo con Cholesky,
aunque no lo mencionaremos).
Además ( A'*A) −1 * A' tiene interés 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: [( A'*A) −1 * A' ] * A = Id nxn . (recordemos que rg(A)=n
ya que , como el producto matricial es asociativo es [( A'*A) −1 * A' ] * A = ( A'*A) −1 * ( A'*A) = Id nxn .
En Matlab hay una función específica 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 solución de cuadrados mínimos, 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);
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
>> 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 más corta de escribir es la menos eficiente.
Si tuviéramos que resolver 100 sistemas de éste tamaño, con la función resuelve demoramos 30 seg , y, con pinv demoramos
como media hora!!!!!!!!!!
Después resolvemos el ejemplo que había quedado pendiente:
Ej:
Con la tabla
x
y
0.21 16.3
1.5
54.0
2.8 95.5
5.1. 161.8
10.5. 328.1
20.1 615.2
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
a) Hallar la recta de cuadrados mínimos
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 verosímil.
c) Hallar la diferencia (en norma 2) entre la recta y los puntos :
Solución:
>> 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.5000
2.8000
5.1000
10.5000
20.1000
1.0000
1.0000
1.0000
1.0000
1.0000
1.0000
>> ab=resuelve(A'*A,A'*y)
y mc − y
2
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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:
x1 1
x 2 1
. . .
. .
x 1
6
y1
y2
a
a
= . . con solución de cuadrados mínimos
c
c .
y
6
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
700
600
500
400
300
200
100
0
0
5
10
15
20
25
>> 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.
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Los criterios más importantes son la disposición de los puntos y lo que sepamos teóricamente acerca del modelo.
Veamos:
Ejercicio:
x
−4
−3
−2
−1
0
1
2
3
4
5
6
7
8
9
10
y
2.2
8.7
18.8
28.2
32.6
32.0
27.2
20.2
18.9
30.9
66.4
140.4
266.8
464.4
753.3
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 mínimos.
b) Ajustar un modelo cuadrático ax 2 + bx + c por cuadrados mínimos.
c) Ajustar un modelo cúbico ax 3 + bx 2 + cx + d por cuadrados mínimos.
d) Ajustar un modelo de orden 6, o sea, ax 6 + bx 5 + cx 4 + dx 3 + ex 2 + fx + g por cuadrados mínimos.
e) En cada caso calcular los errores relativos. Graficar en todos los casos.
Resolvemos:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
>> 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
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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
>> plot(x,y,'.',x,ylin)
(o sea, da 0.58… ‐ o sea un 58% inadmisible ¡!!!!)
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
800
700
600
500
400
300
200
100
0
-100
-200
-4
-2
0
2
4
6
8
10
Ahora Cuadrático!
>> 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 sólo 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 =
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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 más largo de escribir. La función”polyval(a,x)” hace esa
tarea. Si : a = [a1 , a 2 ,......, a k , a k +1 ] entonces
poyval(a,x)
a1 * x ^ k + a 2 * x ^ k − 1 + ...... + a k * x + a k +1 ] .
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
equivale a :
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
>> norm(ycuad‐y)/norm(y)
ans =
0.3201
notemos que todavía es como 0.32
>> plot(x,y,'.',x,ycuad)
800
700
600
500
400
300
200
100
0
-100
-4
-2
0
2
4
6
Ahora va la Cúbica!
>> A=[x.^3
A=
‐64
‐27
‐8
‐1
0
1
8
27
64
125
216
343
512
729
1000
A]
16
‐4
9
‐3
4
‐2
1
‐1
0
0
1
1
4
2
9
3
16
4
25
5
36
6
49
7
64
8
81
9
100
10
1
1
1
1
1
1
1
1
1
1
1
1
1
1
>> ccubi=resuelve(A'*A,A'*y)
1
8
10
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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!!!
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
>> plot(x,y,'.',x,ycubi)
800
700
600
500
400
300
200
100
0
-100
-4
-2
0
2
4
6
8
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
10
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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)
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
ans =
0.0013
Ahora con grado 6 sí da un valor chico – menos de 1/10 , del 1% ¡!!!!!!!!‐
>> plot(x,y,'.',x,ysex)
800
700
600
500
400
300
200
100
0
-4
-2
0
2
4
6
8
10
•
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 quizás con un polinomio de menor grado (entre 4 y 5)
quizás también hubiera ajustado bien:
>> A=A(:,3:end)
todas la filas, desde la columna 3 en adelante (x^4) (x^3 x^2 x ones)
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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 =
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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 parámetros menos!!!!!!!!!!!
>> plot(x,y,'.',x,ycuart)
también gráficamente ajusta bien!!!!1
800
700
600
500
400
300
200
100
0
-4
-2
0
2
4
6
8
10
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Hay casos donde un modelo no polinómico parece más adecuado.
Ejercicio:
x
y
− 4 − 5.64
− 3 − 2.8
− 2 1.65
−1
4.4
0
4.1
1
1.41
2
0.35
3
2.5
4
6.9
5 10.04
6 11.03
7
8.3
8
6.46
9
7.62
10 11.7
•
•
•
•
•
•
•
•
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
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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);
yap =
‐5.7495
(aquí no sirve poyval ¡!!!!!)
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
‐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)
12
10
8
6
4
2
0
-2
-4
-6
-4
-2
0
2
4
6
8
10
Ejercicio propuesto:
Programar una función: function coef=polcm(x,y,m) que reciba vectores x e y , y un n ∈ N 0 ,
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
y que devuelva el polinomio de orden n que mejor ajuste por cuadrados mínimos.
********************************************************************************************************
Habíamos dejado como ejercicio programar una función polcm: function coef=polcm(x,y,m) que reciba como entradas
vectores x e y , y un n ∈ N 0 ,
y que devuelva los coeficientes del polinomio de mejor ajuste por cuadrados mínimos, de
orden n.
La función quedaría, por ejemplo, así:
Function coef=polcm(x,y,n)
If size(x,2)==1
x=x’
end
If size(y,2)==2
y=y’
end
A=[ones(size(x))];
For k=1:n
A=[x.^k A];
End
Coef=resuelve(A’*A,A’*y);
% si x llega a estar en fila lo pone en columna.
% idem para y
Podemos probarlo, por ejemplo, para buscar un polinomio de orden n que aproxime bien el seno en un intervalo. Por ejemplo
en un período.
Ejercicio:
Sean
x=linspace(0,2*pi,100);
(un período)
y=sin(x);
Hallar el polinomio (de cuadrados mínimos) 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 más grandes.
Solución:
>> x=linspace(0,2*pi,100);
>> y=sin(x);
n=‐1;
err_rel=1;
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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 aún, 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á serán las 8:30 hs??????
En general, hasta aquí, vimos como ajustar modelos de la forma:
y = a1ϕ1 ( x) + ........ + a k ϕ k ( x)
NOTA: Si ϕ1 ( x) =x.^(k‐1), ϕ 2 ( x) =x.^(k‐2),…………, ϕ k ≡ 1 , quedan los polinomios, pero recordemos que también 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 ; ϕ 4 ( x) ≡ 1 .
Pero también es posible, si φ es inversible, ajustar un modelo:
y = φ (a1ϕ1 ( x) + ........ + a k ϕ k ( x)) ⇔ φ −1 ( y ) = a1ϕ1 ( x) + ........ + a k ϕ k ( x)
Entonces se renombra:
z = φ −1 ( y ) ,
z = a1ϕ1 ( x) + ........ + a k ϕ k ( x) , se usa cuadrados mínimos y luego se halla
y = φ (z ) .
Ejemplo Típico:
Ajustar un modelo exponencial y = ka x a los datos:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
x
y
−2
6.3
− 1 24.9
0
99.6
1. 398.1
1.5. 803.1
2 1592.8
Solución:
>> 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);
Observación:
z=log(k)+log(a)*x
z=A*x+B
con A=log(a)
y
A
B
a
k
B=log(k) ⇒ exp =
Otro Caso No Lineal es el de las Aproximaciones de Padé:
La idea es conseguir y ≅
P( x)
un modelo racional.
Q( x)
Muchas veces es necesario, ya que si hay polos – incluso aunque no estén en la recta real, si están cerca de ella ‐ , la
convergencia de los polinomios es lenta. (Por Ejemplo: y =
1
).
1+ x2
Además 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 ecuación)
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 común adecuado) para que el término constante del denominador sea 1.
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
⇒y=
P( x)
⇒ y + y.R( x) = P ( x) ⇒ y = P( x) − yR( x)
1 + R( x)
Observación:
El orden del aproximante se nota ( N / n)
y hay que averiguar los coeficientes de P(x) y R(x).
(gr(P)/gr(Q))
Ejercicio:
Dado
x
y
− 10
−9
−8
−7
.
.
.
.
.
.
6
7
8
9
10
Esto lo generamos con : >> x=(‐10:10)';
>> y=(2*x+1)./(x.^2+1)+0.05*randn(21,1);
>> y=round(100*y)/100;
% size(x)=21
(pero sin decirlo)
Se pide:
a) Ajustar un aproximante de Padé (1/2) (4 parámetros) y hallar el error relativo.
b) Buscar el orden del polinomio de menor grado que tiene un error relativo similar.
c) Graficar ambas.
Solución:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
ax + b
⇒ cx 2 y + dxy + y = ax + b ⇒ ax + b − cx 2 y − dxy = y
cx + dx + 1
a
b
2
Corresponde a : x 1 x y xy
= ( y)
−c
− d
Debe ser y =
2
(
)
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 aplicación posible de los polinomios de cuadrados mínimos es la
Integración Aproximada:
Si tenemos una función no integrable fácilmente ( o no integrable en absoluto) con los métodos usuales de integración, una
opción es aproximarla por polinomios (globalmente o por tramos) y luego integrar las polinómicas:
Recordemos que: :
b
b
∫ (a
a
n
x n + a n −1 x n −1 + ...... + a1 x 1 + a 0
a
a n +1 an −1 n
)dx = n x
x +.........+ 1 x 2 + a0 x + 0
+
n
2
n +1
a
y hacemos :
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
a
[ n +n1 ,
Con los coeficientes:
a n −1
a1
x ,.........,
, a 0 ,0 ]
n
2
, polyval(coeficientes,b)‐ polyval(coeficientes,a)=Integral buscada
y agregamos el 0 al final para completar el polinomio que es primitiva del original
Luego: f ( x) ≅ P( x) ⇒
∫ f ( x)dx ≅ ∫ P( x)dx
y ésta última es fácil.
Ejercicio:
a) Programar una función que calcule la integral de un polinomio cuyos coeficientes estén en el vector p , entre los límites a y b.
( a la función llamémosla : integrapol )
b) Probarla para integrar aproximadamente (usar el mismo grado que en el 1er ejercicio – en que aproximamos sin(x) en
[0,2 π ]) :
π
∫ sin( x)dx
(acá podemos chequear fácilmente)
0
2
c) Probarlo para
∫e
−
x2
2
dx
(n=7)
1
Solución:
La función quedaría, 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);
>> Iseno=integrapol(p,0,pi)
>>x=linspace(1,2,20);
>>y=exp(‐(x.^2)/2);
>>q=polcm(x,y,7)
>> integrapol(q,r,2)
;
% es 8 o lo que haya salido en el ejercicio 1
% elijo partir en 20 puntos
********************************************************************************************************
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Mencionamos que las Aproximaciones de Padé no tienen un desempeño mucho mejor para “errores” aleatorios sobre datos
que se aproximen bien por Polinómicas, pero en cambio son muy útiles para funciones que tengan asíntotas horizontales, que
son especialmente incómodas para la interpolación polinómica (debido a que los polinomios no tienen tales asíntotas).
Ejemplo:
arctan(x) ,
Si ponemos :
>> x=‐20:0.1:20;
>> y=atan(x);
>> plot(x,y)
2
1.5
1
0.5
0
-0.5
-1
-1.5
-2
-20
-15
-10
-5
0
5
10
15
20
Podemos ver que las aproximaciones por polinomios de cuadrados mínimos, incluso para polinomios de cuadrados mínimos de
grado grande, son malas.
Por ejemplo:
>>coef=polcm(x,y,30);
>> yp=polyval(coef,x);
>>plot(x,y, '.' ,x,yp)
2.5
2
1.5
1
0.5
0
-0.5
-1
-1.5
-2
-2.5
-20
-15
-10
O mejor:
>> plot(x,y,'o',x,yp)
-5
0
5
10
15
20
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
2.5
2
1.5
1
0.5
0
-0.5
-1
-1.5
-2
-2.5
-20
-15
-10
-5
0
5
10
15
20
La razón es evidente, ya que los únicos polinomios que son constantes en algún 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 críticos, lo que requiere agrandar mucho el grado.
En cambio con Padé, uno puede obtener aproximaciones muy aceptables con grado de P y Q ( y ≅
P( x)
) no muy grandes.
1 + Q( x)
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á cómodo 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];
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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….
2
1.5
1
0.5
0
-0.5
-1
-1.5
-2
-20
-15
-10
-5
0
5
10
15
20
muy bien!
Ahora veamos un poco la INTEGRACION NUMERICA:
La clave será que:
∫ (a
k
x k + a k −1 x k −1 + ..... + a 2 x 2 + a1 x 1 + a 0 )dx =
a k k +1 a k −1 k
a
a
a
x +
x + ......... + 2 x 3 + 1 x 2 + 0 x + 0 → completamos
k +1
k
3
2
1
para usar luego polyval
Entonces si tenemos una tabla tipo x|y , y si elegimos n, la siguiente función calcula el polinomio de cuadrados mínimos de
orden n, e integra el polinomio, como aproximación 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))
La probamos con algún ejemplo:
>> x=linspace(0,pi,100);
>> y=sin(x);
% ponemos max(x) y min(x) en lugar de x(end) y x(1) por si x está
desordenado.
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
>> Int=integra(x,y,7)
ans
π
2.0000
% coincide con
∫ sin( x)dx = 2
0
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
>> integra(x,y,140)
15,038
>> integra(x,y,141)
15,0720
% error en la segunda cifra
O sea, NO parece converger!!!!!, los errores por arriba más o menos se cancelan, pero la precisión es pobre, y no resulta un
método 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 pequeño).
Esta idea está implícita en la Sumas de Riemann:
(constante de a tramos, o sea, polinomios de grado cero)
O suplantando los rectángulos de antes, por TRAPECIOS (lineal de a tramos, o sea, polinomios de grado 1)
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
CUADRÁTICAS (Regla de Simpson) P polinomio de grado 2 que aproxima a f en [a,b]
Etc,….. en general las fórmulas correspondientes se llaman: de Newton‐Cotes.
f la función
a borde izquierdo
b borde derecho
Recapitulando, el procedimiento requiere:
n elementos de la partición
m puntos tomados en cada sub - intervalo
k orden del polinomio de Cuadrados Mín
Si la función no existe en Matlab, hay que crearla. Por ejemplo: f ( x) =
Hay varias maneras:
function y=fun(x)
y=sin(x.^2)./(1+x.^2);
o en línea 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 función)
La función que hace Newton‐Cotes sería:
sen( x 2 )
1+ x2
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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
Observación:
La partición y la sub‐partición es equi‐espaciada. Podría 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 función NO admite primitiva por sustitución 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 población de media 170 cm y desviación estándar 6 cm (con distribución normal), una
persona mida entre 140 cm y 200 cm.
Resolución:
>>f=@(x) (1/(sqrt(2.pi)*6))*exp(‐((x‐170).^2)/2*6);
>>integraF(f,140,200,100,8,3)
% elijo una partición de 100 intervalos, 8 puntos en cada intervalo, y cúbicas en cada intervalo
********************************************************************************************************
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Hasta aquí hemos considerado sistemas lineales que, matricialmente, se pueden plantear como:
AX = b
con
A ∈ IR n × m , y b ∈ IR n × 1 .
Podemos asumir, eventualmente considerando un sistema equivalente adecuado que estamos en el caso de que
rg ( A) = max{n, m}.
Asumiendo dicha hipótesis, el caso con n=m es
rg ( A) = n = m , y el sistema es determinado, situación que ya
estudiamos, por ejemplo, cuando vimos la descomposición LU.
El caso con n>m es el de los sistemas sobredeterminados. Con
rg ( A) = m < n el sistema por lo general no tiene solución,
y llamábamos solución de cuadrados mínimos a aquel
X ∈ IR m × 1 tal que AX − b
cuadrados mínimos se encontraba, por ejemplo, como
X = (( A' A) − 1 A' )b , siendo A' la matriz traspuesta de A . Debido
sea mínima. Dicha solución de
rg ( A) = m resulta que A' A ∈ IR m × m es de rango completo, m, y por ello está definida su inversa, y la matriz
( A' A) − 1 A' que resulta una pseudo‐inversa a izquierda de A , es decir: (( A' A) − 1 A' ) A = I , donde I es la identidad
de m× m .
a que
Ahora nos toca considerar el caso con m>n, con
rg ( A) = n < m . En este caso, si existe X ∈ IR m × 1 tal que AX = b
C = { X ∈ IR m × 1 : AX = b} , ya que si h ∈ IR m × 1 cumple
A( X + h) = b , y el conjunto Co = {h : Ah = 0}
resulta que hay infinitos elementos en el conjunto:
Ah = 0 , y si AX = b entonces
= Nu ( A) tiene dimensión m − n > 0 , y por lo tanto Co tiene infinitos elementos, y también 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 razón.
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Una de las elecciones más frecuentes consiste en elegir la solución de mínima norma al cuadrado. Esto es lo que entenderemos
como solución de cuadrados mínimos para un sistema subdeterminado.
Es decir: buscamos
2
X o ∈ C = {X ∈ IR m × 1 : AX = b} tal que X o ≤ X
2
para todo
X ∈C .
A continuación veremos que dicha solución de cuadrados mínimos del sistema sub‐determinado puede hallarse como
X o = ( A' ( AA' ) − 1)b . Nótese que como rg ( A) = n < m es AA' ∈ IR n × n con rg ( AA' ) = n de modo que
( AA' ) − 1 está bien definido, y la matriz obtenida como ( A' ( AA' ) − 1) ∈ IR m × n resulta ser una pseudo‐inversa a
derecha de A, esto es que: A( A' ( AA' ) − 1 ) = I , donde I es la identidad de n× n .
A continuación esbozamos la idea que permite proponer a
X o = ( A' ( AA' ) − 1)b como la solución buscada.
El problema puede verse como un problema de extremos de minimización de
X
, o equivalentemente de
X
2
ó de un
múltiplo positivo de ello, sujeto a las condiciones de ligadura correspondientes a que
X ∈ C = { X ∈ IR m × 1 : AX = b} . Esto lo podemos interpretar entonces como el problema de hallar un mínimo para la
A X = b
1
1
1 '
función F ( X ) = X X sujeto a las condiciones de ligadura: ...
, siendo X ' ∈ IR1 × m el vector traspuesto
2
An X = bn
de
X y por lo tanto X ' X = X
2
, y siendo
Ai la i‐ésima fila de A.
De esta manera el problema se puede encarar mediante la búsqueda de n multiplicadores de Lagrange para la función F. O sea
consideramos:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
1
G( X , λ ) = X ' X − λ1( A1 X − b1) − ... − λn ( An X − bn ) con λ ∈ IR n × 1 .
2
Un extremo de la función auxiliar G requiere que se anulen las derivadas parciales respecto de las componentes de
λ , es decir que (derivando en cada caso):
X
y de
GX = X i − λ1 A1i − ... − λn Ani = X i − A' λ = 0
i
i
Gλ = − A j X − b j = 0
j
X ) obtenemos: X = A'λ , y
reemplazando así X en las n ecuaciones de las derivadas respecto de las λ se obtiene A A'λ − b = 0 para j=1…n. Es
j
j
j
De las m primeras ecuaciones (las de las derivadas respecto de las coordenadas de
decir que resulta:
AA'λ = b . Como AA' tiene inversa (por ser cuadrada de rango completo) resulta que λ = ( AA' ) − 1b . Y volviendo a
reemplazar en X = A'λ obtenemos como único posible extremo: A' ( AA' ) − 1b . Denotémoslo X . O sea:
o
X o = ( A' ( AA' ) − 1)b
No es difícil convencerse que
X o cumple lo pedido. Por una parte se tiene que
AX o = A( A' ( AA' ) − 1)b = ( AA' )( AA' ) − 1b = b , o sea AX o = b .
Por otra parte, está claro que si
ortogonal a las filas de
X ∈ C = { X ∈ IR m × 1 : AX = b} es A( X − X o ) = 0 , por lo que X − X o es
A (puestas en columna, para interpretar el producto matricial como producto interno en IR m × 1).
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
'
'
r = ( AA' ) − 1b resulta que X o = A'r , o sea resulta que X o = r1 A + ... + rn An de
1
X = X o + W con X o generado por las filas de A (puestas luego en columna), y W es ortogonal a ellas (y por
Por otra parte llamando
modo que
lo tanto es ortogonal a X. De allí resulta que
F(X ) =
1
X
2
2
≥
X
2
2
= Xo + W
2
de donde resulta que
2
1
X o = F ( X o ) , de donde realmente nuestro punto crítico es un mínimo global de F
2
para el
conjunto C.
A ∈ IR n × m de rango completo
pinv(A) = ( A' A)− 1 A' , también nos da en el caso de que rg ( A) = n < m una
La misma función pinv(), de matlab, que proporcionaba la inversa a izquierda de una matriz
con
rg ( A) = m < n , es decir:
inversa a derecha, es decir que en este caso:
pinv(A) = A' ( AA' )− 1 . Por ejemplo:
>> A=[1 2 4;3 5 11]
A=
1
2
4
3
5 11
>> A_1=pinv(A)
A_1 =
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
‐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.
>> % Nótese 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
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Ejercicio:
i) Para la matriz dada anteriormente
para el sistema
1
2 4
3
, y para el vector columna b = , hallar dos soluciones distintas
8
3 5 11
A =
AX = b , y calcular sus normas.
ii) Hallar la solución de mínima norma
X o de AX = b y verificar que su norma es menor o igual a la de las otras soluciones
halladas.
Resolución:
Como tenemos 3‐2=1 variable más que el numero de ecuaciones podemos proponer un valor para una de ellas y obtener, a
partir de ella, las otras dos.
Si
X
x
= y y ponemos x
z
= 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
>> X=[3;2;‐1]
= 2, z = ‐1, es decir X
3
= 2 , verificamos:
− 1
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
X=
3
2
‐1
>> A*X
ans =
3
8
De la misma manera, ponemos, por ejemplo: x
X
1
= 1
0
>> 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
= 1, y obtenemos como nueva solución:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Si bien esta solución tiene una norma que parece bastante chica podemos mejorarlo. Busquemos la solución de mínima norma
para el sistema subdeterminado,
AX = b , 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
Nótese que Xo tiene la mitad de la norma de la solución hallada anteriormente.
Exponencial de Una Matriz
Para matrices cuadradas se pueden definir las potencias, con exponente en INo, de la matriz por
y
A0 = I
Ak = 1
⋅4
⋅3
A 42
A ⋅...
A si k ∈ IN
44
k veces
(la identidad del tamaño de A)
Como también está definido el producto por un escalar, podemos definir polinomios en las matrices cuadradas.
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Por ejemplo, si
p( x) = −2 x5 + 4 x3 + 2 x + 3 , se define p( A) = −2 A5 + 4 A3 + 2 A + 3I , de donde se obtiene
una aplicación de los polinomios con escalares en IR (ó en C), en las matrices cuadradas del tamaño de A que preserva sumas,
productos de potencias de A y productos por escalares (un morfismo).
Cómo además tenemos definida una norma podemos hacer aún más. La norma nos permite definir una noción de convergencia
en
A ∈ IR n × m :
Dada una sucesión de matrices
{Ak }k ∈ IN , decimos que M ∈ IRn × m es el límite de {Ak }k ∈ IN , o que
lim A = M si y sólo si lim A − M = 0 . Este último es un límite de una sucesión de números reales, y por lo
k
k →∞ k
k →∞
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
dada por
Sk = pk (A) , donde pk ( x) =
Se puede demostrar que
k
∑
j=0
1 j
x . Es decir
j!
{ }k ∈ IN
A ∈ IR n × n , la sucesión de matrices: S k
Sk =
k
∑
j=0
1 j
A .
j!
{pk ( A )}k ∈ IN es una sucesión convergente de números reales, y que a consecuencia de ello
{S k }k ∈ IN converge, es decir que existe el klim
S , y denotamos tal límite: lim Sk = ∑
k →∞
→∞ k
∞
j=0
En el anillo de los números complejos con la norma usual existe el límite
límite como la exponencial compleja:
ez =
∞
∑
j=0
•
•
•
e z + w = e zew
e0 = 1
Si t ∈ IR , etz = (e z )t
lim
k
∑
k →∞ j=0
1 j
z
j!
=
∞
∑
j=0
1 j
A .
j!
1 j
z y se define a dicho
j!
1 j
z , y dicha exponencial tiene, entre otras propiedades las siguientes:
j!
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Es entonces natural, para A ∈ IR n × n , definir
eA =
∞
1
∑ j! A j , y se obtienen de manera totalmente análoga las
j=0
siguientes propiedades:
•
•
•
e A + B = e Ae B
eO = I , donde O es la matriz nula.
Si t ∈ IR , etA = (e A )t
Ejercicio
Como ejercicio podemos tratar de evaluar aproximadamente la exponencial de una matriz en Matlab efectuando sumas
parciales de la serie mencionada, deteniéndonos cuando el término siguiente es numéricamente nulo, es decir si:
1
Ak + 1 = 1
(k + 1)!
(k + 1)!
Ak + 1
≤
1
(k + 1)!
k
k
1 j
A ) donde eps( ∑ 1 A j ) es el Epsilon de
j!
j!
j=0
j=0
A k + 1 ≤ eps( ∑
máquina de la suma parcial. Compárese el resultado con alguna matriz cuadrada usando la función de Matlab “expm” que
evalúa la exponencial matricial.
Resolución:
Programamos la siguiente función
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
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Nótese 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 función ya existente en Matlab).
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Observación importante
No se debe confundir la exponencial matricial –que se obtiene con expm‐ con la función 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. Además, 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 sólo tiene sentido para matrices cuadradas –a diferencia de la exponencial coordenada a
coordenada obtenida con exp‐.
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Una de las aplicaciones importantes de la exponencial matricial, es que, como la función exponencial en una variable, nos
permite obtener solución para ecuaciones diferenciales lineales a coeficientes constantes.
Se puede verificar a partir de la definición de derivada de una función de variable escalar que: Si
Entonces si buscamos
X (t ) : IR → IR n
tal que
X ′ = AX
las funciones de la forma
t ∈ IR ,
d (etA ) = AetA
dt
X (t ) = ketA con k ∈ IR
resultan solución.
Asimismo el problema de valor inicial:
X ′ = AX
resulta ser
(
)
=
X
t
X
o
o
X (t ) = X o ⋅ etA
Lo anterior corresponde a ecuaciones homogéneas.
Hay distintas formas de acceder a las soluciones del caso no homogéneo.
Por ejemplo se puede verificar que:
t
X (t ) = ( X o + ∫ e − sA B(s)ds) ⋅ etA resulta solución de:
t0
X ′ = AX + B
X (to ) = X o
Más adelante veremos de estimar numéricamente las integrales.
Nótese que si A y J son matrices semejantes, es decir
A = L− 1.J .L donde L es una matriz inversible entonces
e A = L− 1e J L . Esto es claro a partir de la definición de la exponencial como sumas de múltiplos de potencias de la matriz,
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
y del hecho de que
eA =
∞
∑
j=0
Ak = A ⋅ A ⋅ ... ⋅ A = L− 1.J .J ...J .L = L− 1.J k .L , y entonces
1 j
A
j!
=
∞
∑
j=0
1 −1 j
L J L = L− 1(
j!
∞
∑
j=0
1 j
J
j!
)L = L− 1e J L
Si entonces A es diagonalizable podemos estudiar y analizar cualitativamente las soluciones de las ecuaciones diferenciales
mencionadas arriba con matriz A, de manera más sencilla teniendo en cuenta los autovalores y autovectores de A.
********************************************************************************************************
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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 ecuación f(x)=g(x) suele ser cómodo escribirla de alguna manera equivalente pero más sencilla para
pensarla en términos de algunos resultados. Algunas formas serían:
H(x)=0 (por ejemplo: con H(x)=f(x)-g(x) )
T(x)=x (por ejemplo: con T(x)= f(x)-g(x)+x
, o,
,o,
T(X)=
x f ( x)
si g no se anula ).
g ( x)
En el 1er caso, la búsqueda de soluciones de la ecuación coincide con la búsqueda de ceros de la función H(x).
En el 2do caso, las soluciones de la ecuación son puntos fijos de la función T.
Los primeros métodos 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 contínua 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 c ∈ (a, b) tal que H(c)=0.
Observación: La condición de que los valores H(a) y H(b) sean uno positivo y uno negativo, en términos de
programa, se puede chequear fácilmente de una sola vez, verificando que H(a).H(b)<0.
El método basado en el teorema de Bolzano, se llama Método de BISECCION, y consiste en ir precisando la
ubicación de alguna raíz de H, por el procedimiento de partir el intervalo en partes iguales y observar en cuál de
ellas es posible volver a aplicar el teorema.
Por Ejemplo:
--------------------------------------Paso n: Intervalo [a,b]
Paso
estimación de la raíz:
n+1 : Evalúo H( x0 ). Tenemos tres posibilidades:
1) el signo (H( x0 ))=signo (H(a))
2) el signo (H( x0 ))=signo (H(b))
3) H( x0 )=0
Si H( x0 )=0 devolvemos como solución x0 y terminamos ahí.
x0 =
a+b
2
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Si el signo (H( x0 ))=signo (H(a)) entonces puedo aplicar el teorema de Bolzano en el intervalo [ x0 ,b].
Entonces renombramos a= x0 , y vuelvo al paso n.
Si el signo (H( x0 ))=signo (H(b)) entonces puedo aplicar el teorema de Bolzano en el intervalo [a, x0 ].
Entonces renombramos b= x0 , y vuelvo al paso n.
En cada paso la longitud del intervalo se divide por 2 (salvo cuando hallamos justo la raíz), por lo que se gana en
cada caso un dígito binario en cada paso. (o 0,30103 ≅ dígitos decimales en cada paso- es decir 1 decimal cada
3 o 4 pasos-). Por ello se dice que es un método de orden 1.
Una cuestión pendiente consiste en decidir cuándo detenernos. Algunas posibilidades son:
1) Después de cierta cantidad N de pasos prefijada.
2) Cuando el intervalo es menor (en longitud) que cierto δ > 0 prefijado.
3) Cuando H ( x0 ) < ε para cierto ε > 0 prefijado.
4) Combinando condiciones tipo
ε
y
δ .
Las dos primeras son esencialmente lo mismo, ya que a y b están dados y después de N pasos la longitud del
intervalo está completamente determinada por a,b y N: longitud =
b−a
2N
, o sea fijar N equivale a fijar δ =
b−a
2N
.
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 pequeño (así forzamos a que ambos ε
y
δ sean pequeños).
El criterio de la δ puede dar soluciones mediocres si la pendiente “es grande” cerca de la raíz:
Después de cuatro pasos ( x0 , x1 , x 2 , x3 )
---------------------------------------------------------------
H( x3 ) está lejos de 0 (e incluso H( x 2 )<H( x3 ) )
El criterio de las ε
puede dar una solución lejana y la correcta si la pendiente “es chica” cerca de la raíz:
(En una de esas ya paró en x0 porque H ( x0 ) < ε )
-------------------------------------------------
Pero la raíz correcta c está bastante lejos.
Proponemos entonces usar el criterio mixto (pedir que
(longitud Intervalo) 2 + ( H ( x medio )) 2 < α , para cierto α > 0 .
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Entonces proponemos programar el método y probarlo:
Ejercicio:
a) Programar el método de Bisección: poniendo como encabezado de la función: function sol=bisección (H,a,b,alfa).
b) Probarlo hallando alguna raíz de :
i) 9 x 3 + 3 x = 6 x 2 + 2
(solución verdadera para verificar x =
2
)
3
ii) cos(x)=x
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐hasta aquí serán 8:30 aprox
Solución:
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)
Matlab
9*x.^3+3*x‐6*x.^2‐2
(o sea, H(x)= 9 x 3 + 3 x − 6 x 2 − 2 ) con @ puedo poner una function en el prompt de
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
>> H(0)
ans=‐2
>> H(1)
ans=4
(luego podemos usar bisección!!!!)
>> 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 bisección!!!!)
>> solu=biseccion(G,0,pi/2, 0.00000001 ) por ejemplo!!!
solu=………. (algún número)
>> G(solu)
(verif)
0
( o un número x 10 − numero grande
(tipo 10 −10 ) )
Ventajas y Desventajas del Método de Bisección:
Ventajas:
• Sólo requiere continuidad.
• Converge siempre si se cumplen las hipótesis. (en teoría)
Desventajas: • Sólo encuentra raíces asociadas a un cambio de signo.
(no puede hallar una raíz por ej de multiplicidad 2 , así
-------------------------)
• Converge relativamente lento (orden 1, como mencionáramos).
• No se puede generalizar a varias variables.
------------------------------------------------------------------------------------------------------------------------------------------------A continuación propondremos otros métodos. Veamos primero la idea geométrica:
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 método es debido a Evangelista
Torricelli (el mismo del barómetro), pero Newton lo usó en un caso particular y Raphson lo generalizó y se conoce
como el Método de Newton-Raphson.
El Método de Newton-Raphson puede entenderse fácilmente con éste esquema:
Una raíz es un x tal que H(x)=0.
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
~
En general se parte de una cierta estimación de la raíz de H, y se busca la siguiente, hallando donde H ( x) = 0 ,
~
siendo H =la función lineal cuyo gráfico es la recta tangente a H en la estimación anterior:
~
Es decir, x n +1 es tal que H ( x n +1 ) = 0 , o sea, 0 = H ' ( x n ).( x n +1 − x n ) + H ( x n ) .
O sea, despejando:
x n +1 = x n −
H ( xn )
H ' ( xn )
(paso iterativo)
OBSERVACIONES:
Es claro que éste método tiene requerimientos bastante más restrictivos:
• Tiene que existir H’, además de H.
Además debe poder pasarse explícitamente H’, ya que MATLAB NO HALLA derivadas en forma simbólica.
• Hay que partir de una suposición razonable de la raíz, para que además H ' ≠ 0 en cierto intervalo donde iteremos.
( Si H’ se anula el paso iterativo podría no aplicarse).
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
Además, se ve que si estamos “en otra colina” (más allá de un punto crítico), el método puede llevarnos a alejarnos de la raíz.
• También es preferible que NO haya cambios de concavidad
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
• Por otra parte, en general el método converge rápido (en caso de que converja).
En dicha situación es de orden 2.
∃k : si c es la raíz correcta, con c − x n
= ε ⇒ c − xn
≤ kε 2 (con k que sólo depende de f en cierto intervalo alrededor
de “c”).
(Sale que: H ( x) = H ( x0 ) + H ' ( x 0 ).( x − x0 ) + H ' ' (ζ ).( x − x0 ) 2 , (el desarrollo de Taylor)
~
siendo los dos 1eros sumandos H ( x) = H ( x0 ) + H ' ( x0 ).( x − x0 ) lo que nos da las aproximaciones lineales).
• Si c es una raíz doble (o de mayor multiplicidad) también converge
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
Aunque el orden vuelve a ser 1 en este caso. (Si se sabe el orden, se puede modificar el método para que vuelva a ser de orden
2)
• Puede generalizarse para resolver ecuaciones vectoriales; o sistemas de ecuaciones no‐lineales de varias incógnitas.
Proponemos ahora programar el método de Newton-Raphson (N-R) para el caso escalar, y usarlo en algún ejemplo.
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Como converge rápido, lo usual es pararlo después de cierta cantidad fija de iteraciones (8, 10, 12, por ejemplo. Por
ejemplo, si parto de una estimación distante aproximadamente
1
del valor absoluto de la solución, en 25 pasos
2
estaremos en el orden del épsilon de máquina de ese número).
Otras alternativas son parar cuando H ( x n ) < ε para cierto ε > 0 , o cuando x n +1 − x n < δ para cierto δ > 0 .
Aquí implementamos la versión con n iteraciones (si uno quiere, se puede tomar el valor de la raíz que devuelva el
método y si uno no está satisfecho con H ( sol ) o con
H ( sol )
H ( sol )
H ( sol )
= sol − ( sol −
) , siendo sol −
la
H ' ( sol )
H ' ( sol )
H ' ( sol )
iteración siguiente, entonces se puede volver a ejecutar Newton-Raphson con algunas iteraciones más (total, nunca
van a ser muchos los intentos) ).
Solución: Aquí va la función:
function sol=NR_escalar (H,Hprima, x0 ,n)
sol= x0 ;
for k=1:n
sol=sol‐H(sol) / Hprima(sol) ;
end
Ejemplo: (también se pueden probar con los ejemplos usados para bisección)
Observación: lim ln(ln(1 + x 2 )) = −∞ , y , lim− x = 0 . Por otra parte: lim ln(ln(1 + x 2 )) = +∞ , y ,
x →0
x →0
x → +∞
lim − x = −∞ .
x → +∞
Hallar una solución de ln(ln(1 + x 2 )) = − x .
Entonces buscamos ceros de H ( x) = ln(ln(1 + x 2 )) + x .
Vemos que la solución no debe andar lejos de x0 = 1 , y, H ' ( x) =
1
1
2x
.2 x + 1 =
+1.
2
2
2
ln(1 + x ).(1 + x 2 )
ln(1 + x ) 1 + x
Entonces:
>> H=@(x)
log(log(1+x.^2))+x ;
>> Hprima=@(x)
(en Matlab ln es log, y log10 es log10 , también está disponible log 2 es log2 )
2*x./(log(1+x.^2)* (1+x.^2))+1 ;
>> solaprox=NR_escalar (H,Hprima, 1,10)
(o sea, x0 =1 y n=10 ) y verificamos
>> H(solaprox)
0,…….. (debe dar casi 0)
********************************************************************************************************
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Comentamos que uno de los inconvenientes del Método de Newton‐Raphson (N‐R) es que se debe disponer explícitamente de
la derivada de la función. Si dicha derivada es trabajosa de calcular o de evaluar, o si directamente no sabemos como hallarla‐
por ejemplo si los valores de la función pueden calcularse en forma explícita pero quizás no los de la derivada, Por ejemplo:
Sea H : α a H (α ) = solución de e αx = − x , uno supone que H varía en forma suave con α , pero no conocemos una
fórmula para H (α ) , pero sí podemos hallar H (α ) para cada α usando algún tipo de método,
en ese caso nos gustaría poder aplicar un método semejante al de Newton‐Raphson (N‐R) pero sin tener que disponer de la
derivada.
Un posible método en ese sentido es el Método de la SECANTE:
METODO de la SECANTE:
La idea es similar al de N‐R, pero se parte de dos aproximaciones iniciales y la aproximación que sigue consiste en aquel punto
~
~
donde se anule H (en lugar de H ), donde H ( x) =
~
H ( x) = H ' ( x n ).( x − x n ) + H ( x n ) .
O sea que:
x n +1 = x n −
H ( x n ) − H ( x n −1 )
.( x n − x n −1 ) + H ( x n ) , en lugar de
x n − x n −1
H ( xn )
H ( xn )
. (En N‐R era x n +1 = x n −
).
H ( x n ) − H ( x n −1 )
H ' ( xn )
x n − x n −1
Gráficamente: Veamos las dos primeras iteraciones del Método de la Secante:
A partir de x0 y x1 se halla x 2 , en el paso siguiente me olvido de x0 , y x1 pasa a jugar el papel de x0 y x 2 el papel de x1 , y
repito….
Como en N‐R, cortamos después de un número de iteraciones que pasamos como parámetro. A continuación lo programamos:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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 precisión como permite el Matlab!
Observación: 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 operación indefinida, en este caso es un 0
0
, pues cuando el método converge a la raíz‐ y
generalmente lo hace rápido‐ puede suceder que x0 = x1 = raíz de H, y entonces el denominador
En N‐R:
H ( x1 ) − H ( x0 )
es 0 .
0
x1 − x0
1
no tenía problemas si x n = raíz de H, si la raíz es simple.
H ' ( xn )
Como reflexión nos queda que en el Método 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).
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Comentario sobre las operaciones con ∞ (Inf) y/o con indeterminaciones en Matlab:
Generalmente MATLAB respeta las definiciones usuales, pero no siempre. Algunas cuestiones que podrían sorprendernos:
1
es “Inf”
0
Inf
Inf
−1
es “‐Inf” (o sea que 0 es 0 + ),
0
, y,
es NaN,
Pero 0^0 es 1
y
1^Inf es NaN.
y también:
Inf^0 es 1.
0
es NaN,
0
0*Inf es NaN,
Inf‐Inf es NaN,
Además: 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 Método:
Se denomina ORDEN de un Método a lo siguiente:
Si las aproximaciones dadas por cierto método: x1 , x 2 ,………., x n , x n +1 ,…….. → ξ , raíz de H, entonces en general existe q tal
que
x n +1 − ξ
xn − ξ
q
= O(1) (es decir, lim
n→∞
x n +1 − ξ
xn − ξ
Equivalentemente se puede pedir :
q
= k , para k ∈ R>0 ).
H ( x n +1 )
= O(1) .
H ( xn ) q
El orden “q” es 2 para N‐R
El orden “q” es 1 para BISECCION.
El orden “q” es
1+ 5
≅ 1,61...... para SECANTE.
2
Estor valores pueden hallarse teóricamente, o estimarlos numéricamente como en la búsqueda de Exponente Hölder:
x n +1 − ξ ≈ k . x n − ξ
log( x n +1 − ξ )
log( x n − ξ )
≅
q
⇒ log( x n +1 − ξ ) ≅ log k + q. log( x n − ξ ) , entonces dividiendo por log( xn − ξ ) obtenemos:
log(k )
+q
log( x n − ξ )
ya que
log( H ( x n +1 ))
log(k )
→ q)
→ 0 . (o análogamente:
log( H ( x n ) ) n→∞
log( x n − ξ ) n→∞
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Recordemos la función NR_1:
function sol=NR_1(H,Hprima,x0,n)
sol=x0;
for k=1:n
sol=sol‐H(sol)/Hprima(sol);
end
% Hprima=la derivada de H
% es la primera estimacion de sol=la solucion
% n = numero de iteraciones
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 método termina)
O también:
>> 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 método terminó!
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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
1+ 5
≅ 1,61...... )
2
Inf
(cuando da Inf el método termina)
Volviendo al Método de la SECANTE, lo que hacemos es aproximar la derivada de H en xn por un cociente incremental lateral
(de qué lado depende de la posición de x n −1 respecto de xn ).
Una alternativa mixta sería usar una derivada “aproximada”. En este caso, una estimación más estable de la derivada se puede
obtener promediando cocientes incrementales a izquierda y derecha. Armamos la siguiente función:
function Hprima_x=derivaprox(H,x,epsi)
Hprima_x=(H(x+epsi)‐H(x‐epsi))/(2*epsi );
%corresponde a estimar a
H (x + ε ) − H (x − ε )
≈ H ' ( x)
2ε
Con esta otra función podemos armar un N‐R con derivada numérica:
function sol=NR_1_ap(H,x0,n,epsi)
if nargin==3
epsi=0.001;
% si no se pasa el parámetro epsi , se toma por defecto 0.001
end
sol=x0;
for k=1:n
sol=sol‐H(sol)/derivaprox(H,sol,epsi);
end
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Caso MULTIVARIADO:
Queríamos ahora resolver sistemas no‐lineales de n ecuaciones y n incógnitas.
h1 ( x1 , x 2 ,........., x n ) = 0
f1 ( x1 , x 2 ,........., x n ) = g1 ( x1 , x 2 ,........., x n )
h ( x , x ,........., x ) = 0
f ( x , x ,........., x ) = g ( x , x ,........., x )
2 1 2
2
1
2
n
n
n
,
⇔ 2 1 2
................................................
..............................
hn ( x1 , x 2 ,........., x n ) = 0
f n ( x1 , x 2 ,........., x n ) = g n ( x1 , x 2 ,........., x n )
donde hi = f i − g i
Es decir que lo podemos escribir en forma vectorial como:
r
Hallar X para H : R n → R n tal que H(X)=0, (o sea, H ([ x1 ; x 2 ;.........; x n ]) = [0;0;..............;0] )
Resulta cómodo pensarlo en columnas, y buscar
x1 0
x1
.
. .
X = . / H . = . .
. .
.
x n
x n 0
Proponemos generalizar N‐R, pero en su versión aproximada.
Nótese que, incluso aunque las derivadas sean fáciles de calcular, por ejemplo, H : R 5 → R 5 , las derivadas a programar
son ¡25!, y puede ser muy pesado de programarlas a mano. En cambio, podemos hallarlas numéricamente usando H, sin dar
explícitamente ninguna fórmula para
∂H i
.
∂x j
Por otra parte, notemos que el paso iterativo de N‐R era: x n +1 = x n −
H ( xn )
).
H ' ( xn )
Esto también se puede escribir como: x n +1 = x n − ( H ' ( x n )) −1 * H ( x n ) .
Escrito así se puede generalizar a más variables poniendo x n +1 = x n − ( JH ( x n )) −1 * H ( x n ) donde JH (•) es la matriz
Jacobiana de H en cada punto. Programamos su cálculo aproximado:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
∂H 1
( x)
∂x1
∂H 2
( x)
∂x1
.
En cada columna de JH ( x) =
.
.
∂H n
( x)
∂x1
∂H 1
( x)
∂x j
∂H 2
( x)
∂x j
.
.
.
∂H n
( x)
∂x j
. .
.
. .
.
. . están las derivadas respecto de 1 variable por vez, entonces:
.
. .
.
. .
.
. .
0
0
0
.
.
.
∂
( H ) = ( H ( x + ε 1 ) − H ( x + ε 1 )) / 2ε , donde 1 es la j‐ésima columna de la matriz identidad I nxn .
∂x j
.
.
.
0
0
0
.
Y entonces programamos:
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
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
% derivo en cada columna
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Veamos un Ejemplo:
cos( x1 − x 2 ) − 1 = 0
2
x1 + x 2 − 6 = 0
Hallar alguna solución de:
(una solución es (2,2), pero vamos a hacer como que no lo sabemos y la buscamos con NR_MULTI).
x1 cos( x1 − x 2 ) − 1
= x + x 2 − 6 , y ponemos:
x
2
2
1
Lo armamos vectorialmente (como antes), H es: H
>> H=@(x)
[cos(x(1)‐x(2))‐1; x(1)+x(2)^2‐6]
2 .5
1
.
8
% calculamos H
>> H([2.5 1.8])
ans =
‐0.2352
‐0.2600
0
0
no está lejos de
Buscamos con NR_MULTI:
>> NR_MULTI(H,[2.5;1.8],10,0.0001)
ans =
2.0005
1.9999
2
2
( ≈ la verdadera solución)
En realidad, tal como lo programamos NR_MULTI también 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 solución de cos(x)=x !!)
********************************************************************************************************
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Recordemos que habíamos programado un método N-R multivariado que permite buscar soluciones de ecuaciones
n
n
.
vectoriales (o sistemas de ecuaciones) de
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, algún extremo de la función
F : R 3 → R dada por
F ( x, y, z ) = x 2 + y 2 + z 2 + sen2 ( y − z ) + 2 yz − 2 x + 6
cerca del
1.2
0.1
.
0.15
Probar que ∇F debe anularse.
Solución:
Llamo H= ∇F ( x, y, z , ) = [2 x − 2; 2 y + 2 sen( y − z ) cos( y − z ) + 2 z; 2 z + 2 sen( y − z ) cos( y − z ) + 2 y ] y
busco ceros de H:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
>> 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)]
1
(debería dar: − 0 aprox.)
0
>> PUNTO_CRITICO=NR_MULTI(H,[1.2;0.1;0.15],12)
Presentamos por último un método que puede aplicarse en contextos aún más generales (por ejemplo: espacios
métricos), aunque, claro, requiere más condiciones (o más 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 Aplicación Contractiva)
Sea U un espacio métrico (léase R n ), y sea T una aplicación de U en U, o sea, T : U → U tal que ∃c ∈ (0,1) , o sea,
0<c<1 / d(T(u),T(v)) ≤ d(u,v) (esto es una aplicación contractiva) con d la función distancia en U,
entonces ∃ ! p ∈ U / T(p)=p.
Además, partiendo de x0 ∈ U cualquiera, vale que lim T ( n ) ( x0 ) = p donde T ( n ) = T o T o ..... o T (n veces).
n → +∞
→ →
→ →
→
→
Si tenemos una determinada ecuación f ( X ) = g ( X ) (escalar o vectorial) que podemos escribir como x = T ( x ) , y si T resulta
ser contractiva, entonces podemos estimar la solución haciendo:
x0 , x1 = T ( x 0 ), x 2 = T ( x1 ),........., → X ( solución) .
Nótese que en realidad necesitamos que valga, no en general, sino para un x0 “bien elegido”.
Si x n +1 − x n < c x n − x n −1 < c 2 x n −1 − x n − 2 < ......... < c n x1 − x0 → 0 porque 0 < c < 1
n →∞
Entonces para n grande es x n +1 ≈ x n
En particular, si en N‐R ponemos
y como T ( x n ) = x n +1 luego x n ≅ T ( x n ) (casi un punto fijo)
T ( x) = x −
T ( x n +1 ) − T ( x n ) = T ( x n +1 ) − x n +1 = x n +1 −
H ( x)
, vale que
H ' ( x)
H ( x n +1 )
H ( x n +1 )
.
− x n +1 =
H ' ( x n +1 )
H ' ( x n +1 )
Entonces si (y éste “si” es la restricción) podemos escribir f(x)=g(x) como x=T(x) para T contraída, el método sale con ésta
función:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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 solución de cos(x)=x.
Directamente aquí es T(x)=cos(x) y sabemos por cuestiones generales (ver un gráfico de cos(x) y x) que debe haber
una solución entre 0 y 1 aproximadamente.
Allí T’(x)=sen(x) y
T (u ) − T (v)
u−v
= T ' (c) = sen(ξ ) por el Teo de Lagrange, y en [0,1] es sen(ξ ) < sen(1) <1.
Entonces T contrae con c< sen(1) .
Entonces partimos de, por ejemplo: x0 = 0.3
>> sol=PUNTO_FIJO(@cos, 0.3, 20)
sol=0.7391
------------------------------------------------------------------------------------------------------------------------------------
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Soluciones numéricas de ecuaciones diferenciales.
En éste caso las ecuaciones diferenciales pueden ser no-lineales y de R en R n ; pero en principio, sí, van a ser de 1er
orden. Las de orden n se pueden reescribir como si fueran de 1er orden (con más variables), haciendo un cambio de variables
x1 = x(t )
x 2 = x' (t )
estándar:
, (lo que los físicos llamarían: Representación en el espacio de fases).
x3 = x' ' (t )
...............
El problema de valores iniciales se puede escribir como:
(más adelante veremos cómo adaptarlo a problemas de contorno)
X ' (t ) = f (t , X (t ))
X (t 0 ) = X 0
Hallar X : R → R n / ( P.V .I .)
Nótese que, en principio, esto podría escribirse como:
t
t
X ' (t ) = f (t , X (t ))
. Y siendo T ( X (t )) = ∫ f ( s, X ( s )ds + X 0 , lo que
X (t ) = ∫ f ( s, X ( s )ds + X 0 ; verifica que
X (t 0 ) = X 0
t0
t0
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
demostración del Teorema de Picard de Existencia y Unicidad de las soluciones, se basa en el Teorema de Punto Fijo de Banach.
La búsqueda numérica de las soluciones, sin embargo, se suele hacer usando otras ideas.
El método más rústico, 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 solución, aproximando en cada punto por la tangente.
(depende de la curvatura, uno se va aproximando por debajo o por arriba de la verdadera solución)
Descargamos un programita muy fácil de usar:
http://math.rice.edu/~dfield/
For use with version 7.7 of MATLAB.
dfield8.m New December 10, 2009.
>> dfield8
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
x ' = x2 - t
4
3
2
x
1
0
-1
-2
-3
-4
-2
0
2
4
t
6
8
10
Interpretamos X(t)=X´(t)^2‐t
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
El método lo que hace en cada paso temporal, es estimar:
X(t+h)=X(t)+X’(t).h
X(t+h)=X(t)+f(t,X(t)).h
como X’(t)= f(t,X(t)),
Hagamos una 1era versión:
function [ t , X ]=euler(f,t0,X0,tfinal,h)
pasos=1+floor((tfinal-t0) / h);
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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
X ' (t ) = X (t )
en [0,2]
X (0) = 1
(solución: X(t)= e t )
>> [ t , X ]=euler(@(t,X)X,0,1,2,0.001);
>> plot(t,X)
8
7
6
5
4
3
2
1
0
0.2
0.4
0.6
0.8
1
1.2
1.4
1.6
1.8
2
>> X(end)
ans =
7.3817
≈ e2
----------------------------------------------------------------------------------------------------------------------------------------------
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
>> 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)]
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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]
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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
********************************************************************************************************
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Sigamos con soluciones numéricas de Ecuaciones Diferenciales:
Programamos el Método de EULER que mencionamos antes:
Idea:
x' (t ) = f (t , x(t ))
x(t 0 ) = x 0
Queremos hallar X solución de
x' ' (t 0 ) 2 x' ' ' (t 0 ) 3
.h +
.h + ........
2
3!
Si h es chico ( h ≈ 0 ) entonces h 2 , h 3 ,.............. << h y descartamos los términos de orden 2,3,……….
x(t 0 + h) = x(t 0 ) + x' (t 0 ).h +
Quedándonos:
Llamamos:
x(t 0 + h) ≈ x(t 0 ) + x' (t 0 ).h y como x' (t ) = f (t , x(t )) , obtenemos: x(t 0 + h) ≅ x(t 0 ) + f (t 0 , x(t 0 )).h
t (1) al t0
y
x(1) a x0
t (2) es t 0 + h
y
x(2) a x(1) + f (t (1), x(1)) + h
t (3) es t 0 + 2h
y
x(3) a x(2) + f (t (2), x(2) + h , etc.
Si h = 0.5 :
function [ t , X ]=euler(f,t0,X0,tfinal,h) %donde t=[t(1),t(2),……,t(k)]es una partición del intervalo[t0,tfinal]donde estimo la
solución, y la matriz x=[(x1),(x2),………..]tiene en cada columna el vector posición en tiempo ti
pasos=1+floor(abs(tfinal‐t0) / h);
t=linspace(t0,tfinal,pasos);
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 más 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
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
x' = x
cuya solución es x(t ) = e t .
x(0) = 1
Lo probamos primero con una ecuación cuya solución conocemos:
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 sólo 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 h → 0 la solución va mejorando
Pero cada vez hace falta dar más pasos al achicar el h, y el método cada vez tarda más!!
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
También resolvimos antes con el programita dfield8.m
x' (t ) = x(t ) 2 − t
x(−2) = 1.4
en [‐2,‐1.5]
Esta vez no sabemos que fórmula tendría la solución 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 solución 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
están cerca
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
También podemos resolver alguna con X : R → R n con n>1.
Por Ejemplo:
x(t )
Hallemos X : R → R con X (t ) = y (t )
z (t )
3
x 2 (t )
2
x
t
t
'
(
)
cos(
)
*
=
y (t )
z 2 (t )
tal que
0
.
5
X (0) = − 0.5
0.2
en [0,4], donde la solución
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.26
0.24
0.22
0.2
0.18
0.16
-0.2
-0.4
1
0.8
-0.6
0.6
-0.8
0.4
-1
0.2
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
También podemos resolver ecuaciones de orden n:
x ( n ) + a(t ).x ( n −1) + .......... + p (t ).x(t ) = q(t )
Hacemos la representación en el espacio de fases:
x1 = x
x2
x1 ' x'
x 2 = x'
x3
x 2 ' x' '
.
.
.
.
entonces X’=
=
=
.
.
. .
.
.
. .
x ' x ( n ) q (t ) − px − ........ − ax
x n = x ( n −1)
1
n
n
Por Ejemplo: (Oscilador armónico no‐lineal y forzado)
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
t
x' ' (t ) − 2 sin(t ).x' (t ) − ( 3 ) x(t ) = cos(2t )
x(0) = 2
x' (0) = −0.5
en [0 , 3] con paso h=0.001 . Entonces:
x2
x'
'
'
=
=
X
x
t
x' '
cos(
2
)
(
)
2
sin(
)
+
+
t
x
t
x
x1 x
1
2
⇒
X= = ⇒
3
x 2 x' X (0) = x(0)
2
x' (0)
x(0) =
− 0.5
>> 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);
(x era x1 , la 1er fila de X)
>> plot(t,X(1,:))
12
10
x
8
6
4
2
0
0
0.5
1
1.5
t
2
2.5
3
>> plot(X(1,:), X(2,:))
(es la solución vista en el plano de fases)
18
16
14
12
x'
10
8
6
4
2
0
-2
0
2
4
6
x
8
10
12
Si en cierto tramo las curvas solución tienen una concavidad de signo fijo, Euler sobrevalúa o subevalúa de forma recurrente.
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Una forma de compensar es, en lugar de usar la tangente en t k , 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 debería haber en la “llegada”, para que, retrocediendo, regresemos
correctamente al punto inicial, es decir, ¿Cuál es X(:,k) de modo que X(:,k)= X(:,k-1)+f(t(k),X(:,k))* ∆t ?
El problema es que X(:,k) está IMPLÍCITO (aparece en ambos lados de la ecuación)
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 ( X (:, k )) − T ( X (:, k )) = f (t (k ), X (:, k )) − f (t (k ), X (:, k )) ∆t
Y para ∆t suficientemente chico se puede hacer de T un operador de contracción si f cumple una condición 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 aproximación de Euler) e ir iterando hasta aproximarnos al X(:,k) implícito.
En la práctica 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;
t=linspace(t0,tfinal,pasos);
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 estimación con eulerimp aproxima la solución correcta cometiendo errores “contrarios” a los de Euler
Por Ejemplo:
x' = x
cuya solución es x(t ) = e t , para t ∈ [0,2] .
x(0) = 1
Miremos el que ya hicimos:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
>> 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 e´2 ≅ 7.3891......... )
>> [tk,xk]=eulerimp(f,0,1,2,0.01); (dejamos la tolerancia por default 0.001)
ans =
7.4623
e´2 = 7.389
Esto sugiere que promediar los resultados de ambos métodos 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!!
********************************************************************************************************
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Antes mencionamos que combinando los Métodos de Euler y de Euler implícito (con Eulercomb) los resultados eran
probablemente (casi siempre) mejores que con cada método por separado.
Podemos testear ésta característica viendo “cuándo es necesario achicar el paso” para que dos aproximaciones con
pasos distintos disten entre sí en menos de un ε prefijado. (Aunque no conozcamos la solución exacta).
Ejemplo:
x' '+3.t.x'−9 x = 6t 2 − 4
Sea el problema de segundo orden:
x(0) = 0
x' (0) = 1
a) Buscar solución aproximada con Euler para h=0.1 ,
0.1
y
2N
en [0 , 1.5]
0.1 0.1 0.1
,
,
, ………………………………………. Hasta que las soluciones con
2
4
8
0.1
en x(1.5) (es decir en x(end)) disten en menos de 0.001.
2 N +1
b) Idem con Euler imp
c) Idem con Euler comb
d) Comparar qué potencia de N se requirió con cada método para que las aproximaciones con
0.1
y
2N
0.1
disten en menos
2 N +1
de ε = 0.001 .
Solución:
Hacemos la representación (el cambio de coordenadas, para transformarlo en un problema de 1er orden):
x2
x' =
x1 x
9 * x1 − 3 * t * x 2 + 6 * t.^ 2 − 4
X= = ⇒
0
x 2 x'
x(0) =
1
Se puede hacer la búsqueda automáticamente:
>> 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;
en
[0 , 1.5]
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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 métodos se copian las mismas líneas 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;
>> while(abs(xl(end)-xl2(end))>0.001)
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;
>> while(abs(xl(end)-xl2(end))>0.001)
n=n+1;
h=h/2;
tl = tl2 ;
xl = xl2 ;
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
[tl2 ,xl2 ]= eulercomb(f,0,[0;1],1.5,h/2);
end
>>n
n=
4
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
x' = f (t , x)
de Euler es que como estima:
x(t 0 ) = x0
Comentamos ahora que el problema básico
x(t k ) = x(t k −1 ) + x' (t k −1 ) .∆t +
123
f ( t k −1 , xk −1 )
x ' ' (c k ) 2
.∆t
2
14243
con ck entre t k −1 y t k (Lagrange)
desprecia la curvatura
por
x(t k ) = x(t k −1 ) + f (t k −1 , x k −1 ).∆t
Una vía de solución es lo que hicimos con Euler combinado, tratando de compensar la curvatura por el lado contrario.
Otra idea, que además admite luego generalizaciones más agudas aún, es tratar de representar el término
de alguna manera.
Si ponemos:
~
x ( t k ) euler
644
47444
8
f (t k , xtk −1 + f (t k −1 , xtk −1 ) − f (t k −1 , x k −1 ))
x(t k ) = x(t k −1 ) + f (t k −1 , x k −1 ).∆t +
.∆t
14243
2 4444444
1
4
4
4
4
4
4
4
2
3
x ( t k −1 )
144424
443
x '( t k ) − x '( t k −1 ) x ''(ξ )
≅
=
. ∆t
~
= x ( t k +1 ) paso de euler
14444442 42424444443
(
x ''(ξ )
x ''( c ) 2
. ∆t
.∆t ).∆t =
2
2
Entonces, llamando m1 = f (t k −1 , x k −1 ) =pendiente de Euler, y,
m2 = f (t k , ~
x k euler ) ≅ pendiente (estimada en el punto de llegada)de Euler
x(t k ) = x(t k −1 ) + m1 ∆t +
(m2 − m1 )
m
m
∆t = x(t k −1 ) + m1 ∆t + 2 ∆t − 1 ∆t , o sea,
2
2
2
x ' ' (c k )
2
.(∆t )
2
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
x(t k ) = x(t k −1 ) +
(m1 + m2 )
∆t Este es el método de RUNGE‐KUTTA (de orden 2)
2
(este promedio de las pendientes hace un promedio similar al de Euler combinado). Además lo hace localmente, de modo que
posiblemente corrige antes de que los errores locales se aumenten de manera crítica.
En general la idea de los métodos de RUNGE‐KUTTA de orden n es combinar “pendientes” en distintos puntos para estimar
términos hasta el orden n del desarrollo de Taylor de la solución.
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
Programemos en Matlab:
function [t,X]=RK2(F,t0,X0,T,h)
pasos=ceil(abs(T-t0)/h);
t=linspace(t0,T,pasos);
X(:,1)=X0;
hutil=t(2)-t(1);
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
% function [t,X]=RK2(f,t0,X0,tfinal,h)
% pasos=floor(abs(tfinal-t0)/h)+1;
% t=linspace(t0,tfinal,pasos);
% hutil=t(2)-t(1);
% X(:,1)=X0;
Ejercicio:
Probar con RK2 el h de la forma
0.1
h
tal que la solución con N y
N
2
2
h
N +1
disten en tfinal=1.5 en menos de 0.001 como
2
x' '+3.t.x'−9 x = 6t 2 − 4
x(0) = 0
hicimos con Euler, Eulerimp y Eulercomb en el mismo problema de antes:
x' (0) = 1
Solución:
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;
>> while(abs(xl(end)-xl2(end))>0.001)
en [0 , 1.5]
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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 método de RUNGE-KUTTA, pero proponemos uno más como ejercicio:
RK4:
Dado t k −1 , xk −1 hacer:
h = ∆t
Entonces, llamando m1 = f (t k −1 , x k −1 ) ;
es la de Euler
m2 = f (t k −1 + h / 2, x k −1 + m1 * h / 2);
m3 = f (t k −1 + h / 2, x k −1 + m2 * h / 2);
m4 = f (t k + h, x k −1 + m3 * h);
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 más las del medio), para estimar los términos de Taylor
(hasta orden 4)
xk + (
m1 + 2m2 + 2m3 + m4
).∆t
6
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Ejemplo:
Euler (too Eulerimp y Eulercomb)
X ' (t ) = X (t )
para Hallar X tal que
en [0,2] con
Probar las soluciones de
RK 2
X (0) = 1
RK 4
todos el mismo paso h=0.01, para poder compararlos (solución: X(t)= e t )
e 2 ≈ 7.3817
Comparando en cada caso X(end) con
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));
8
7
6
5
4
3
2
1
0
0.2
0.4
0.6
0.8
1
1.2
1.4
1.6
1.8
2
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
********************************************************************************************************
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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:
− x2
x' ' = 2 * cos(10 * t ). *
x1
x1
1
Hallar X : R → R 2 tal que X = con
x(0) =
− 1
x2
− 0.5
x' (0) =
0.5
en
[0 , 3].
Hallar la solución con RK2 y con RK4 con paso h=0.1. Si el error relativo de uno respecto del otro (en norma de Fröbenius) fuera
> 0.001 entonces achicar el h y repetir. El error relativo mencionado sería
X RK 2 − X RK 4
Solución:
w3
x1
x1 '
w4
x2
x2 '
=
Hay que llamar W = entonces W ' =
x'
2 * cos(10 * t ) * (− w2 )
x ''
1
1
x '
x ' ' 2 * cos(10 * t ) * w
1
2
2
w3
w4
W ' =
2 * cos(10 * t ) * (− w )
2
2 * cos(10 * t ) * w1
Queda
1
−1
W ( 0) =
− 0.5
0.5
>> 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,:);
X RK 4
.
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
>> norm(XR2-XR4,'fro')/norm(XR4,'fro')
ans =
0.2240
da más 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,:);
>> norm(XR2-XR4,'fro')/norm(XR4,'fro')
ans =
0.0237
da más de 0.001, entonces repetimos con h=0.001:
>> 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,:);
>> norm(XR2-XR4,'fro')/norm(XR4,'fro')
ans =
0.0023
da más de 0.001, entonces repetimos con h=0.0001:
>> 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,:);
>> norm(XR2-XR4,'fro')/norm(XR4,'fro')
ans =
2.3425e-004
ahora sí
Esta idea de realizar la cuenta con dos métodos distintos y considerar que la solución es aceptable si las soluciones
no difieren mucho puede sistematizarse. (De hecho los “solvers” de MATLAB comparan 2 métodos para decidir el h).
Podemos programarlo así:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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);
[t4,X4]=RK4(F,t0,X0,tfinal,h);
while((norm(X2‐X4), 'fro' )/(norm(X4), 'fro')) >tol)
h=h/2;
[t2,X2]=RK2(F,t0,X0,tfinal,h);
[t4,X4]=RK4(F,t0,X0,tfinal,h);
end
t=t4;
X=X4;
Podemos probarlo, Po Ejemplo, con:
x' = x
cuya solución es x(t ) = e t , en el intervalo [0,2].
x
(
0
)
1
=
>> 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 ecuación sencilla pero requiere un gran esfuerzo de cálculo para algunos valores
del parámetro:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
x' = x 2 − x 3
con δ ≈ 0
x ( 0) = δ
en [ 0, 2 ] .
δ
Está asociado a la ignición de un combustible concentrado (por ejemplo un fósforo) con x=radio de la llama.
Al principio la llama es pequeña, en un momento se alcanza un valor crítico de ignición, y la llama crece hasta alcanzar una
nueva estabilidad. El gráfico tiene una pinta de “escalón” tanto más empinada cuanto menor sea δ (como vemos debajo).
Observación: “ x 2 − x 3 ” indica que las estabilidades se alcanzan cuando se anulan (en 0 y 1) la componente x 2 (proporcional a
la superficie de la llama) y x 3 (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')
delta=0.01
1
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0
0
20
40
60
80
100
120
140
160
>> delta=0.001;
>> [t,X]=RK24(f,0,delta,2/delta,0.1,0.01);
>> plot(t,X,'o')
180
200
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
delta=0.001
1
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0
0
200
400
600
800
1000
1200
1400
1600
1800
>> delta=0.0001;
>> [t,X]=RK24(f,0,delta,2/delta,1,0.01);
>> plot(t,X,'o')
2000
OJO!! hace falta agrandar el paso porque el intervalo es muy largo 2/delta=20000
delta=0.0001 y Paso=1
1
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0
0
0.2
0.4
0.6
0.8
1
1.2
1.4
1.6
1.8
2
4
x 10
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 (después de largo rato) una respuesta, pero la respuesta requiere 200000 puntos!!
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
delta=0.00001
Paso=1 con RK4
1
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0
0
0.2
0.4
0.6
0.8
1
1.2
1.4
1.6
1.8
2
5
x 10
Una alternativa es usar un método que no use el mismo paso siempre, sino que lo achique, o agrande según haga falta!
A continuación veremos y programaremos el Método de BOGACKI‐SHAMPINE (BS23), (el 23 hace alusión a que compara en
cada paso) un método de orden 2 y de orden 3, y modifica el paso si no se cumple cierto criterio.
********************************************************************************************************
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Recién planteamos un problema que tiene una ecuación sencilla pero requiere para algunos valores del parámetro,
un gran esfuerzo de cálculo:
x' = x 2 − x 3
x ( 0) = δ
δ ≈0
en [0 ,
2
δ
]
Está asociado a la ignición de combustible concentrado (por ejemplo: un fósforo), con x=radio de la llama.
Al principio la llama es pequeña, en un momento se alcanza un valor crítico de ignición y la llama crece hasta
alcanzar una nueva estabilidad. El gráfico tiene una pinta de “escalón”, tanto más empinada cuanto menor sea el δ .
Observación: “ x 2 − x 3 ” indica que las estabilidades se alcanzan cuando se anulan (en 0 y 1) la componente x 2
(proporcional a la superficie de la llama) y x 3 (proporcional al volumen).
Con RK4 (no con RK24 q se cuelga!), después d largo rato, el Matlab da una respuesta pero ésta requiere de 200000 puntos!!
Una alternativa es usar un método que no use el mismo paso siempre, sino que lo achique, o agrande según haga
falta. Presentamos (y empezamos a programar) el Método de Bogacki-Shampine : BS23 (el 23 hace alusión a que
compara en cada paso) un método de orden 2 y uno de orden 3, y achica el paso si no se cumple cierto criterio.
Escribamos el algoritmo de BS23, que también está en la página 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)
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
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 ')
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
1.4
1.2
1
0.8
0.6
0.4
0.2
0
0
0.2
0.4
0.6
0.8
1
1.2
1.4
1.6
1.8
2
5
x 10
Idem
(casi inmediatamente)
En los casos razonables es más rápido!!!
Con programas del matlab:
>> ode23s(f,[0 2/delta],delta)
1.4
1.2
1
0.8
0.6
0.4
0.2
0
0
0.2
0.4
0.6
0.8
1
1.2
1.4
1.6
1.8
2
5
x 10
>> ode45(f,[0 2/delta],delta)
1.4
1.2
1
0.8
0.6
0.4
0.2
0
0
0.2
0.4
0.6
0.8
1
1.2
1.4
1.6
1.8
2
5
x 10
----------------------------------------------------------------------------------------------------.
Queremos plantear a continuación otro tipo de ecuación diferencial:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Ejemplo:
(tipo oscilador armónico)
x' ' (t ) − 2 * cos(t ) * .x' (t ) + x(t ) = sin( 2 * t )
Hallar x : [0,2] → R tal que
x ( 0) = 2
x ( 2) = 3
. Este es un Problema de CONTORNO.
Solución:
Tenemos datos en ambos bordes del intervalo [0,2], pero no podemos usar directamente ninguno de los métodos
que vimos, ya que si ponemos: haciendo la representación (el cambio de coordenadas):
x x
X (2)
X = 1 = el problema queda :
X ' =
x
sin(2 * t ) − X (1) + 2 * cos(t ) * X (2)
2 x'
⇒
x2
X (0) = ? no conocemos la velocidad inicial!!!!!
x'
X ' = =
?
x' ' sin(2t ) − x1 + 2 cos(t ) x 2
X (1)(t = 2) = 3
Cómo 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 “puntería”.
De hecho a ésta búsqueda se la llama ”SHOOTING”.
Podemos probar un poquito a mano y luego tratar de programar una forma más sistemática (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)
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
K=k+1;
end
>> plot(Valfin)
Y localizamos cuál es el k para el que Valfin está más cerca de 3 y guardamos ese V.
Una forma más sistemática consistiría en plantearlo como un problema de búsqueda de soluciones de una ecuación
(aunque en realidad lo anterior no se descarta, ya que había que tener una idea previa de por dónde hallar la
solución) y resolverlo con Newton-Raphson, o Bisección, u otro método.
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 teníamos de la búsqueda anterior (pongámosle v=1.2), resolvemos:
>>sol=NR_MULTI(@valorfinal,1.2,8)
1.2341
(pongámosle)
>>[t,X]=RK24(f,0,[2;sol],2,0.01);
>>X(1,end)
ans=
3.0000
>>plot(t,x) % la solución del Problema de Contorno
>> [t ,X ]=RK24(f,0,[2;sol],2,0.01);
>> X(1,end)
ans =
3.0000
>> plot(t,X(1,:))
3.5
3
2.5
2
0
0.2
0.4
0.6
0.8
1
1.2
1.4
1.6
1.8
2
********************************************************************************************************
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Planteamos otro problema de contorno:
Ejercicio:
X 1 (t )
(
)
X
t
2
3 x1
:
[
0
,
3
]
→
,
(
)
=
X
R
X
t
Hallar
X (t )
3
t ⋅ X (t )
2
X ′(t ) = X (t )
1
X (t ) − X (t )
1
3
tal que
X (0) = 1
2
X 2 (3) = 1.5
X 3 (3) = 0
Resolución:
X (0) = a
1
Creamos una función H que reciba como entrada valores a y b, de modo que asignando X (0) = 1 resuelva el problema de
2
X 3 (0) = b
valores iniciales con dichos datos, y que para la X solución del mismo devuelva como valor de H el vector columna:
a X (3) − 1.5
X (3) = 1.5
a 0
2
2
de manera que si H = entonces
‐y como también pedimos
H =
b 0
X 3 (3) = 0
b X 3 (3)
X 2 (0) = 1 entonces tendremos la solución del problema de contorno.
Para la solución 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
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
>> 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 solución, 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 solución 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);
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
>> 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:
X (0) = 1
2
X 2 (3) = 1.5
X 3 (3) = 0
Problema de Eventos
Llamamos así a aquellos problemas donde se busca la solución de una ecuación diferencial en un intervalo [to,T], donde to está
dado, y el T corresponde a un tiempo a determinar donde ocurre que la solución, en tiempo T, satisface alguna condición –
dependiendo de X(T) y las derivadas de X en T (allí “sucede”un cierto evento).
Podemos, por lo general, también plantear dicho problema como una búsqueda de ceros de una función –univariada o
multivariada‐.
A continuación vemos un ejemplo:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Consideremos el siguiente Problema de Eventos:
Cierto móvil de masa 1 responde a la siguiente ley de movimiento:
( y ' ) 2 + y. y ' ' = 1
y (0) = 1
y ' (0) = 0
Halle T>0 tal que la energía cinética (
1
1
.masa. velocidad 2 = .1.( y ' ) 2 ) del mismo sea 1 (en unidades [m]. [v] 2 ).
4
2
2
O sea, las que sean unidades de masa por las que sean las de velocidad al cuadrado, o sea que resolviendo
numéricamente como si no hubiera unidades.
Resolución Numérica:
Planteamos:
1 − ( y' ) 2
y' ' =
y
=
y
(
0
)
1
y ' (0) = 0
y
1 − ( y 2 ).^ 2
=
Y
'
y
2
2
y1 y
y'
2
y
con Y = = ⇒ Y ' = = 1 − ( y 2 ) , o sea,
1
y' '
y2 y'
1
y1
Y (0) =
0
Y armamos una función que para cada T calcule la energía cinética 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 línea de comandos planteamos la solución de G(T) - 1 = 0
4
>> 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 ecuación:
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
( y ' ) 2 + y. y ' ' = 1 equivale a : ( y. y ' )' = 1 ⇒ y. y ' = t + k ⇔ (
y2
y2 t2
q
)' = t − k ⇒
= − k .t + ⇒ y 2 = t 2 − 2k .t + q ⇔
2
2
2
2
⇔ y 2 = (t − k ) 2 + q − k 2 ⇔ y = (t − k ) 2 + q − k 2 sup y>0.
Con y(0)=1=q
Y’=
t−k
(t − k ) 2 + 1 − k 2
−k
⇒ k=0
1
Y’(0)=0=
y (t ) = t + 1 ⇒ y ' (t ) =
t
2
t2 +1
⇒ ( y ' (t ) )
2
1
1 t2
1
1
t2
t2
2
= 2
⇒ ( y ') =
= ⇒ 2
= ⇒ 2t 2 = t 2 + 1 ⇒ t 2 = 1 ⇒ t = 1
2
2
2 t +1 4
t +1 2
t +1
pues t>o.
-----------------------------------------------------------------------------------------------.
Ahora vamos a considerar brevemente otro tema acerca del Análisis de Frecuencias de una serie de datos.
La cuestión puede tratarse a partir del caso continuo – con ventajas e inconvenientes-, pero en esta ocasión
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 contribución de las diferentes frecuencias a los valores
de la serie.
Dada una serie temporal: ( x 0 , x1 ,............, x N −1 ) (es decir x(n)= x n con n=0,1,……,N-1)
La idea es escribirla como: x(n) =
N −1
∑e
− 2πif
f =0
n
N
t
con X ( f ) = X f =
.X f
1 N −1 2πif N
.∑ e
.x(t )
N t =0
La igualdad anterior vale porque el producto escalar:
< x(n), e
− 2πil
N
con
si
n
N
>= ∑ X f < e
n
− 2πif
n
N
,e
− 2πil
n
N
n
n
− 2πif
− 2πil
1
N
N
e
.e
dn = δ ( f , l ) la Delta de Kronecker , ya que:
∫
2π 0
l= f
es
e
− 2πif
t
N
.e
− 2πil
t
N
N
=1
∫e
con
0
si
n
N
− 2πif
− 2πil
1
N
N
>= ∑ X f .
e
.
e
dn
2π ∫0
l≠ f
queda 0 por la periodicidad de e
2πi
k
N
.
− 2πif
n
N
.e
− 2πil
n
N
dn = 2π
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
Luego: < x(n), e
− 2πil
n
N
>= X f
N −1
Recapitulando:
x = ∑ X f .e
− 2πif
n
N
f =0
− 2πif Nn
es la descomposición de x en la b. o. n. e
donde F es el conjunto
f ∈F
de frecuencias representables.
Para que valga la representación, debemos tener un conjunto de N frecuencias, que en realidad son simétricas
respecto del 0 (para una señal real), es decir f en [−
- y en realidad las distintas son de 0 a
N N
, ] (pero por periodicidad podemos asumir f en [0,N-1],
2 2
N
).
2
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-.
t
1 N −1 2πif
Recordemos X f = .∑ e N .xt
N t =0
Si
1 N −1
.∑ xt
N t =0
n=0
X0 =
n=1
1 N −1 2πi
X 1 = .∑ e N .xt
N t =0
(el promedio de xt )
constante en arg=0
t
Si
Etcétera.
Para cada f se gira e
2πif
t
N
y se mira la proyección (que es máxima cuando xt da los conjugados girando a la misma
velocidad y sentido opuesto).
Esto requeriría O ( N .N ) = O ( N 2 )
con distintas velocidades angulares.
Pero hay una forma más aguda de hacerlo:
Mirar la contribución de los promedios como frecuencia N (en lugar de 0).
( Si N es entero e
2πi
N
N
= e 2πi 0 = 1 )
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
N
N
, luego
,……., etc. Con ellas, y usando la periodicidad para cada intervalo
2
4
N N N
frecuencial, sólo hace falta ver las contribuciones de frecuencias
N,
,
, ,……………, 1 (y las demás se
2 4 8
Luego mirar la frecuencia
deducen de estas).
Esto requiere (si N = 2 k ) los datos para
N= 2 k ,
N
N
= 2 k −1 ,
= 2 k − 2 ,………….,
2
4
(N
N
2
→ Nyquist )
= 21
=
k datos
(por N)
y
log 2 N = k .
Luego con N .k = N . log 2 N datos reconstruimos la descomposición frecuencial.
Este esquema, que permite calcularla con un algoritmo O( N . log 2 N ) << O( N 2 ) se llama TRANSFORMADA
RAPIDA de FOURIER (FFT) por Fast Fourier Transform.
(Si N = 2 20 ≅ 10 6 ⇒ N 2 ≅ 1012 = 1000.000.000.000
y
N . log 2 N ≈ 20.000.000 )
Hay varias sutilezas y “rebusques” cuando N ≠ 2 k , en los que no entraremos.
Usaremos las funciones fft (y su inversa: ifft)
de MATLAB.
Una observación útil es que si la serie no es estacionaria (si tiene tendencias de mayor orden que 0 – lineales (o de
mayor orden aún)-) la representación en frecuencias converge lentamente – porque tienen componentes en cada
frecuencia- , y la representación discreta adolece por lo general de “aliasing” (superposición de frecuencias).
Por ello es útil extraer previamente (si corresponde) las tendencias lineales (eventualmente otras, pero las lineales
son, por mucho, las más usuales). Ello puede hacerse hallando el polinomio de cuadrados mínimos de orden 1, y
restándoselo a la señal.
Un par de ejemplos:
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
1ro) Una en que sea estacionaria: (verificación ver que polyfit(x,1) tiene 1er coeficiente 0 (la pendiente))
Podemos bajarla de la página, pero la construímos 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));
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
>> 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
XL(k)=0;
end
end
>> plot(XL)
>> XL=abs(ifft(XL));
>> plot(XL)
% es el 10% del maximo
------------------------------------------------------------------------------------Ejercicio:
Hacer lo mismo con otra señal: x= lo mismo + 0.01*t.
Retirar primero la parte lineal (guárdese en xlin ) con polyfit .
Solución:
>> 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)
Métodos Numéricos
Romina Cardo & Álvaro Corvalán
METODOS NUMERICOS – GUÍA DE ESTUDIO
>> xestacionaria=abs(ifft(XL));
>> xlimpia=xestacionariaL+xlin
>> plot(xlimpia)
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
15
800
700
10
600
5
500
0
400
300
-5
200
-10
-15
100
0
50
100
150
200
250
0
300
0
50
100
150
200
250
300
15
10
5
0
-5
-10
-15
0
50
100
150
200
250
300
Comparamos la serie y su limpiada….. MUY ACEPTABLE
15
15
10
10
5
5
0
0
-5
-5
-10
-10
-15
0
50
100
150
200
250
300
-15
0
50
100
150
200
250
300
