Algoritmos numéricos

1
Capítulo 23
Algoritmos numéricos.
23.1. Solución de sistema simultáneo de ecuaciones lineales.
Si se aplica método nodal con modificaciones, para tratar fuentes de voltajes controladas e
independientes, se obtiene un sistema de ecuaciones, del tipo:
A x
b
Donde A es la matriz nodal aumentada, x es el vector de incógnitas y b el vector de excitaciones.
Existen dos esquemas generales para resolver sistemas lineales de ecuaciones: Métodos de
eliminación directa y Métodos Iterativos. Los métodos directos, están basados en la técnica de
eliminación de Gauss, que mediante la aplicación sistemática de operaciones sobre los
renglones transforma el problema original de ecuaciones en uno más simple de resolver.
De entre los variados esquemas, basados en la eliminación de Gauss, el método de
descomposición 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 número de ecuaciones se emplean métodos iterativos.
La mayoría de estos procedimientos están basados en el método de Gauss Seidel, con
aceleraciones para la convergencia.
23.1.1. Descomposición LU.
Está basado en descomponer la matriz de coeficientes en dos matrices triangulares L y U, según:
A
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
b
Que puede ser interpretado como dos sistemas de ecuaciones:
Profesor Leopoldo Silva Bijit
20-01-2010
2
Estructuras de Datos y Algoritmos
L d
b
U x
d
Los dos sistemas anteriores son sencillos de resolver, como se verá más adelante. El sistema con
matriz L, puede ser resuelto por substituciones hacia adelante; el sistema con matriz U se
resuelve por substituciones hacia atrás.
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 solución en el vector x.
Existen varias formas de efectuar la descomposición, el método de Doolittle asigna unos a los
elementos de la diagonal principal de L.
Veremos a través de un ejemplo, las principales ideas, intentando obtener un algoritmo para el
cálculo.
Se tiene la matriz A de 4x4 y se desea obtener L y U.
A
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
1
u13 u14
u23 u24
0
0 u33
0
0
u34
0 u44
Efectuando la multiplicación de las matrices L y U, se obtiene:
A
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 renglón de A permite, por comparación, determinar el primer renglón de U.
u11
a11; u12
a12 ; u13
a13 ; u14
a14
Una vez conocido u11, la primera columna de A permite determinar el primer renglón de L, se
obtienen:
l21
Profesor Leopoldo Silva Bijit
a21 / u11; l31
a31 / u11; l41
20-01-2010
a41 / u11
Algoritmos numéricos
3
El segundo renglón de A, permite calcular el segundo renglón de U, una vez conocidos los
elementos del primer renglón de U, se tienen:
l21u12 u22
a22 ; l21u13 u23
a23 ; l21u14 u24
a24
Despejando los elementos del segundo renglón 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 renglón de A, resultan:
l31u13 l32u23 u33
a33 ; l31u14 l32u24 u34
a34
Las que permiten despejar los elementos del tercer renglón 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 renglón de A, permite calcular el cuarto renglón 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 continuación:
Con N es el número de renglones y columnas de A.
Profesor Leopoldo Silva Bijit
20-01-2010
4
Estructuras de Datos y Algoritmos
Para: n 1,..., N ;
ln, n
1
La diagonal de L, se obtiene por definición de la descomposición de Doolittle.
El n-avo renglón de U se obtiene según:
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 continuación se obtiene el algoritmo para la substitución hacia delante:
De la relación:
L d
b
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 según:
Profesor Leopoldo Silva Bijit
20-01-2010
Algoritmos numéricos
5
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 expresión siguiente para calcular d2; con d1 y d2, se
puede calcular d3; y así sucesivamente. Por esta razón, al procedimiento se lo denomina
substitución hacia adelante (forward).
El vector d, puede recalcularse para diferentes valores del vector b, que es la situación que se
produce en un barrido DC. Debido a que en el método de Gauss se ocupa, desde el inicio de las
operaciones, los valores de b; el efectuar cálculos con b variable lo realiza con ventajas el
método de descomposición triangular.
La relación anterior, permite deducir una expresión 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 descomposición de Doolittle, los lii son unos.
El algoritmo para la substitución hacia atrás se obtiene de manera similar a las anteriores.
Para la triangular superior:
U x
d
Se tiene:
u11 u12
0 u22
u13 u14
u23 u24
x1
x2
d1
d2
0
0
u33
u34
x3
d3
0
0
0
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:
Profesor Leopoldo Silva Bijit
20-01-2010
6
Estructuras de Datos y Algoritmos
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 solución del sistema de ecuaciones. Nótese que primero se obtiene x4; y luego x3,
que se calcula en términos de x4; y así sucesivamente. Por esta razón a este algoritmo se lo
denomina substitución hacia atrás (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 observación cuidadosa de la generación 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 definición. Entonces luego de la descomposición, la matriz original queda, en el
caso del ejemplo de 4x4:
A
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 descomposición 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;
}
Profesor Leopoldo Silva Bijit
20-01-2010
n 1
un,i
an,i
ln, k uk ,i
k 1
Algoritmos numéricos
7
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 atrás.
a[1..N][1..N] es de entrada y debe contener la descomposición L y U.
b[1..N] el vector de excitación.
Retorna en b la solución.
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 solución x en el espacio ocupado por b.
}
Ejemplo de uso.
//Resuelve el sistema de ecuaciones lineales a·X = b.
ludcmp(a, n);
lufwbksb(a, n, b);
23.1.2. Métodos iterativos.
Para deducir expresiones generales que permitan escribir algoritmos iterativos, consideremos el
sistema lineal de tres ecuaciones:
a11 a12
a21 a22
a31 a32
Profesor Leopoldo Silva Bijit
a13 x1
a23 x2
a33 x3
20-01-2010
b1
b2
b3
8
Estructuras de Datos y Algoritmos
Despejando de la primera ecuación, 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 iteración (i+1); y xi [n] es el valor obtenido en la
iteración anterior.
Durante el proceso iterativo se verifica la convergencia calculando el mayor cambio relativo
entre una iteración 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 iteración.
Si se tienen N variables, pueden generalizarse las iteraciones según:
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 método de Jacobi.
Si el cálculo 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
cálculo xi se pueden emplear los nuevos valores de las variables desde x1 hasta xi 1 .
Entonces el esquema iterativo puede plantearse:
Profesor Leopoldo Silva Bijit
20-01-2010
Algoritmos numéricos
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 método 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 método
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 fórmula de Gauss Seidel. Con a>1, el nuevo valor, en la iteración (n+1),
tiene mayor importancia. Con a<1, se tiene subrelajación. La elección de este valor, y su
influencia en la convergencia debería aclararse en un curso de análisis numérico.
La recurrencia para encontrar el nuevo valor por el método 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 código:
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
Profesor Leopoldo Silva Bijit
20-01-2010
10
Estructuras de Datos y Algoritmos
/*Dados a[1..N][1..N], b[1..N] calcula x[1..N]
Con nmax iteraciones y factor de relajación alfa. Retorna solución 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. Solución numérica de sistemas de ecuaciones diferenciales.
Una ecuación diferencial de primer orden puede resolverse numéricamente mediante
integración.
Si se tiene:
dr (t )
dt
F (t )
Entonces:
t
r (t )
r (0)
F ( )d
0
F (t ) considera la variación de r(t) y de las excitaciones que producen la respuesta r(t).
Profesor Leopoldo Silva Bijit
20-01-2010
Algoritmos numéricos
11
Una manera simple y aproximada de realizar la integración es calcular el área mediante la suma
de rectángulos, que estudiaremos como el método de Euler.
Una mejor aproximación se logra sumando trapecios, si se desea mayor precisión se emplea
aproximación por segmentos parabólicos, con la regla de Simpson. Para disminuir la
acumulación de errores se emplea el método de Runge-Kutta.
23.2.1. Formulación de ecuaciones de estado.
La formulación de las ecuaciones de una red eléctrica en términos de las variables de estado
permite encontrar la solución de un sistema de ecuaciones diferenciales de primer orden en el
dominio del tiempo. La solución numérica, que veremos a continuación, puede extenderse a
sistemas no lineales.
La representación 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 términos del estado, según:
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. Método de Euler.
A partir de la expansión 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 relación 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.
Profesor Leopoldo Silva Bijit
20-01-2010
12
Estructuras de Datos y Algoritmos
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 ecuación de estado se determina el valor de las derivadas en un punto.
La siguiente función 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 homogéneas 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 diseño 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 función ilustra la generación 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 gráficos 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 numéricos
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 invocación 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 acumulación 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
1
hf (tn , y (tn ))
Si definimos:
k1
hf (tn , yn )
Se realiza la integración mediante:
yn
1
yn
k1
Se tiene que f (tn , yn ) es la derivada de la función y (t ) , y k1 es el área del rectángulo bajo la
curva de f (t , y) , y también el incremento de la ordenada. Las relaciones se muestran en la
Figura 1, para la variable y (t ) .
Profesor Leopoldo Silva Bijit
20-01-2010
14
Estructuras de Datos y Algoritmos
yn
tn
tg ( n )
1
1
yn
tn
k1
h
f (tn , yn )
yn+1
k1
n
yn
tn
f(tn+1,yn+1)
f(tn,yn)
tn+1
h
tn
tn+1
h
Figura 23.1. Método de Euler.
23.2.4. Algoritmo trapezoidal.
Una mejor aproximación 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
h
tn
h
Figura 23.2. Método trapezoidal.
Entonces:
yn
1
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 integración trapezoidal mediante:
Profesor Leopoldo Silva Bijit
20-01-2010
tn+1
Algoritmos numéricos
15
yn
1
1
(k1 k2 )
2
yn
En cada paso de integración es preciso evaluar dos veces la función: f (t , y) . La determinación
de yn
1
que se emplea en el cálculo de k2 , puede determinarse, aplicando Euler,
según: yn
1
yn
k1
23.2.5. Algoritmo de Simpson.
Para refinar el cálculo del área, se define un punto dentro del intervalo, de este modo puede
calcularse el área bajo una parábola 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
h
f(tn,yn)
tn+1
fa(t)
tn
h
tn+1
Figura 23.3. Método de Simpson.
Si la ecuación de la parábola 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
A
f a (t )dt
t t0
Profesor Leopoldo Silva Bijit
20-01-2010
16
Estructuras de Datos y Algoritmos
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 integración puede realizarse según:
yn
1
yn
1
(k0 4k1 k2 )
6
En cada paso de integración es preciso evaluar tres veces la función: f (t , y) .
Los valores de las ordenadas intermedias, pueden calcularse, según:
y (tn
h / 2)
y (tn
h)
yn
yn
k0 h / 2
k0 h
La fórmula anterior permite deducir la conocida fórmula para la aproximación de Simpson.
Si se tienen cinco valores de tiempos para los cuales se calcula la integral, se tiene el área
acumulada, según:
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 número 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
Profesor Leopoldo Silva Bijit
20-01-2010
2
4 f2n
1
f2n )
Algoritmos numéricos
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. Métodos multietapas.
Existen métodos más elaborados para efectuar un paso de integración, En éstos la función se
evalúa en varias etapas entre dos puntos. Los puntos de las etapas sólo se emplean para el
cálculo del nuevo valor.
Consisten en definir una función en la cual se escogen los parámetros de tal modo de minimizar
los errores.
Sea la función
yn , tn ; h , entonces, la integración se realiza mediante:
yn
El método de Euler es:
yn , t n ; h
yn
1
h
yn , t n ; h
f ( yn , t n )
El siguiente esquema es de Runge-Kutta, de segundo orden, con cuatro parámetros.
k1
f yn , t n
k2
f yn
hk1 , tn
yn
h ak1 bk2
yn
1
h
Con:
y tn , tn
af y(tn ), tn
Donde deben determinarse: a, b, ,
bf y(tn )
hf y(tn ), tn , tn
h
por consideraciones de exactitud.
Si se define el error de la aproximación por:
Tn
y tn h
y tn
h
y tn , tn
Para el primer término de Tn, por expansión de Taylor de y(t), resulta:
y tn
h
y tn
h
dy (tn )
dt
h 2 d 2 y (tn )
2! dt 2
Como se tiene:
Profesor Leopoldo Silva Bijit
20-01-2010
h3 d 3 y (tn )
O(h 4 )
3
3! dt
18
Estructuras de Datos y Algoritmos
dy
dt
f y t ,t
La segunda derivada de y, se obtiene según:
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 subíndices.
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
2
f
t
2
2
f
f
t y
2
f
y t
2
f
y
2
f
f
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 expansión de Taylor, se logra:
y tn
h
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 término de Tn, se requiere expandir el término que está multiplicado por b. Para
y, tn
t ,
esto se emplea la expansión de Taylor de dos variables de f yn
con: y
hf , t
h . Como
los términos de segundo orden.
está multiplicado por h, sólo es necesario considerar hasta
Entonces;
Profesor Leopoldo Silva Bijit
20-01-2010
Algoritmos numéricos
f y
19
y, t
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 notación abreviada
para las derivadas parciales de f, se logra:
f yn
y, tn
f y ( hf )
t
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 expresión anterior en:
y tn , tn
af y(tn ), tn
bf y(tn )
hf y(tn ), tn , tn
h
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 están 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 parámetros: a, b, ,
f yy f 2
2 fty f
f yy
f t )h
f
f y ft
fy f
f yt
fh 2
2
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
Profesor Leopoldo Silva Bijit
1
b ) 0 , de la que se desprenden:
2
1
b
2
ff y (
20-01-2010
0
20
Estructuras de Datos y Algoritmos
Con a 1, b 0 se tiene el método de Euler. No pueden ajustarse , . Por esta razón puede
decirse que el algoritmo de Euler pertenece a la familia Runge-Kutta de segundo orden.
23.4.6.1. Método de Heun.
Considera:
1
que satisfacen las dos relaciones anteriores.
2
0, a b
1,
Se realiza la integración mediante:
yn
h
k1 k2
2
yn
1
Con:
k1
k2
f yn , t n
f yn
k1h, tn
h
23.4.6.2. Método del punto medio.
1
, a 0, b 1 que satisfacen las dos relaciones anteriores.
2
Considera:
yn
1
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
n
yn
tn
f(tn+h/2,yn+k1h/2)
tn+1
h
f(tn+1,yn+1)
f(tn,yn)
tn
h
tn+1
Figura 23.4. Método del punto medio.
23.4.6.3. Método de Ralston.
Considera:
3
a
4
1
, b
3
Profesor Leopoldo Silva Bijit
2
que satisfacen las dos relaciones anteriores.
3
20-01-2010
Algoritmos numéricos
21
Se integra mediante:
yn
h
(k1 2k2 )
3
yn
1
Con:
k1
k2
f yn , t n
f yn
3k1h
, tn
4
3h
4
En los algoritmos del método de Runge-Kutta de segundo orden, debe evaluarse dos veces la
función: f y (t ), t , para obtener el siguiente punto de la función.
23.4.7. Métodos de Runge-Kutta de cuarto orden.
Para derivar el algoritmo de cuarto orden de Runge Kutta, se definen los 10 parámetros:
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
1
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 expresión para el error es:
Tn
yn
1
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:
Profesor Leopoldo Silva Bijit
20-01-2010
f y ft
f y2 f )
22
Estructuras de Datos y Algoritmos
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 expansión de Taylor, se logra la serie:
y tn
h
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:
Profesor Leopoldo Silva Bijit
20-01-2010
f yy f 2
5 f yt f y f
f y ft
f y2 f )
Algoritmos numéricos
23
h
y tn , tn
w1k1 w2 k2 w3k3 w4k4
Se emplea la expansión de Taylor de dos variables de
diferentes y, t . Como
términos de tercer orden.
f yn
y, tn
t , con los
está multiplicado por h, sólo es necesario considerar hasta los
Entonces;
f yn
y , tn
fy y
ft t
1
f yyy y 3
6
t
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 notación 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
fyy b3 2 f ( fy b2 f
fy b3 fy b2 ( fy b1 f
Profesor Leopoldo Silva Bijit
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
Estructuras de Datos y Algoritmos
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:
h
y tn , tn
b1 3 f 3 fyyy
w2
6
b1 2 f 2 fyyt a1
2
fyy b3 2 f ( fy b2 f
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
fyy b2 2 f ( fy b1 f
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 están evaluadas en tn.
Deducir los valores de los parámetros para eliminar términos en la expresión para el error de la
aproximación resulta complejo.
Profesor Leopoldo Silva Bijit
20-01-2010
Algoritmos numéricos
La generación automática de la función
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^i=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^i=0)
od:
> temp:=collect(w1*k1+w2*k2+w3*k3+w4*k4,h):
> for i from 5 to 40 do
temp:=eval(temp,h^i=0)
od:
Phi:=collect(temp,h):
La generación del primer término del error, puede generarse automáticamente 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):
Profesor Leopoldo Silva Bijit
20-01-2010
26
Estructuras de Datos y Algoritmos
d4:=subs(sus1,d4):d4:=subs(sus4,d4):d4:=subs(sus3,d4):d4:=subs(sus2,d4
):d4:=expand(d4):
> F;
Efectuando la comparación de los coeficientes del error, de tal forma de anular hasta la potencia
cuarta de h, se obtienen 19 ecuaciones:
Para eliminar el término del error proporcional a h:
e1 := w1
w2
w3
w4
1
Para eliminar el término del error proporcional a h2:
e2 := w4 b3
w2 b1
w3 b2
1
2
e3 := w4 a3
w2 a1
w3 a2
1
2
Para eliminar el término del error proporcional a h3:
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
Para eliminar el término del error proporcional a h4:
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
Profesor Leopoldo Silva Bijit
1
b3 b2 2
2
1
8
w3
20-01-2010
1
6
Algoritmos numéricos
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 incógnitas, 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 idénticas. Sólo se requiere
considerar una de ellas.
Las ecuaciones 4, 5 y 8, con a1 = b1, a2 = b2 y a3 = b3 son idénticas. Sólo se requiere considerar
una de ellas.
Las ecuaciones 12 y 11 implican la ecuación 18. Por lo tanto no se requiere emplear la ecuación
11.
Las ecuaciones 12 y 14 implican la ecuación 18. Por lo tanto no se requiere emplear la ecuación
14.
Lo anterior reduce el sistema a 10 ecuaciones en 10 incógnitas (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 solución satisface las 19 ecuaciones, y que el error queda:
Profesor Leopoldo Silva Bijit
20-01-2010
28
Estructuras de Datos y Algoritmos
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
h
1
k1 2k2
6
yn
2 k3 k 4
Se calculan cuatro valores de la función, para obtener el siguiente punto.
Existen numerosos algoritmos en los que se varía el intervalo de tiempo entre puntos.
23.3. Solución de ecuación no lineal.
El problema consiste en encontrar la raíz de la ecuación no lineal: f ( x)
0
Normalmente la solución de f ( x) 0 , puede ser difícil de encontrar analíticamente, pero como
veremos es sencilla de resolver iterativamente.
23.3.1. Método de Newton-Raphson.
0 , se parte de un valor x0 y se genera una serie de iteraciones xi que se
acerquen a la solución xs , donde f ( xs ) 0 .
Para resolver f ( x)
En cursos de análisis numérico se responden las preguntas: ¿Cuándo la secuencia xi converge a
la solución correcta? ¿Cuán rápido se converge? ¿La convergencia depende del intento inicial
x0 ? ¿Cuándo detener las iteraciones?.
El método de Newton-Raphson consiste en reemplazar, mediante la expansión de Taylor, la
función por su versión lineal, en torno a la solución:
f ( x)
f ( xs )
df
( xs )( x xs )
dx
Para un punto cualquiera se obtiene:
Profesor Leopoldo Silva Bijit
20-01-2010
Algoritmos numéricos
29
f ( xk 1 )
Efectuando: f ( xk 1 )
f ( xk )
df
( xk )( xk
dx
xk )
1
0 , se obtiene la fórmula de la iteración de Newton-Raphson,
despejando xk 1 :
xk
xk
1
f ( xk )
df
( xk )
dx
Podemos interpretar la fórmula de la iteración, planteando la relación anterior en x0 , y
calculando x1 . Situación que se ilustra en la Figura 23.5.
f(x)
f(x0)
f(x1)
xs
0
x2
x1
x0
Figura 23.5. Iteración Newton-Raphson.
Resulta, de la interpretación gráfica de la derivada en x0 :
df
( x0 )
dx
tg ( 0 )
f ( x0 )
x0 x1
Despejando x1 , se obtiene el primer valor de aproximación del método de Newton-Raphson:
x1
x0
df
( x0 )
dx
1
f ( x0 )
Nótese que f ( x1 ) no es cero, lo cual implica que x1 es una aproximación de xs . También debe
notarse que para calcular la siguiente aproximación deben calcularse la función 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 pequeño, para que la solución
se considere aceptable. Con números reales de precisión simple (float en C), un valor razonable
Profesor Leopoldo Silva Bijit
20-01-2010
30
Estructuras de Datos y Algoritmos
de tolerancia es 10-6, que es el valor del número real más pequeño representable, en el formato
interno normalizado IEEE754.
Si el valor inicial es adecuado conviene limitar el número máximo de iteraciones, de este modo
si no existe convergencia se asegura que el algoritmo termine.
También 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 número de iteraciones. Pueden
producirse en un caso como el que se ilustra en la Figura 23.6.
Figura 23.6. Oscilación.
Se emplea un intervalo [x1..x2] en el cual se busca la raíz, para evitar la no convergencia debido
a máximos o mínimos dentro del intervalo. Si en una iteración se encuentra un punto con
derivada casi horizontal en el intervalo, el valor para el nuevo x se aleja de la raíz, como se
ilustra en la Figura 23.7. Para prevenir esta situación se verifica que la nueva aproximación de la
raíz permanezca dentro del intervalo.
Figura 23.7. Divergencia.
Se detienen
tolerancia.
las iteraciones si los dos últimos valores obtenidos difieren en determinada
La siguiente función intenta encontrar una raíz en el intervalo [x1, x2].
El primer argumento es un puntero a función con un argumento flotante y que retorna un
flotante. Cuando se invoca a NewtonRaphson el argumento actual es el nombre de la función
que calcula el cuociente de la función con su derivada evaluada en el x actual.
Profesor Leopoldo Silva Bijit
20-01-2010
Algoritmos numéricos
31
#define nmax 20 //Máximo número 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 función 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 función, para un polinomio, define la derivada y retorna el cuociente entre la
función y su derivada. Nótese que la función 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; //función 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 función: f ( x) 0.2 x 4 2 x3 x 7 , tiene dos raíces reales, como se ilustra en la Figura
23.8.
La solución con fsolve de Maple, entrega: 1.742869875, 9.913192964
Profesor Leopoldo Silva Bijit
20-01-2010
32
Estructuras de Datos y Algoritmos
Figura 23.8.
Empleando la función NewtonRaphson, pueden obtenerse las raíces mediante:
printf("Valor de la raíz = %f\n", NewtonRaphson(fun2,1,2,1e-6 ));
printf("Valor de la raíz = %f\n", NewtonRaphson(fun2,9,11,1e-6 ));
23.3.2. Generalización para sistemas de ecuaciones no lineales.
Para un sistema de ecuaciones no lineales, se emplea la expansión de Taylor para varias
variables.
La expansión es una linealización en torno a la solución:
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 aproximación de primer orden, se tiene:
F ( xk 1 )
F ( xk ) J ( xk )( xk
1
xk )
Para entender la relación 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
1
x1k
F2 ( x1k 1 , x 2 k 1 )
F2 ( x1k , x 2 k )
F2 ( x1k , x 2 k )
F2 ( x1k , x 2 k )
x2k
1
x2k
x1
x2
Una explicación del cambio de la función de dos variables, puede efectuarse considerando el
plano tangente a la superficie, en el punto (x10, x20) que pasa también por el punto (x11, x21).
Profesor Leopoldo Silva Bijit
20-01-2010
Algoritmos numéricos
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. Interpretación del Jacobiano de dos variables.
Aplicando la interpretación geométrica 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 función, resulta:
F1x1
F1x 2
F1 ( x10 , x20 )
( x10
x1
x11 )
F1 ( x10 , x20 )
( x 20
x2
x21 )
Aplicando el método de Newton-Raphson, que consiste en asumir que el plano tangente pasa
por el punto que es una aproximación a la solución. Esto equivale a efectuar:
F1 ( x1k 1 , x 2k 1 )
F2 ( x1k 1 , x 2k 1 )
0
Entonces la fórmula de iteración, resulta:
F1 ( x1k , x 2 k )
F1 ( x1k , x 2 k )
x1
x2
x1k
1
x1k
F1 ( x1k , x 2 k )
F2 ( x1k , x 2 k )
F2 ( x1k , x 2 k )
x 2k
1
x 2k
F2 ( x1k , x 2 k )
x1
x2
Finalmente, despejando el nuevo punto:
Profesor Leopoldo Silva Bijit
20-01-2010
34
Estructuras de Datos y Algoritmos
x1k
1
x1k
x 2k
1
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 términos de vectores y la matriz inversa del Jacobiano, resulta en general,
para n variables:
xk
J ( xk ) 1 F ( xk )
xk
1
Una mejor visualización de la suma de los incrementos, se logra observando los triángulos
semejantes en la Figura 23.10.
Por el punto inicial (2, 2, 10) se pasa el plano z=2x+3y que también pasa por el punto (0, 0, 0).
Se han dibujado además los planos de z constante, z=4 y z=6.
z
x
z
y
2,
z
x
x
3
4,
z
y
y
6
Figura 23.10. Variación total de función de dos variables.
Volviendo al caso de dos variables, considerando el álgebra de matrices, se tiene:
1
a b
c d
x
y
by dx
ad bc cx ay
1
Entonces las fórmulas de iteración 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
1
Profesor Leopoldo Silva Bijit
x1k
20-01-2010
F2 (k )
F1 (k ))
x2
F1 (k ) F2 (k )
x2
x1
Algoritmos numéricos
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
1
x 2k
En caso de mayores órdenes debe invertirse el Jacobiano, o alternativamente resolverse el
sistema lineal de ecuaciones, para las incógnitas xk 1 :
J ( xk )( xk
1
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.
Profesor Leopoldo Silva Bijit
20-01-2010
36
Estructuras de Datos y Algoritmos
Índice general.
CAPÍTULO 23 ............................................................................................................................................1
ALGORITMOS NUMÉRICOS.................................................................................................................1
23.1. SOLUCIÓN DE SISTEMA SIMULTÁNEO DE ECUACIONES LINEALES. .....................................................1
23.1.1. Descomposición LU. ................................................................................................................1
23.1.2. Métodos iterativos. ...................................................................................................................7
23.2. SOLUCIÓN NUMÉRICA DE SISTEMAS DE ECUACIONES DIFERENCIALES. ...........................................10
23.2.1. Formulación de ecuaciones de estado. ..................................................................................11
23.2.2. Método 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. Métodos multietapas. .............................................................................................................17
23.4.6.1. Método de Heun. ............................................................................................................................. 20
23.4.6.2. Método del punto medio. ................................................................................................................ 20
23.4.6.3. Método de Ralston. ......................................................................................................................... 20
23.4.7. Métodos de Runge-Kutta de cuarto orden. ............................................................................21
23.3. SOLUCIÓN DE ECUACIÓN NO LINEAL...............................................................................................28
23.3.1. Método de Newton-Raphson. .................................................................................................28
23.3.2. Generalización para sistemas de ecuaciones no lineales. .....................................................32
REFERENCIAS. .........................................................................................................................................35
ÍNDICE GENERAL. ....................................................................................................................................36
ÍNDICE DE FIGURAS. ................................................................................................................................37
Profesor Leopoldo Silva Bijit
20-01-2010
Algoritmos numéricos
37
Índice de figuras.
FIGURA 23.1. MÉTODO DE EULER. .............................................................................................................. 14
FIGURA 23.2. MÉTODO TRAPEZOIDAL. ........................................................................................................ 14
FIGURA 23.3. MÉTODO DE SIMPSON. .......................................................................................................... 15
FIGURA 23.4. MÉTODO DEL PUNTO MEDIO. ................................................................................................. 20
FIGURA 23.5. ITERACIÓN NEWTON-RAPHSON. ........................................................................................... 29
FIGURA 23.6. OSCILACIÓN. ......................................................................................................................... 30
FIGURA 23.7. DIVERGENCIA....................................................................................................................... 30
FIGURA 23.8. .............................................................................................................................................. 32
FIGURA 23.9. INTERPRETACIÓN DEL JACOBIANO DE DOS VARIABLES. ........................................................ 33
FIGURA 23.10. VARIACIÓN TOTAL DE FUNCIÓN DE DOS VARIABLES. .......................................................... 34
Profesor Leopoldo Silva Bijit
20-01-2010