3.

Solución de sistemas de ecuaciones lineales

El sistema de n ecuaciones con n incógnitas

a11 x1 + a12 x2 + a13 x3 + ⋯ + a1n xn = b1

a21 x1 + a22 x2 + a23 x3 + ⋯ + a2n xn = b2
a31 x1 + a32 x2 + a33 x3 + ⋯ + a3n xn = b3
: ∶ ∶
: ∶ ∶
an1 x1 + an2 x2 + an3 x3 + ⋯ + ann xn = bn

se puede escribir en forma matricial como Ax = b , donde A es la matriz de coeficientes,

a11 a12 a13 ⋯ a1n
a21 a22 a23 ⋯ a2n
a31 a32 a33 ⋯ a3n
𝐀= ⋮ ⋮
⋮ ⋮
[an1 an2 an3 ⋯ ann ]

x es el vector de incógnitas y b el vector de términos del lado derecho

x1 b1
x2 b2
x3 b
𝐱= ⋮ 𝐛= 3
⋮
⋮ ⋮
[xn ] [b n ]

Existen dos tipos de métodos para resolver el problema Ax = b; los exactos y los iterativos.
Los primeros son llamados exactos porque, en ausencia de errores de redondeo, obtienen la
solución analítica o exacta y están basados en la eliminación de Gauss o en la factorización
LU. Los métodos del segundo tipo encuentran una solución aproximada mediante procesos
iterativos.
Para sistemas con matrices de coeficientes densas y relativamente pequeñas, se prefieren
los métodos exactos. En el caso de sistemas con matrices de coeficientes de orden grande y
poco densas, son recomendados los métodos iterativos. Una matriz densa es aquella que
contiene pocos elementos iguales a cero, y por lo contrario, la mayoría de los elementos en
una matriz poco densa o dispersa son ceros.

3.1 Eliminación de Gauss

1
Es un proceso que convierte a la matriz de coeficientes A de n x n en una matriz triangular
superior mediante la aplicación sistemática de transformaciones elementales de renglón.
Una vez obtenida la matriz triangular superior se aplica un procedimiento conocido como
sustitución hacia atrás para obtener el vector solución x.
Las transformaciones elementales de renglón son:
1.- La fila i de una matriz puede ser multiplicada por un constante  ≠ 0

Ri → Ri

2.- A la fila j de un matriz le puede ser sumada otra fila i de la misma matriz multiplicada
por una constante 

Ri + Rj → Rj

3.- Las filas i y j de una matriz pueden ser intercambiadas

Ri  Rj

La eliminación de Gauss consta de n - 1 pasos de eliminación y cada uno de ellos consiste

en:
1.- Seleccionar un pivote: en el i-ésimo paso de eliminación se escoge como pivote al i-
ésimo elemento de la diagonal principal de A, estrategia conocida como pivoteo natural.
2.- Colocar ceros debajo del pivote en la misma columna.

Ejemplo
Resolver el sistema

x1 – x2 + x3 = – 4
5x1 – 4x2 + 3x3 = –12
2x1 + x2 + x3 = 11

con eliminación de Gauss y sustitución hacia atrás. Use una estrategia de pivoteo natural.
En primer lugar, se forma una matriz agregando una columna a la matriz de coeficientes.
La columna añadida es el vector de términos del lado derecho y la matriz así formada se
conoce como matriz aumentada del sistema:

1.00000 −1.00000 1.00000 −4.00000

[5.00000 −4.00000 3.00000 −12.00000]
2.00000 1.00000 1.00000 11.00000

Primer paso de eliminación:

El pivote es el primer elemento de la diagonal principal en la parte correspondiente a la
matriz de coeficientes, a11 = 1.00000. Ahora se trata de colocar ceros debajo del pivote en la
primera columna y para lograrlo es necesario calcular las cantidades, llamadas
multiplicadores, que son los elementos por convertir en cero divididos entre el pivote. En
este primer paso de eliminación los multiplicadores son a21 / a11 = 5.00000 / 1.00000 =

2
5.00000 y a31 / a11 = 2.00000 / 1.00000 = 2.00000. Las transformaciones de renglón
requeridas para tal efecto son

-5.00000R1 + R2 → R2
-2.00000R1 + R3 → R3

Después de aplicar estas transformaciones a la matriz aumentada, el resultado es:

1.00000 −1.00000 1.00000 −4.00000

[0.00000 1.00000 −2.00000 8.00000 ]
0.00000 3.00000 −1.00000 19.00000

Segundo paso de eliminación:

El pivote es ahora a22 = 1.00000 y el único multiplicador es a32 / a22 = 3.00000 / 1.00000 =
3.00000. Por lo tanto, la transformación elemental requerida es:

-3.00000R2 + R3 → R3

y la matriz aumentada se convierte en:

1.00000 −1.00000 1.00000 −4.00000

[0.00000 1.00000 −2.00000 8.00000 ]
0.00000 0.00000 5.00000 −5.00000

Con estos dos pasos termina la eliminación de Gauss y la parte correspondiente a la matriz
de coeficientes es una matriz triangular superior. La última matriz aumentada define un
sistema cuya solución es equivalente a la del sistema original:

1.00000x1 – 1.00000x2 + 1.00000x3 = – 4.00000

1.00000x2 – 2.00000x3 = 8.00000
5.00000x3 = – 5.00000

Esta solución x se puede encontrar fácilmente:

x3 = –5.00000 / 5.00000 = -1.00000

x2 = (8.00000 + 2.00000x3) / 1.00000 = (8.00000 + 2.00000*(–1.00000)) / 1.00000 =
6.00000
x1 = (–4.00000 + 1.00000x2 –1.00000x3) / 1.00000
x1 = (–4.0000 + 1.00000*(6.00000) – 1.00000*(–1.0000)) / 1.00000 = 3.00000

Este proceso es la sustitución hacia atrás, conocido así porque se obtienen los valores de las
incógnitas comenzando con la última xn y terminando con la primera x1. Las siguientes
fórmulas describen la sustitución hacia atrás y en ellas la letra a denota a los elementos de
la matriz aumentada después de la eliminación de Gauss:
an,n+1
xn =
an,n

3
 ai,n+1 − ∑nj=i+1 ai,j xj
xi = para i = n − 1, n − 2, … ,1
ai,i

El último ejercicio muestra que para poder calcular los multiplicadores en cada paso de
eliminación, el pivote necesariamente debe ser distinto de cero. Por lo tanto, si en el i-ésimo
paso de eliminación aii es cero, se debe intercambiar la fila i con alguna otra colocada
debajo de ella de tal forma que se lleve a la posición del pivote un número distinto de cero.
Si no es posible colocar un pivote diferente de cero, entonces el sistema lineal no tiene
solución única. Otra posible situación en la cual no existe solución única es aquella en la
cual después del último paso de eliminación el elemento ann es igual a cero.
Con eliminación de Gauss también es factible calcular el determinante de la matriz de
coeficientes del sistema lineal:
n

det(A) = (−1)ncf ∏ aii

i=1

aquí ncf es el número de cambios de filas efectuados en la eliminación y aii representa los
elementos de la diagonal principal de la matriz triangular superior resultado de la
eliminación. Por lo tanto, el determinante de la matriz de coeficientes del último ejemplo
es:

det(A) = (-1)0 [1.00000*1.00000*5.00000)] = 5.00000

Es posible contar el número de operaciones necesarias para resolver un sistema lineal con
eliminación de Gauss y sustitución hacia atrás:

Multiplicaciones o divisiones: n3 / 3 + n2 – n / 3

Sumas o restas: n3 / 3 + n2 / 2 - 5n / 6

En este caso se dice el número de operaciones es de “orden n3”, y se indica con la notación
O(n3). La conclusión es: la eliminación gaussiana con sustitución hacia atrás es un proceso
muy costoso en términos de operaciones aritméticas ya que el número de operaciones
aritméticas es proporcional a n3.
A continuación, un pseudocódigo de un procedimiento que resuelve el sistema Ax = b con
eliminación gaussiana y sustitución hacia atrás. Pivoteo natural es empleado.

procedure eliminación_Gauss(n, (Aij), (xi), solucion_unica)

integer n, i, p, k, j
real array (Aij)1:n x 1:n+1, (xi)1:n
boolean solucion_unica
real cero, auxiliar, multiplicador, suma
//
// Este procedimiento resuelve un sistema lineal de ecuaciones con eliminación

