c23 PDF

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
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
a13
a23
a14
a24
1
l21
0
1
0 0
0 0
a31
a32
a33
a34
l31 l32
1 0
a41 a42
a43
a44
l41 l42
l43
u11 u12
0 u22
u13 u14
u23 u24
0 u33
u34
0 u44
Efectuando la multiplicacin de las matrices L y U, se obtiene:
u11 u12
l21u11 l21u12 u22
u13
l21u13 u23
u14
l21u14 u24
l31u11 l31u12 l32u22 l31u13 l32u23 u33
l31u14 l32u24 u34
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
20-01-2010
a41 / u11
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
a22 l21u12
u23
a23 l21u13
u24
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
(a32 l31u12 ) / u22
l42
(a42 l41u12 ) / u22
Del tercer rengln de A, resultan:
l31u13 l32u23 u33
a33 ; l31u14 l32u24 u34
a34
Las que permiten despejar los elementos del tercer rengln de U:
u33
a33 l31u13 l32u23
u34
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
Para: n 1,..., N ;
ln, n
La diagonal de L, se obtiene por definicin de la descomposicin de Doolittle.

El n-avo rengln de U se obtiene segn:
n 1
un,i
an,i
ln, k uk ,i
k 1
Para: i
n,..., N ;
Y la n-ava columna de L con:

n 1
l j,n
a j,n
l j , k uk , n / un, n
k 1
Para: j
n 1,..., N
A continuacin se obtiene el algoritmo para la substitucin hacia delante:

