Resolución de Sistemas de Ecuaciones Lineales Dispersos

BENEMÉRITA
RITA UNIVERSIDAD AUTONOMA DE PUEBLA
FACULTAD DE CIENCIAS DE LA COMPUTACIÓN
TESIS DE LICENCIATURA
SISTEMAS DE ECUACIONES LINEALES PARA MATRICES

DISPERSAS
QUE PARA OBTENER EL TÍTULO DE
INGENIERO EN CIENCIAS DE LA COMPUTACIÓN
PRESENTA
ALBERTO ROMÁN FLORES
ASESOR DE TESIS:
ESIS: DRA. LOURDES SANDOVAL SOLÍ
SOLÍS
PUEBLA, PUE. 2012

Resolución de Sistemas de Ecuaciones Lineales Dispersos 2012
AGRADECIMIENTOS
A toda mi familia, en especial a mi madre por su apoyo en los

momento más difíciles, a mi hermano Agustín por su paciencia y
apoyo, a mis profesores por sus enseñanzas, a la Dra. Lourdes por la
paciencia y apoyo que me ha brindado en la realización de esta tesis.
2
INDÍCE
INTRODUCCIÓN ........................................................................................................................
CAPÍTULO 1 CONCEPTOS BÁSICOS ........................................................................................ 9
Definición 1.1 Matriz Dispersa ............................................................................................ 9
Definición 1.2 Sistema de Ecuaciones Lineales ................................................................... 9
Teorema 1 ......................................................................................................................... 11
Definición 1.3 Factorización LU ......................................................................................... 12
Definición 1.4 Residuo....................................................................................................... 20
Teorema 2 ......................................................................................................................... 20
Definición 1.5 .................................................................................................................... 21
Teorema 3 ......................................................................................................................... 21
CAPÍTULO 2 GENERACIÓN DE MATRICES DISPERSAS ........................................................ 22
CAPÍTULO 3 ESQUEMAS DE ALMACENAMIENTO PARA MATRICES DISPERSAS................. 25
3.1 ESQUEMA COORDENADO ........................................................................................... 26

3.2 ESQUEMA DE ALMACENAMIENTO CSR ....................................................................... 27
3.3 ESQUEMA MSR ............................................................................................................ 30
CAPÍTULO 4 REORDENAMIENTO DE MATRICES DISPERSAS ............................................... 33
4.1 ALGORITMO DE CUTHILL-MCKEE ................................................................................ 33

4.2 CUTHILL-MCKEE EXPLÍCITO ......................................................................................... 34
4.3 CUTHILL-MCKEE IMPLÍCITO ......................................................................................... 42
CAPÍTULO 5 PRUEBAS .......................................................................................................... 51
CONCLUSIONES .................................................................................................................... 59
BIBLIOGRAFÍA ....................................................................................................................... 60
3
INTRODUCCIÓN
El problema de minimizar o reducir el ancho de banda (Bandwidth Minimization
Problem (BMP)) de matrices, se originó en 1950 cuando los ingenieros estudiaron
los marcos de acero haciendo uso de las computadoras [1] [2] [3]. El BMP se
encuentra en un gran número de aplicaciones entre las que podemos mencionar:
• Solución de Sistemas de Ecuaciones Lineales Grandes.
• Ecuaciones Diferenciales.
• Diseño de Circuitos.
• Hipertextos.
• Sistemas de Transmisión de Alta Potencia, entre otras más.
Por esta razón el BMP es un tema muy importante que se estudia día con día con
el objetivo de implementar algoritmos que resuelvan dicho problema.
El BMP consiste en encontrar una permutación de filas y columnas de tal forma
que los elementos diferentes de ceros de la matriz estén lo más cerca de la
diagonal.
Ahora nos enfocaremos en una de las aplicaciones mencionadas: la solución de
Sistemas de Ecuaciones Lineales, para ello trabajaremos con matrices dispersas.
El término de matriz dispersa se le atribuye al economista Harry Markowitz [L1]
quien al analizar modelos de actividad industrial en la Rand Corporation
durante1950, observó que al trabajar con matrices la mayoría de sus elementos
eran ceros.
4
William Orchand-Hayes fue el primero en implementar un código para matrices
dispersas. La investigación y los trabajos realizados sobre este tipo de matrices
son ahora de mucha importancia, ya que son estándares que se utilizan en
códigos de programación lineal [L1].
Por su trabajo Harry Markowitz fue premiado en 1989 con el Premio Von Neumann
por la Sociedad de Investigación de Operaciones de América y en 1990 recibió el
Premio Nobel en Ciencias Económicas [L2].
Por otra parte Ralph Arthur Willoughby [L1] fue otro de los pioneros de la
utilización de las matrices dispersas, cuando intento resolver sistemas de
ecuaciones a gran escala, al trabajar en la simulación de circuitos. Junto con su
compañero Werner Liniger, observaron que las ecuaciones con las que trabajaban
eran muy grandes y dispersas. Los primeros códigos desarrollados fueron para
resolver problemas específicos de este tipo, tiempo después Fred Gustavson un
compañero de trabajo de ellos en IBM, creó un programa de Factorización
Triangular Simbólica, el cual genera código en Fortran para cualquier problema.
Antes de estas investigaciones, la matrices dispersas de gran tamaño se resolvían
utilizando métodos iterativos, ya que los métodos directos eran considerados
apropiados para trabajar con matrices pequeñas.
Ralph Willoughby y su equipo de trabajo en IBM, desarrollaron técnicas para
resolver la simulación de circuitos electrónicos. Las técnicas desarrolladas también
se aplicaron en otros problemas como: programación lineal, análisis de sistemas
de potencia, análisis estructural, entre otros. Él organizó el primer “Symposium on
5
Sparse Matrices and Their Applications”, el encuentro fue financiado por la IBM T.J
Watson Research Center in Yorktown Heights, New York, September 9-10, 1968.
Las memorias de este Symposium aparecieron sólo como un reporte de la IBM
“Sparse Matrix Proceedings” (RAI 3-12-69), que fue solicitado por mucha gente en
todo el mundo.
En 1971 en el tercer encuentro de este Symposium, se presentaron principalmente
trabajos de métodos directos para resolver sistemas de ecuaciones lineales
dispersos grandes, los cuales fueron publicados en 1972 por la IBM [L3].
A través de los años se han desarrollado varios algoritmos para resolver el BMP,
que también nos sirve para resolver sistemas de ecuaciones lineales grandes, la
mayoría de ellos están basados en teoría de grafos, entre los más importantes
podemos mencionar: el algoritmo de Cuthill-Mckee propuesto en 1969, también
tenemos el algoritmo de Grado Mínimo que fue propuesto por Tinney y Walker en
1967 que se utiliza para reducir el fill-in cuando se utiliza el método de eliminación
Gaussiana, otro algoritmo es el inverso de Cuthill-Mckee desarrollado por George
en 1971 que es una mejora de Cuthill-Mckee [14].
En cuanto a los métodos para resolver sistemas de ecuaciones lineales, hay dos
tipos, los métodos directos y los iterativos, dentro de los métodos directos mas
comunes tenemos el método de eliminación gaussiana propuesto por Johann
Friedrich Gauss que también propuso el método de factorización LDLT, también
tenemos el método de factorización LU que Doolitle propuso, por último tenemos
el método de factorización de Cholesky creado y propuesto por el Mayor Andre-
6
Luis Cholesky, que fue publicado por el comandante Benoit en 1924 en la revista
“Bulletin geodesique” desde la pagina 67-77 [L4].
Dentro de los métodos iterativos tenemos el método de Jacobi que fue creado y
propuesto por el matemático alemán Carl Gustav Jakob Jacobi [9], también está el
método de Gauss-Seidel el cual fue propuesto y nombrado así en honor a los
matemáticos Carl Friederich Gauss y Phillip Ludwing Von Seidel [9].
Los sistemas de ecuaciones lineales siempre han estado presentes en nuestra
vida diaria, en el pasado resolver dichos sistemas era complicado y muy laborioso
ya que el tiempo que se invertía para solucionarlos era demasiado
Por otro lado existen diferentes esquemas de almacenamiento para trabajar con
este tipo de matrices, dentro de lo más utilizados están el Esquema Coordenado,
el Esquema Compressed Sparse Row (CSR), el Esquema Compressed Column
(CSC), y el Esquema Modified Sparse Row (MSR) [5] [6] [10] [7] [4] [14].
A continuación procedemos a definir el esquema de esta tesis:
• Capítulo 1. Conceptos Básicos.
• Capítulo 2. Generación de Matrices Dispersas.
• Capítulo 3. Esquema de Almacenamiento.
• Capítulo 4. Algoritmo de Cuthill-Mckee Explícito e Implícito.
• Capitulo 5. Pruebas.
• Conclusiones.
• Bibliografía.
7
En el primer capítulo vamos a definir los conceptos que vamos a utilizar
durante el desarrollo de la tesis, en el capítulo 2 explicaremos como generar
las matrices dispersas con las que vamos a trabajar, el capítulo 3 trata acerca
de los esquemas de almacenamiento para poder guardar nuestras matrices, ya
en el capítulo 4 se explica el algoritmo de Cuthill-Mckee y la implementación de
tal algoritmo, ya en el capítulo 5 se presentan las pruebas y resultados que
obtuvimos al aplicar el algoritmo de Cuthill-Mckee para resolver los sistemas de
ecuaciones lineales asociados a las matrices que hemos generado, por último
se presentan las conclusiones del trabajo y la bibliografía que se utilizo.
8
CAPÍTULO 1 CONCEPTOS BÁSICOS
Primero comenzaremos dando algunas definiciones que utilizaremos a lo largo del
trabajo como: matriz dispersa, sistema de ecuaciones lineales, factorización y
residuo.
Definición 1.1: MATRIZ DISPERSA
Una matriz dispersa es una matriz en la que la mayor parte de sus elementos son
ceros.
A continuación se muestra un ejemplo de este tipo de matrices
1 0 0 2 0 0 0 0 3 0 
0 4 0 0 5 0 6 0 0 7 

