Algoritmos Numericos Lu PDF

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.
a11 a12 a13 a14 1 0 0 0 u11 u12 u13 u14

a21 a22 a23 a24 l21 1 0 0 0 u22 u23 u24
A
a31 a32 a33 a34 l31 l32 1 0 0 0 u33 u34
a41 a42 a43 a44 l41 l42 l43 1 0 0 0 u44
Efectuando la multiplicación de las matrices L y U, se obtiene:
u11 u12 u13 u14

l21u11 l21u12 u22 l21u13 u23 l21u14 u24
A
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 a21 / u11; l31 a31 / u11; l41 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.

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
Se obtiene:
l11 0 0 0 d1 b1
l21 l22 0 0 d2 b2
l31 l32 l33 0 d3 b3
l41 l42 l43 l44 d4 b4
Efectuando las multiplicaciones, en el lado derecho, se tienen:
l11d1 b1
l21d1 l22 d 2 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:

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 u13 u14 x1 d1
0 u22 u23 u24 x2 d2
0 0 u33 u34 x3 d3
0 0 0 u44 x4 d4
Efectuando las multiplicaciones, se obtiene:
u11 x1 u12 x2 u13 x3 u14 x4 d1

u22 x2 u23 x3 u24 x4 d2
u33 x3 u34 x4 d3
u44 x4 d4
Despejando los xi, se obtienen:

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 uij x j
j i 1
xi
uii
Para: i ( N 1), ( N 2), ,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:
u11 u12 u13 u14

l21 u22 u23 u24
A
l31 l32 u33 u34
l41 l42 l43 u44
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; n 1
for (k=1; k<=(n-1); k++) sum += a[n][k]*a[k][i]; un,i an,i ln, k uk ,i
a[n][i]-=sum; k 1
}