De la relacin:
L d
l11 0
l21 l22
0
0
l31 l32
l33
0 d1
0 d2
0 d3
l41 l42
l43 l44
Se obtiene:
d4
b1
b2
b3
b4
Efectuando las multiplicaciones, en el lado derecho, se tienen:
l11d1
l21d1 l22 d 2
b1
b2
l31d1 l32 d 2 l33d3
b3
l41d1 l42 d 2 l43d3 l44 d 4
b4
Las componentes del vector d, se obtienen segn:
20-01-2010
Algoritmos numricos
d1
b1 / l11
d2
(b2 l21d1 ) / l22
d3
(b3 l31d1 l32 d 2 ) / l33
d4
(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
(bi
lij d j ) / lii
j 1
Para: i 1, 2,
,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
u13 u14
u23 u24
x1
x2
d1
d2
u33
u34
x3
d3
u44
x4
d4
u11 x1 u12 x2 u13 x3 u14 x4
d1
u22 x2 u23 x3 u24 x4
d2
u33 x3 u34 x4
d3
u44 x4
d4
Efectuando las multiplicaciones, se obtiene:
Despejando los xi, se obtienen:
20-01-2010
x4
d 4 / u44
x3
(d3 u34 x4 ) / u33
x2
(d 2 u23 x3 u24 x4 ) / u22
x1
(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
( N 1), ( N 2),
uij x j
j i 1
uii
,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
u13 u14
u23 u24
l31
l32
u33
l41
l42
l43 u44
u34
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;
}
20-01-2010
n 1
un,i
an,i
ln, k uk ,i
k 1
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];
}
n 1
l j,n
a j,n
l j , k uk , n / un, n
k 1
}
}
/*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.
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
20-01-2010
b1
b2
b3
Despejando de la primera ecuacin, la variable x1 ; de la segunda x2 ; y de la tercera x3 ,

obtenemos:
x1
(b1 a12 x2 a13 x3 ) / a11
x2
(b2 a21 x1 a23 x3 ) / a22
x3
(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
xi [n 1] (bi
j N
aij x j [n]
j 1
aij x j [n]) / aii

j i 1
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
9
j i 1
xi [n 1] (bi
j N
aij x j [n 1]
j 1
aij x j [n]) / aii

j i 1
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
xi [n 1] (1 a) xi [n] a(bi
j N
aij x j [n 1]
j 1
aij x j [n]) / aii

j i 1
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 i 1
yi [n] (1 a) xi [n] a(bi
j N
aij y j [n]
j 1
aij x j [n]) / aii

j i 1
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
F (t )
Entonces:
t
r (t )
r (0)
F ( )d
0
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
xi [k 1]
xi [k ] (
j n
aij x j [k ]
j 1
Para: i
1, 2,
bij u j [k ]) t
j 1
,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');
20-01-2010
Algoritmos numricos
13
}
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:
dy (t )
dt
f (t , y (t ))
Se pueden obtener los valores sucesivos de y, mediante:
yn
yn
hf (tn , y (tn ))
Si definimos:
k1
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
yn
tn
tg ( n )
1
1
yn
tn
k1
h
f (tn , yn )
yn+1
k1
yn
tn
f(tn+1,yn+1)
f(tn,yn)
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
f(tn+1,yn+1)
(k1 + k2)/2
n
yn
tn
f(tn,yn)
tn+1
tn
Figura 23.2. Mtodo trapezoidal.

Entonces:
yn
yn
h
( f (tn , yn )
2
f (tn 1 , yn 1 ))
Con:
k1
hf (tn , yn )
k2
hf (tn 1 , yn 1 )
Se realiza la integracin trapezoidal mediante:
20-01-2010
tn+1
Algoritmos numricos
15
yn
1
(k1 k2 )
2
yn
En cada paso de integracin es preciso evaluar dos veces la funcin: f (t , y) . La determinacin

de yn
que se emplea en el clculo de k2 , puede determinarse, aplicando Euler,
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
t0 h / 2 y t 2
t0
h.
f(tn+h/2, y(tn+h/2))
yn+1
f(tn+1,yn+1)
(k0 +4 k1+ k2)/6

n
yn
tn
f(tn,yn)
tn+1
fa(t)
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 )
at 2 bt c
Se tienen:
f0
at0 2 bt0 c
f1
at12 bt1 c
f2
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
f a (t )dt
t t0
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
Con:
k0
hf (tn , yn )
k1
hf (tn
h / 2, y (tn
k2
hf (tn
h, y (tn
h / 2))
h))
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
h / 2)
y (tn
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
1
1
(k0 4k1 k2 )
(k2 4k3 k4 )
6
6
La cual puede simplificarse a:
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
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
4 f2n
f2n )
Algoritmos numricos
17
}
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.
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
El mtodo de Euler es:
yn , t n ; h
yn
yn , t n ; h
f ( yn , t n )
El siguiente esquema es de Runge-Kutta, de segundo orden, con cuatro parmetros.
k1
f yn , t n
k2
f yn
hk1 , tn
yn
h ak1 bk2
yn
Con:
y tn , tn
af y(tn ), tn
Donde deben determinarse: a, b, ,
bf y(tn )
hf y(tn ), tn , tn
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
y tn
dy (tn )
dt
h 2 d 2 y (tn )
2! dt 2
Como se tiene:
20-01-2010
h3 d 3 y (tn )
O(h 4 )
3
3! dt
18
dy
dt
f y t ,t
La segunda derivada de y, se obtiene segn:
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
d
dt
f
t
f
f
y
d f
d f
( )
( )f
dt t
dt y
f df
y dt
La cual permite obtener:
d3y
dt 3
f
f
t y
f
y t
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
Donde se ha empleado: f
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 )
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.
est multiplicado por h, slo es necesario considerar hasta
Entonces;
20-01-2010
Algoritmos numricos
f y
19
y, t
f ( y, t )
y
y
f y, t
f ( y, t )
t
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
Reemplazando en la anterior, los valores de los incrementos y empleando notacin abreviada

para las derivadas parciales de f, se logra:
f yn
y, tn
f y ( hf )
f t ( h)
f yn , t n
1
f yy ( hf ) 2
2
f yt ( hf )( h)
1
f tt ( h) 2 O(h 3 )
2
Reemplazando la expresin anterior en:
y tn , tn
af y(tn ), tn
bf y(tn )
hf y(tn ), tn , tn
Se obtiene:
y tn , tn
af
b( f
f y hf
1
f yy ( hf )2
2
ft h
f yt ( hf ) h
1
f tt
2
2 2
h ) O h3
Donde las funciones y las derivadas parciales estn evaluadas en tn.

Se tiene finalmente para el error:
Tn
h f
h af
h
ft
2
b f
h2
ftt
3!
ff y
( fy f
Los parmetros: a, b, ,
f yy f 2
2 fty f
f yy
f t )h
f y ft
fy f
f yt
fh 2
h2
ftt 2 2
h
2
O (h 4 )
, 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
af bf 0
Para eliminar la parte proporcional a h , se debe cumplir: ( ft ff y ) / 2 bf y f
2
bf t
De la primera se obtiene: a b 1
De la segunda, debe cumplirse: ft (
1
b )
2
b
1
b ) 0 , de la que se desprenden:
2
1
b
2
ff y (
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
que satisfacen las dos relaciones anteriores.
2
0, a b
1,
Se realiza la integracin mediante:
yn
h
k1 k2
2
yn
Con:
k1
k2
f yn , t n
f yn
k1h, tn
23.4.6.2. Mtodo del punto medio.
1
, a 0, b 1 que satisfacen las dos relaciones anteriores.
2
Considera:
yn
yn
hk2
Con:
k1
k2
f yn , t n
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
hk2
yn
tn
f(tn+h/2,yn+k1h/2)
tn+1
f(tn+1,yn+1)
f(tn,yn)
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
21
Se integra mediante:
yn
h
(k1 2k2 )
3
yn
Con:
k1
k2
f yn , t n
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
hf yn , tn
k2
hf yn b1k1 , tn
a1h
k3
hf yn b2 k2 , tn
a2 h
k4
hf yn b3k3 , tn
a3h
yn
w3k3 w4 k4
yn
w1k1 w2 k2
Con:
y tn , tn
w1 f yn , tn
w3 f yn b2 k2 , tn
a2 h
w2 f yn b1k1 , tn
a1h
w4 f yn b3k3 , tn a3h
La expresin para el error es:
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
d
( ftt
dt
2 fty f
f yy f 2
Derivando, se obtiene:
20-01-2010
f y ft
f y2 f )
22
d4y
dt 4
2( f yy
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 yyy
dy
dt
f ytt
dy
dt
f ttt
Reemplazando la primera derivada de y:
d4y
dt 4
(( f yyy f
2( f yy f
f yt )
f yyt ) f
d2y
dt 2
fy
f yy
d2y
dt 2
f yyt f
d3y
( f yyt f
dt 3
f ytt ) f
f ytt ) f
f yt
d2y
dt 2
f ytt f
f ttt
Reemplazando la segunda derivada de y, se tiene:
d4y
dt 4
(( f yyy f
2( f yy f
f yt )( f t
f yyt ) f
fy f )
f yy ( f t
fy
fy f )
f yyt f
d3y
( f yyt f
dt 3
f ytt ) f
f ytt ) f
f yt ( f t
fy f )
f ytt f
f ttt
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!
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
2 f ty f
3 f yyt f
f y tn , tn
La segunda componente del error, requiere calcular:
20-01-2010
f yy f 2
5 f yt f y f
f y ft
f y2 f )
Algoritmos numricos
23
y tn , tn
w1k1 w2 k2 w3k3 w4k4
Se emplea la expansin de Taylor de dos variables de

diferentes y, t . Como
trminos de tercer orden.
f yn
y, tn
t , con los
est multiplicado por h, slo es necesario considerar hasta los
Entonces;
f yn
y , tn
fy y
ft t
1
f yyy y 3
6
f yn , t n
1
f yy y 2
2
1
f yyt y 2 t
2
1
f tt t 2
2
1
y t2
f ttt t 3
6
f yt y t
1
f ytt
2
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 =
fyy b1 2 f 2
2
fy b2
b2 ( fy b1 f
h4
b1 f fyt a1
fyy b2 2 f ( fy b1 f
ft a1 )
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
ft a1 ) fyt a2
fy b2 ( fy b1 f
( fy b2 f
ftt a1 2
2
ft a2 ) h 2
hf
k4 =
hf
a3 3 fttt
6
fy b3 fy b2 ( fy b1 f
ft a1 )
ft a2 )
b3 3 f 3 fyyy
6
ftt a2 2
2
20-01-2010
fyy b2 2 f 2
2
b3 f a3 2 fytt
2
b2 f fyt a2
a2 3 fttt
6
24
b3 ( fy b2 f
ft a2 ) fyt a3
fyy b3 2 f 2 ftt a3 2
2
2
2
( fy b3 f ft a3 ) h
b3 2 f 2 fyyt a3
h4
2
fy b3 ( fy b2 f
Reemplazando las expresiones anteriores en:
ft a2 )
b3 f fyt a3 h 3
y tn , tn
Se obtiene:
y tn , tn
b1 3 f 3 fyyy
w2
6
b1 2 f 2 fyyt a1
2
b3 3 f 3 fyyy
6
ftt a2 2
ft a1 )
2
ft a2 )
fy b3 fy b2 ( fy b1 f
b3 ( fy b2 f
fy b2
fyy b1 2 f 2
2
w2
w4
a1 3 fttt
6
a3 3 fttt
w4
6
b3 f a3 2 fytt
2
fyy b2 2 f 2
b2 f fyt a2
2
b3 2 f 2 fyyt a3
w3
2
ftt a1 2
b1 f fyt a1
2
ft a2 ) fyt a3
b2 ( fy b1 f
h4
b1 f a1 2 fytt
2
ft a1 )
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
ft a1 ) fyt a2
fyy b3 2 f 2
2
fyy b1 2 f 2
2
b1 f fyt a1
w3 fy b2 ( fy b1 f
( w4 ( fy b3 f
( w1 f w2 f
ft a1 )
ftt a1 2
2
ftt a2 2 fyy b2 2 f 2
2
2
ft a3 ) w2 ( fy b1 f
w4 f w3 f ) h
ft a1 )
b2 f fyt a2
w3 ( fy b2 f
a2 3 fttt
6
h3
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.
20-01-2010
Algoritmos numricos
La generacin automtica de la funcin
25
, se logra con el segmento:
> 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
Para eliminar el trmino del error proporcional a h2:
e2 := w4 b3
w2 b1
w3 b2
1
2
e3 := w4 a3
w2 a1
w3 a2
1
2
e4 :=
w2 b1 2
2
e5 := w4 b3 a3
w4 b3 2
2
w2 b1 a1
w3 b2 2
2
w3 b2 b1
e7 := w4 b3 a2
w3 b2 a1
w4 a3 2
2
w2 a1 2
2
1
3
w3 b2 a2
e6 := w4 b3 b2
e8 :=
1
6
1
6
1
6
w3 a2 2
2
1
6
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
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
ec11 := w4 b3 2 b2
1
b3 b2 2
2
1
8
w3
20-01-2010
1
6
Algoritmos numricos
27
ec14 := w4 ( b3 b2 a2
b3 b2 a3 )
w3 ( b2 b1 a1
b2 b1 a2 )
ec15 := w4 b3 a2 a3
w3 b2 a1 a2
1
8
5
24
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:
20-01-2010
28
O(h5 )
Tn
Entonces el algoritmo de Runge Kutta de cuarto orden resulta:
k1
hf yn , tn
k2
hf yn
k1
, tn
2
h
2
k3
hf yn
k2
, tn
2
h
2
k4
hf yn
k3 , t n
yn
1
k1 2k2
6
yn
2 k3 k 4
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)
f ( xs )
df
( xs )( x xs )
dx
Para un punto cualquiera se obtiene:

20-01-2010
Algoritmos numricos
29
f ( xk 1 )
Efectuando: f ( xk 1 )
f ( xk )
df
( xk )( xk
dx
xk )
0 , se obtiene la frmula de la iteracin de Newton-Raphson,
despejando xk 1 :
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
x0
Figura 23.5. Iteracin Newton-Raphson.

Resulta, de la interpretacin grfica de la derivada en x0 :
df
( x0 )
dx
tg ( 0 )
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
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
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
31
#define nmax 20 //Mximo nmero de Iteraciones.

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 , x 2 k )
F1 ( x1k 1 , x 2 k 1 )
F1 ( x1k , x 2 k )
x1
x2
x1k
x1k
F2 ( x1k 1 , x 2 k 1 )
F2 ( x1k , x 2 k )
F2 ( x1k , x 2 k )
F2 ( x1k , x 2 k )
x2k
x2k
x1
x2
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).
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
F1x2
x21
x1
x2
x20
Figura 23.9. Interpretacin del Jacobiano de dos variables.

Aplicando la interpretacin geomtrica de las derivadas parciales, se tienen:
tg (
x1
F1 ( x10 , x 20 )
x1
F1x1
x10 x11
tg (
x2
F1 ( x10 , x 20 )
x2
F1x 2
x 20 x 21
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 )
F1 ( x1k , x 2 k )
x1
x2
x1k
x1k
F1 ( x1k , x 2 k )
F2 ( x1k , x 2 k )
F2 ( x1k , x 2 k )
x 2k
x 2k
F2 ( x1k , x 2 k )
x1
x2
Finalmente, despejando el nuevo punto:
20-01-2010
34
x1k
x1k
x 2k
x 2k
F1 ( x1k , x 2k )
F1 ( x1k , x 2k )
x1
F2 ( x1k , x 2k )
x2
F2 ( x1k , x 2k )
x1
x2
1
F1 ( x1k , x 2k )
F2 ( x1k , x 2k )
La que expresada en trminos de vectores y la matriz inversa del Jacobiano, resulta en general,
para n variables:
xk
J ( xk ) 1 F ( xk )
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
z
y
2,
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:
F1 (k )
F2 (k )
x2
F1 (k ) F2 (k )
x1
x2
(
x1k
x1k
20-01-2010
F2 (k )
F1 (k ))
x2
F1 (k ) F2 (k )
x2
x1
Algoritmos numricos
35
F2 (k )
F1 (k )
x2
F1 (k ) F2 (k )
x1
x2
F1 (k )
F2 (k ))
x1
F1 (k ) F2 (k )
x2
x1
(
x 2k
x 2k
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

c23 PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

c23 PDF

Încărcat de

Drepturi de autor:

Formate disponibile

1

Donde A es la matriz nodal aumentada, x es el vector de incgnitas y b el vector de excitaciones.

Que puede ser interpretado como dos sistemas de ecuaciones:

Profesor Leopoldo Silva Bijit

Estructuras de Datos y Algoritmos

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

l31u11 l31u12 l32u22 l31u13 l32u23 u33

l31u14 l32u24 u34

Profesor Leopoldo Silva Bijit

a21 / u11; l31

a31 / u11; l41

a22 ; l21u13 u23

a23 ; l21u14 u24

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

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

Del tercer rengln de A, resultan:

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:

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

l31d1 l32 d 2 l33d3

l41d1 l42 d 2 l43d3 l44 d 4

Las componentes del vector d, se obtienen segn:

Profesor Leopoldo Silva Bijit

(b2 l21d1 ) / l22

(b3 l31d1 l32 d 2 ) / l33

(b4 l41d1 l42 d 2 l43d 3 ) / l44

En la descomposicin de Doolittle, los lii son unos.

u11 x1 u12 x2 u13 x3 u14 x4

u22 x2 u23 x3 u24 x4

Efectuando las multiplicaciones, se obtiene:

Despejando los xi, se obtienen:

Profesor Leopoldo Silva Bijit

Estructuras de Datos y Algoritmos

(d3 u34 x4 ) / u33

(d 2 u23 x3 u24 x4 ) / u22

(d1 u12 x2 u13 x3 u14 x4 ) / u11

La observacin cuidadosa de la generacin de las matrices L y U, muestra que no es necesario

void ludcmp(float **a, int N)

Profesor Leopoldo Silva Bijit

for (j=n+1; j<=N; j++)

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 ,

(b1 a12 x2 a13 x3 ) / a11

(b2 a21 x1 a23 x3 ) / a22

(b3 a31 x1 a32 x2 ) / a33

x1[n 1] (b1 a12 x2 [n] a13 x3 [n]) / a11