0 0 8 0 0 9 10 0 0 0 
 
11 0 0 12 0 0 0 0 0 0 
0 13 0 0 14 0 0 0 15 0 
A= 
0 0 16 0 0 17 0 18 0 19 
0 20 21 0 0 0 23 0 24 0 
 
0 0 0 0 0 25 0 26 27 0 
28 0 0 0 29 0 30 31 32 0 
 
0 0 0 0 0 0 0 0 0 33
Matriz dispersa de 10 x 10
Definición 1.2: SISTEMA DE ECUACIONES LINEALES
Un sistema de ecuaciones lineales es un conjunto de ecuaciones que tiene m
ecuaciones con incógnitas, además de un vector de términos independientes.
9
Cabe aclarar que los sistemas de ecuaciones con los que trabajaremos son
cuadrados, es decir tienen el mismo número de ecuaciones que de incógnitas, así
un sistema de ecuaciones lineales se representa en forma matricial de la siguiente
forma:
 a11 L a1n   x1   b1 
     
M O M  * M  = M 
a  x  b 
 n1 L a nn   n  n
Representación Matricial de un Sistema de Ecuaciones Lineales
Como se puede observar los elemento de nuestra matriz representan los
coeficientes de cada ecuación, el vector es de tamaño

y representan las
incógnitas de nuestras ecuaciones, por último el vector b que tiene el mismo
tamaño que el vector es el vector de términos independientes asociado a
nuestro sistema de ecuaciones lineales [9], en general nuestra sistema de
ecuaciones lineales se expresa en forma matricial como sigue:
Ax = b
Cabe señalar que al resolver sistemas de ecuaciones lineales podemos tener tres
tipos de soluciones que son:
a) el sistema de ecuaciones lineales puede tener solución única, es decir, hay
un solo valor para cada incógnita del sistema.
b) otro caso que se puede dar es que el sistema tenga una familia de
soluciones, esto quiere decir que algunas incógnitas son dependientes de
10
otras y pueden tomar cualquier valor y las incógnitas restantes están en
función de estas.
c) el último caso que puede darse es que el sistema no tenga solución, es
decir, el sistema de ecuaciones lineales es inconsistente.
Cuando nuestra matriz es no singular, es decir que su determinante es diferente
de cero, el sistema de ecuaciones tiene una solución única, si la matriz es
singular entonces el sistema de ecuaciones no tiene solución o puede tener una
familia de soluciones.
Se sabe que si el determinante de nuestra matriz es diferente de cero la matriz es
invertible, es decir existe su inversa, en caso de que el determinante sea cero la
matriz no tiene inversa, a continuación se presenta el siguiente teorema que
garantiza que el sistema de ecuaciones asociado a la matriz tiene solución única:
Teorema 1 [12]
Sea

un sistema de ecuaciones lineales. Si A es invertible, el sistema tiene
una solución única, más aun la solución es de la forma

. La
demostración de este teorema se encuentra en [12].
Como se mencionó previamente en la introducción existen principalmente dos
tipos de métodos para resolver este tipo de sistemas, que son los métodos
directos y los métodos iterativos
Dentro de los métodos directos tenemos los siguientes:
1. Método de Eliminación Gaussiana.
11
2. Factorización .
3. Factorización de Cholesky.
4. Factorización .
5. Factorización .
En lo que respecta a los métodos iterativos tenemos:
1. Método de Jacobi.
2. Método de Gauss –Seidel.
3. Método SOR.
4. Método de Gradientes Conjugados.
En este trabajo resolveremos sistemas de ecuaciones lineales que tengan
solución única y el método que utilizaremos para resolver dichos sistemas será
Factorización .
Definición 1.3: FACTORIZACION LU [11] [13] [9]
El método de Factorización es uno de los más utilizados para resolver
Sistemas de Ecuaciones Lineales, esta factorización nos permite descomponer
una matriz en dos, una matriz triangular inferior y otra matriz triangular superior
denotadas por y respectivamente de tal forma que:
A = LU
Este método es eficiente cuando se quieren resolver varios sistemas de
ecuaciones lineales en donde las matrices de coeficientes son las mismas, lo
único que varia son los términos independientes de los sistemas de ecuaciones
12
lineales. A continuación se presenta un ejemplo de como se factoriza una matriz
de orden tres por tres
a11 a12 a13  1 0 0  u11 u12 u13 

a     u 23 
 21 a 22 a 23  = l 21 1 0 0 u 22
a31 a32 a33  l31 l32 1 0 0 u 33 
Factorización LU de una matriz de orden 3 x 3
Conviene observar que los elementos de la diagonal de valen 1. Para evaluar
y de la ecuación anterior sin pivoteo, primero multiplicamos el primer
renglón de por cada columna de y comparamos el resultado con el primer
renglón de . Tenemos entonces que el primer renglón de es idéntico al de :

Multiplicamos el segundo y tercer renglón de por la primera columna de , y lo
comparamos con el lado izquierdo para obtener:

O en forma equivalente

Multiplicamos el segundo renglón de por la segunda y tercera columna de y
las comparamos con el lado izquierdo para obtener:

O bien
13

!

!

Multiplicamos el tercer renglón de por la segunda columna de y tenemos:

