Pseudo

1
Captulo 23
Algoritmos numricos.
23.1. Solucin de sistema simultneo de ecuaciones lineales.
Si se aplica mtodo nodal con modificaciones, para tratar fuentes de voltajes controladas e independientes, se obtiene un sistema de ecuaciones, del tipo:
A x
Donde A es la matriz nodal aumentada, x es el vector de incgnitas y b el vector de excitaciones. Existen dos esquemas generales para resolver sistemas lineales de ecuaciones: Mtodos de eliminacin directa y Mtodos Iterativos. Los mtodos directos, estn basados en la tcnica de eliminacin de Gauss, que mediante la aplicacin sistemtica de operaciones sobre los renglones transforma el problema original de ecuaciones en uno ms simple de resolver. De entre los variados esquemas, basados en la eliminacin de Gauss, el mtodo de descomposicin en submatrices triangulares (LU, de Lower y Upper) es preferentemente empleado en implementaciones computacionales, para sistemas de menos de 300 ecuaciones. Para sistemas de un mayor nmero de ecuaciones se emplean mtodos iterativos. La mayora de estos procedimientos estn basados en el mtodo de Gauss Seidel, con aceleraciones para la convergencia. 23.1.1. Descomposicin LU. Est basado en descomponer la matriz de coeficientes en dos matrices triangulares L y U, segn:
L U
Donde L es una matriz triangular inferior (lower), y U es una matriz triangular superior (upper). El sistema original de ecuaciones, queda:
L U x
Que puede ser interpretado como dos sistemas de ecuaciones:
Profesor Leopoldo Silva Bijit
20-01-2010
Estructuras de Datos y Algoritmos
L d U x
b d
Los dos sistemas anteriores son sencillos de resolver, como se ver ms adelante. El sistema con matriz L, puede ser resuelto por substituciones hacia adelante; el sistema con matriz U se resuelve por substituciones hacia atrs. El procedimiento est basado en obtener las matrices L y U, a partir de A; luego en obtener el vector d; y finalmente en calcular la solucin en el vector x. Existen varias formas de efectuar la descomposicin, el mtodo de Doolittle asigna unos a los elementos de la diagonal principal de L. Veremos a travs de un ejemplo, las principales ideas, intentando obtener un algoritmo para el clculo. Se tiene la matriz A de 4x4 y se desea obtener L y U.
a11 a12 a21 a22 a31 a32 a41 a42
a13 a23 a33 a43
a14 a24 a34 a44
1 l21
0 1
0 0 0 0 1 0 l43 1
u11 u12 0 u22 0 0 0
u13 u14 u23 u24 u34 0 u44
l31 l32 l41 l42
0 u33
Efectuando la multiplicacin de las matrices L y U, se obtiene:
u11 u12 l21u11 l21u12 u22
u13 l21u13 u23
u14 l21u14 u24 l31u14 l32u24 u34
l31u11 l31u12 l32u22 l31u13 l32u23 u33
l41u11 l41u12 l42u22 l41u13 l42u23 l43u33 l41u14 l42u24 l43u34 u44
El primer rengln de A permite, por comparacin, determinar el primer rengln de U.
u11
a11; u12
a12 ; u13
a13 ; u14
a14
Una vez conocido u11, la primera columna de A permite determinar el primer rengln de L, se obtienen:
l21
a21 / u11; l31
a31 / u11; l41
a41 / u11
20-01-2010
Algoritmos numricos
El segundo rengln de A, permite calcular el segundo rengln de U, una vez conocidos los elementos del primer rengln de U, se tienen:
l21u12 u22
a22 ; l21u13 u23
a23 ; l21u14 u24
a24
Despejando los elementos del segundo rengln de U, se obtienen:
u22 u23 u24
a22 l21u12 a23 l21u13 a24 l21u14
La segunda columna de A, permite calcular la segunda columna de L.
l31u12 l32u22
a32 ; l41u12 l42u22
a42
Despejando los elementos de la segunda columna de L. se obtienen:
l32 l42
Del tercer rengln de A, resultan:
(a32 l31u12 ) / u22 (a42 l41u12 ) / u22
l31u13 l32u23 u33
a33 ; l31u14 l32u24 u34
a34
Las que permiten despejar los elementos del tercer rengln de U:
u33 u34
a33 l31u13 l32u23 a34 l31u14 l32u24
De la tercera columna de A, se puede calcular la tercera columna de L:
l43
(a43 l41u13 l42u23 ) / u33
Finalmente, el cuarto rengln de A, permite calcular el cuarto rengln de U.
u44
a44 l41u14 l42u24 l43u34
Si bien se ha desarrollado para una matriz de 4x4, de las expresiones obtenidas puede inducirse relaciones generales, como veremos a continuacin: Con N es el nmero de renglones y columnas de A.
20-01-2010
4 Para: n 1,..., N ;
ln, n
El n-avo rengln de U se obtiene segn:
La diagonal de L, se obtiene por definicin de la descomposicin de Doolittle.
n 1
un,i
Para: i
an,i
k 1
ln, k uk ,i
n,..., N ;
Y la n-ava columna de L con:

n 1
l j,n
Para: j
a j,n
k 1
l j , k uk , n / un, n
n 1,..., N
A continuacin se obtiene el algoritmo para la substitucin hacia delante: De la relacin:
L d
Se obtiene:
l11 0 l21 l22 l31 l32 l41 l42
0 0 l33
0 d1 0 d2 0 d3 d4
b1 b2 b3 b4
l43 l44
Efectuando las multiplicaciones, en el lado derecho, se tienen:
l11d1 l21d1 l22 d 2 l31d1 l32 d 2 l33d3 l41d1 l42 d 2 l43d3 l44 d 4
Las componentes del vector d, se obtienen segn:
b1 b2 b3 b4
20-01-2010
Algoritmos numricos
d1 d2 d3 d4
b1 / l11 (b2 l21d1 ) / l22 (b3 l31d1 l32 d 2 ) / l33 (b4 l41d1 l42 d 2 l43d 3 ) / l44
Una vez obtenido d1, se substituye en la expresin siguiente para calcular d2; con d1 y d2, se puede calcular d3; y as sucesivamente. Por esta razn, al procedimiento se lo denomina substitucin hacia adelante (forward). El vector d, puede recalcularse para diferentes valores del vector b, que es la situacin que se produce en un barrido DC. Debido a que en el mtodo de Gauss se ocupa, desde el inicio de las operaciones, los valores de b; el efectuar clculos con b variable lo realiza con ventajas el mtodo de descomposicin triangular. La relacin anterior, permite deducir una expresin para calcular los d i, en una matriz de orden N.
i l
di
Para: i 1, 2,
(bi
j 1
lij d j ) / lii
,N
En la descomposicin de Doolittle, los lii son unos. El algoritmo para la substitucin hacia atrs se obtiene de manera similar a las anteriores. Para la triangular superior:
U x
Se tiene:
u11 u12 0 u22 0 0 0 0
u13 u14 u23 u24 u33 0 u34 u44
x1 x2 x3 x4
d1 d2 d3 d4
Efectuando las multiplicaciones, se obtiene:
u11 x1 u12 x2 u13 x3 u14 x4 u22 x2 u23 x3 u24 x4 u33 x3 u34 x4 u44 x4
Despejando los xi, se obtienen:
d1 d2 d3 d4
20-01-2010
x4 x3 x2 x1
d 4 / u44 (d3 u34 x4 ) / u33 (d 2 u23 x3 u24 x4 ) / u22 (d1 u12 x2 u13 x3 u14 x4 ) / u11
Que entrega la solucin del sistema de ecuaciones. Ntese que primero se obtiene x4; y luego x3, que se calcula en trminos de x4; y as sucesivamente. Por esta razn a este algoritmo se lo denomina substitucin hacia atrs (back). En general:
xN
d N / u NN
N
di xi
Para: i
j i 1
uij x j uii
( N 1), ( N 2),
,3, 2,1
La observacin cuidadosa de la generacin de las matrices L y U, muestra que no es necesario emplear espacio adicional para stas. Los valores que se van calculando pueden almacenarse en la matriz A. Tampoco es necesario almacenar los elementos de la diagonal principal de L, ya que son unos por definicin. Entonces luego de la descomposicin, la matriz original queda, en el caso del ejemplo de 4x4:
u11 u12 l21 u22 l31 l41 l32 l42
u13 u14 u23 u24 u33 u34 l43 u44
void ludcmp(float **a, int N) /*Dada a[1..N][1..N], la reemplaza por la descomposicin LU Doolittle.*/ { int n,i,j,k; float sum; for (n=1; n<=N; n++) { for (i=n; i<=N; i++) { sum=0; for (k=1; k<=(n-1); k++) sum += a[n][k]*a[k][i]; a[n][i]-=sum; }
n 1
un,i
an,i
k 1
ln, k uk ,i
20-01-2010
Algoritmos numricos for (j=n+1; j<=N; j++) { sum=0; for (k=1; k<=(n-1); k++) sum += a[j][k]*a[k][n]; a[j][n]=(a[j][n]-sum)/a[n][n]; } } } /*Realiza substituciones hacia adelante y hacia atrs. a[1..N][1..N] es de entrada y debe contener la descomposicin L y U. b[1..N] el vector de excitacin. Retorna en b la solucin. a no es modificada y pueden realizarse sucesivos llamados con diferentes valores de b. */ void lufwbksb(float **a, int N, float b[]) { int i,j; float sum; for (i=1; i<=N; i++) { sum=0; i l for (j=1; j<=(i-1); j++) sum += a[i][j]*b[j]; di (bi lij d j ) / lii b[i]-=sum; //l[i][i]=1. j 1 } //se genera vector d en el espacio ocupado por b. b[N]/=a[N][N]; xN d N / u NN for (i=(N-1); i>=1; i--) N { sum=0; di uij x j for (j=(i+1); j<=N; j++) sum += a[i][j]*b[j]; j i 1 xi b[i]=(b[i]-sum)/a[i][i]; uii } //se almacena solucin x en el espacio ocupado por b. } Ejemplo de uso. //Resuelve el sistema de ecuaciones lineales aX = b. ludcmp(a, n); lufwbksb(a, n, b); 23.1.2. Mtodos iterativos.
n 1
l j,n
a j,n
k 1
l j , k uk , n / un, n
Para deducir expresiones generales que permitan escribir algoritmos iterativos, consideremos el sistema lineal de tres ecuaciones:
a11 a12 a21 a22 a31 a32
a13 x1 a23 x2 a33 x3
b1 b2 b3
20-01-2010
Despejando de la primera ecuacin, la variable x1 ; de la segunda x2 ; y de la tercera x3 , obtenemos:
x1 x2 x3
(b1 a12 x2 a13 x3 ) / a11 (b2 a21 x1 a23 x3 ) / a22 (b3 a31 x1 a32 x2 ) / a33
Si consideramos conocidos los valores de las variables del lado derecho, podremos estimar un nuevo valor para las variables del lado izquierdo de las ecuaciones. Podemos anotar lo anterior, mediante:
x1[n 1] (b1 a12 x2 [n] a13 x3 [n]) / a11 x2 [n 1] (b2 a21 x1[n] a23 x3[n]) / a22 x3 [n 1] (b3 a31 x1[n] a32 x2 [n]) / a33
Donde xi [n 1] es el valor de xi en la iteracin (i+1); y xi [n] es el valor obtenido en la iteracin anterior. Durante el proceso iterativo se verifica la convergencia calculando el mayor cambio relativo entre una iteracin y la siguiente, y comparando el valor absoluto de esta diferencia con la tolerancia deseada.
| xi [n 1] xi [n] |
tolerancia
Si el error es menor que la exactitud requerida el proceso termina; en caso contrario se realiza una nueva iteracin. Si se tienen N variables, pueden generalizarse las iteraciones segn:
j i 1 j N
xi [n 1] (bi
j 1
aij x j [n]
j i 1
aij x j [n]) / aii
El esquema anterior se reconoce como mtodo de Jacobi. Si el clculo de las variables se realiza en orden, desde x1 hasta xN , puede observarse que una vez obtenido x1 puede usarse este valor para calcular x2 ; y as sucesivamente. Entonces en el clculo xi se pueden emplear los nuevos valores de las variables desde x1 hasta xi 1 . Entonces el esquema iterativo puede plantearse:
20-01-2010
Algoritmos numricos
j i 1 j N
xi [n 1] (bi
j 1
aij x j [n 1]
j i 1
aij x j [n]) / aii
El que se denomina mtodo de Gauss Seidel. Mejores resultados se logran calculando las variables en orden decreciente de los valores de la diagonal principal. Una mejora notable de la convergencia se logra empleando un promedio ponderado de los resultados de las dos ltimas iteraciones para obtener el nuevo valor. Esto se denomina mtodo de sucesivas sobre relajaciones (SOR Successive Over-Relaxation).
xi [n 1] axi [n 1] (1 a) xi [n]
Con: 0
a 2
Si a es 1, se tiene la frmula de Gauss Seidel. Con a>1, el nuevo valor, en la iteracin (n+1), tiene mayor importancia. Con a<1, se tiene subrelajacin. La eleccin de este valor, y su influencia en la convergencia debera aclararse en un curso de anlisis numrico. La recurrencia para encontrar el nuevo valor por el mtodo SOR:
j i 1 j N
xi [n 1] (1 a) xi [n] a(bi
j 1
aij x j [n 1]
j i 1
aij x j [n]) / aii
El algoritmo descrito en pseudo cdigo: SOR. Dados: N, a, b, x[0], tol, nmax. for n = 1, nmax do for i = 1,.... N do
Comienza iteraciones
j N
j i 1
yi [n] (1 a) xi [n] a(bi

j 1
aij y j [n]
j i 1
aij x j [n]) / aii
end for i
yi
xi
for j = 1,.. N do
xj
yj
end for i tol ) stop if ( end for n
20-01-2010
10
/*Dados a[1..N][1..N], b[1..N] calcula x[1..N] Con nmax iteraciones y factor de relajacin alfa. Retorna solucin en x[1..N]*/ int sor(float **a, int N, float *x, float *b, int nmax, float alfa) { int n, i, j, and; float sumi, sums; float *y; y=vector(1, N); //vector de flotantes for (n=1; n<=nmax; n++) { for(i=1; <=N; i++) { sumi=0; for (j=1; j<=(i-1); j++) sumi += a[i][j]*y[j]; sums=0; for (j=i+1; j<=N; j++) sums += a[i][j]*x[j]; y[i]=(1.-alfa)*x[i] + alfa*(b[i]-sumi-sums)/a[i][i]; } and=1; for(j=1; j<=N; j++) { and = and && (fabs(y[j]-x[j]) < tol*(fabs(x[j])); //error relativo if( and==0) break; } for(j=1; j<=N; j++) x[j]=y[j]; if (and) break; //putchar('.'); } free_vector(y, 1, N); return (n); } En lugar de emplear errores absolutos: (fabs(y[j]-x[j]) < tol), es preferible utilizar errores relativos: (fabs(y[j]-x[j]) < tol*(fabs(x[j]) );
23.2. Solucin numrica de sistemas de ecuaciones diferenciales.

Una ecuacin diferencial de primer orden puede resolverse numricamente mediante integracin. Si se tiene:
dr (t ) dt
Entonces:
F (t )
t
r (t )
r (0)
0
F ( )d
F (t ) considera la variacin de r(t) y de las excitaciones que producen la respuesta r(t).
20-01-2010
Algoritmos numricos
11
Una manera simple y aproximada de realizar la integracin es calcular el rea mediante la suma de rectngulos, que estudiaremos como el mtodo de Euler. Una mejor aproximacin se logra sumando trapecios, si se desea mayor precisin se emplea aproximacin por segmentos parablicos, con la regla de Simpson. Para disminuir la acumulacin de errores se emplea el mtodo de Runge-Kutta. 23.2.1. Formulacin de ecuaciones de estado. La formulacin de las ecuaciones de una red elctrica en trminos de las variables de estado permite encontrar la solucin de un sistema de ecuaciones diferenciales de primer orden en el dominio del tiempo. La solucin numrica, que veremos a continuacin, puede extenderse a sistemas no lineales. La representacin se logra con un sistema de ecuaciones diferenciales de primer orden:
dx dt
Ax Bu
Donde x es el vector de estado, u es el vector de entrada o de excitaciones. El resto de las variables del sistema puede expresarse en trminos del estado, segn:
y Cx Du
Donde y es el vector de salida. A se denomina matriz de estado del sistema, B es la matriz de entrada, C es la matriz de salida, y D se denomina matriz de alimentaciones directas (feedforward). 23.2.2. Mtodo de Euler. A partir de la expansin en serie de Taylor, para una variable escalar x, se tiene:
x(t
t)
x(t )
dx(t ) t dt
1 dx 2 (t ) 2 t .... 2 dt 2
La relacin anterior, puede generalizarse considerando a x como el vector de estado. Pueden calcularse, aproximadamente, los valores de las variables de estado en el instante siguiente (k+1), a partir de los valores en el instante k-simo, mediante:
xi [k 1] xi [k ]
dxi (tk ) t dt
Este procedimiento iterativo se denomina esquema simple de Euler.
20-01-2010
12
Los valores de las derivadas, en un instante determinado, se obtienen mediante la matriz de estado.
j n j n
xi [k 1]
Para: i
xi [k ] (
j 1
aij x j [k ]
j 1
bij u j [k ]) t
1, 2,
,n
A partir de la ecuacin de estado se determina el valor de las derivadas en un punto. La siguiente funcin calcula en la matriz x, los valores de las variables de estado en npuntos separados en intervalos de tiempo Delta. No se considera la matriz b, ni el vector u de excitaciones. Esto equivale a resolver un sistema de ecuaciones diferenciales lineales homogneas y de primer orden. void euler(float **a, int N, float **x, float *ic, int npuntos, float Delta) /*Dados a[1..N][1..N], ic[1..N] calcula x[1..N][1..npuntos]*/ { int i, j, k; float sum, t=0.; for(i=1; i<=N; i++) x[i][1]=ic[i]; //condiciones iniciales. for (k=1; k<npuntos; k++) { t= t+Delta; for(i=1; i<=N; i++) { sum=0; for (j=1; j<=N; j++) sum += a[i][j]*x[j][k]; x[i][k+1]= x[i][k]+sum*Delta; } } } Una alternativa de diseo es generar un archivo de datos en lugar de almacenar los puntos en una matriz. Con el archivo de datos se pueden generar formas de ondas. La siguiente funcin ilustra la generacin de un archivo de datos compatible con el comando pointplot de Maple. Generando los puntos (t[k], x[i][k]) para la variable xi . void genseq(float **a, int N, float **x, int npuntos, float Delta, int i) /*Dados a[1..N][1..N], ic[1..N] y x[1..N][1..npuntos] genera seq compatible para grficos de tipo pointplot en Maple.*/ { int k; float t=0.; printf("Seq:=["); for (k=1; k<=npuntos; k++, t=t+Delta) { printf("[%g,%g]\n", t, x[i][k]); if (k<npuntos) putchar(','); } putchar(']'); putchar('\n'); Profesor Leopoldo Silva Bijit 20-01-2010
Algoritmos numricos } Ejemplo de uso: n=2;npuntos=20; a=matrix(1, n, 1, n); //pide espacio a[1][1]=0.; a[1][2]=1.; a[2][1]=-3.; a[2][2]=-2.; ic=vector(1, n); ic[1]=1.;ic[2]=0.; x=matrix(1, n, 1, npuntos); //pide espacio //Resuelve sistema ecuaciones diferenciales. euler(a,n,x,ic,npuntos,0.1); genseq(a,n,x,npuntos,0.1,1); La ltima invocacin genera para la variable x1 : Seq:=[[0,1],[0.1,1],[0.2,0.97],[0.3,0.916],[0.4,0.8437],[0.5,0.75838],[0.6,0.664813] ,[0.7,0.567208],[0.8,0.46918],[0.9,0.373741],[1,0.283314],[1.1,0.199761] ,[1.2,0.124418],[1.3,0.0581519],[1.4,0.00140604],[1.5,-0.0457352] ,[1.6,-0.0834903],[1.7,-0.112322],[1.8,-0.132883],[1.9,-0.145962] ] Debido a la acumulacin de errores no suele emplearse el algoritmo de Euler. 23.2.3. Algoritmo de Euler. Para el caso de una variable, tenemos:
13
dy (t ) dt
f (t , y (t ))
Se pueden obtener los valores sucesivos de y, mediante:
yn
Si definimos:
yn k1
hf (tn , y (tn )) hf (tn , yn )
Se realiza la integracin mediante:
yn
yn
k1
Se tiene que f (tn , yn ) es la derivada de la funcin y (t ) , y k1 es el rea del rectngulo bajo la curva de f (t , y) , y tambin el incremento de la ordenada. Las relaciones se muestran en la Figura 1, para la variable y (t ) .
20-01-2010
14
tg ( n )
yn tn
yn+1
1 1
yn tn
k1 h
f (tn , yn )
f(tn+1,yn+1)
yn
k1
f(tn,yn)
tn
tn+1
tn
tn+1
Figura 23.1. Mtodo de Euler.
23.2.4. Algoritmo trapezoidal. Una mejor aproximacin para el rea bajo la curva de f (t , y) es mediante el trapecio entre las paralelas tn y tn 1 .
yn+1 (k1 + k2)/2 yn
n
f(tn+1,yn+1) f(tn,yn)
tn
tn+1
tn
tn+1
Figura 23.2. Mtodo trapezoidal. Entonces:
yn
Con:
yn
h ( f (tn , yn ) 2
k1 k2 hf (tn , yn )
f (tn 1 , yn 1 ))
hf (tn 1 , yn 1 )
Se realiza la integracin trapezoidal mediante:
20-01-2010
Algoritmos numricos
15
yn
yn
1 (k1 k2 ) 2
En cada paso de integracin es preciso evaluar dos veces la funcin: f (t , y) . La determinacin de yn

1
que se emplea en el clculo de k2 , puede determinarse, aplicando Euler,

1
segn: yn
yn
k1
23.2.5. Algoritmo de Simpson. Para refinar el clculo del rea, se define un punto dentro del intervalo, de este modo puede calcularse el rea bajo una parbola que pasa por los tres puntos:
f (t0 , y0 ) , f (t1 , y1 ) , f (t2 , y2 ) , con t1

yn+1 (k0 +4 k1+ k2)/6 yn
n
t0 h / 2 y t 2
t0
h.
f(tn+h/2, y(tn+h/2)) f(tn+1,yn+1) f(tn,yn) fa(t)
tn
tn+1
tn
tn+1
Figura 23.3. Mtodo de Simpson. Si la ecuacin de la parbola que aproxima el rea bajo la curva de f (t , y) es:
f a (t )
Se tienen:
at 2 bt c
f0 f1 f2
at0 2 bt0 c at12 bt1 c at2 2 bt2 c
Que permiten calcular a, b, c , conociendo: f 0 , f1 , f 2 , t0 , t1 , t2 . Luego se realiza la integral:

t t2
A
t t0
f a (t )dt
20-01-2010
16 Aplicando que t1
t0 h / 2 y t 2
t0
h , se obtiene: h A ( f 0 4 f1 f 2 ) 6
hf (tn , yn ) hf (tn hf (tn h / 2, y (tn h, y (tn h / 2)) h))
Con:
k0 k1 k2
El paso de integracin puede realizarse segn:
yn
yn
1 (k0 4k1 k2 ) 6
En cada paso de integracin es preciso evaluar tres veces la funcin: f (t , y) . Los valores de las ordenadas intermedias, pueden calcularse, segn:
y (tn y (tn
h / 2) h) yn
yn
k0 h / 2
k0 h
La frmula anterior permite deducir la conocida frmula para la aproximacin de Simpson. Si se tienen cinco valores de tiempos para los cuales se calcula la integral, se tiene el rea acumulada, segn:
Area
La cual puede simplificarse a:
1 1 (k0 4k1 k2 ) (k2 4k3 k4 ) 6 6
1 (k0 4k1 2k2 4k3 k4 ) 6 Con 2n+1 puntos en total, se tiene en general: Area
Area h ( f 0 4 f1 2 f 2 4 f3 ...... 2 f 2 n 6 4 f2n f2n )
double SimpsonIntegral(double a, double b, int n) { double h, suma, sumap, sumai; int i; if (n%2==1) n++; //deja a n como nmero par. h=(b-a)/n; suma=f(a)+f(b); //suma los extremos for(i=1, sumap=0; i<n; i+=2){ sumap+=f(a+i*h); //acumula impares
20-01-2010
Algoritmos numricos } for(int i=2, sumai=0; i<n; i+=2){ sumai+=f(a+i*h); //acumula pares. } return ((suma+4*sumap+2*sumai)*h/3); } 23.4.6. Mtodos multietapas.
17
Existen mtodos ms elaborados para efectuar un paso de integracin, En stos la funcin se evala en varias etapas entre dos puntos. Los puntos de las etapas slo se emplean para el clculo del nuevo valor. Consisten en definir una funcin en la cual se escogen los parmetros de tal modo de minimizar los errores. Sea la funcin
yn , tn ; h , entonces, la integracin se realiza mediante: yn

1
yn
yn , t n ; h
El mtodo de Euler es:
yn , t n ; h
f ( yn , t n )
El siguiente esquema es de Runge-Kutta, de segundo orden, con cuatro parmetros.
k1 k2 yn
Con:
1
f yn , t n f yn yn hk1 , tn h ak1 bk2 h
y tn , tn
af y(tn ), tn
bf y(tn )
hf y(tn ), tn , tn
Donde deben determinarse: a, b, ,
por consideraciones de exactitud.
Si se define el error de la aproximacin por:
Tn
y tn h
y tn
y tn , tn
Para el primer trmino de Tn, por expansin de Taylor de y(t), resulta:
y tn
Como se tiene:
y tn
dy (tn ) dt
h 2 d 2 y (tn ) 2! dt 2
h3 d 3 y (tn ) O(h 4 ) 3 3! dt
20-01-2010
18
dy dt
La segunda derivada de y, se obtiene segn:
f y t ,t
d2y dt 2
d f y t ,t dt
f t
f dy y dt
f t
f f y
ft
fy f
Las derivadas parciales de f se han representado, en forma abreviada, mediante subndices. Para la tercera derivada, se tiene:
d3y dt 3
La cual permite obtener:
d dt
f t
f f y
d f d f ( ) ( )f dt t dt y
f df y dt
d3y dt 3
f
2
f f t y
f y t
f
2
f y
f t
f f y
Finalmente para la tercera derivada:
d3y dt 3
ftt
f yt f
( f yt
f yy f ) f
f y ( ft
fy f )
Reemplazando las derivadas obtenidas, en la expansin de Taylor, se logra:
y tn
y tn
hf
h2 ( ft 2!
fy f )
h3 ( ftt 3!
2 f ty f
f yy f 2
f y ft
f y 2 f ) O (h 4 )
Donde se ha empleado: f
f y tn , tn
Para el segundo trmino de Tn, se requiere expandir el trmino que est multiplicado por b. Para y, tn t , esto se emplea la expansin de Taylor de dos variables de f yn con: y hf , t h . Como los trminos de segundo orden. Entonces; est multiplicado por h, slo es necesario considerar hasta
20-01-2010
Algoritmos numricos
19
f y
y, t
f y, t 1 f 2 ( y, t ) 2 y 2 y2 f 2 ( y, t ) y t y t 1 f 2 ( y, t ) 2 t 2 t2
f ( y, t ) y y
f ( y, t ) t t
Reemplazando en la anterior, los valores de los incrementos y empleando notacin abreviada para las derivadas parciales de f, se logra:
f yn f y ( hf )
y, tn
f yn , t n 1 f yy ( hf ) 2 2 f yt ( hf )( h) 1 f tt ( h) 2 O(h 3 ) 2
f t ( h)
Reemplazando la expresin anterior en:
y tn , tn
Se obtiene:
af y(tn ), tn
f y hf ft h
bf y(tn )
1 f yy ( hf )2 2
hf y(tn ), tn , tn
f yt ( hf ) h
h
1 f tt 2
2 2
y tn , tn
af
b( f
h ) O h3
Donde las funciones y las derivadas parciales estn evaluadas en tn. Se tiene finalmente para el error:
Tn
h f
h ft 2 b f
ff y
h2 ftt 3!
2 fty f f yy 2
f yy f 2 f
2
f y ft
fy f fh 2 ftt 2 2 h 2 O (h 4 )
h af
( fy f
f t )h
h2
f yt
Los parmetros: a, b, ,
, se escogen del tal modo de minimizar el error. En este caso pueden
hacerse cero los coeficientes de h y h 2 , pero no es posible eliminar la parte que depende de h3 . Para eliminar la parte proporcional a h , se debe cumplir: f
2
af bf 0 Para eliminar la parte proporcional a h , se debe cumplir: ( ft ff y ) / 2 bf y f

De la primera se obtiene: a b 1 De la segunda, debe cumplirse: ft (
bf t
1 b ) 2 b
ff y (
1 b ) 0 , de la que se desprenden: 2 1 b 2
20-01-2010
20
Con a 1, b 0 se tiene el mtodo de Euler. No pueden ajustarse , . Por esta razn puede decirse que el algoritmo de Euler pertenece a la familia Runge-Kutta de segundo orden. 23.4.6.1. Mtodo de Heun. Considera:
1,
0, a b
1 que satisfacen las dos relaciones anteriores. 2
Se realiza la integracin mediante:
yn
Con:
yn
k1
h k1 k2 2
f yn , t n k1h, tn h
k2
23.4.6.2. Mtodo del punto medio. Considera:
f yn
1 , a 0, b 1 que satisfacen las dos relaciones anteriores. 2

yn
1
yn
hk2
Con:
k1
f yn , t n
k2
f yn
k1h , tn 2
h 2
La pendiente de y est dada ahora por el valor de f en el punto medio del intervalo.
yn+1 yn
n
f(tn+h/2,yn+k1h/2) f(tn+1,yn+1) f(tn,yn)
hk2
tn
tn+1
tn
tn+1
Figura 23.4. Mtodo del punto medio. 23.4.6.3. Mtodo de Ralston. Considera:
3 a 4
1 , b 3
2 que satisfacen las dos relaciones anteriores. 3

20-01-2010
Algoritmos numricos Se integra mediante:
21
yn
Con:
yn
k1
h (k1 2k2 ) 3
f yn , t n
k2
f yn
3k1h , tn 4
3h 4
En los algoritmos del mtodo de Runge-Kutta de segundo orden, debe evaluarse dos veces la funcin: f y (t ), t , para obtener el siguiente punto de la funcin. 23.4.7. Mtodos de Runge-Kutta de cuarto orden. Para derivar el algoritmo de cuarto orden de Runge Kutta, se definen los 10 parmetros: a1 , b1 , a2 , b2 , a3 , b3 , w1 , w2 , w3 , w4 . Los cuales deben elegirse de tal modo de eliminar los errores proporcionales hasta la cuarta potencia del intervalo temporal h.
k1 k2 k3 k4 yn
Con:
1
hf yn , tn hf yn b1k1 , tn hf yn b2 k2 , tn hf yn b3k3 , tn yn w1k1 w2 k2 a1h a2 h a3h w3k3 w4 k4

a1h
y tn , tn
w1 f yn , tn a2 h
w2 f yn b1k1 , tn
w3 f yn b2 k2 , tn
La expresin para el error es:
w4 f yn b3k3 , tn a3h
Tn
yn
yn h
y tn , tn
Antes se obtuvieron las tres primeras derivadas de y. Se requiere calcular la cuarta derivada de y, se tiene:
d4y dt 4
Derivando, se obtiene:
d ( ftt dt
2 fty f
f yy f 2
f y ft
f y2 f )
20-01-2010
22
d4y dt 4 2( f yy
(( f yyy dy dt
dy dy d2y dy dy f yyt ) f yy 2 f yyt f ytt ) dt dt dt dt dt 2 3 d y d y dy dy d2y f yt ) 2 f y 3 ( f yyt f ytt ) f yt 2 dt dt dt dt dt
f ytt
dy dt
f ttt
Reemplazando la primera derivada de y:
d4y dt 4 2( f yy f
(( f yyy f f yt )
f yyt ) f d2y dt 2 fy
f yy
d2y dt 2
f yyt f
f ytt ) f f yt d2y dt 2 f ytt f f ttt
d3y ( f yyt f dt 3
f ytt ) f
Reemplazando la segunda derivada de y, se tiene:
d4y dt 4 2( f yy f
(( f yyy f f yt )( f t
f yyt ) f fy f )
f yy ( f t fy
fy f )
f yyt f
f ytt ) f f yt ( f t fy f ) f ytt f f ttt
d3y ( f yyt f dt 3
f ytt ) f
Reemplazando la tercera derivada de y, se obtiene:
d4y (( f yyy f f yyt ) f f yy ( ft dt 4 2( f yy f f yt )( ft f y f ) f y ( f tt f y ( ft f y f )) ( f yyt f f ytt ) f
fy f ) f ty f f yt ( ft
f yyt f ( f yt fy f )
f ytt ) f f yy f ) f f ytt f fttt
Reemplazando las derivadas obtenidas, en la expansin de Taylor, se logra la serie:
y tn
y tn
hf
h2 ( ft 2!
fy f )
h3 ( f tt 3!
2 f ty f 3 f yyt f
f yy f 2 5 f yt f y f
f y ft
f y2 f )
h4 ( f yyy f 3 3 f yyt f 2 4 f yy f y f 2 3 f yy f t f 4! 3 f yt f t f y 3 f f y 2 f t f y f tt f ttt ) O (h5 )

Donde se ha empleado: f
f y tn , tn
La segunda componente del error, requiere calcular:
20-01-2010
Algoritmos numricos
23
y tn , tn
w1k1 w2 k2 w3k3 w4k4

f yn y, tn t , con los
Se emplea la expansin de Taylor de dos variables de diferentes y, t . Como trminos de tercer orden. Entonces;
est multiplicado por h, slo es necesario considerar hasta los
f yn fy y
y , tn ft t
f yn , t n f yt y t 1 f ytt 2 1 f tt t 2 2 1 y t2 f ttt t 3 6
1 f yy y 2 2 1 f yyt y 2 t 2
1 f yyy y 3 6
Reemplazando en la anterior, los valores de los incrementos y empleando notacin abreviada para las derivadas parciales de f, se logra:
k1
hf
1 3 3 1 2 2 1 1 3 b1 f fyyy b1 f fyyt a1 b1 f a1 2 fytt a1 fttt h 4 6 2 2 6 1 1 fyy b1 2 f 2 b1 f fyt a1 ftt a1 2 h 3 ( fy b1 f ft a1 ) h 2 2 2
k2 =
hf
k3 =
fy b2 fyy b1 2 f 2 2 b2 ( fy b1 f
h4
b1 f fyt a1 ft a1 ) fyt a2
ftt a1 2 2
fyy b2 2 f ( fy b1 f
ft a1 ) a2 3 fttt 6
fy b2 ( fy b1 f ft a2 ) h 2
b2 2 f 2 fyyt a2 b2 f a2 2 fytt b2 3 f 3 fyyy 2 2 6 2 2 2 ftt a2 fyy b2 f ft a1 ) b2 f fyt a2 h 3 2 2

hf
( fy b2 f
k4 =
hf a3 3 fttt 6 fyy b3 2 f ( fy b2 f ft a1 ) ft a2 ) ftt a2 2 2 b3 3 f 3 fyyy 6 fyy b2 2 f 2 2 b3 f a3 2 fytt 2 b2 f fyt a2
fy b3 fy b2 ( fy b1 f
20-01-2010
24
b3 ( fy b2 f
ft a2 ) fyt a3
b3 2 f 2 fyyt a3 h4 2 ft a2 ) b3 f fyt a3 h 3
fyy b3 2 f 2 ftt a3 2 2 2 2 ( fy b3 f ft a3 ) h
fy b3 ( fy b2 f
Reemplazando las expresiones anteriores en: Se obtiene:
y tn , tn
y tn , tn
b1 3 f 3 fyyy w2 6 b1 2 f 2 fyyt a1 2 ft a2 ) b1 f a1 2 fytt 2 a1 3 fttt 6 a3 3 fttt w4 6
fyy b3 2 f ( fy b2 f
fy b3 fy b2 ( fy b1 f b3 ( fy b2 f
b3 3 f 3 fyyy 6 ftt a2 2 ft a1 ) 2
b3 f a3 2 fytt 2 fyy b2 2 f 2 b2 f fyt a2 2
ft a2 ) fyt a3
fy b2
fyy b1 2 f 2 2
b3 2 f 2 fyyt a3 w3 2 ftt a1 2 b1 f fyt a1 fyy b2 2 f ( fy b1 f 2
ft a1 ) a2 3 fttt 6
b2 ( fy b1 f h4 w2 w4
ft a1 ) fyt a2 fyy b3 2 f 2 2
b2 2 f 2 fyyt a2 b2 f a2 2 fytt b2 3 f 3 fyyy 2 2 6 2 ftt a3 fy b3 ( fy b2 f ft a2 ) b3 f fyt a3 2 ftt a1 2 2 ftt a2 2 fyy b2 2 f 2 2 2

ft a1 )
fyy b1 2 f 2 2
b1 f fyt a1
ft a1 )
w3 fy b2 ( fy b1 f ( w4 ( fy b3 f ( w1 f w2 f
b2 f fyt a2
h3
ft a3 ) w2 ( fy b1 f w4 f w3 f ) h
w3 ( fy b2 f
ft a2 ) ) h 2
Donde las funciones y las derivadas parciales estn evaluadas en tn. Deducir los valores de los parmetros para eliminar trminos en la expresin para el error de la aproximacin resulta complejo. Profesor Leopoldo Silva Bijit 20-01-2010
Algoritmos numricos La generacin automtica de la funcin , se logra con el segmento:
25
> restart; > tmv:=mtaylor(f(y,t),[y=yn,t=tn],4): > sus1:={D[1,1](f)(yn,tn)=fyy,D[1,2](f)(yn,tn)=fyt,D[2](f)(yn,tn)=ft, D[1](f)(yn,tn)=fy,D[2,2](f)(yn,tn)=ftt,f(yn,tn)=f, D[1,1,2](f)(yn,tn)=fyyt,D[1,2,2](f)(yn,tn)=fytt, D[2,2,2](f)(yn,tn)=fttt,D[1,1,1](f)(yn,tn)=fyyy}: > tmv:=subs(sus1,tmv): > k1:=h*f: > k2:=h*eval(tmv,{y-yn=b1*k1,t-tn=a1*h}):collect(k2,h): > k3:=h*eval(tmv,{y-yn=b2*k2,t-tn=a2*h}):k3:=collect(k3,h): > temp3:=k3: for i from 5 to 13 do temp3:=eval(temp3,hî=0) od: collect(temp3,h): > k4:=h*eval(tmv,{y-yn=b3*k3,t-tn=a3*h}): k4:=collect(k4,h): temp4:=k4: for i from 5 to 40 do temp4:=eval(temp4,hî=0) od: > temp:=collect(w1*k1+w2*k2+w3*k3+w4*k4,h): > for i from 5 to 40 do temp:=eval(temp,hî=0) od: Phi:=collect(temp,h):
La generacin del primer trmino del error, puede generarse automticamente con:
> restart; > y1:=taylor(y(t),t=tn,5):y1:=subs({t-tn=h},y1): > sus0:={y(tn)=0,D(y)(tn)=f,`@@`(D,2)(y)(tn)=d2,`@@`(D,3)(y)(tn)=d3,`@@` (D,4)(y)(tn)=d4}: F:=subs(sus0,y1): > d2:=diff(f(y(t),t),t): > d3:=diff(d2,t): > d4:=diff(d3,t): > sus1:={D[1,1](f)(y(t),t)=fyy,D[1,2](f)(y(t),t)=fyt,D[2](f)(y(t),t)=ft, D[1](f)(y(t),t)=fy, D[2,2](f)(y(t),t)=ftt,f(y(t),t)=f,D[1,1,1](f)(y(t),t)=fyyy,D[1,1,2](f) (y(t),t)=fyyt, D[1,2,2](f)(y(t),t)=fytt,D[2,2,2](f)(y(t),t)=fttt}: sus2:={diff(y(t),t)=f}: sus3:={diff(y(t),`$`(t,2))=fy*f+ft}: sus4:={diff(y(t),`$`(t,3))=(fyy*f+fyt)*f+fy*(fy*f+ft)+fyt*f+ftt}: > d2:=subs(sus1,d2):d2:=subs(sus2,d2): d3:=subs(sus1,d3):d3:=subs(sus3,d3):d3:=subs(sus2,d3):d3:=expand(d3):
20-01-2010
26
d4:=subs(sus1,d4):d4:=subs(sus4,d4):d4:=subs(sus3,d4):d4:=subs(sus2,d4 ):d4:=expand(d4): > F;
Efectuando la comparacin de los coeficientes del error, de tal forma de anular hasta la potencia cuarta de h, se obtienen 19 ecuaciones: Para eliminar el trmino del error proporcional a h:
e1 := w1
w2
w3
w4
1
1 2 1 2
Para eliminar el trmino del error proporcional a h2:
e2 := w4 b3 e3 := w4 a3
w2 b1 w2 a1
w3 b2 w3 a2
e4 :=
w2 b1 2 2
w4 b3 2 2
w3 b2 2 2
1 6
e5 := w4 b3 a3
w2 b1 a1
w3 b2 a2
1 6 1 6
1 6
1 3
e6 := w4 b3 b2
w3 b2 b1
e7 := w4 b3 a2
e8 := w4 a3 2 2
w3 b2 a1
w2 a1 2 2
w3 a2 2 2
w2 b1 3 6 2 w2 b1 a1 ec10 := 2 ec9 :=
w4 b3 3 w3 b2 3 1 6 6 24 2 2 w4 b3 a3 w3 b2 a2 2 2
1 8
ec11 := w4 b3 2 b2
1 b2 b1 2 b2 2 b1 2 1 ec12 := w4 b3 2 a2 w3 b2 2 a1 8 2 2 w2 b1 a1 w4 b3 a3 w3 b2 a2 2 1 ec13 := 2 2 2 8 w3
20-01-2010
1 b3 b2 2 2
1 6
Algoritmos numricos
27
ec14 := w4 ( b3 b2 a2
b3 b2 a3 )
w3 ( b2 b1 a1
b2 b1 a2 )
5 24
ec15 := w4 b3 a2 a3
w3 b2 a1 a2
1 8
1 24 1 ec17 := w4 b3 b2 a1 24 2 w4 b3 a2 w3 b2 a1 2 1 ec18 := 2 2 24 3 3 3 w2 a1 w4 a3 w3 a2 1 ec19 := 6 6 6 24 ec16 := w4 b3 b2 b1

Se tienen 19 ecuaciones para 10 incgnitas, sin embargo considerando que: Las ecuaciones 16 y 17, implican que a1 = b1. Las ecuaciones 6 y 7, con a1 = b1, implican: a2 = b2 Las ecuaciones 2 y 3, con a1 = b1, y a2 = b2 implican: a3 = b3 Las ecuaciones 12 y 15 implican, con a1 = b1, a2 = b2 que a3 = b3. Por lo tanto no se requieren las ecuaciones 12 y 15. Las ecuaciones 9, 10, 13 y 19, con a1 = b1, a2 = b2 y a3 = b3 son idnticas. Slo se requiere considerar una de ellas. Las ecuaciones 4, 5 y 8, con a1 = b1, a2 = b2 y a3 = b3 son idnticas. Slo se requiere considerar una de ellas. Las ecuaciones 12 y 11 implican la ecuacin 18. Por lo tanto no se requiere emplear la ecuacin 11. Las ecuaciones 12 y 14 implican la ecuacin 18. Por lo tanto no se requiere emplear la ecuacin 14. Lo anterior reduce el sistema a 10 ecuaciones en 10 incgnitas (a1, a2, a3, b1, b2, b3, w1, w2, w3, w4). Las 10 ecuaciones son las numeradas: 1, 2, 3, 6, 7, 16, 17, 4, 9, 18.
> ecc:={e1,e2,e3,e6,e7,ec16,ec17,e4,ec9,ec18}: > sol:=[solve(ecc)]:sol[1];
{ b1
1 , a2 2
1 , w1 2
1 , a3 6
1, b3
1, a1
1 , w3 2
1 , w2 3
1 , b2 3
1 , w4 2
1 } 6
Puede comprobarse que la solucin satisface las 19 ecuaciones, y que el error queda:
Profesor Leopoldo Silva Bijit 20-01-2010
28
Tn
O(h5 )
Entonces el algoritmo de Runge Kutta de cuarto orden resulta:
k1 k2 k3 k4 yn
1
hf yn , tn hf yn hf yn hf yn yn k1 , tn 2 k2 , tn 2 k3 , t n h 2 k3 k 4 h 2 h 2
1 k1 2k2 6
Se calculan cuatro valores de la funcin, para obtener el siguiente punto. Existen numerosos algoritmos en los que se vara el intervalo de tiempo entre puntos.
23.3. Solucin de ecuacin no lineal.

El problema consiste en encontrar la raz de la ecuacin no lineal: f ( x)
Normalmente la solucin de f ( x) 0 , puede ser difcil de encontrar analticamente, pero como veremos es sencilla de resolver iterativamente. 23.3.1. Mtodo de Newton-Raphson.
0 , se parte de un valor x0 y se genera una serie de iteraciones xi que se acerquen a la solucin xs , donde f ( xs ) 0 .
Para resolver f ( x) En cursos de anlisis numrico se responden las preguntas: Cundo la secuencia xi converge a la solucin correcta? Cun rpido se converge? La convergencia depende del intento inicial x0 ? Cundo detener las iteraciones?. El mtodo de Newton-Raphson consiste en reemplazar, mediante la expansin de Taylor, la funcin por su versin lineal, en torno a la solucin:
f ( x)
Para un punto cualquiera se obtiene: Profesor Leopoldo Silva Bijit
f ( xs )
df ( xs )( x xs ) dx
20-01-2010
Algoritmos numricos
29
f ( xk 1 )
Efectuando: f ( xk 1 ) despejando xk 1 :
f ( xk )
df ( xk )( xk dx
xk )
0 , se obtiene la frmula de la iteracin de Newton-Raphson,
xk
xk
f ( xk ) df ( xk ) dx
Podemos interpretar la frmula de la iteracin, planteando la relacin anterior en x0 , y calculando x1 . Situacin que se ilustra en la Figura 23.5.
f(x) f(x0) f(x1) xs x2 x1
0
x0
Figura 23.5. Iteracin Newton-Raphson. Resulta, de la interpretacin grfica de la derivada en x0 :
tg ( 0 )
df ( x0 ) dx
f ( x0 ) x0 x1
Despejando x1 , se obtiene el primer valor de aproximacin del mtodo de Newton-Raphson:
x1
x0
df ( x0 ) dx
f ( x0 )
Ntese que f ( x1 ) no es cero, lo cual implica que x1 es una aproximacin de xs . Tambin debe notarse que para calcular la siguiente aproximacin deben calcularse la funcin y la derivada en el punto anterior. El proceso debe repetirse hasta que: xk
1
xk
tolerancia
Donde el valor de tolerancia debe ser un valor lo suficientemente pequeo, para que la solucin se considere aceptable. Con nmeros reales de precisin simple (float en C), un valor razonable Profesor Leopoldo Silva Bijit 20-01-2010
30
de tolerancia es 10-6, que es el valor del nmero real ms pequeo representable, en el formato interno normalizado IEEE754. Si el valor inicial es adecuado conviene limitar el nmero mximo de iteraciones, de este modo si no existe convergencia se asegura que el algoritmo termine. Tambin puede verificarse que la ordenada en los puntos sucesivos est dentro de cierto rango:
f ( xk 1 )
tolerancia
Para evitar oscilaciones o ciclos no convergentes se limita el nmero de iteraciones. Pueden producirse en un caso como el que se ilustra en la Figura 23.6.
Figura 23.6. Oscilacin. Se emplea un intervalo [x1..x2] en el cual se busca la raz, para evitar la no convergencia debido a mximos o mnimos dentro del intervalo. Si en una iteracin se encuentra un punto con derivada casi horizontal en el intervalo, el valor para el nuevo x se aleja de la raz, como se ilustra en la Figura 23.7. Para prevenir esta situacin se verifica que la nueva aproximacin de la raz permanezca dentro del intervalo.
Figura 23.7. Divergencia. Se detienen tolerancia. las iteraciones si los dos ltimos valores obtenidos difieren en determinada
La siguiente funcin intenta encontrar una raz en el intervalo [x1, x2]. El primer argumento es un puntero a funcin con un argumento flotante y que retorna un flotante. Cuando se invoca a NewtonRaphson el argumento actual es el nombre de la funcin que calcula el cuociente de la funcin con su derivada evaluada en el x actual.
20-01-2010
Algoritmos numricos #define nmax 20 //Mximo nmero de Iteraciones.
31
float NewtonRaphson(float (*pfuncion)(float), float x1, float x2, float tolerancia) { int k; float dx, x; x=0.5*(x1+x2); //Intento inicial. for (k=1; k<=nmax; k++) { dx=(*pfuncion)(x); //se invoca a la funcin cuyo nombre se pasa como primer argumento. x -= dx; //nuevo valor if ((x<x1) || (x>x2)) {printf("Salta fuera del intervalo"); exit(1); } if (fabs(dx) < tolerancia) return (x); //Converge. } printf("No converge en %d iteraciones.\n", nmax); exit(1); return (0.0); //Para evitar warning. } La siguiente funcin, para un polinomio, define la derivada y retorna el cuociente entre la funcin y su derivada. Ntese que la funcin recibe un argumento flotante y retorna un flotante. De este modo, su nombre fin2 es un puntero constante compatible con el primer argumento de NewtonRaphson. float fun2(float x) { float funcion, derivada; funcion=.2*pow(x,4)-2*pow(x,3)+x+7; //funcin de x, evaluada en x; derivada=.8*pow(x,3)-6*pow(x,2)+1; //derivada de f evaluada en x; return (funcion/derivada); } La funcin: f ( x) 0.2 x 4 2 x3 x 7 , tiene dos races reales, como se ilustra en la Figura 23.8. La solucin con fsolve de Maple, entrega: 1.742869875, 9.913192964
20-01-2010
32
Figura 23.8. Empleando la funcin NewtonRaphson, pueden obtenerse las races mediante: printf("Valor de la raz = %f\n", NewtonRaphson(fun2,1,2,1e-6 )); printf("Valor de la raz = %f\n", NewtonRaphson(fun2,9,11,1e-6 )); 23.3.2. Generalizacin para sistemas de ecuaciones no lineales. Para un sistema de ecuaciones no lineales, se emplea la expansin de Taylor para varias variables. La expansin es una linealizacin en torno a la solucin:
F ( x)
Las cantidades F ( x) y ( x denominada Jacobiano.
F ( xs ) J ( xs )( x xs )
xs ) se expresan como vectores, y J ( xs ) como una matriz,
Para un punto cualquiera, con aproximacin de primer orden, se tiene:
F ( xk 1 )
F ( xk ) J ( xk )( xk
xk )
Para entender la relacin anterior se ilustra la forma que ella toma para dos funciones de dos variables x1 y x2, se tiene:
F1 ( x1k , x 2 k ) F1 ( x1k 1 , x 2 k 1 ) F2 ( x1k 1 , x 2 k 1 ) F1 ( x1k , x 2 k ) F2 ( x1k , x 2 k ) x1 F2 ( x1k , x 2 k ) x1
F1 ( x1k , x 2 k ) x2 F2 ( x1k , x 2 k ) x2 x1k x2k

1
x1k x2k
Una explicacin del cambio de la funcin de dos variables, puede efectuarse considerando el plano tangente a la superficie, en el punto (x10, x20) que pasa tambin por el punto (x11, x21). Profesor Leopoldo Silva Bijit 20-01-2010
Algoritmos numricos
33
Donde el punto 0 es el inicial, y el punto 1, se obtiene pasando un plano tangente a la superficie en el punto 0.
x10 F1x1 x11 x21
x2 x1
F1x2
x20
Figura 23.9. Interpretacin del Jacobiano de dos variables. Aplicando la interpretacin geomtrica de las derivadas parciales, se tienen:
tg ( tg (
x1
) )
F1 ( x10 , x 20 ) x1 F1 ( x10 , x 20 ) x2
F1x1 x10 x11 F1x 2 x 20 x 21
x2
El cambio total de la funcin, resulta:
F1x1
F1x 2
F1 ( x10 , x20 ) ( x10 x1
x11 )
F1 ( x10 , x20 ) ( x 20 x2
x21 )
Aplicando el mtodo de Newton-Raphson, que consiste en asumir que el plano tangente pasa por el punto que es una aproximacin a la solucin. Esto equivale a efectuar:
F1 ( x1k 1 , x 2k 1 ) F2 ( x1k 1 , x 2k 1 )
Entonces la frmula de iteracin, resulta:
F1 ( x1k , x 2 k ) x1 F2 ( x1k , x 2 k ) x1
F1 ( x1k , x 2 k ) x2 F2 ( x1k , x 2 k ) x2 x1k x 2k

1 1
x1k x 2k
F1 ( x1k , x 2 k ) F2 ( x1k , x 2 k )
Finalmente, despejando el nuevo punto:
20-01-2010
34
F1 ( x1k , x 2k ) x1k x 2k
1 1
F1 ( x1k , x 2k ) x2 F2 ( x1k , x 2k ) x2
1 F1 ( x1k , x 2k ) F2 ( x1k , x 2k )
x1k x 2k
x1 F2 ( x1k , x 2k ) x1
La que expresada en trminos de vectores y la matriz inversa del Jacobiano, resulta en general, para n variables:
xk
xk
J ( xk ) 1 F ( xk )
Una mejor visualizacin de la suma de los incrementos, se logra observando los tringulos semejantes en la Figura 23.10. Por el punto inicial (2, 2, 10) se pasa el plano z=2x+3y que tambin pasa por el punto (0, 0, 0). Se han dibujado adems los planos de z constante, z=4 y z=6.
z x
2,
z y
z x x
4,
z y y
Figura 23.10. Variacin total de funcin de dos variables. Volviendo al caso de dos variables, considerando el lgebra de matrices, se tiene:
a b c d
x y
by dx ad bc cx ay 1
Entonces las frmulas de iteracin de Newton-Raphson para un sistema de ecuaciones no lineales de dos variables, resultan:
( x1k
1
x1k
F1 (k ) F2 (k ) x2 F1 (k ) F2 (k ) x1 x2
20-01-2010
F2 (k ) F1 (k )) x2 F1 (k ) F2 (k ) x2 x1
Algoritmos numricos
35
( x 2k
1
x 2k
F2 (k ) F1 (k ) x2 F1 (k ) F2 (k ) x1 x2
F1 (k ) F2 (k )) x1 F1 (k ) F2 (k ) x2 x1
En caso de mayores rdenes debe invertirse el Jacobiano, o alternativamente resolverse el sistema lineal de ecuaciones, para las incgnitas xk 1 :
J ( xk )( xk
xk )
F ( xk )
Donde el vector de las funciones y el Jacobiano deben evaluarse para cada xk
Referencias.
Numerical Recipes In C: The Art of Scientific Computing. Cambridge University Press. 1992.
20-01-2010
36
ndice general.
CAPTULO 23 ............................................................................................................................................1 ALGORITMOS NUMRICOS.................................................................................................................1 23.1. SOLUCIN DE SISTEMA SIMULTNEO DE ECUACIONES LINEALES. .....................................................1 23.1.1. Descomposicin LU. ................................................................................................................1 23.1.2. Mtodos iterativos. ...................................................................................................................7 23.2. SOLUCIN NUMRICA DE SISTEMAS DE ECUACIONES DIFERENCIALES. ...........................................10 23.2.1. Formulacin de ecuaciones de estado. ..................................................................................11 23.2.2. Mtodo de Euler. ....................................................................................................................11 23.2.3. Algoritmo de Euler. ................................................................................................................13 23.2.4. Algoritmo trapezoidal. ...........................................................................................................14 23.2.5. Algoritmo de Simpson. ...........................................................................................................15 23.4.6. Mtodos multietapas. .............................................................................................................17
23.4.6.1. Mtodo de Heun. ............................................................................................................................. 20 23.4.6.2. Mtodo del punto medio. ................................................................................................................ 20 23.4.6.3. Mtodo de Ralston. ......................................................................................................................... 20
23.4.7. Mtodos de Runge-Kutta de cuarto orden. ............................................................................21 23.3. SOLUCIN DE ECUACIN NO LINEAL...............................................................................................28 23.3.1. Mtodo de Newton-Raphson. .................................................................................................28 23.3.2. Generalizacin para sistemas de ecuaciones no lineales. .....................................................32 REFERENCIAS. .........................................................................................................................................35 NDICE GENERAL. ....................................................................................................................................36 NDICE DE FIGURAS. ................................................................................................................................37
20-01-2010
Algoritmos numricos
37
ndice de figuras.
FIGURA 23.1. MTODO DE EULER. .............................................................................................................. 14 FIGURA 23.2. MTODO TRAPEZOIDAL. ........................................................................................................ 14 FIGURA 23.3. MTODO DE SIMPSON. .......................................................................................................... 15 FIGURA 23.4. MTODO DEL PUNTO MEDIO. ................................................................................................. 20 FIGURA 23.5. ITERACIN NEWTON-RAPHSON. ........................................................................................... 29 FIGURA 23.6. OSCILACIN. ......................................................................................................................... 30 FIGURA 23.7. DIVERGENCIA....................................................................................................................... 30 FIGURA 23.8. .............................................................................................................................................. 32 FIGURA 23.9. INTERPRETACIN DEL JACOBIANO DE DOS VARIABLES. ........................................................ 33 FIGURA 23.10. VARIACIN TOTAL DE FUNCIN DE DOS VARIABLES. .......................................................... 34
20-01-2010

Pseudo

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Pseudo

Uploaded by

Copyright:

Available Formats

1

Que puede ser interpretado como dos sistemas de ecuaciones:

Profesor Leopoldo Silva Bijit

Estructuras de Datos y Algoritmos

a11 a12 a21 a22 a31 a32 a41 a42

a13 a23 a33 a43

a14 a24 a34 a44

u11 u12 0 u22 0 0 0

u13 u14 u23 u24 u34 0 u44

l31 l32 l41 l42

Efectuando la multiplicacin de las matrices L y U, se obtiene:

u11 u12 l21u11 l21u12 u22

u13 l21u13 u23

u14 l21u14 u24 l31u14 l32u24 u34

l31u11 l31u12 l32u22 l31u13 l32u23 u33

a21 / u11; l31

a31 / u11; l41

Profesor Leopoldo Silva Bijit

a22 ; l21u13 u23

a23 ; l21u14 u24

Despejando los elementos del segundo rengln de U, se obtienen:

u22 u23 u24

a22 l21u12 a23 l21u13 a24 l21u14

La segunda columna de A, permite calcular la segunda columna de L.

a32 ; l41u12 l42u22

Despejando los elementos de la segunda columna de L. se obtienen:

(a32 l31u12 ) / u22 (a42 l41u12 ) / u22

l31u13 l32u23 u33

a33 ; l31u14 l32u24 u34

Las que permiten despejar los elementos del tercer rengln de U:

a33 l31u13 l32u23 a34 l31u14 l32u24

De la tercera columna de A, se puede calcular la tercera columna de L:

(a43 l41u13 l42u23 ) / u33

Finalmente, el cuarto rengln de A, permite calcular el cuarto rengln de U.

a44 l41u14 l42u24 l43u34

Profesor Leopoldo Silva Bijit

Estructuras de Datos y Algoritmos

La diagonal de L, se obtiene por definicin de la descomposicin de Doolittle.

Y la n-ava columna de L con:

A continuacin se obtiene el algoritmo para la substitucin hacia delante: De la relacin:

l11 0 l21 l22 l31 l32 l41 l42

Efectuando las multiplicaciones, en el lado derecho, se tienen:

Profesor Leopoldo Silva Bijit

u11 u12 0 u22 0 0 0 0

u13 u14 u23 u24 u33 0 u34 u44

Efectuando las multiplicaciones, se obtiene:

Profesor Leopoldo Silva Bijit

Estructuras de Datos y Algoritmos

u11 u12 l21 u22 l31 l41 l32 l42

u13 u14 u23 u24 u33 u34 l43 u44

Profesor Leopoldo Silva Bijit

a11 a12 a21 a22 a31 a32

a13 x1 a23 x2 a33 x3

Profesor Leopoldo Silva Bijit

Estructuras de Datos y Algoritmos

Despejando de la primera ecuacin, la variable x1 ; de la segunda x2 ; y de la tercera x3 , obtenemos:

aij x j [n]) / aii

Profesor Leopoldo Silva Bijit

aij x j [n]) / aii

aij x j [n]) / aii

yi [n] (1 a) xi [n] a(bi

aij x j [n]) / aii

end for i tol ) stop if ( end for n

Profesor Leopoldo Silva Bijit