4
// gaussiana y sustitución hacia atrás. Se emplea una estrategia de pivoteo natural.
// Descripción de parámetros:
// n Número de ecuaciones y de incógnitas.
// A Matriz aumentada del sistema, de n filas y n+1 columnas.
// x Si en solucion_unica se devuelve el valor true, entonces x
// es la solución única. De n elementos.
// solucion_unica Bandera que indica la existencia de una solución única:
// solucion_unica = true el sistema tiene solución única
// solucion_unica = false la matriz de coeficientes es singular
// y no hay solución única.
//
cero ← 1X10-12 // si |valor| < cero, se considera a valor como si fuera 0
// Eliminación de Gauss con pivoteo natural
for i = 1 to n – 1 do
solucion_unica ← false
for p = i to n do // selección del pivote
if |Api| ≥ cero then
solucion_unica ← true
exit
end if
end for
if not solucion_unica then
return
end if
if p ≠ i then // intercambio de las filas p e i, en caso necesario
for k = 1 to n+1 do
auxiliar ← Apk
Apk ← Aik
Aik ← auxiliar
end for
end if
for j = i +1 to n do // colocación de ceros debajo del pivote
multiplicador ← Aji / Aii
for k = i to n + 1 do
Ajk ← Ajk – multiplicador*Aik
end for
end for
end for
if |Ann| < cero then
solucion_unica ← false
return
end if
// sustitución hacia atrás
xn ← An,n+1 / Ann
for i = n -1 to 1 step -1 do
suma ← 0.0
for j = i + 1 to n do
5
 suma ← suma + Aij*xj
end for
xi ← (Ai,n+1 – suma) / Aii
end for
return
end procedure eliminación_Gauss

3.2 Pivoteo máximo de columna

Si los cálculos involucrados en la eliminación gaussiana se efectuaran en una computadora

o en una calculadora con longitud de palabra infinita, los resultados obtenidos serían
exactos. Pero como lo anterior no es posible y las computadoras solo pueden representar y
operar un número finito de dígitos, necesariamente los resultados serán aproximados debido
a los inevitables errores de redondeo.
Una forma de minimizar los errores de redondeo en la eliminación de Gauss es emplear
alguna técnica de pivoteo. De todas las estrategias de pivoteo la más simple, y
frecuentemente muy efectiva, es el pivoteo parcial o pivoteo máximo de columna: en cada
paso de eliminación siempre se escoge como pivote al elemento de mayor valor absoluto
entre los colocados en y abajo de la diagonal principal:

Pivoteo máximo de columna

En el i-ésimo paso de eliminación, se determina un valor p ≥ i tal que:

|api| = máx |aki| para i = 1, 2,...., n - 1 pasos de eliminación

i≤k≤n

Ejemplo
Resuelva el sistema

x1 + 3x2 – 2x3 = 7
4x1 – x2 + 3x3 = 10
–5x1 + 2x2 + 3x3 = 7

empleando eliminación de Gauss con pivoteo máximo de columna.

La matriz aumentada del sistema es:

1.00000 3.00000 −2.00000 7.00000

[ 4.00000 −1.00000 3.00000 10.00000]
−5.00000 2.00000 3.00000 7.00000

Primer paso de eliminación:

El este pivote se escoge como el elemento con el mayor valor absoluto entre los elementos
de la primera columna desde la fila 1 hasta la 3, por lo tanto, el pivote es a31 = –5.00000.
Como el pivote está en la fila 3, es necesario intercambiar la fila 1 con la 3 para colocar en
el primer renglón al –5.00000.

6
R1  R3
−5.00000 2.00000 3.00000 7.00000
[ 4.00000 −1.00000 3.00000 10.00000]
1.00000 3.00000 −2.00000 7.00000

Los multiplicadores son ahora 4.00000 / (-5.00000) y 1.00000 / (-5.00000) y las

transformaciones elementales que colocan ceros debajo de a11 son:

– (4.00000 / (–5.00000))R1 + R2 → R2
– (1.00000 / (–5.00000))R1 + R3 → R3
La matriz aumentada queda al final de este primer paso de eliminación de esta manera:

−5.00000 2.00000 3.00000 7.00000

[ 0.00000 0.60000 5.40000 15.60000]
0.00000 3.40000 −1.40000 8.40000

Segundo paso de eliminación:

Aquí los posibles pivotes son a22 = 0.60000 y a23 = 3.40000. Como |a23| > |a22|, entonces el
pivote es a23 = 3.40000 y por lo tanto se requiere intercambiar las filas 2 y 3:

R2 R3

−5.00000 2.00000 3.00000 7.00000

[ 0.00000 3.40000 −1.40000 8.40000 ]
0.00000 0.60000 5.40000 15.60000

El multiplicador es 0.60000 / 3.40000 y la transformación que coloca un cero debajo del

pivote es:

– (0.60000 / 3.40000) R2 + R3 → R3
Entonces la matriz aumentada al final queda así:

−5.00000 2.00000 3.00000 7.00000

[ 0.00000 3.40000 −1.40000 8.40000 ]
0.00000 0.00000 5.64706 14.11765

La sustitución hacia atrás genera el vector solución x = [1.50000, 3.50000, 2.50000]T .

Pseudocódigo de un procedimiento que resuelve un sistema lineal, con eliminación de

Gauss y pivoteo máximo de columna:

procedure eliminación_Gauss_pm(n, (Aij), (xi), solucion_unica)

integer n, i, p, k, j
real array (Aij)1:n x 1:n+1, (xi)1:n

7
boolean solucion_unica
real cero, auxiliar, multiplicador, suma
//
// Este procedimiento resuelve un sistema lineal de ecuaciones con eliminación
// gaussiana y sustitución hacia atrás. Se emplea una estrategia de pivoteo máximo
// de columna.
// Descripción de parámetros:
// n Número de ecuaciones y de incógnitas.
// A Matriz aumentada del sistema, de n filas y n+1 columnas.
// x Si en solucion_unica se devuelve el valor true, entonces x
// es la solución única. De n elementos.
// solucion_unica Bandera que indica la existencia de una solución única:
// solucion_unica = true el sistema tiene solución única
// solucion_unica = false la matriz de coeficientes es singular
// y no hay solución única.
//
cero ← 1X10-12 // si |valor| < cero, se considera a valor como si fuera 0
// Eliminación de Gauss con pivoteo máximo de columna
solucion_unica ← false
for i = 1 to n – 1 do
p←i
for j = i + 1 to n do // selección del pivote
if |Aji| > |Api| then
p←j
end if
end for
if |Api| < cero then
return
end if
if p ≠ i then // intercambio de las filas p e i, en caso necesario
for k = 1 to n+1 do
auxiliar ← Apk
Apk ← Aik
Aik ← auxiliar
end for
end if
for j = i +1 to n do // colocación de ceros debajo del pivote
multiplicador ← Aji / Aii
for k = i to n + 1 do
Ajk ← Ajk – multiplicador*Aik
end for
end for
end for
if |Ann| < cero then
return
end if
solucion_unica ← true
8
// sustitución hacia atrás
xn ← An,n+1 / Ann
for i = n -1 to 1 step -1 do
suma ←0.0
for j = i + 1 to n do
suma ← suma + Aij*xj
end for
xi ← (Ai,n+1 – suma) / Aii
end for
return
end procedure eliminación_Gauss_pm

3.3 Descomposición LU

Dada una matriz A de n x n, es posible encontrar las matrices L y U tales que:

A = LU. Las matrices L y U son también de n x n. L es triangular inferior y U es triangular
superior.
Para mostrar los detalles de la descomposición LU, considere una matriz A de 4 x 4:

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

a21 a22 a23 a24 l21 l22 0 0 0 1 u23 u24
[a a32 a33 a34 ] = [l31 ] [ ]
31 l32 l33 0 0 0 1 u34
a41 a42 a43 a44 l41 l42 l43 l44 0 0 0 1

A = LU

Para poder realizar la descomposición es necesario asignar valores arbitrarios a una de las
diagonales, ya sea la de L o la de U. Si los elementos de la diagonal principal de U se hacen
iguales a uno, se trata de la descomposición de Crout, como es el caso mostrado arriba. Si
los elementos de la diagonal principal de L se toman iguales a uno, entonces es la
descomposición de Doolittle.
Para determinar a las matrices L y U se usa el concepto de multiplicación de matrices:

Multiplicación de los renglones de L por la primera columna de U:

l11 (1) = a11

l21 (1) = a21
l31 (1) = a31
l41 (1) = a41
Multiplicación del primer renglón de L por las columnas de U:

l11 (1) = a11

l11 u12 = a12 y por lo tanto u12 = a12 / l11
l11 u13 = a13 y por lo tanto u13 = a13 / l11

9
l11 u14 = a14 y por lo tanto u14 = a14 / l11
Multiplicación de los renglones de L por la segunda columna de U:

l11 u12 = a12

l21 u12 + l22 (1) = a22 y por lo tanto l22 = a22 – l21 u12
l31 u12 + l32 (1) = a32 y por lo tanto l32 = a32 – l31 u12
l41 u12 + l42 (1) = a42 y por lo tanto l42 = a42 – l41 u12
Multiplicación del segundo renglón de L por las columnas de U:

l21 (1) = a21

l21 u12 + l22 (1) = a22
l21 u13 + l22 u23 = a23 y por lo tanto u23 = (a23 – l21 u1) / l22
l21 u14 + l22 u24 = a24 y por lo tanto u24 = (a24 – l21 u14) / l22
Multiplicación de los renglones de L por la tercera columna de U:

l11 u13 = a13

l21 u13 + l22 u23 = a23
l31 u13 + l32 u23 + l33 (1) = a33 y por lo tanto l33 = a33 – l31 u13 – l32 u23
l41 u13 + l42 u23 + l43 (1) = a43 y por lo tanto l43 = a43 – l41 u13 – l42 u23

Multiplicación del tercer renglón de L por las columnas de U:

l31 (1) = a31

l31 u12 + l32 (1) = a32
l31 u13 + l32 u23 + l33 (1) = a33
l31 u14 + l32 u24 + l33 u34 = a34 y por lo tanto u34 = (a34 – l31 u14 – l32 u24) / l33

Multiplicación de los renglones de L por la cuarta columna de U:

l11 u14 = a14

l21 u14 + l22 u24 = a24
l31 u14 + l32 u24 + l33 u34 = a34
l41 u14 + l42 u24 + l43 u34 + l44 (1) = a44 y por lo tanto l44 = a44 – l41 u14 – l42 u24 – l43 u34
Las siguientes ecuaciones representan el procedimiento anterior para matrices de orden n:

li1 = ai1 para i = 1,2, … , n

a
u1j = l 1j para j = 2,3, … , n
11

Para k = 2,3, … , n − 1

10
 k−1

lik = aik − ∑ lij ujk , i = k, k + 1, … , n