O en forma equivalente
" !
#
Finalmente, se obtiene multiplicando la última columna de por el último
renglón de y lo igualamos a como sigue:

O bien

!
!

El esquema general de la factorización para una matriz de orden N es el
siguiente:
1. El primer renglón de , para j = 1 hasta N, se obtiene por medio de

$%&
'.
2. La primera columna de , para i = 2 hasta N, se obtiene por medio de
(
+ )*
, -
$%&
'
**
3. El segundo renglón de se obtiene como

!

-
$%&
'
14
4. La segunda columna de se obtiene mediante
"().
/.* +*. #
,
$%&
'
+..
5. El n-ésimo renglón de se obtiene de
0
0 !
10
24 02 23

$%&
'
6. La n-ésima columna de se obtiene de
"()5
157*
68* /)6 +65 #
0

,
$%&
'
+55
Ahora estudiemos las formas para resolver un conjunto de ecuaciones lineales. La
ecuación

9 se puede escribir como:
: ;
Donde

, la ecuación anterior se resuelve como sigue. Sea
: <
Entonces la ecuación queda
< ;
La solución de la ecuación anterior para z es fácil, debido a la forma triangular de
. Una vez que se conoce z, se resuelve

= en términos de .
Para una matriz de orden N, las sustituciones hacia adelante y hacia atrás se
resumen de la siguiente forma:
15
Paso de sustitución hacia adelante
<
;

<
; !
>? < @
, - A '
4
Paso de la sustitución hacia atrás
<B
:B
BB
C< !
1B
4D : E
:

, ' ! ' ! - A 3 -

En el caso de una matriz de 3 x 3 tenemos:
F
<

;
>
F@
G <
H
G ;
H

<
;
La solución se calcula en forma recursiva como:
< ;
< C; !
< E
< C; !
< !
< E
Escribimos la ecuación

= en forma más explícita:

:

<
G F

H
G :
H
G <
H
F
:
<
16
Y la solución es
<
:

< !
:
:

< !
: !
:
:

Cabe señalar que la factorización se puede llevar a cabo si la matriz no es
estrictamente dominante diagonalmente pero en este caso se tendrían que hacer
intercambios de renglones en la matriz y la factorización de seria I

donde I es una matriz de permutación en la que se indican los intercambios de
renglones que se harán en la matriz.
A continuación se muestra el código de la función que se implemento para la
factorización
function [L, U]= factorizacion(A,n)

A;
L=eye(n);
%Proceso de eliminacion Gaussiana
for i=1:n
for j=1:n+1
if (i==j)
if(A(i,j)==0)
for r=i+1:n
if(A(r,j)~=0)
17
ind=r;
c=A(i,:);
A(i,:)=A(r,:);
A(r,:)=c;
for k=r+1:n
piv=-(A(k,j)/A(i,j));
A(k,:)=piv*A(i,:)+A(k,:);
end
end
end
else
for k=i+1:n
if j<n
piv=-(A(k,j)/A(i,j));
A(k,:)=piv*A(i,:)+A(k,:);
L(k,j)=-1*piv;
end
end
end
end
end
end
U=A;
L;
Como se observa en el código primero creamos una matriz de tamaño , donde
es la dimensión de nuestra matriz, con unos en la diagonal ya que la matriz de
acuerdo a la definición tiene unos en la diagonal. Después comenzamos con el
18
proceso de eliminación gaussiana primero verificamos que el elemento de la
diagonal sea diferente de cero si lo es entonces a la variable JKL toma el valor de
dividir el valor del elemento de abajo entre el elemento de la diagonal con signo
menos, a la matriz en esa posición se le asigna el valor de – N JKL, después se
multiplica todo el renglón del elemento de la diagonal por este JKL y se suma al
renglón de abajo, dicho resultado sustituye al renglón que estén por debajo del
elemento de la diagonal, este proceso se repite hasta que se llegue al último
elemento de la diagonal, por último a la matriz le asignamos la matriz que
resulta después de efectuar dichas operaciones, si el elemento de la diagonal es
cero entonces buscamos un elemento diferente de cero en los renglones
siguientes hasta encontrarlo y realizamos los pasos explicados anteriormente, en
nuestro caso como nuestra matriz es estrictamente dominante diagonalmente el
elemento de la diagonal será siempre diferente de cero y es por eso que se
garantiza que no se harán intercambios de renglones.
La factorización está considerada como un método directo que nos sirve para
resolver sistemas de ecuaciones lineales, sin embargo para poder utilizar este
método de factorización tenemos que tener en cuenta ciertos aspectos, en este
trabajo la matriz con la que trabajamos debe ser estrictamente dominante
diagonalmente, esto nos permite asegurar que podemos aplicar sin necesidad
de intercambiar filas o columnas de nuestra matriz, además nos garantiza la
existencia de una solución única, estas definiciones se encuentran en el
capítulo de Conceptos básicos y están definidas en los teoremas 2 y 3, mientras
19
que la definición de matriz estrictamente dominante diagonalmente está en la
definición 1.5
Definición 1.4: RESIDUO
Sea Ax = b un sistema de ecuaciones lineales. Sea x’ una solución numérica de
dicho sistema. Se define el residuo como:
residuo = b − Ax '
El residuo es un término importante ya que nos sirve para saber que tan buena es
la solución que obtenemos al resolver nuestro sistema de ecuaciones.
A continuación se mencionan algunos teoremas que nos permiten asegurar
cuando podemos utilizar la factorización LU para resolver el sistema de
ecuaciones lineales y que garantizan que dicho sistema tenga solución única,
además de que también nos aseguramos de que la eliminación gaussiana se
realiza sin intercambio de renglones.
Teorema 2 [9]
Si la eliminación gaussiana puede realizarse en un sistema lineal Ax=b sin
intercambio de renglones, entonces la matriz A se puede factorizar como el
producto de una matriz triangular inferior L y una matriz triangular superior U.
O

20
Definición 1.5 [9]
Sea A una matriz de orden n x n. Se dice que A es estrictamente diagonalmente
dominante cuando:
P P Q ? R R
4
S
Se cumple para i=1, 2, 3,…, n.
Teorema 3 [9]
Si A es una matriz estrictamente diagonalmente dominante, entonces A es no
singular.
Además, en este caso, la eliminación gaussiana puede realizarse en cualquier
sistema lineal de la forma Ax=b para obtener su solución única sin intercambio de
renglones o columnas.
21
CAPITULO 2 GENERACIÓN DE MATRICES DISPERSAS
En este capitulo se realiza una breve descripción del procedimiento que se realizó
para la generación de matrices dispersas, las cuales son objeto de estudio para
este trabajo.
Para generar nuestras matrices dispersas nosotros pedimos al usuario el tamaño
o dimensión de la matriz, así como un valor de dispersión entre 0 y 1 que nos
permitirá hacer un cierto porcentaje de cero en nuestra matriz, luego utilizamos la
función rand para crear una matriz aleatoria de tamaño

, una vez creada la
hacemos simétrica y estrictamente diagonalmente para asegurarnos que no haya
ceros en la diagonal y asegurar la existencia de la factorización , después
checamos si cada elemento de la matriz es menor o igual que el valor de
dispersión entonces el elemento se vuelve cero si es mayor entonces el elemento
se vuelve uno, también utilizamos esta función para generar el vector T de
términos independientes.
A continuación se muestra el código de la función que implementamos para
generar matrices dispersas:
function [A, B]=generamatriz (n, density)