for (j=n+1; j<=N; j++)
{ sum=0; n 1
for (k=1; k<=(n-1); k++) sum += a[j][k]*a[k][n]; l j,n a j,n l j , k uk , n / un, n
a[j][n]=(a[j][n]-sum)/a[n][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
b[i]=(b[i]-sum)/a[i][i]; xi
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 a13 x1 b1
a21 a22 a23 x2 b2
a31 a32 a33 x3 b3

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

j i 1 j N
xi [n 1] (bi aij x j [n 1] aij x j [n]) / aii
j 1 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 j N
xi [n 1] (1 a) xi [n] a(bi aij x j [n 1] aij x j [n]) / aii
j 1 j i 1
El algoritmo descrito en pseudo código:
SOR. Dados: N, a, b, x[0], tol, nmax.

for n = 1, … nmax do Comienza iteraciones
for i = 1,.... N do
j i 1 j N
yi [n] (1 a) xi [n] a(bi aij y j [n] aij x j [n]) / aii
j 1 j i 1
end for i
yi xi
for j = 1,….. N do
xj yj
end for i
if ( tol ) stop
end for n

/*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 )
F (t )
dt
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).

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
Ax Bu
dt
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:
dx(t ) 1 dx 2 (t ) 2
x(t t) x(t ) t t ....
dt 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:
dxi (tk )
xi [k 1] xi [k ] t
dt
Este procedimiento iterativo se denomina esquema simple de Euler.

Los valores de las derivadas, en un instante determinado, se obtienen mediante la matriz de
estado.
j n j n
xi [k 1] xi [k ] ( aij x j [k ] bij u j [k ]) t
j 1 j 1
Para: i 1, 2, ,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');

}
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 )
f (t , y (t ))
dt
Se pueden obtener los valores sucesivos de y, mediante:
yn 1 yn 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 ) .

yn 1 yn k1
tg ( n ) f (tn , yn )
tn 1 tn h
yn+1 f(tn+1,yn+1)
n
k1
yn f(tn,yn)
tn tn+1 tn tn+1
h 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 f(tn,yn)
tn tn+1 tn tn+1
h h
Figura 23.2. Método trapezoidal.
Entonces:
h
yn 1 yn ( f (tn , yn ) f (tn 1 , yn 1 ))
2
Con:
k1 hf (tn , yn )
k2 hf (tn 1 , yn 1 )
Se realiza la integración trapezoidal mediante:

1
yn 1 yn (k1 k2 )
2
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.
yn+1 f(tn+h/2, y(tn+h/2))

f(tn+1,yn+1)
(k0 +4 k1+ k2)/6
n
yn f(tn,yn) fa(t)
tn tn+1 tn tn+1
h h
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

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 h / 2))
k2 hf (tn h, y (tn h))
El paso de integración puede realizarse según:
1
yn 1 yn (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) yn k0 h / 2
y (tn h) yn 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:
1 1
Area (k0 4k1 k2 ) (k2 4k3 k4 )
6 6
La cual puede simplificarse a:
1
Area (k0 4k1 2k2 4k3 k4 )
6
Con 2n+1 puntos en total, se tiene en general:
h
Area ( f 0 4 f1 2 f 2 4 f3 ...... 2 f 2 n 2 4 f2n 1 f2n )
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

}
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 1 yn h yn , t n ; h
El método de Euler es: 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 h
yn 1 yn h ak1 bk2
Con:
y tn , tn af y(tn ), tn bf y(tn ) hf y(tn ), tn , tn h
Donde deben determinarse: a, b, , 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:
dy (tn ) h 2 d 2 y (tn ) h3 d 3 y (tn )

y tn h y tn h O(h 4 )
dt 2! dt 2 3! dt 3
Como se tiene:

dy
f y t ,t
dt
La segunda derivada de y, se obtiene según:
d2y d f f dy f f
f y t ,t f ft fy f
dt 2 dt t y dt t y
Las derivadas parciales de f se han representado, en forma abreviada, mediante subíndices.
Para la tercera derivada, se tiene:
d3y d f f d f d f f df
f ( ) ( )f
dt 3 dt t y dt t dt y y dt
La cual permite obtener:
d3y 2
f f 2 2
f 2
f f f f
f f f f
dt 3 t 2
t y y t y 2
y t y
Finalmente para la tercera derivada:
d3y
ftt f yt f ( f yt f yy f ) f f y ( ft fy f )
dt 3
Reemplazando las derivadas obtenidas, en la expansión de Taylor, se logra:
h2 h3
y tn h y tn hf ( ft fy f ) ( ftt 2 f ty f f yy f 2 f y ft f y 2 f ) O (h 4 )
2! 3!
Donde se ha empleado: f f y tn , tn
Para el segundo término de Tn, se requiere expandir el término que está multiplicado por b. Para
esto se emplea la expansión de Taylor de dos variables de f yn y, tn t ,
con: y hf , t h . Como está multiplicado por h, sólo es necesario considerar hasta
los términos de segundo orden.
Entonces;

f y y, t t f y, t
f ( y, t ) f ( y, t ) 1 f 2 ( y, t ) 2 f 2 ( y, t ) 1 f 2 ( y, t ) 2
y t y y t t
y t 2 y2 y 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 t f yn , t n
1 1
f y ( hf ) f t ( h) f yy ( hf ) 2 f yt ( hf )( h) f tt ( h) 2 O(h 3 )
2 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:
1 1
y tn , tn af b( f f y hf ft h f yy ( hf )2 f yt ( hf ) h f tt 2 2
h ) O h3
2 2
Donde las funciones y las derivadas parciales están evaluadas en tn.
Se tiene finalmente para el error:
h h2
Tn h f ft ff y ftt 2 fty f f yy f 2 f y ft fy f
2 3!
2
f yy f ftt 2 2
h af b f ( fy f f t )h h2 f yt fh 2 h O (h 4 )
2 2
Los parámetros: a, b, , , se escogen del tal modo de minimizar el error. En este caso pueden
hacerse cero los coeficientes de h y h 2 , pero no es posible eliminar la parte que depende de
h3 .
Para eliminar la parte proporcional a h , se debe cumplir: f af bf 0

2
Para eliminar la parte proporcional a h , se debe cumplir: ( ft ff y ) / 2 bf y f bf t 0
De la primera se obtiene: a b 1
1 1
De la segunda, debe cumplirse: ft ( b ) ff y (
b ) 0 , de la que se desprenden:
2 2
1
b b
2

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.

1
Considera: 1, 0, a b que satisfacen las dos relaciones anteriores.
2
Se realiza la integración mediante:
h
yn 1 yn k1 k2
2
Con:
k1 f yn , t n
k2 f yn k1h, tn h
23.4.6.2. Método del punto medio.
1
Considera: , a 0, b 1 que satisfacen las dos relaciones anteriores.
2
yn 1 yn hk2
Con:
k1 f yn , t n
k1h h
k2 f yn , tn
2 2
La pendiente de y está dada ahora por el valor de f en el punto medio del intervalo.
yn+1 f(tn+h/2,yn+k1h/2)
f(tn+1,yn+1)
n
hk2
yn f(tn,yn)
tn tn+1 tn tn+1
h h
Figura 23.4. Método del punto medio.
23.4.6.3. Método de Ralston.

3 1 2
Considera: a , b que satisfacen las dos relaciones anteriores.
4 3 3

Se integra mediante:
h
yn 1 yn (k1 2k2 )
3
Con:
k1 f yn , t n
3k1h 3h
k2 f yn , tn
4 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 1 yn w1k1 w2 k2 w3k3 w4 k4
Con:
y tn , tn w1 f yn , tn w2 f yn b1k1 , tn a1h
w3 f yn b2 k2 , tn a2 h 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 d
( ftt 2 fty f f yy f 2 f y ft f y2 f )
dt 4 dt
Derivando, se obtiene:

d4y dy dy d2y dy dy
(( f yyy f yyt ) f yy 2 f yyt f ytt )
dt 4 dt dt dt dt dt
2 3
dy d y d y dy dy d2y dy
2( f yy f yt ) 2 f y 3 ( f yyt f ytt ) f yt 2 f ytt f ttt
dt dt dt dt dt dt dt
Reemplazando la primera derivada de y:
d4y d2y
(( f yyy f f yyt ) f f yy f yyt f f ytt ) f
dt 4 dt 2
d2y d3y d2y
2( f yy f f yt ) fy ( f yyt f f ytt ) f f yt f ytt f f ttt
dt 2 dt 3 dt 2
Reemplazando la segunda derivada de y, se tiene:
d4y
(( f yyy f f yyt ) f f yy ( f t fy f ) f yyt f f ytt ) f
dt 4
d3y
2( f yy f f yt )( f t fy f ) fy ( f yyt f f ytt ) f f yt ( f t fy f ) f ytt f f ttt
dt 3
Reemplazando la tercera derivada de y, se obtiene:
d4y
(( f yyy f f yyt ) f f yy ( ft fy f ) f yyt f f ytt ) f
dt 4
2( f yy f f yt )( ft f y f ) f y ( f tt f ty f ( f yt f yy f ) f
f y ( ft f y f )) ( f yyt f f ytt ) f f yt ( ft fy f ) f ytt f fttt
Reemplazando las derivadas obtenidas, en la expansión de Taylor, se logra la serie:

h2 h3
y tn h y tn hf ( ft fy f ) ( f tt 2 f ty f f yy f 2 f y ft f y2 f )
2! 3!
h4
( f yyy f 3 3 f yyt f 2 4 f yy f y f 2 3 f yy f t f 3 f yyt f 5 f yt f y f
4!
3 f yt f t f y 3 f f y 2 f t f y f tt f ttt ) O (h5 )
Donde se ha empleado: f f y tn , tn
La segunda componente del error, requiere calcular:

h y tn , tn w1k1 w2 k2 w3k3 w4k4
Se emplea la expansión de Taylor de dos variables de f yn y, tn t , con los

diferentes y, t . Como está multiplicado por h, sólo es necesario considerar hasta los
términos de tercer orden.
Entonces;
f yn y , tn t f yn , t n
1 1
fy y ft t f yy y 2 f yt y t f tt t 2
2 2
1 1 1 1
f yyy y 3 f yyt y 2 t f ytt y t2 f ttt t 3
6 2 2 6
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
k2 = 1 1
fyy b1 2 f 2 b1 f fyt a1 ftt a1 2 h 3 ( fy b1 f ft a1 ) h 2 hf
2 2
k3 =
fyy b1 2 f 2 ftt a1 2
fy b2 b1 f fyt a1 fyy b2 2 f ( fy b1 f ft a1 )
2 2
b2 2 f 2 fyyt a2 b2 f a2 2 fytt b2 3 f 3 fyyy a2 3 fttt
b2 ( fy b1 f ft a1 ) fyt a2
2 2 6 6
2 2 2
ftt a2 fyy b2 f
h4 fy b2 ( fy b1 f ft a1 ) b2 f fyt a2 h 3
2 2
( fy b2 f ft a2 ) h 2 hf
k4 =
a3 3 fttt b3 3 f 3 fyyy b3 f a3 2 fytt
hf fyy b3 2 f ( fy b2 f ft a2 )
6 6 2
ftt a2 2 fyy b2 2 f 2
fy b3 fy b2 ( fy b1 f ft a1 ) b2 f fyt a2
2 2

b3 2 f 2 fyyt a3
b3 ( fy b2 f ft a2 ) fyt a3 h4
2
fy b3 ( fy b2 f ft a2 ) b3 f fyt a3 h 3
2 2
2
( fy b3 f ft a3 ) h
Reemplazando las expresiones anteriores en: y tn , tn

Se obtiene:
h y tn , tn
b1 3 f 3 fyyy b1 2 f 2 fyyt a1 b1 f a1 2 fytt a1 3 fttt a3 3 fttt
w2 w4
6 2 2 6 6
b3 3 f 3 fyyy b3 f a3 2 fytt
fyy b3 2 f ( fy b2 f ft a2 )
6 2
fy b3 fy b2 ( fy b1 f ft a1 ) b2 f fyt a2
2 2
b3 2 f 2 fyyt a3
b3 ( fy b2 f ft a2 ) fyt a3 w3
2
fy b2 b1 f fyt a1 fyy b2 2 f ( fy b1 f ft a1 )
2 2
b2 2 f 2 fyyt a2 b2 f a2 2 fytt b2 3 f 3 fyyy a2 3 fttt
b2 ( fy b1 f ft a1 ) fyt a2
2 2 6 6
h4 w4 fy b3 ( fy b2 f ft a2 ) b3 f fyt a3
2 2
w2 b1 f fyt a1
2 2
w3 fy b2 ( fy b1 f ft a1 ) b2 f fyt a2 h3
2 2
( w4 ( fy b3 f ft a3 ) w2 ( fy b1 f ft a1 ) w3 ( fy b2 f ft a2 ) ) h 2
( w1 f w2 f w4 f w3 f ) h
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.

La generación automática de la función , 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 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):

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:

1
e2 := w4 b3 w2 b1 w3 b2
2
1
e3 := w4 a3 w2 a1 w3 a2
2
w2 b1 2 w4 b3 2 w3 b2 2 1
e4 :=
2 2 2 6
1
e5 := w4 b3 a3 w2 b1 a1 w3 b2 a2
3
1
e6 := w4 b3 b2 w3 b2 b1
6
1
e7 := w4 b3 a2 w3 b2 a1
6
w4 a3 2 w2 a1 2 w3 a2 2 1
e8 :=
2 2 2 6
w2 b1 3 w4 b3 3 w3 b2 3 1
ec9 :=
6 6 6 24
2 2 2
w2 b1 a1 w4 b3 a3 w3 b2 a2 1
ec10 :=
2 2 2 8
1 1 1
ec11 := w4 b3 2 b2 b3 b2 2 b2 b1 2 b2 2 b1
w3
2 2 6
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

5
ec14 := w4 ( b3 b2 a2 b3 b2 a3 ) w3 ( b2 b1 a1 b2 b1 a2 )
24
1
ec15 := w4 b3 a2 a3 w3 b2 a1 a2
8
1
ec16 := w4 b3 b2 b1
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
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];
1 1 1 1 1 1 1 1
{ b1 , a2 , w1 , a3 1, b3 1, a1 , w3 , w2 , b2 , w4 }
2 2 6 2 3 3 2 6
Puede comprobarse que la solución satisface las 19 ecuaciones, y que el error queda:

Tn O(h5 )
Entonces el algoritmo de Runge Kutta de cuarto orden resulta:
k1 hf yn , tn
k1 h
k2 hf yn , tn
2 2
k2 h
k3 hf yn , tn
2 2
k4 hf yn k3 , t n h
1
yn 1 yn k1 2k2 2 k3 k 4
6
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.
Para resolver f ( x) 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 .
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:
df
f ( x) f ( xs ) ( xs )( x xs )
dx
Para un punto cualquiera se obtiene:

df
f ( xk 1 ) f ( xk ) ( xk )( xk 1 xk )
dx
Efectuando: f ( xk 1 ) 0 , se obtiene la fórmula de la iteración de Newton-Raphson,

despejando xk 1 :
f ( xk )
xk 1 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 f ( x0 )
tg ( 0 ) ( x0 )
dx x0 x1
Despejando x1 , se obtiene el primer valor de aproximación del método de Newton-Raphson:

1
df
x1 x0 ( x0 ) f ( x0 )
dx
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

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 las iteraciones si los dos últimos valores obtenidos difieren en determinada
tolerancia.
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.

#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

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) F ( xs ) J ( xs )( x xs )
Las cantidades F ( x) y ( x xs ) se expresan como vectores, y J ( xs ) como una matriz,

denominada Jacobiano.
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).

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
x1
x21 x2
x20
Figura 23.9. Interpretación del Jacobiano de dos variables.
Aplicando la interpretación geométrica de las derivadas parciales, se tienen:
F1 ( x10 , x 20 ) F1x1
tg ( x1 )
x1 x10 x11
F1 ( x10 , x 20 ) F1x 2
tg ( x2 )
x2 x 20 x 21
El cambio total de la función, resulta:
F1 ( x10 , x20 ) F1 ( x10 , x20 )

F1x1 F1x 2 ( x10 x11 ) ( x 20 x21 )
x1 x2
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 )
0
F2 ( x1k 1 , x 2k 1 )
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:

F1 ( x1k , x 2k ) F1 ( x1k , x 2k ) 1
x1k 1 x1k x1 x2 F1 ( x1k , x 2k )
x 2k 1 x 2k F2 ( x1k , x 2k ) F2 ( x1k , x 2k ) F2 ( x1k , x 2k )
x1 x2
La que expresada en términos de vectores y la matriz inversa del Jacobiano, resulta en general,
para n variables:
xk 1 xk J ( xk ) 1 F ( xk )
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 z z z
2, 3 x 4, y 6
x y x y
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 x 1 by dx
c d y ad bc cx ay
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 )
( F2 (k ) F1 (k ))
x1k x1k x2 x2
1
F1 (k ) F2 (k ) F1 (k ) F2 (k )
x1 x2 x2 x1

F2 (k ) F1 (k )
( F1 (k ) F2 (k ))
x 2k x 2k x2 x1
1
F1 (k ) F2 (k ) F1 (k ) F2 (k )
x1 x2 x2 x1
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.

Í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

Í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

Algoritmos Numericos Lu PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Algoritmos Numericos Lu PDF

Cargado por

Copyright:

Formatos disponibles

1

23.1. Solución de sistema simultáneo de ecuaciones lineales.

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

De entre los variados esquemas, basados en la eliminación de Gauss, el método de

Para sistemas de un mayor número de ecuaciones se emplean métodos iterativos.

23.1.1. Descomposición LU.

Está basado en descomponer la matriz de coeficientes en dos matrices triangulares L y U, según:

El sistema original de ecuaciones, queda:

Que puede ser interpretado como dos sistemas de ecuaciones:

Profesor Leopoldo Silva Bijit 20-01-2010

El procedimiento está basado en obtener las matrices L y U, a partir de A; luego en obtener el

Se tiene la matriz A de 4x4 y se desea obtener L y U.

a11 a12 a13 a14 1 0 0 0 u11 u12 u13 u14

Efectuando la multiplicación de las matrices L y U, se obtiene:

u11 u12 u13 u14

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

l21 a21 / u11; l31 a31 / u11; l41 a41 / u11

Profesor Leopoldo Silva Bijit 20-01-2010

l21u12 u22 a22 ; l21u13 u23 a23 ; l21u14 u24 a24

Despejando los elementos del segundo renglón de U, se obtienen:

u22 a22 l21u12

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

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

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

Con N es el número de renglones y columnas de A.

Profesor Leopoldo Silva Bijit 20-01-2010

El n-avo renglón de U se obtiene según:

Y la n-ava columna de L con:

A continuación se obtiene el algoritmo para la substitución hacia delante:

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

Las componentes del vector d, se obtienen según:

Profesor Leopoldo Silva Bijit 20-01-2010

Efectuando las multiplicaciones, se obtiene:

u11 x1 u12 x2 u13 x3 u14 x4 d1

Profesor Leopoldo Silva Bijit 20-01-2010

Para: i ( N 1), ( N 2), ,3, 2,1

La observación cuidadosa de la generación de las matrices L y U, muestra que no es necesario

u11 u12 u13 u14

void ludcmp(float **a, int N)

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

Profesor Leopoldo Silva Bijit 20-01-2010

/*Realiza substituciones hacia adelante y hacia atrás.

23.1.2. Métodos iterativos.

Profesor Leopoldo Silva Bijit 20-01-2010

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

Donde xi [n 1] es el valor de xi en la iteración (i+1); y xi [n] es el valor obtenido en la

Durante el proceso iterativo se verifica la convergencia calculando el mayor cambio relativo

Si se tienen N variables, pueden generalizarse las iteraciones según:

El esquema anterior se reconoce como método de Jacobi.

Entonces el esquema iterativo puede plantearse:

Profesor Leopoldo Silva Bijit 20-01-2010

El que se denomina método de Gauss Seidel.

Una mejora notable de la convergencia se logra empleando un promedio ponderado de los