j=1
aki − ∑k−1
j=1 lkj uji
uki = , i = k + 1, k + 2, … . , n
[ lkk

lnn = ann − ∑n−1

j=1 lnj ujn

Una vez obtenida la descomposición LU de la matriz de coeficientes A, es posible resolver

el sistema Ax = b; dado que A = LU, el sistema original se puede escribir como (LU)x =
L(Ux) = b y si se define z como z = Ux, entonces ahora queda el sistema Lz = b, el cual se
puede resolver ahora mediante sustitución hacia adelante. Conocido z, entonces se resuelve
Ux = z con sustitución hacia atrás, encontrándose así al vector x.

Ejemplo
Resolver el sistema

3x1 – x2 + 2x3 = 12
x1 + 2x2 + 3x3 = 11
2x1 – 2x2 – x3 = 2

con descomposición LU.

l11 = a11 = 3.00000

l21 = a21 = 1.00000 u12 = a12 / l11 = –1.00000 / 3.00000 = –0.33333
l31 = a31 = 2.00000 u13 = a13 / l11 = 2.00000 / 3.00000 = 0.66667

3 −1 2 3.00000 0 0 1 −0.33333 0.66667

[1 2 3 ] = [1.00000 l22 0 ] [0 1 u23 ]
2 −2 −1 2.00000 l32 l33 0 0 1

l22 = a22 – l21 u12 = 2.00000 –1.00000*(–0.33333) = 2.33333

l32 = a32 – l31 u12 = –2.00000 – 2.00000*(–0.33333) = –1.33333
u23 = (a23 – l21 u13) / l22 = (3.00000 –1.00000*0.66667) / 2.33333 = 1.00000

3 −1 2 3.00000 0 0 1 −0.33333 0.66667

[1 2 3 ] = [1.00000 2.33333 0 ] [0 1 1.00000]
2 −2 −1 2.00000 −1.33333 l33 0 0 1

l33 = a33 – l31 u13 – l32 u23 = –1.00000 – 2.00000*0.66667 – (–1.33333)*(1.00000)

l33 = –1.00000

Entonces, la descomposición LU es:

11
 3 −1 2 3.00000 0 0 1 −0.33333 0.66667
[1 2 3 ] = [1.00000 2.33333 0 ] [0 1 1.00000]
2 −2 −1 2.00000 −1.33333 −1.00000 0 0 1

Lz = b es el sistema:

3.00000z1 = 12.00000
1.00000z1 + 2.33333z2 = 11.00000
2.00000z1 – 1.33333z1 –1.00000z3 = 2.00000

el cual se resuelve con sustitución hacia adelante. Este algoritmo es llamado así porque la
primera incógnita que se determina es z1 y la última zn.

z1 = 12.00000 / 3.00000 = 4.00000

z2 = (11.00000 – z1) / 2.33333 = (11.00000 – 4.00000) / 2.33333 = 3.00000
z3 = (2.00000 – 2z1 + 1.33333z2) / (–1.00000)
z3 = (2.00000 – 2.00000*4.00000 + 1.33333*3.00000) / (–1.00000) = 2.000000

Por último, es necesario resolver el sistema Ux = z mediante sustitución hacia atrás:

1.00000x1 – 0.33333x2 + 0.66667x3 = 4.00000

1.00000x2 + 1.00000x3 = 3.00000
1.00000x3 = 2.00000

x3 = 2.00000 / 1.00000 = 2.00000

x2 = (3.00000 –1.00000x3) / 1.00000 = (3.00000 – 2.00000) / 1.00000 = 1.00000
x1 =(4.00000 + 0.33333x2 – 0.66667x3) / 1.00000
x1 = (4.00000 + 0.33333*1.00000 – 0.66667*2.00000) / 1.00000 = 3.00000

Finalmente, la solución del sistema es x = [3.00000, 1.00000, 2.00000]T.

La sustitución hacia adelante que permite resolver a Lz = b se puede resumir con las
fórmulas:

b1
z1 =
l11

bi − ∑i−1
j=1 lij zj
zi = , i = 2,3, … , n
lii

El proceso de sustitución hacia atrás empleado en la solución de Ux = z se describe

mediante:
zn
xn = = zn
unn

12
 zi − ∑nj=i+1 uij xj
xi = , i = n − 1, n − 2, … ,1
uii

Si se conoce la descomposición LU de A, la solución de Ax = b implica solamente resolver

Lz = b y Ux = z. El trabajo computacional asociado con cualquiera de estas soluciones es
de O(n2/2) multiplicaciones o divisiones. Esta es la razón por la que se prefiere la
descomposición LU para resolver varios sistemas lineales con la misma matriz de
coeficientes. La descomposición LU junto con la solución de Lz = b y de Ux = z requieren
un total de O(n3/3) multiplicaciones o divisiones.
En el algoritmo de la reducción de Crout, los elementos de la diagonal principal de L deben
ser distintos de cero. Si en algún momento, se detecta que lii = 0 entonces es obligado un
intercambio de filas. Más específicamente; si lii = 0, se debe intercambiar la fila i con
alguna de las filas colocadas debajo de ella, cuidando que el intercambio solo afecte a los
elementos de la parte triangular inferior. El mismo intercambio de filas deberá realizarse
también en A y en b. Si no es posible encontrar un lii ≠ 0, entonces la matriz A es singular y
el sistema Ax = b no tiene solución única. Después de los cambios de renglones, al
terminar la descomposición LU la igualdad A = LU sigue siendo válida, L sigue siendo
triangular inferior y U triangular superior, pero A ahora es la matriz original afectada por
los cambios de filas.
A continuación, el pseudocódigo de un procedimiento que realiza la descomposición LU:

procedure LU(n, (Aij), (Lij), (Uij), (info_cambiosfi), exito)

integer n, i, j, k, p, auxiliari
real array (Aij)1:n x 1:n, (Lij)1:n x 1:n, (Uij)1:n x 1:n
integer array (info_cambiosfi)1:n
boolean exito, distinto_cero
//
// Factorización A = LU mediante reducción de Crout.
// Descripción de parámetros:
// n Orden de las matrices cuadradas A, L y U.
// A Matriz por factorizar. Como resultado de la factorización, en el
// regreso, A puede tener algunas filas intercambiadas.
// L Matriz triangular inferior.
// U Matriz triangular superior.
// info_cambiosf Vector que contiene información sobre los cambios de filas
// efectuados durante la factorización.
// exito Bandera cuyo valor indica el tipo de situación detectada durante
// el proceso:
// exito = true factorización exitosa, A = LU
// exito = false no fue posible la factorización o A es singular.
//
real cero, auxiliar, suma
cero ← 1X10-12 // si |valor| < cero, se considera a valor como si fuera 0
for i = 1 to n do
info_cambiosfi ← i // cuando info_cambiosi = i, no se ha intercambiado la fila i
end for

13
for i = 1 to n do
Uii ← 1.0 // se asigna 1 a todos los elementos de la diagonal principal de U
end for
exito ← false
distinto_cero ← false
for i = 1 to n do // búsqueda de un L11 diferente de cero
if |Ai1| ≥ cero then
distinto_cero ← true
break
end if
end for
if not distinto_cero then
return
end if
if i ≠ 1 then
for j = 1 to n do
auxiliar ← A1j // intercambio de las filas 1 e i
A1j ← Aij
Aij ← auxiliar
end for
auxiliari ← info_cambiosf1
info_cambiosf1 ← info_cambiosfi
info_cambiosfi ← auxiliari
end if
for i = 1 to n do // cálculo de la primera columna de L
Li1 ← Ai1
end for
for j = 2 to n do // cálculo de los elementos restantes de la primera fila de U
U1j ← A1j / L11
end for
for k = 2 to n – 1 do
for p = k to n do // búsqueda de un Lii distinto de cero
distinto_cero ← false
suma ← 0.0
for j = 1 to k -1 do
suma ← suma + Lpj*Ujk
end for
auxiliar ← Apk – suma
if |auxiliar| ≥ cero then
distinto_cero ← true
break
end if
end for
if not distinto_cero then
return
end if
if p ≠ k then
14
 for j = 1 to n do // intercambio de las filas k y p en A
auxiliar ← Akj
Akj ← Apj
Apj ← auxiliar
end for
for j = 1 to k -1 do // intercambio de las filas k y p en L
auxiliar ← Lkj
Lkj ← Lpj
Lpj ←auxiliar
end for
auxiliari ← info_cambiosfk // intercambio de los elementos con índices
info_cambiosfk ← info_cambiosfp // k y p en info_cambiosf
info_cambiosfp ← auxiliari
end if
for i = k to n do
suma ← 0.0
for j = 1 to k – 1 do // cálculo de la columna k de L
suma ← suma +Lij*Ujk
end for
Lik ← Aik – suma
end for
for i = k + 1 to n do // cálculo de los elementos restantes de la fila k de U
suma ← 0.0
for j = 1 to k -1 do
suma ← suma + Lkj*Uji
end for
Uki ← (Aki – suma) / Lkk
end for
end for
suma ← 0.0
for j = 1 to n – 1 do // cálculo del último elemento de la diagonal principal de L
suma ← suma + Lnj*Ujn
end for
Lnn ← Ann – suma
if |Lnn| < cero then
return
end if
exito ← true
return
end procedure LU

Ahora, el pseudocódigo de una función, en la cual dada la factorización A = LU, resuelve

el sistema Ax = (LU)x = b.

function solve_lu(n, (Lij), (Uij), (info_cambiosfi), (bi)) result (xi)

integer n, i, j, auxiliar
real array (Lij)1:n x 1:n, (Uij)1:n x 1:n, (bi)1:n, (zi)1:n
15
real array (xi:n)
//
// Dada la factorización A = LU, este procedimiento determina el vector solución x de
// Ax = b.
// Descripción de parámetros:
// n Orden de las matrices cuadradas L y U. También es el
// número de incógnitas.
// L Matriz triangular inferior.
// U Matriz triangular superior.
// info_cambiosf Vector que contiene información sobre los cambios de filas
// efectuados en la factorización A = LU.
// b Vector de términos del lado derecho del sistema lineal.
// Las matrices L y U y el vector info_cambiosf son calculados con
// el procedimiento LU o LU_pm.
// Resultado de la función:
// x Vector solución.
//
real suma
z1 ← binfo_cambiosf(1) / L11 // sustitución hacia adelante
for i = 2 to n do
suma ← 0.0
for j = 1 to i -1 do
suma ← suma + Lij*zj
end for
zi ← (binfo_cambiosf(i) – suma) / Lii
end for
//
// Solución de Ux = z
//
xn ← zn / Unn // sustitución hacia atrás
for i = n – 1 to 1 step -1 do
suma ← 0.0
for j = i + 1 to n do
suma ← suma + Uij*xj
end for
xi ← (zi – suma) / Uii
end for
return
end function solve_lu

Con descomposición de Crout también es posible calcular el determinante de una matriz:

n
ncf
det(A) = (−1) ∏ lii
i=1

16
aquí ncf es el número de cambios de filas efectuados en la descomposición y lii representa
los elementos de la diagonal principal de la última matriz triangular inferior L.
La matriz inversa, A-1, de una matriz A de n filas y n columnas se puede calcular mediante
la solución de n sistemas lineales, ya que la i-ésima columna de la matriz inversa es la
solución del sistema Ax = ei, en el cual el vector columna ei es la i-ésima columna de la
matriz identidad I. Como los n sistemas lineales comparten la misma matriz de coeficientes
A, es conveniente descomponer A como el producto LU y emplear a L y U en la solución
de todos los sistemas.
Es factible implementar un pivoteo máximo de columna en la descomposición de Crout. En
este caso, se busca colocar en la posición lii al elemento de mayor valor absoluto entre los
colocados en y debajo de la diagonal principal de L. El intercambio de filas deberá afectar
solamente a la parte triangular inferior de L y también deberá ser aplicado a la matriz A y al
vector b.

Ejemplo
Resolver el sistema

x1 – x2 + 3x3 = –3
–x1 – 2x3 = 1
2x1 + 2x2 + 4x3 = 0

con factorización de Crout y pivoteo máximo de columna.

l11 = a11 = 1.00000, l21 = a21 = –1.00000, l31 = a31 = 2.00000

1 −1 3 1.00000 0 0 1 u12 u13

[−1 0 −2] = [ −1.00000 l22 0 ] [0 1 u23 ]
2 2 4 2.00000 l32 l33 0 0 1

|l11| = |1.00000| = 1.00000, |l21| = |–1.00000| = 1.00000, |l31| = |2.00000| = 2.00000

b = [ –3.0000, 1.00000, 0.00000]T

Dado que el elemento de mayor valor absoluto en la primera columna de L es l31, es

necesario intercambiar las filas 1 y 3 (R1 R3) en A, L y b:

2 2 4 2.00000 0 0 1 u12 u13

[−1 0 −2] = [−1.00000 l22 0 ] [0 1 u23 ]
1 −1 3 1.00000 l32 l33 0 0 1

b = [0.00000, 1.00000, –3.00000]T

u12 = a12 / l11 = 2.00000 / 2.00000 = 1.00000

u13 = a13 / l11 = 4.00000 / 2.00000 = 2.00000

2 2 4 2.00000 0 0 1 1.00000 2.00000

[−1 0 −2] = [−1.00000 l22 0 ] [0 1 u23 ]
1 −1 3 1.00000 l32 l33 0 0 1
17
l22 = a22 – l21u12 = 0.00000 – (–1.00000)*(1.00000) = 1.00000
l32 = a32 – l31u12 = –1.00000 – (1.00000)*(1.00000) = –2.00000
|l22| = |1.00000| = 1.00000, |l32| = |–2.00000| = 2.00000

Entre los elementos de la segunda columna de L, el de mayor valor absoluto es l32, lo que
implica cambiar las filas 2 y 3 (R2 R3) en A, L y b:

2 2 4 2.00000 0 0 1 1.00000 2.00000

[ 1 −1 3 ] = [ 1.00000 −2.00000 0 ] [0 1 u23 ]
−1 0 −2 −1.00000 1.00000 l33 0 0 1

b = [0.00000 –3.00000 1.00000]T

u23 = (a23 – l21u13) / l22 = (3.00000 – (1.00000)*(2.00000)) / (–2.00000) = –0.50000

2 2 4 2.00000 0 0 1 1.00000 2.00000

[ 1 −1 3 ] = [ 1.00000 −2.00000 0 ] [0 1 −0.50000]
−1 0 −2 −1.00000 1.00000 l33 0 0 1

l33 = a33 – (l31u13 + l32u23) = –2.00000 – [(–1.00000)*(2.00000) + (1.00000)*( –0.500000)]

l33 = 0.50000

Entonces, la descomposición LU es:

2 2 4 2.00000 0 0 1 1.00000 2.00000

[ 1 −1 3 ] = [ 1.00000 −2.00000 0 ] [0 1 −0.50000]
−1 0 −2 −1.00000 1.00000 0.50000 0 0 1

El sistema Lz = b queda así:

2.00000z1 = 0.00000
1.00000z1 – 2.00000z2 = –3.00000
–1.00000z1 + 1.00000z2 + 0.50000z3 = 1.00000

y su solución es z = [0.00000, 1.500000, –1.00000]T. Ux = z es el sistema:

1.00000x1 + 1.00000x2 + 2.00000x3 = 0.00000

1.00000x2 – 0.50000x3 = 1.50000
1.00000x3 = –1.00000

con solución x = [1.00000, 1.00000, –1.00000]T.

El siguiente es un seudocódigo de un procedimiento que implementa la descomposición de

Crout con pivoteo máximo de columna:

procedure LU_pm(n, (Aij), (Lij), (Uij), (info_cambiosfi), exito)

18
integer n, i, j, k, p, q, auxiliari
real array (Aij)1:n x 1:n, (Lij)1:n x 1:n, (Uij)1:n x 1:n
integer array (info_cambiosfi)1:n
boolean exito
//
// Factorización A = LU mediante reducción de Crout con pivoteo máximo de columna.
// Descripción de parámetros:
// n Orden de las matrices cuadradas A, L y U.
// A Matriz por factorizar. Como resultado de la factorización, en el
// regreso, A puede tener algunas filas intercambiadas.
// L Matriz triangular inferior.
// U Matriz triangular superior.
// info_cambiosf Vector que contiene información sobre los cambios de filas
// efectuados durante la factorización.
// exito Bandera cuyo valor indica el tipo de situación detectada durante
// el proceso:
// exito = true factorización exitosa, A = LU
// exito = false no fue posible la factorización o A es singular.
//
real cero, auxiliar, suma
cero ← 1X10-12 // si |valor| < cero, se considera a valor como si fuera 0
for i = 1 to n do
info_cambiosfi ← i // cuando info_cambiosi = i, no se ha intercambiado la fila i
end for
for i = 1 to n do
Uii ← 1.0 // se asigna 1 a todos los elementos de la diagonal principal de U
end for
exito ← false
p←1
for i = 2 to n do // búsqueda del L11 con el máximo valor absoluto
if |Ai1| > |Ap1| then
p←i
end if
end for
if |Ap1| < cero then
return
end if
if p ≠ 1 then
for j = 1 to n do
auxiliar ← A1j // intercambio de las filas 1 e i
A1j ← Aij
Aij ← auxiliar
end for
auxiliari ← info_cambiosf1
info_cambiosf1 ← info_cambiosfi
info_cambiosfi ← auxiliari
end if
19
for i = 1 to n do // cálculo de la primera columna de L
Li1 ← Ai1
end for
for j = 2 to n do // cálculo de los elementos restantes de la primera fila de U
U1j ← A1j / L11
end for
for k = 2 to n – 1 do
for i = k to n do
suma ← 0.0
for j = 1 to k – 1 do
suma ← suma + Lij*Ujk
end for
Lik ← Aik – suma // cálculo de la columna k de L
end for
p←k
for i = k +1 to n do // pivoteo parcial
if |Lik| > |Lpk| then
p←i
end for
end for
if |Lpk| < cero then
return
end if
if p ≠ k then
for j = 1 to n do // intercambio de las filas k y p en A
auxiliar ← Akj
Akj ← Apj
Apj ← auxiliar
end for
for j = 1 to k do // intercambio de las filas k y p en L
auxiliar ← Lkj
Lkj ← Lpj
Lpj ←auxiliar
end for
auxiliari ← info_cambiosfk // intercambio de los elementos con índices
info_cambiosfk ← info_cambiosfp // k y p en info_cambiosf
info_cambiosfp ← auxiliari
end if
for i = k + 1 to n do // cálculo de los elementos restantes de la fila k de U
suma ← 0.0
for j = 1 to k -1 do
suma ← suma + Lkj*Uji
end for
Uki ← (Aki – suma) / Lkk
end for
end for
suma ← 0.0
20
for j = 1 to n – 1 do // cálculo del último elemento de la diagonal principal de L
suma ← suma + Lnj*Ujn
end for
Lnn ← Ann – suma
if |Lnn| < cero then
return
end if
exito ← true
return
end procedure LU_pm

3.4 Solución de sistemas tridiagonales

Un caso especial y muy importante ocurre cuando en el sistema lineal Ax = b, la matriz de

coeficientes A es tridiagonal. Una matriz cuadrada es tridiagonal si sus elementos distintos
de cero se concentran en tres diagonales: la principal y las colocadas arriba (superdiagonal)
y abajo de ella (subdiagonal):

a11 a12
a21 a22 a23
a32 a33 a34
𝐀= ⋱ ⋱ ⋱
⋱ ⋱ ⋱
an−1,n−2 an−1,n−1 an−1,n
[ an,n−1 an,n ]

Los algoritmos de factorización se simplifican considerablemente cuando son aplicados a

una matriz tridiagonal. En la descomposición LU de una matriz de este tipo, se tienen (3n –
2) elementos diferentes de cero en A y si las matrices L y U son:

l11 1 u12
l21 l22 1 u23
l32 l33 1 u34
𝐋= 𝐔=
⋱ ⋱ ⋱ ⋱
⋱ ⋱ ⋱ un−1,n
[ ln,n−1 ln,n ] [ 1 ]

entonces se tendrán 2n – 1 valores desconocidos en L y n – 1 en U, lo que da un total de 3n

– 2 incógnitas. Nótese que la diagonal principal de U se considera formada de n unos
(reducción de Crout).
Aplicando las propiedades de la multiplicación matricial, es posible plantear las siguientes
ecuaciones

l11 = a11

21
u12 = a12 / l11
li,i-1 = ai,i-1 para i = 2,3, ..., n

lii = ai,i – li,i-1ui-1,i, ui,i+1 = ai,i+1 / lii para i=2,3, …, n – 1

lnn = ann – ln,n-1 un-1,n

El procedimiento para resolver el sistema Ax = b con A tridiagonal consiste en encontrar la

descomposición LU de A con las fórmulas arriba descritas, aplicar entonces sustitución
hacia adelante para resolver Lz = b y por último emplear sustitución hacia atrás para
resolver Ux = z.
El sistema tridiagonal Ax = b tiene solución única si se cumplen las condiciones indicadas
en el teorema:

Supóngase que A = {aij} es tridiagonal con ai,i-1 ai,i+1 ≠ 0 para

cada i = 2,3,...,n-1. Si |a11| > |a12|, |aii| > |ai,i-1| +
|ai,i+1| para cada i = 2,3,...,n-1, y |ann| > |an,n-1|, entonces
el sistema Ax = b tiene solución única, A es no singular y
los elementos de la diagonal principal de L en A = LU,
calculados con reducción de Crout, son todos distintos de

Ejemplo
Resuelva el sistema

0.50x1 + 0.25x2 = 0.35

0.35x1 + 0.80x2 + 0.40x3 = 0.77
0.25x2 + x3 + 0.50x4 = –0.50
x3 – 2x4 = –2.25

mediante descomposición LU específica para un sistema tridiagonal.

l11 = a11 = 0.50000

u12 = a12 / l11 = 0.25000 / 0.50000 = 0.50000
l21 = a21 = 0.35000 l32 = a32 = 0.250000 l43 = a43 = 1.00000
l22 = a22 – l21 u12 = 0.80000 – 0.35000*0.50000 = 0.62500
u23 = a23 / l22 = 0.40000 / 0.62500 = 0.64000
l33 = a33 – l32 u23 = 1.0000 – 0.25000*.64000 = 0.84000
u34 = a34 / l33 = 0.50000 / 0.84000 = 0.59524
l44 = a44 – l43 u34 = –2.00000 – 1.00000*0.59524 = –2.59524

0.50000 0 0 0
0.35000 0.62500 0 0
𝐋=[ ]
0 0.25000 0.84000 0
0 0 1.00000 −2.59524

22
 1.00000 0.50000 0 0
0 1.00000 0.64000 0
𝐔=[ ]
0 0 1.00000 0.59524
0 0 0 1.00000

El sistema Lz = b queda entonces

0.50000z1 = 0.35000
0.35000z1 + 0.62500z2 = 0.77000
0.25000z2 + 0.84000z3 = –0.50000
1.00000z3 – 2.59524z4 = –2.25000

cuya solución es z = [ 0.70000, 0.84000, –0.84524, 0.54128]T. Para calcular la solución x se

resuelve ahora el sistema Ux = z:

1.00000x1 + 0.50000x2 = 0.70000

1.00000x2 + 0.64000x3 = 0.84000
1.00000x3 + 0.59524x4 = –0.84524
1.00000x4 = 0.54128

La solución del sistema es x = [-0.09358, 1.58716, –1.16743, 0.54128]T.

La descomposición LU para matrices tridiagonales junto con las sustituciones hacia
adelante y hacia atrás requieren solamente de (5n – 4) multiplicaciones o divisiones y (3n –
3) adiciones o sustracciones.
Con el objeto de almacenar en memoria solamente las tres diagonales y el vector de
términos del lado derecho, se recomienda ahora escribir el sistema lineal en términos de
vectores:

b1 x1 + c1 x2 = d1
a2 x1 + b2 x2 + c2 x3 = d2
a3 x2 + b3 x3 + c3 x4 = d3
. . . = .
. . . = .
an-1 xn-2 + bn-1 xn-1 + cn-1 xn = dn-1
an xn-1 + bn xn = dn

La factorización LU queda entonces de la siguiente forma:

r1 1 w1
v2 r2 1 w2
v3 r3 1 w3
𝐋= 𝐔=
⋱ ⋱ ⋱ ⋱
⋱ ⋱ ⋱ wn−1
[ vn rn ] [ 1 ]

23
La reducción de Crout con las sustituciones hacia adelante y hacia atrás, en términos de los
vectores a, b, c, d, r, v y w, queda como:

r1 = b1
w1 = c1 / r1
Para i = 2, 3, ..., n – 1
┌
│ vi = ai
│
│ ri = bi – vi wi-1
│
│ wi = ci / ri
└

vn = an
rn = bn - vn wn-1

z1 = d1 / r1
zi = (di - vi zi-1) / ri para i = 2, 3, ..., n

x n = zn
xi = zi - wi xi+1 para i = n - 1, n -2, ...,1

El procedimiento mostrado a continuación resuelve un sistema tridiagonal expresado en

términos de los vectores a, b, c y d. El algoritmo supone satisfechas las condiciones que
garantizan la solución única del sistema.

procedure tridiagonal(n, (ai), (bi), (ci), (di), (xi))

integer n, i
real array (ai)1:n, (bi)1:n, (ci)1:n, (di)1:n, (xi)1:n, (vi)1:n, (ri)1:n, (wi)1:n, (zi)1:n
//
// Este procedimiento resuelve un sistema de ecuaciones tridiagonales mediante
// factorización LU.
// Descripción de parámetros:
// n Número de ecuaciones y de incógnitas.
// a Vector que almacena a la subdiagonal del sistema, de n elementos. El
// primer elemento de este vector, a1, es igual a cero.
// b Vector que almacena a la diagonal del sistema, de n elementos.
// c Vector que almacena a la superdiagonal del sistema, de n elementos.
// El último elemento de este vector, cn, es igual a cero.
// d Vector que almacena los términos del lado derecho del sistema.
// x Vector solución, de n elementos.
//
r1 ← b1

24
w1 ← c1 / r1
for i = 2 to n -1 do
vi ← ai
ri ← bi - vi*wi-1 // i-ésima fila de L
wi ← ci / ri // (i+1)-ésima columna de U
end for
vn ← an // n-ésima fila de L
rn ← bn – vn*wn-1
//
// solución de Lz = b
//
z1 ← d1 / r1
for i = 2 to n do
zi ← (di – vi*zi-1) / ri
end for
//
// solución de Ux = z
//
xn ← zn
for i = n – 1 to 1 step -1 do
xi ← zi – wi*xi+1
end for
return
end procedure tridiagonal

3.5 Métodos iterativos: Jacobi y Gauss Seidel

Dado el sistema lineal

a11 x1 + a12 x2 + a13 x3 + ⋯ + a1n xn = b1

a21 x1 + a22 x2 + a23 x3 + ⋯ + a2n xn = b2
a31 x1 + a32 x2 + a33 x3 + ⋯ + a3n xn = b3
: ∶ ∶
: ∶ ∶
an1 x1 + an2 x2 + an3 x3 + ⋯ + ann xn = bn

es factible despejar a x1 de la primera ecuación, a x2 de la segunda ecuación, a x3 de la

tercera y así sucesivamente:

x1 = ( b1 – a12x2 – a13x3 – .............. – a1nxn ) / a11

x2 = ( b2 – a21x1 – a23x3 – .............. – a2nxn ) / a22

x3 = ( b3 – a31x1 – a32x2 – .............. – a3nxn ) / a33

. .
. .
25
. .
. .

xn = ( bn – an1x1 – an2x2 – .............. – an,n-1xn-1 ) / ann

Entonces se parte de una estimación inicial de la solución, x(0), la cual se sustituye en las
últimas ecuaciones para producir un nueva estimación, x(1) :

x1(1) = ( b1 – a12x2(0) – a13x3(0) – .............. – a1nxn(0) ) / a11

x2(1) = ( b2 – a21x1(0) – a23x3(0) – .............. – a2nxn(0) ) / a22

x3(1) = ( b3 – a31x1(0) – a32x2(0) – .............. – a3nxn(0) ) / a33

. .
. .
. .
. .

xn(1) = ( bn – an1x1(0) – an2x2(0) – .............. – an,n-1xn-1(0) ) / ann

El vector x(1) se sustituye en esas mismas ecuaciones para obtener ahora a x(2). Este
procedimiento se repite entonces para calcular las estimaciones x(3), x(4), x(5), .... . Lo
anterior se puede generalizar mediante las ecuaciones:

x1(k+1) = (b1 – a12x2(k) – a13x3(k) – .............. – a1nxn(k)) / a11

x2(k+1) = (b2 – a21x1(k) – a23x3(k) – .............. – a2nxn(k)) / a22

x3(k+1) = (b3 – a31x1(k) – a32x2(k) – .............. – a3nxn(k)) / a33

. .
. .
. .
. .

xn(k+1) = (bn – an1x1(k) – an2x2(k) - .............. – an,n-1xn-1(k)) / ann

las cuales se pueden escribir en una forma más compacta:

n (k)
bi − ∑j=1 aij xj
(k+1) j≠i
xi = , i = 1,2,3, … , n
aii

Estas ecuaciones definen al método de Jacobi o de los desplazamientos simultáneos.

El proceso termina cuando se cumple alguno de estos criterios de convergencia:

26
1.- ǁx(k+1) – x(k)ǁ < 

2.- ǁx(k+1) – x(k)ǁ / ǁx(k+1)ǁ < 

La tolerancia  es fijada antes de iniciar los cálculos. En ambos criterios, ǁvǁ, define la
norma de un vector v. La norma de un vector se calcula con cualquiera de estas dos
definiciones:

Las normas ǁvǁ2 y ǁvǁ∞ del vector v = [v1,v2,v3, ...,vn]T están

definidas por

ǁvǁ2 = (v12+v22+v32+…+vn2)1/2

ǁvǁ∞ = max(|v1|,|v2|,|v3|, …,|vn|)

A ǁvǁ2 se le conoce como norma euclidiana del vector v.

La distancia entre dos vectores u y v es la norma de la diferencia u - v.

Ejemplo
Encuentre una solución aproximada del sistema

5x1 – x3 + x5 = 4
7x2 + 2x4 = 20
4x3 + x5 = –6
2x2 + 3x4 = 13
2x3 + 5x5 = –12

con el método de Jacobi. Inicie con x(0) = [0, 0, 0, 0, 0]T y tome a ǁx(k+1) – x(k)ǁ2 < 1X10-4
como criterio de convergencia.

Al aplicar el método de Jacobi se generan las ecuaciones:

x1(k+1) = (4.00000 + 1.00000x3(k) – 1.00000x5(k)) / 5.00000

x2(k+1) = (20.00000 – 2.00000x4(k)) / 7.00000

x3(k+1) = (–6.00000 – 1.00000x5(k)) / 4.00000

x4(k+1) = (13.00000 – 2.00000x2(k)) / 3.00000

x5(k+1) = (–12.00000 – 2.00000x3(k)) / 5.00000

que evaluadas en la estimación inicial x(0) permiten calcular la nueva iteración x(1)

x1(1) = (4.00000 + 1.00000x3(0) – 1.00000x5(0)) / 5.00000

x1(1) = (4.00000 + 1.00000*0.00000 – 1.00000*0.00000) / 5.00000 = 0.80000
x2(1) = (20.00000 – 2.00000x4(0)) / 7.00000

27
x2(1) = (20.00000 – 2.00000*0.00000) / 7.00000 = 2.85714
x3(1) = (–6.00000 – 1.00000x5(0)) / 4.00000
x3(1) = (–6.00000 – 1.00000*0.00000) / 4.00000 = –1.50000
x4(1) = (13.00000 – 2.00000x2(0)) / 3.00000
x4(1) = (13.00000 – 2.00000*0.00000) / 3.00000 = 4.33333
x5(1) = (–12.00000 – 2.00000x3(0)) / 5.00000
x5(1) = (–12.00000 – 2.00000*0.00000) / 5.00000 = –2.40000
Con x(1) = [0.80000, 2.85714, –1.50000, 4.33333, 2.40000]T se checa la convergencia del
método:

ǁx(1) – x(0) ǁ2 =√((0.80000 – 0.00000)2 + (2.85714 – 0.00000)2 + (–1.500000 – 0.00000)2 +

(4.33333 – 0.00000)2 + (–2.40000 – 0.00000)2)
ǁx – x(0) ǁ2 = 5.96582
(1)

Como la distancia entre las dos últimas iteraciones, ǁx(1) – x(0)ǁ2, no es menor que 1X10-4,
será necesario calcular al menos una iteración más.

x1(2) = (4.00000 + 1.00000x3(1) – 1.00000x5(1)) / 5.00000

x1(2) = (4.00000 + 1.00000*(–1.50000) – 1.00000*(–2.40000)) / 5.00000 = 0.98000
x2(2) = (20.00000 – 2.00000x4(1)) / 7.00000
x2(2) = (20.00000 – 2.00000*4.33333) / 7.00000 = 1.61905
x3(2) = (–6.00000 – 1.00000x5(1)) / 4.00000
x3(2) = (–6.00000 – 1.00000*(–2.40000)) / 4.00000 = –0.90000
x4(2) = (13.00000 – 2.00000x2(1)) / 3.00000
x4(2) = (13.00000 – 2.00000*2.85714) / 3.00000 = 2.42857
x5(2) = (–12.00000 – 2.00000x3(1)) / 5.00000
x5(2) = (–12.00000 – 2.00000*(–1.50000)) / 5.00000 = –1.80000

ǁx(2) – x(1) ǁ2 = =√((0.98000 – 0.80000)2 + (1.61905 – 2.85714)2 +

(–0.900000 – (–1.50000))2 + (2.42857 – 4.33333)2 +
(–1.80000 – (–2.40000))2)

ǁx(2) – x(1) ǁ2 = 2.43175

Iteración k x1(k) x2(k) x3(k) x4(k) x5(k) ǁx(k) – x(k-1)ǁ2

0 0.00000 0.00000 0.00000 0.00000 0.00000
1 0.80000 2.85714 –1.50000 4.33333 –2.40000 5.96582
2 0.98000 1.61905 –0.90000 2.42857 –1.80000 2.43175
3 0.98000 2.16327 –1.05000 3.25397 –2.04000 1.02837
4 0.99800 1.92744 –0.99000 2.89116 –1.98000 0.44133
5 0.99800 2.03110 –1.00500 3.04837 –2.00400 0.19043
6 0.99980 1.98618 –0.99900 2.97927 –1.99800 0.08288
7 0.99980 2.00592 –1.00050 3.00921 –2.00040 0.03598
8 0.99998 1.99737 –0.99990 2.99605 –1.99980 0.01572
9 0.99998 2.00113 –1.00005 3.00176 –2.00004 0.00684
10 1.00000 1.99950 –0.99999 2.99925 –1.99998 0.00299

28
 11 1.00000 2.00021 –1.00001 3.00033 –2.00000 0.00130
12 1.00000 1.99990 –1.00000 2.99986 –2.00000 0.00057
13 1.00000 2.00004 –1.00000 3.00006 –2.00000 0.00025
14 1.00000 1.99998 –1.00000 2.99997 –2.00000 0.00011
15 1.00000 2.00001 –1.00000 3.00001 2.00000 0.00005

El siguiente es el pseudocódigo de un procedimiento que resuelve al sistema Ax = b con el

método de Jacobi:

procedure Jacobi(n, (Aij), (bi), (xiniciali), , maxiter, (xi), convergencia)

integer n, iter, i, j
real array (Aij)1:n x 1:n, (bi)1:n, (xinicial)1:n, (x)1:n
real , suma, norma2
integer maxiter
boolean convergencia
//
// Este procedimiento encuentra una solución aproximada x del sistema lineal
// Ax = b con el método iterativo de Jacobi.
// Descripción de parámetros:
// n Número de ecuaciones y de incógnitas.
// A Matriz de coeficientes del sistema.
// b Vector de términos del lado derecho del sistema.
// xinicial Vector de estimaciones iniciales.
//  Máximo error permisible. Cuando la norma euclidiana de la
// diferencia entre las dos últimas aproximaciones es menor que ,
// se considera haber llegado a solución.
// maxiter Número máximo de iteraciones.
// x Última iteración calculada. Si en convergencia se devuelve
// true, entonces x también es el vector solución de Ax=b.
// convergencia Bandera cuyo valor indica si hubo convergencia:
// convergencia = true se alcanzó la convergencia
// convergencia = false no se alcanzó la convergencia.
//
convergencia ← true
for iter = 1 to maxiter do
for i = 1 to n do // cálculo de la nueva aproximación x
suma ← 0.0
for j = 1 to n do
if i ≠ j then
suma ← suma + Aij*xinicialj
end if
end for
xi ← (bi – suma) / Aii
end for
suma ← 0.0
for i = 1 to n do

29
 suma ← suma + (xi – xiniciali)2
end for
norma2 ← √(suma)
if norma2 <  then // se checa la convergencia
return
end if
for i =1 to n do // preparación de la siguiente iteración
xiniciali ← xi
end for
end for
convergencia ← false
return
end procedure Jacobi

Al definir las matrices:

a11 0 0 a12 … a1n

a22 a21 0 0
𝐃= 𝐋=[ ] 𝐔=[ ]
⋱ ⋮ ⋱ ⋱
[ ann ] an1 an2 … 0 0

de tal forma que A = D + L + U, entonces

Ax = b

(D + L + U)x = b

Dx = b – (L + U)x

x = D-1[b – (L + U)x]

al incluir la notación de iteraciones

x(k+1) = D-1[b – (L + U)x(k)]

se obtiene la fórmula del método de Jacobi en términos matriciales.

Una forma de acelerar la convergencia del método de Jacobi pudiera ser utilizar una
estrategia de desplazamientos sucesivos: una vez calculada xi(k+1), se sustituye
inmediatamente en la expresión para calcular xi+1(k+1). Las ecuaciones por emplear ahora
son:

x1(k+1) = (b1 – a12x2(k) – a13x3(k) – .............. – a1nxn(k)) / a11

x2(k+1) = (b2 – a21x1(k+1) – a23x3(k) - .............. – a2nxn(k)) / a22

x3(k+1) = (b3 – a31x1(k+1) – a32x2(k+1) - .............. – a3nxn(k)) / a33

30
. .
. .
. .
. .

xn(k+1) = (bn – an1x1(k+1) – an2x2(k+1) - .............. – an,n-1xn-1(k+1)) / ann

las cuales se pueden representar como:

(k+1) (k)
(k+1)
bi − ∑i−1
j=1 a ij xj + ∑nj=i+1 aij xj
xi = , i = 1,2,3, … , n
aii

Esta estrategia define al método de Gauss Seidel o de los desplazamientos sucesivos.

Ejemplo
Resolver el sistema lineal del ejemplo anterior empleando Gauss Seidel. Considere el
mismo vector inicial y también idéntico criterio de convergencia.

Las ecuaciones del método de Gauss Seidel son:

x1(k+1) = (4.00000 + 1.00000x3(k) – 1.00000x5(k)) / 5.00000

x2(k+1) = (20.00000 – 2.00000x4(k)) / 7.00000

x3(k+1) = (–6.00000 – 1.00000x5(k)) / 4.00000

x4(k+1) = (13.00000 – 2.00000x2(k+1)) / 3.00000

x5(k+1) = (–12.00000 – 2.00000x3(k+1)) / 5.00000

Con con x(0) = [0, 0, 0]T, entonces

x1(1) = (4.00000 + 1.00000x3(0) – 1.00000x5(0)) / 5.00000

x1(1) = (4.00000 + 1.00000*0.00000 – 1.00000*0.00000) / 5.00000 = 0.80000
x2(1) = (20.00000 – 2.00000x4(0)) / 7.00000
x2(1) = (20.00000 – 2.00000*0.00000) / 7.00000 = 2.85714
x3(1) = (–6.00000 – 1.00000x5(0)) / 4.00000
x3(1) = (–6.00000 – 1.00000*0.00000) / 4.00000 = –1.50000
x4(1) = (13.00000 – 2.00000x2(1)) / 3.00000
x4(1) = (13.00000 – 2.00000*2.85714) / 3.00000 = 2.42857
x5(1) = (–12.00000 – 2.00000x3(1)) / 5.00000
x5(1) = (–12.00000 – 2.00000*(–1.50000)) / 5.00000 = –1.80000

Ahora con x(1) = [0.80000, 2.85714, –1.50000, 2.42857, –1.80000]T se checa la

convergencia del método:

31
ǁx(1) – x(0) ǁ2 =√((0.80000 – 0.00000)2 + (2.85714 – 0.00000)2 + (–1.500000 – 0.00000)2 +
(2.42857 – 0.00000)2 + (–1.80000 – 0.00000)2)
ǁx – x ǁ2 = 4.49346
(1) (0)

Como  = 1X10-4, se requiere al menos de una iteración adicional:

x1(2) = (4.00000 + 1.00000x3(1) – 1.00000x5(1)) / 5.00000

x1(2) = (4.00000 + 1.00000*(–1.50000) – 1.00000*(–1.80000) / 5.00000 = 0.86000
x2(2) = (20.00000 – 2.00000x4(1)) / 7.00000
x2(2) = (20.00000 – 2.00000*0.00000) / 7.00000 = 2.16327
x3(2) = (–6.00000 – 1.00000x5(1)) / 4.00000
x3(2) = (–6.00000 – 1.00000*0.00000) / 4.00000 = –1.05000
x4(2) = (13.00000 – 2.00000x2(2)) / 3.00000
x4(2) = (13.00000 – 2.00000*2.16327) / 3.00000 = 2.89116
x5(2) = (–12.00000 – 2.00000x3(2)) / 5.00000
x5(2) = (–12.00000 – 2.00000*(–1.50000)) / 5.00000 = –1.98000

ǁx(1) – x(0) ǁ2 =√((0.86000 – 0.80000)2 + (2.16327 – 2.85714)2 + (–1.05000 – (–1.500000))2

+ (2.89116 – 2.42857)2 + (–1.98000 – (–1.8000))2)
ǁx – x ǁ2 = 0.96641
(1) (0)

Iteración k x1(k) x2(k) x3(k) x4(k) x5(k) ǁx(k) – x(k-1)ǁ2

0 0.00000 0.00000 0.00000 0.00000 0.00000
1 0.80000 2.85714 –1.50000 2.42857 –1.80000 4.49346
2 0.86000 2.16327 –1.05000 2.89116 –1.98000 0.96641
3 0.98600 2.03110 –1.00500 2.97927 –1.99800 0.20846
4 0.99860 2.00592 –1.00050 2.99605 –1.99980 0.03313
5 0.99986 2.00113 –1.00005 2.99925 –1.99998 0.00592
6 0.99999 2.00021 –1.00001 2.99986 –2.00000 0.00111
7 1.00000 2.00004 –1.00000 2.99997 –2.00000 0.00021
8 1.00000 2.00001 –1.00000 2.99999 –2.00000 0.00004

En general, Gauss Seidel es más rápido que Jacobi.

Ahora, un procedimiento para resolver un sistema Ax = b con el método de Gauss Seidel:

procedure Gauss_Seidel(n, (Aij), (bi), (xiniciali), , maxiter, (xi), convergencia)

integer n, iter, i, j
real array (Aij)1:n x 1:n, (bi)1:n, (xinicial)1:n, (x)1:n
real , suma, norma2
integer maxiter
boolean convergencia
//
// Este procedimiento encuentra una solución aproximada x del sistema lineal
// Ax = b con el método iterativo de Gauss Seidel.
// Descripción de parámetros:
// n Número de ecuaciones y de incógnitas.

32
// A Matriz de coeficientes del sistema.
// b Vector de términos del lado derecho del sistema.
// xinicial Vector de estimaciones iniciales.
//  Máximo error permisible. Cuando la norma euclidiana de la
// diferencia entre las dos últimas aproximaciones es menor que
// , se considera haber llegado a solución.
// maxiter Número máximo de iteraciones.
// x Última iteración calculada. Si en convergencia se devuelve
// true, entonces x también es el vector solución de Ax=b.
// convergencia Bandera cuyo valor indica si hubo convergencia:
// convergencia = true se alcanzó la convergencia
// convergencia = false no se alcanzó la convergencia.
//
convergencia ← true
for iter = 1 to maxiter do
for i = 1 to n do // cálculo de la nueva aproximación x
suma ← 0.0
for j = 1 to i -1 do
suma ← suma + Aij*xj
end for
for j = i + 1 to n do
suma ← suma + Aij*xinicialj
end for
xi ← (bi – suma) / Aii
end for
suma ← 0.0
for i = 1 to n do
suma ← suma + (xi – xiniciali)2
end for
norma2 ← √(suma)
if norma2 <  then // se checa la convergencia
return
end if
for i =1 to n do // preparación de la siguiente iteración
xiniciali ← xi
end for
end for
convergencia ← false
return
end procedure Gauss_Seidel

Gauss Seidel también puede ser expresado en términos matriciales:

x(k+1) = D-1[b – Ux(k) – Lx(k+1)]

en donde las matrices D, U y L se definen igual que en la fórmula matricial de Jacobi.

33
La condición suficiente pero no necesaria que garantiza la convergencia tanto de Jacobi
como de Gauss Seidel para cualquier vector inicial x(0) es que la matriz de coeficientes del
sistema sea estrictamente diagonal dominante. A continuación, la definición de una matriz
estrictamente diagonal dominante.

Una matriz A de n x n es estrictamente diagonal dominante si

y sólo si
n
|aii| > ∑ |aij| para i=1,2,3,…,n
j=1
j≠i

De acuerdo con esta definición, la matriz de coeficientes de los dos últimos ejemplos es
estrictamente diagonal dominante ya que

|5| > |-1| + |1|

|7| > |2|

|4| > |1|

|3| > |2|

|5| > |2|

Esto asegura la convergencia de ambos métodos para cualquier estimación inicial x(0).

34