E=eye(n);
E=diag(1:n);
A=rand(n);
A=A+E;
%Hacer A simétrica
22
S=(A+A')/2;
A=S;
%Hacer A estrictamente dominante
for i=1:n
A(i,i)=A(i,i)*50*n;
end
A(find(A<=density))=0;
figure(1);
spy(A)
B=rand(n,1);
Enseguida se muestra una matriz generada a partir de la función que
implementamos:
Matriz Dispersa de orden 6 x 6
Para poder visualizar nuestra matriz utilizamos la función spy que nos provee
MATLAB a continuación se muestra la Gráfica de una matriz dispersa de orden
100 x 100:
23
Figura 1 Gráfica de una matriz dispersa de orden 100 x 100
24
CAPITULO 3 ESQUEMAS DE ALMACENAMIENTO PARA
MATRICES DISPERSAS
En el capitulo anterior se implementó un procedimiento para generar matrices
dispersas. Ahora nuestro objetivo es poder almacenarlas para poder trabajar con
ellas.
Existen una gran variedad de esquemas de almacenamiento, que nos permiten
trabajar con matrices dispersas grandes entre los más importantes podemos
mencionar [5] [6] [10] [14]:
• Esquema de Almacenamiento Coordenado.
• Esquema de Almacenamiento Compressed Sparse Row (CSR).
• Esquema Modified Sparse Row (MSR).
Una vez que generamos la matriz dispersa con la que vamos a trabajar, debemos
buscar una forma de almacenarla en memoria ya que las matrices que vamos a
manejar son muy grandes, tenemos el problema de almacenar dichos elementos.
En este capítulo se dan ciertos detalles de los tipos de almacenamiento
mencionados y el que se implementará para este trabajo es el Esquema CSR, ya
que este es uno de los esquemas mas utilizados en la bibliografía
25
3.1 ESQUEMA COORDENADO
Este método es el más fácil de entender e implementar, consta de tres arreglos de
longitud U=, donde U= representa el número de elementos diferentes de cero de
la matriz con la que estemos trabajando, El primer arreglo val contiene el valor de
todos los elementos diferentes de cero, el arreglo ifi

contiene el índice del renglón
en el que está almacenado dicho elemento, y finalmente el arreglo icol contiene el
índice de la columna en el que está ese elemento.
Por ejemplo supongamos que tenemos la siguiente matriz de tamaño 5x5
F
_
F h
^ g
O ^ b
e g
^F
F
F

F
g
] F
F
- f
Matriz de orden 5 x 5
Entonces al aplicar el esquema de almacenamiento coordenado, la matriz estaría
representada como sigue:
Lij
F

-
KkK
Klmj
A continuación se muestra el pseudocódigo para implementar este esquema de
almacenamiento
26
Para i desde 1 hasta n hacer

Para j desde 1 hasta m hacer
Si A (i, j) diferente de cero entonces hacer
Val (i) = A (i, j);
Ifi (i) = i;
Icol (i) = j;
End_Si
End_Para
End_Para
Ahora supongamos que tenemos los tres arreglos anteriores y queremos obtener
la matriz a partir de ellos, a continuación se presenta el pseudocódigo para
implementarlo:
Para i=1 hasta longitud del vector ifi hacer

A (ifi (i), icol (i)) = val (i);
End_Para
3.2 ESQUEMA DE ALMACENAMIENTO CSR
Este método es uno de los más usados para trabajar con matrices dispersas,
también es de fácil de implementar, consta de tres arreglos, dos de, los cuales
tienen longitud U=, es decir tiene que ver con la cantidad de elementos diferentes
de cero, y el último arreglo tiene longitud , donde es el número de filas de
la matriz. El primer arreglo val contiene el valor de los elementos diferentes de
cero, el arreglo ico contiene el índice de la columna en el que está almacenado
27
dicho elemento, por último el arreglo ia contiene punteros que delimitan el
inicio de cada renglón
Para ver el esquema de almacenamiento CSR veamos el siguiente ejemplo:
supongamos que tenemos la siguiente matriz de 5 x 5:
1 0 0 2 0
3 4 0 5 0 

A = 6 0 7 8 9 
 
0 0 10 11 0 
0 0 0 0 12
Aplicando este esquema de almacenamiento a la matriz anterior obtenemos:
Lij

F

-
Klm

Ki

F
-

Enseguida se muestra el pseudocódigo para implementar el esquema CSR:
Índice =1;
Cont=1;
Ia (1) = 1;
Para i=1 hasta n hacer
Para j=1 hasta m hacer
Si A (i, j) diferente de cero entonces hacer
Val (índice) = A (i, j);
Ico (índice) = j;
28
Índice = índice + 1;
Cont = Cont +1;
End_Si
End_Para
Ia (i+1) = Cont;
End_Para
Así es como trabaja el esquema de almacenamiento CSR, ahora bien, si nosotros
tuviéramos solamente estos tres vectores ¿como podemos recuperar un elemento
de nuestra matriz? o mejor aun ¿como podemos saber cual es la matriz original?
Luego de pensarlo detenidamente observamos que esto se podía resolver de la
siguiente manera:
Con ayuda del arreglo ia, obtenemos el número de elementos que tenemos que
leer por fila, para obtener dicho número hacemos la diferencia entre el elemento
ia
(ii )
ia
( )
––
ia
(i) después con este resultado procedemos a leer los índices de las
columnas correspondientes que obtenemos del arreglo ico, finalmente con el
número de fila y el número de columna procedemos a asignar a nuestra matriz en
dicha posición el elemento no nulo el cual se obtiene del arreglo val.
Supongamos que tenemos los siguientes vectores:
Lij

-

`
a
b
c
d
e
F

-
Klm

Ki

F
-

29
Para obtener la matriz original a partir de estos tres vectores, tenemos el siguiente
pseudocódigo de la función que nos permite hacer esto:

Para j = ia (i) hasta ia (i+1) - 1 hacer
A (i, ico (j)) = val (j);
End_Para
End_Para
Al aplicar esta función descrita anteriormente obtenemos la siguiente matriz:
1 0 0 2 0
3 4 0 5 0 

A = 6 0 7 8 9 
 
0 0 10 11 0 
0 0 0 0 12
3.3 ESQUEMA MSR
El esquema Modified Sparse Row (MSR) a diferencia de los dos esquemas
anteriores, solo maneja dos vectores de longitud U=

, donde U= representa el
número de elementos distintos de cero. Las primeras posiciones del arreglo AA
contienen los elementos de la diagonal de la matriz en orden, la posición
comúnmente no se utiliza, a partir de la posición q se almacenan los
elementos diferentes de cero por renglón, excluyendo los elementos de la diagonal
que ya tenemos almacenados.
30
Por otra parte las primeras posiciones del otro arreglo JA contiene el puntero
al inicio de cada elemento diferente de cero de cada renglón, a partir de la
posición q se almacenan los índices de las columnas donde están los
elementos distintos de cero.
Aplicando este esquema a la matriz del ejemplo anterior, obtenemos:
OO

-
N
F
sO
F

`
`
Enseguida se muestra el pseudocódigo para implementar dicho esquema de
almacenamiento:
Ind = n+2;
JA (1) = ind;
Para j=1 hasta m hacer
Si i es igual a j entonces hacer
AA (i) = A (i, i);
Si no entonces hacer
Si i diferente de j y A (i, j) diferente de cero entonces hacer
AA (ind) = A (i, j);
JA (ind) = j;
Ind = ind +1;
End_Si
End_Si
End_Para
31
JA (i+1) = ind;
End_Para
Si queremos recuperar la matriz original a partir de estos dos vectores, a
continuación de muestra el pseudocódigo de la función que nos permite hacer
esto:
Temp = 1;
Indi = 1;
Clave = n+1;
A (i, i) = AA (i);
Dif =JA (indi +1) – JA (indi);
Mientras Temp sea menor o igual Dif hacer
A (i, JA (clave + indi)) = AA (clave + indi);
Indi = indi + 1;
Temp = temp + 1;
End_Mientras
Temp = 1;
End_Para
32
CAPITULO 4 REORDENAMIENTO DE MATRICES
DISPERSAS
En este capítulo se aborda el ordenamiento de las matrices dispersas que se
hayan generado y almacenado. Existen varios algoritmos de ordenamiento entre
los que destacan:
1. Algoritmo de Cuthill-Mckee [8] [14].
2. Algoritmo inverso de Cuthill-Mckee.
3. Algoritmo de Mínimo Grado.
4. Algoritmo de Conteo por columnas.
En este trabajo nosotros trabajamos con el algoritmo de Cuthill-Mckee, así que
implementamos el algoritmo para trabajar con la matriz original al que llamamos
Mckee explícito, y también implementamos el algoritmo para trabajar con el
esquema CSR al que denominamos Mckee implícito, a continuación se describe
cada uno de estos algoritmos.
4.1 ALGORITMO DE CUTHILL-MCKEE
El primer algoritmo que se implemento para reordenar matrices dispersas que
ayudó a reducir el ancho de banda de tales matrices fue el de Cuthill-Mckee,
dicho algoritmo fue publicado por E. Cuthill y J. Mckee en su artículo “Reducing
the bandwidth of Sparse symmetric matrices” en 1969 y esta basado en teoría de
grafos.
33
Este algoritmo consta de los siguientes pasos:
1. Construir una tabla donde se indique el grado de cada uno de los nodos.
2. Elegir un nodo inicial de menor grado.
3. Renumerar los nodos adyacentes al nodo inicial en orden ascendente de
grado, los pasos 2 y 3 se repiten hasta que todos los nodos se hayan
visitados.
Tanto el algoritmo de Cuthill-Mckee Explícito como el Implícito fueron
implementados en base a estos pasos, a continuación se describe cada uno de las
implementaciones de estos algoritmos, comenzando por el método explícito y
posteriormente el implícito
4.2 CUTHILL_MCKEE EXPLÍCITO
1. Primero calculamos el grado de cada uno de los nodos, para ello contamos
el número de nodos adyacentes a dicho nodo, esto lo almacenamos en un
vector que denominamos grado, luego procedemos a reordenar dicho
vector en forma ascendente.
2. Luego se toma el nodo de menor grado se marca como visitado y se coloca
en un vector denominado orden, luego se escoge el nodo adyacente al
nodo que visitamos y se checa si ya esta visitado, en caso afirmativo se
toma otro nodo adyacente en caso de que el nodo visitado lo tenga, en el
caso en que el nodo adyacente no haya sido visitado este se guarda en un
vector llamado cola para que una vez que se hayan visitado todos los
nodos adyacentes al nodo inicial se visiten los nodos adyacentes al
34
siguiente nodo, también se marca como visitado y se coloca en el vector
orden, este proceso se continua hasta que todos los nodos hayan sido
visitados.
3. Por último procedemos a reordenar nuestra matriz con ayuda del vector
orden.
A continuación se muestra un pequeño ejemplo [8] supongamos que tenemos el
siguiente grafo:
Figura 2 Grafo de 10 nodos
Su matriz de adyacencia se muestra en la siguiente tabla:
Nodo A B C D E F G H I J
A 1 0 0 1 0 1 0 0 0 0
B 0 1 1 0 0 0 1 0 0 1
C 0 1 1 1 1 0 0 0 0 0
D 1 0 1 1 0 1 0 0 1 0
E 0 0 1 0 1 0 1 0 0 0
F 1 0 0 1 0 1 1 1 0 0
G 0 1 0 0 1 1 1 1 0 0
H 0 0 0 0 0 1 1 1 0 0
I 0 0 0 1 0 0 0 0 1 0
J 0 1 0 0 0 0 0 0 0 1
Tabla 1 Matriz de Adyacencia Original
Ahora se muestra el vector llamado grado donde se almacenan los grados de
cada nodo, ya en orden:
35
NODO GRADO
(9) I 1
(10) J 1
(1) A 2
(5) E 2
(8) H 2
(2) B 3
(3) C 3
(4) D 4
(6) F 4
(7) H 4
Tabla 2 Lista de grado de cada nodo
Al aplicar el algoritmo de Cuthill-Mckee a este ejemplo, obtenemos el siguiente
vector orden:
myz{ | }
~

q

Ahora se muestra la matriz de adyacencia reordenada para que se observe que
los elementos diferentes de cero están más cerca de la diagonal.
Nodo I D A C F E B H G J
I 1 1 0 0 0 0 0 0 0 0
D 1 1 1 1 1 0 0 0 0 0
A 0 1 1 0 1 0 0 0 0 0
C 0 1 0 1 0 1 1 0 0 0
F 0 1 1 0 1 0 0 1 1 0
E 0 0 0 1 0 1 0 0 1 0
B 0 0 0 1 0 0 1 0 1 1
H 0 0 0 0 1 0 0 1 1 0
G 0 0 0 0 1 1 1 1 1 0
J 0 0 0 0 0 0 1 0 0 1
Tabla 3 Matriz de Adyacencia Reordenada con CM Explícito
Enseguida se muestra el código de la función que se implementó para aplicar el
algoritmo de Cuthill-Mckee explícito:
36
function [A]=mckee(LA,grado,n,MA,A)
%Ordenar Lista de Adyacencia
tam=size(LA);
for r=1:n
for i=1:tam(2)
for j=i+1:tam(2)
if LA(r,j)~=0 && LA(r,i)~=0
if grado(LA(r,j))< grado(LA(r,i))
temporal=LA(r,j);
LA(r,j)=LA(r,i);
LA(r,i)=temporal;
end
else
break;
end
if grado(LA(r,j))==grado(LA(r,i))
if LA(r,j)<LA(r,i)
temp2=LA(r,i);
LA(r,i)=LA(r,j);
LA(r,j)=temp2;
end
end
end
end
end
[valor,indice]=sort(grado);
%tres vectores orden, cola y visitados
37
% cola=zeros(1,n);
visitados=zeros(1,n);
incola=1;
inorden=1;
incolumna=1;
inaux=1;
innodo=1;
in=indice(innodo); %Seleccionar el nodo de menor grado
visitados(in)=1; %Marcarlo como visitado
orden(inorden)=in; %Colocarlo en el vector orden
inorden=inorden+1;
nodo=LA(in,incolumna); % Asignar nodo adyacente
while nodo==0 % Verificar si el nodo adyacente es cero
innodo=innodo+1;
if innodo<n
in=indice(innodo); %Seleccionar el nodo de menor grado siguiente
orden(inorden)=in; %Colocarlo en el vectro orden
inorden=inorden+1;
nodo=LA(in,incolumna);
else
break;
end
end
while nodo~=0 %Verificar si el nodo adyacente es diferente de cero
if visitados(nodo)==0 %Verificar si el nodo no ha sido visitado en caso
afirmativo
visitados(nodo)=1; %Marcarlo como visitado
38
cola(incola)=nodo; %Colocarlo en el vector cola

incola=incola+1;
orden(inorden)=nodo; %Ponerlo en el vector orden
inorden=inorden+1;
incolumna=incolumna+1;
if incolumna<tam(2)
end
else %En caso negativo
end
if incolumna<=tam(2)
else
nodo=0;
end
if nodo==0
incolumna=1;
tama=size(cola);
if inaux>tama
break;
else
in=cola(inaux);
inaux=inaux+1;
if in==0
if innodo<n
in=indice(innodo+1);
39
innodo=innodo+1;
end
end
end
end
end
incolumna=1;
for i=1:n
in=indice(i);
if visitados(in)==0
visitados(in)=1;
orden(inorden)=in;
inorden=inorden+1;
if visitados(nodo)==0 %Verificar si el nodo no ha sido visitado en
caso afirmativo
incola=incola+1;
inorden=inorden+1;
if incolumna<tam(2)
end
40
end
else
nodo=0;
end
if nodo==0
incolumna=1;
tama=size(cola);
if inaux>tama
break;
else
in=cola(inaux);
inaux=inaux+1;
if in==0
if innodo<n
innodo=innodo+1;
end
end
end
end
end
end
end
41
orden;
AA=A(orden,:);
AA=AA(:,orden);
A=AA;
figure(2)
spy(MA)
Como se observa en el código de nuestra función primero ordenamos nuestra lista
de adyacencia para así tener los nodos adyacentes de menor grado al principio y
los de mayor grado al final, luego procedemos a implementar los pasos dos y tres
del algoritmo, para obtener nuestra matriz reordenada.
4.3 CUTHILL_MCKEE IMPLÍCITO
Si no tuviéramos la matriz original podemos reordenar la matriz utilizando los tres
vectores del formato CSR, en los que tenemos almacenada la matriz, a
continuación se describe cómo funciona este algoritmo:
Los pasos uno y dos son los mismos que se mencionaron anteriormente, la
modificación esta en el paso tres, que es donde reordenamos la matriz, en vez de
trabajar con la matriz tal cual, trabajamos con los vectores del formato CSR,
primero recorremos el vector orden de uno en uno, y en un nuevo vector llamado
Ki
()

, luego sacamos la diferencia entre el
Ki
(myz{
(K) )
9
{j
Ki
(myz{
(K)) y lo guardamos en zKk, en un contador
almacenamos el valor que tenga y le sumamos el valor de zKk para luego
guardarlo en Ki
(K ), a una variable zKl{ le asignamos Ki
(myz{
(K)),
luego en Lij copiamos los valores que tenemos en Lij que corresponden al
42
nodo que tenemos en el vector orden, de igual manera copiamos los índices de las
columnas correspondientes al nodo del vector orden, estos los sacamos del vector
Klm y los almacenamos en el nuevo vector Klm.
Esto solo nos permite intercambiar los renglones, pero nos falta intercambiar las
columnas para tener la matriz reordenada completamente, para ello recorremos el
arreglo myz{ y en un vector llamado zKl{ guardamos los índices del vector
Klm que tengan el valor de myz{

(K), posteriormente recorremos el vector de
zKl{ y cambiamos el valor de Klm en esa posición por el valor del índice del
vector orden en el que está almacenado dicho valor, finalmente utilizamos la
función descrita en la parte de Esquema CSR, que nos permite obtener la matriz
original, y listo tenemos la matriz reordenada para poder trabajar con ella.
Si aplicamos este algoritmo a nuestro ejemplo anterior obtenemos la siguiente
matriz:
Nodo I D A C F E B H G J
I 1 1 0 0 0 0 0 0 0 0
D 1 1 1 1 1 0 0 0 0 0
A 0 1 1 0 1 0 0 0 0 0
C 0 1 0 1 0 1 1 0 0 0
F 0 1 1 0 1 0 0 1 1 0
E 0 0 0 1 0 1 0 0 1 0
B 0 0 0 1 0 0 1 0 1 1
H 0 0 0 0 1 0 0 1 1 0
G 0 0 0 0 1 1 1 1 1 0
J 0 0 0 0 0 0 1 0 0 1
Tabla 4 Matriz A Reordenada con CM Implícito
Esta matriz se representaría en el formato CSR como sigue:

43
,

-

-

`
a
-

a
-
`
b
c
-

a
d
e
`
b
e
`
c
e
F
a
d
e
a
b
c
d
e
c
F
,

d

a
-F
-
-c
F
a
c
Enseguida se muestra el código de la función que se implemento para aplicar el
algoritmo de Cuthill-Mckee implícito:
function [AM]=mckeeim(val,ico,ia,LA,grado,n)
%Ordenar Lista de Adyacencia
tam=size(LA);
for r=1:n
for i=1:tam(2)
for j=i+1:tam(2)
if LA(r,j)~=0 && LA(r,i)~=0
if grado(LA(r,j))< grado(LA(r,i))
temporal=LA(r,j);
LA(r,j)=LA(r,i);
LA(r,i)=temporal;
end
else
break;
end
if grado(LA(r,j))==grado(LA(r,i))
if LA(r,j)<LA(r,i)
temp2=LA(r,i);
LA(r,i)=LA(r,j);
LA(r,j)=temp2;
end
44
end
end
end
end
[valor,indice]=sort(grado);
%tres vectores orden, cola y visitados
% cola=zeros(1,n);
visitados=zeros(1,n);
incola=1;
inorden=1;
incolumna=1;
inaux=1;
innodo=1;
in=indice(innodo); %Seleccionar el nodo de menor grado
orden(inorden)=in; %Colocarlo en el vector orden
inorden=inorden+1;
nodo=LA(in,incolumna); % Asignar nodo adyacente
while nodo==0 % Verificar si el nodo adyacente es cero
innodo=innodo+1;
if innodo<n
in=indice(innodo); %Seleccionar el nodo de menor grado siguiente
orden(inorden)=in; %Colocarlo en el vectro orden
inorden=inorden+1;
else
45
break;
end
end
if visitados(nodo)==0 %Verificar si el nodo no ha sido visitado en caso
afirmativo
incola=incola+1;
inorden=inorden+1;
if incolumna<tam(2)
end
end
else
nodo=0;
end
if nodo==0
incolumna=1;
tama=size(cola);
if inaux>tama
break;
46
else
in=cola(inaux);
inaux=inaux+1;
if in==0
if innodo<n
innodo=innodo+1;
end
end
end
end
end
incolumna=1;
for i=1:n
in=indice(i);
if visitados(in)==0
visitados(in)=1;
orden(inorden)=in;
inorden=inorden+1;
if visitados(nodo)==0 %Verificar si el nodo no ha sido visitado en
caso afirmativo
incola=incola+1;
47
inorden=inorden+1;
if incolumna<tam(2)
end
end
else
nodo=0;
end
if nodo==0
incolumna=1;
tama=size(cola);
if inaux>tama
break;
else
in=cola(inaux);
inaux=inaux+1;
if in==0
if innodo<n
innodo=innodo+1;
end
end
48
end
end
end
end
end
orden;
tam=length(orden);
clave=1;
% Paso 3 Reordenar la matriz como se explico anteriormente
contnz=1;
wia(1)=contnz;
for i=1:tam
dif=ia(orden(i)+1)-ia(orden(i));
contnz=contnz+dif;
wia(i+1)=contnz;
indice=ia(orden(i));
for j=1:dif
wval(clave)=val(indice);
wico(clave)=ico(indice);
clave=clave+1;
indice=indice+1;
end
end
wia;
wval;
wico;
49
for i=1:tam
indices=find(wico==(orden(i)));
for j=1:length(indices)
wicom(indices(j))=i;
end
end
wicom;
[AM]=invschemecsr(wia,wicom,wval,n);
figure(3)
spy(AM)
Como se observa en el código de nuestra función primero ordenamos nuestra lista
de adyacencia para así tener los nodos adyacentes de menor grado al principio y
los de mayor grado al final, luego procedemos a implementar los pasos dos y tres
del algoritmo, para obtener nuestra matriz reordenada.
50
CAPÍTULO 5 PRUEBAS
En este capítulo se presentan las pruebas que se realizaron y los resultados que
obtuvimos al resolver el sistema de ecuaciones asociado a las matrices dispersas
generadas, almacenadas y reordenadas.
Para realizar las pruebas correspondientes, nosotros implementamos un programa
principal implementado en MATLAB, el cual consta de las siguientes funciones:
• Función Genera Matriz.
• Función Schemecsr.
• Función Mckee.
• Función Mckeeim.
• Función Factorización.
• Función Solucion.
• Función Residuo.
Enseguida se muestra el código en MATLAB del programa principal:
%Programa Principal
1 clc;
2 clear all;
3 n = input('Da la dimensión de la matriz: ');
4 density = input('Da el porcentaje de dispersión de la matriz: ');
5 tic;
6 [A,B]=generamatriz(n, density);
7 [ia, ico, val, LA, MA, grado]=schemecsr(A);
51
8 [A]=mckee(LA, grado, n, MA, A)

9 [AMI]=mckeeim(val, ico, ia, LA,grado,n);
10 [L, U]=factorizacion(A, n);
11 D=norm(L*U-A, inf)
12 [X]=solucion(L, U, B, n);
13 [error, norma]=residuo(A, B, X);
14 norma
15 tiempo=toc
Como se puede observar lo primero que se hace es pedirle al usuario la dimensión
de la matriz que se va a crear así como el porcentaje de dispersión que va a tener
la matriz, ver líneas 3 y 4. En la línea 5 la instrucción tic sirve para medir el tiempo
que tarda nuestro programa desde la creación de la matriz hasta la resolución de
nuestro sistema y en la línea 15 se imprime dicho valor. De la línea 6 a la 14 el
programa genera, almacena, reordena con ayuda de Mckee explícito o con Mckee
implícito, Factoriza y calcula tanto la solución como el residuo para verificar que
tan correcta es la solución que obtenemos.
Enseguida se muestra un ejemplo de la ejecución de este programa:
52
Figura 3 Ventana de ejecución del programa
En este ejemplo la dimensión de la matriz es 200 y el porcentaje de dispersión es
de 0.85., la siguiente ventana nos muestra la matriz que creamos anteriormente:
Figura 4 Gráfica de una matriz dispersa de orden 200
53
Luego almacenamos la matriz en el formato CSR de donde también obtenemos un
vector llamado grado donde se almacena el grado de cada uno de los nodos,
también obtenemos la matriz y lista de adyacencia, posteriormente visualizamos la
matriz que hemos creado con ayuda de MATLAB
Luego se reordena nuestra matriz mediante el algoritmo de Cuthill-Mckee explícito
y entonces nuestra matriz queda como se observa en la siguiente ventana:
Figura 5 Gráfica de una matriz dispersa reordenada con CM de orden 200
Ya que nuestra matriz esta reordenada aplicamos la Factorización LU para
encontrar la solucion de nuestro sistema de ecuaciones y procedemos a calcular
el error de nuestra solucion y a ver el tiempo que tardamos en resolver nuestro
sistema, esto se muestra en la siguiente ventana:
54
Figura 6 Ventana de Salida de ejecución del programa
Ahora se muestra otro ejemplo de una matriz de dimensión 500 con 0.85 de
dispersión:
Figura 7 Gráfica de una matriz dispersa de orden 500
55
La siguiente figura muestra nuestra matriz reordenada
Figura 8 Gráfica de una matriz reordenada con CM de orden 500
Y ahora se muestra el tiempo que tardamos en resolver el sistema de ecuaciones:
Figura 8 Ventana de Salida de ejecución del programa
A continuación se muestra una tabla donde se muestra la dimensión de la matriz
que generamos, luego calculamos el número de elementos diferentes de cero,
después calculamos el tiempo que nos lleva al aplicar el algoritmo de Cuthill-
56
Mckee explícito así como el tiempo que nos lleva aplicar la factorización y
resolver el sistema de ecuaciones, de igual manera calculamos el tiempo que nos
lleva el aplicar el algoritmo de Cuthill-Mckee implícito junto con la factorización
y la resolución del sistema de ecuaciones.
DIMENSION NNZ TIEMPO CM EXPLÍCITO TIEMPO CM IMPLÍCITO
100 602 0.52471 0.33689
200 1952 0.37545 0.08608
300 4156 0.28313 0.24458
400 7408 0.67021 0.64431
500 11814 1.34927 1.38238
600 16592 2.45873 2.47763
700 22712 3.94059 3.99942
800 29680 5.76753 5.84587
900 37890 9.08370 9.08159
1000 45910 12.93046 13.01025
1100 55836 17.95804 18.08274
1200 66044 25.26443 24.91635
1300 76954 39.17144 38.72414
1400 89740 58.08782 58.24498
1500 102454 79.47672 79.28842
2000 22056 98.06004 104.01346
2500 126790 284.91522 282.78771
Tabla 5 Resultados
57
Como se puede observar la máxima dimensión de la matriz que se puede aplicar
ambos algoritmos y resolver los sistemas de ecuaciones correspondientes para
matrices de dimensión 2500.
58
CONCLUSIONES
Se generó nuestra matriz dispersa y asegurarnos de que esta sea estrictamente
dominante diagonalmente nos garantiza que podamos utilizar la factorización
para resolver el sistema de ecuaciones asociado a dicha matriz.
Se aplicó tanto el algoritmo de Cuthill-Mckee explícito como implícito para reducir
el ancho de banda, y así resolver los sistemas de ecuaciones asociados para
matrices de dimensión 2500, ya que como tenemos limitantes en MATLAB no
podemos trabajar con matrices de mayor dimensión.
Después de haber realizado una investigación muy profunda acerca de la
reducción del ancho de banda y de las matrices dispersas llegue a la conclusión
de que ambos son grandes campos de investigación, además de que se aplica en
varias áreas de estudio para la resolución de diferentes problemas.
En lo personal este trabajo me ha servido para adquirir nuevos conocimientos
acerca de este tema y del área, además de que durante el desarrollo del mismo he
aplicado muchos de los conocimientos adquiridos durante mi carrera.
También me ha ayudado a adentrarme dentro del campo de la investigación,
proceso que uno debe de realizar en la vida diaria para crecer profesionalmente.
Por último el terminar esta tesis me llena de un gran orgullo y me impulsa a seguir
adelante, además de que es un logro que no solo me dará satisfacción a mi, si no
a toda mi familia y a los profesores que me apoyaron durante la realización de
este trabajo.
59
BIBLIOGRAFIA
[1] Andrew Lim, Brian Rodrigues, Fei Xiao, "A genetic Algorithm with Hill
Climbing for the Bandwidth Minimization Problem", available from Citeseer-X
(2002).
[2] Andrew Lim, Jing Lin, Brian Rodrigues, 2005, "Ant colony optimization
with Hill Climbing for the bandwidth Minimization Problem", Applied Soft
Computing, vol. 6, pp. 180-188.
[3] Andrew Lim, Jing Lin, Fei Xiao, 2007, "Particle Swarm Optimization and
Hill Climbing for the bandwidth Minimization Problem", Computer Science
Applied Intelligence, vol 6, pp. 175-182.
[4] Damián Ginestar Peiró, 2008-2009, “Matrices Dispersas Curso”,
Departamento de Matemática Aplicada de la Universidad Politécnica de
Valencia, pp. 12-18.
[5] José Luis de la Fuente O´cconor, 1997, “Técnicas de Cálculo para
Sistemas de Ecuaciones, Programación Lineal y Programación Entera”, 2ª
edición, Editorial Revente, pp. 234-241.
[6] José Luis de la Fuente O´cconor, “Sistemas lineales de Grandes
Dimensiones Matrices Dispersas”, notas, pp. 17-18.
[7] M. Dolores García de León, Marzo 2003, Tesis Doctoral “Estrategias para
la resolución de grandes sistemas de ecuaciones lineales. Métodos de
60
Cuasi-Mínimo Residuo Modificados”, Universidad de las Palmas de la Gran
Canaria, Departamento de Matemáticas.
[8] Pedro Ramón Almeida Benítez, José Ramón Franco Brañas, 1999,
“Reducción del Ancho de Banda de matrices en el algoritmo Go-Away para
mallas regulares”, Divulgaciones Matemáticas, Vol. 7 No 1, pp. 1-12.
[9] Richard L. Burden, J. Douglas Faires, 1993, “Análisis Numérico”, Grupo
Editorial Iberoamérica, 2º edición, pp. 375-393.
[10] Sergio Pissanetzky, 1984, Sparse Matrix Technology“”, Academic Press,
pp. 20-22.
[11] Shoichiro Nakamura, 1992, “Métodos Numericos Aplicados con
Software”, Editorial Prentice Hall, 1° edición, pp. 207.
[12] Stanley I. Grossman, 2001, “Algebra Lineal”, Editorial McGraw-Hill, 5º
edición, pp. 101.
[13] Steven C. Chapra, Raymond P. Canale, 2003, “Metodos Numericos para
Ingenieros con Programas de Aplicacion”, Editorial McGraw-Hill, 4° edición,
pp. 278-280.
[14] Yousef Saad, 2003, “Iterative Methods for Sparse Linear Systems”,
Society for Industrial and Applied Mathematics, 2°edicion, pp. 75-98.
61
LIGAS INTERNET
[L1] http://nobelprize.org/nobel_prizes/economics/laureates/1990/markowitz-
autobio.html. (20/01/2012).
[L2] http://en.wikipedia.org/wiki/Harry_M._Markowitz. (20/01/2012).
[L3] http://www.siam.org/news/news.php?id=465. (20/01/2012).
[L4] http://www.netlib.org/na-digest-html/90/v90n07.html#4. (20/01/2012).
62

Resolución de Sistemas de Ecuaciones Lineales Dispersos

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

Resolución de Sistemas de Ecuaciones Lineales Dispersos

Cargado por

Copyright:

Formatos disponibles

BENEMÉRITA

RITA UNIVERSIDAD AUTONOMA DE PUEBLA

FACULTAD DE CIENCIAS DE LA COMPUTACIÓN

SISTEMAS DE ECUACIONES LINEALES PARA MATRICES

QUE PARA OBTENER EL TÍTULO DE

INGENIERO EN CIENCIAS DE LA COMPUTACIÓN

ALBERTO ROMÁN FLORES

PUEBLA, PUE. 2012

A toda mi familia, en especial a mi madre por su apoyo en los

CAPÍTULO 3 ESQUEMAS DE ALMACENAMIENTO PARA MATRICES DISPERSAS................. 25

3.1 ESQUEMA COORDENADO ........................................................................................... 26

4.1 ALGORITMO DE CUTHILL-MCKEE ................................................................................ 33

El problema de minimizar o reducir el ancho de banda (Bandwidth Minimization

Problem (BMP)) de matrices, se originó en 1950 cuando los ingenieros estudiaron

encuentra en un gran número de aplicaciones entre las que podemos mencionar:

• Solución de Sistemas de Ecuaciones Lineales Grandes.

• Sistemas de Transmisión de Alta Potencia, entre otras más.

el objetivo de implementar algoritmos que resuelvan dicho problema.

El BMP consiste en encontrar una permutación de filas y columnas de tal forma

que los elementos diferentes de ceros de la matriz estén lo más cerca de la

Ahora nos enfocaremos en una de las aplicaciones mencionadas: la solución de

Sistemas de Ecuaciones Lineales, para ello trabajaremos con matrices dispersas.

El término de matriz dispersa se le atribuye al economista Harry Markowitz [L1]

quien al analizar modelos de actividad industrial en la Rand Corporation

durante1950, observó que al trabajar con matrices la mayoría de sus elementos

William Orchand-Hayes fue el primero en implementar un código para matrices

dispersas. La investigación y los trabajos realizados sobre este tipo de matrices

son ahora de mucha importancia, ya que son estándares que se utilizan en

códigos de programación lineal [L1].

por la Sociedad de Investigación de Operaciones de América y en 1990 recibió el

Premio Nobel en Ciencias Económicas [L2].

utilización de las matrices dispersas, cuando intento resolver sistemas de

ecuaciones a gran escala, al trabajar en la simulación de circuitos. Junto con su

resolver problemas específicos de este tipo, tiempo después Fred Gustavson un

compañero de trabajo de ellos en IBM, creó un programa de Factorización

Triangular Simbólica, el cual genera código en Fortran para cualquier problema.

Antes de estas investigaciones, la matrices dispersas de gran tamaño se resolvían

utilizando métodos iterativos, ya que los métodos directos eran considerados

apropiados para trabajar con matrices pequeñas.

Ralph Willoughby y su equipo de trabajo en IBM, desarrollaron técnicas para

resolver la simulación de circuitos electrónicos. Las técnicas desarrolladas también

se aplicaron en otros problemas como: programación lineal, análisis de sistemas

de potencia, análisis estructural, entre otros. Él organizó el primer “Symposium on

Las memorias de este Symposium aparecieron sólo como un reporte de la IBM

En 1971 en el tercer encuentro de este Symposium, se presentaron principalmente

trabajos de métodos directos para resolver sistemas de ecuaciones lineales

podemos mencionar: el algoritmo de Cuthill-Mckee propuesto en 1969, también

Gaussiana, otro algoritmo es el inverso de Cuthill-Mckee desarrollado por George

en 1971 que es una mejora de Cuthill-Mckee [14].

comunes tenemos el método de eliminación gaussiana propuesto por Johann

Friedrich Gauss que también propuso el método de factorización LDLT, también

tenemos el método de factorización LU que Doolitle propuso, por último tenemos

el método de factorización de Cholesky creado y propuesto por el Mayor Andre-

“Bulletin geodesique” desde la pagina 67-77 [L4].

método de Gauss-Seidel el cual fue propuesto y nombrado así en honor a los

matemáticos Carl Friederich Gauss y Phillip Ludwing Von Seidel [9].

Los sistemas de ecuaciones lineales siempre han estado presentes en nuestra

ya que el tiempo que se invertía para solucionarlos era demasiado

este tipo de matrices, dentro de lo más utilizados están el Esquema Coordenado,

el Esquema Compressed Sparse Row (CSR), el Esquema Compressed Column

A continuación procedemos a definir el esquema de esta tesis:

• Capítulo 1. Conceptos Básicos.

• Capítulo 2. Generación de Matrices Dispersas.

coeficientes de cada ecuación, el vector es de tamaño

tamaño que el vector es el vector de términos independientes asociado a

de cero, el sistema de ecuaciones tiene una solución única, si la matriz es

una solución única, más aun la solución es de la forma

El método de Factorización es uno de los más utilizados para resolver

denotadas por y respectivamente de tal forma que:

Conviene observar que los elementos de la diagonal de valen 1. Para evaluar

y de la ecuación anterior sin pivoteo, primero multiplicamos el primer

renglón de por cada columna de y comparamos el resultado con el primer

renglón de . Tenemos entonces que el primer renglón de es idéntico al de :

Multiplicamos el segundo y tercer renglón de por la primera columna de , y lo

Multiplicamos el segundo renglón de por la segunda y tercera columna de y

Multiplicamos el tercer renglón de por la segunda columna de y tenemos:

Finalmente, se obtiene multiplicando la última columna de por el último

renglón de y lo igualamos a como sigue:

El esquema general de la factorización para una matriz de orden N es el