UNI-CTIC 1

Eliminacion Gaussiana
Mendoza Olivares, Jesus
Ticse Torres, Royer
Lima, 25 de Agosto del 2009

Resumen—En el siguiente trabajo, se examina uno de los f ila4 ← f ila4 − m41 ∗ f ila1 donde:m41 = a41 /a11 .
algoritmos más conocidos para resolver un sistema lineal de y entonces nuestra matriz A la hemos transformado en:
ecuaciones el algoritmo de eliminación gaussiana en su versión  
paralela. a11 a12 a13 a14
 0 u22 u23 u24 
 
 0 u32 u33 u34 
I. I NTRODUCCI ÓN
0 u42 u43 u44
Este método trabaja directamente sobre la matriz aumentada
para resolver un sistema de ecuaciones lineales, llevandola a 2. Ahora, enfoquemos nuestra atención al subproblema de
la matriz de un sistema triangular que es eqivalente al sistema una matriz de 3x3
 
inicial. La equivalencia del sistema triangular final con el u22 u23 u24
inicial se argumenta debido a que el algoritmo sólo utilizamos  u32 u33 u34 
operaciones elementloes entre las filas y cuya aplicación u42 u43 u44
individual siempre preserva la equivalencia. Implementamos En forma similar, hacemos ceros los elementos por
el algoritmo de eliminación Gaussiana en forma paralela y se debajo de u22 , para lograrlo operemos
realizará una revisión sobre el trabajo computacional realizado f ila3 ← f ila3 − m32 ∗ f ila2 donde:m32 = u32 /u22 .
por este método. f ila4 ← f ila4 − m42 ∗ f ila2 donde:m42 = u42 /u22 .
II. O BJETIVOS 3. Luego, nuestra matriz se ha trasformado en:
Entender el algoritmo de Eliminación Gassuina para  
a11 a12 a13 a14
solucionar un sistema de ecuaciones.  0 u22 u23 u24 
Implementar la versión paralela del algoritmo Elimi- 
 0

0 v33 v34 
nación Gaussiana.
0 0 v43 v44
III. P LANTEAMIENTO DEL PROBLEMA ahora solo nos resta operar con una fila para reducir v43
La principal caracteristica de la Eliminación Gaussiana es a cero.
transformar el sistema original f ila4 ← f ila4 − m43 ∗ f ila3 donde:m43 = v43 /v33 .
Lo que nos da lugar a la matriz triangular superior:
AX = B  
a11 a12 a13 a14
 0 u22 u23 u24 
 
en un sistema lineal equivalente  0 0 v33 v34 
0 0 0 w44
UX = Y
Contando con el sistema:
donde U es una matriz triangular superior. La razón de lograr     
ésta transformación del sistema es que el nuevo sistema es a11 a12 a13 a14 x1 y1
 0 u22 u23 u24  x2  y2 
más simple y resolverlo sólo requiere un proceso hacia atrás.    =  
Por ejemplo, tomemos A una matriz de dimención n = 4.  0 0 v33 v34  x3  y3 
  0 0 0 w44 x4 y4
a11 a12 a13 a14
 a21 a22 a23 a24  Introduzcamos la idea de matriz aumentada:
 
 a31 a32 a33 a34 
[AkB]
a41 a42 a43 a44
y sobre ella, realicemos las operaciones indicadas en los pasos
Las opreraciones disponibles son multiplicar un vector fila por
1, 2, ..., n − 1. Al hacerlo, estaremos trabajando sobre la parte
un escalar y añadirlo a otra fila.
activa de A pero de igual forma sobre las filas correspondientes
1. Nos intereza que las posiciones 21, 31, 41 de la matriz a B. El resultado será
sean ceros, esto lo podemos lograr sustrayendo un
[U kY ]
multiplo adecuado de la primera fila de A.
f ila2 ← f ila2 − m21 ∗ f ila1 donde:m21 = a21 /a11 . donde Y es el resultado de los cambios ocurridos a B al
f ila3 ← f ila3 − m31 ∗ f ila1 donde:m31 = a31 /a11 . aplicarle las operaciones fila que hemos considerado.
UNI-CTIC 2

IV. A LGORITMO for i = k + 1, k + 2, ..., DIM EN SION − 1 do

Aik
El metodo de eliminación de gauss es un método estandar Aik = −1,0. A kk

para resolver el sistema de ecuaciones Ax = b. Se comienza buf f er(i − k − 1) = Aik

por transformar el sistema a la forma equivalente U x = b, end for
donde U es una matriz triangular superior (es decir todos los Donde buf f er es una variable para la transmision de
elemntos debajo de la diagonal son iguales a cero). El sistema data entre procesos.
U x = b es ahora resuelto por sustitución hacia atraz. 5. Difundimos todos los datos desde proceso root a todos
Dada una matriz A = (aij ), un algorı́tmo para llevar a la los procesos.
practica el metodo de eliminación de gaussiana que acabamos 6. El proceso 0 ejecuta lo siguiente :
de escribir es el siguiente. for i = 0, 1, ..., DIM EN SION do
if i mod p <> 0 then
Algorithm 1 input n, (aij ) recibe la data buf f er de los procesos con id (i
for k = 1, 2, ..., n − 1 do mod p).
for i = k + 1, k + 2, ..., n do end if
z ← aik /akk for j = 0, 1, ..., DIM EN SION do
aik ← 0 Aji = buf f er
for j = k + 1, k + 2, ..., n do end for
aij ← aij − zakj end for
end for for i = 0, 1, ..., DIM EN SION do
end for for i = 0, 1, ..., DIM EN SION do
end for Aij = 0,0
output(aij ) end for
end for
7. Los demas procesos con Id distinto de
El algoritmo que se aplico para el caso del problema esta
cero:
paralelisado se muestra acontinuación.
for i = 0, 1, ..., DIM EN SION do
1. Primero reservamos memoria en base a la variable
if myRank = (i mod p) then
definida DIM EN SION , que nos indica la dimension
for i = 0, 1, ..., DIM EN SION do
de la matriz A que vamos triangularizar.
Enviamos buf f er al proceso 0.
2. Si llamamos p el numero de procesos que ejecutaran el
end for
programa y myRank la variable que representa el id de
end if
cada proceso, si myRank = 0 entonces genera y llena
end for
los valore de la matriz de forma aleatoria, cumpliendo
las siguientes restricciones: Este algortimo presenta los mismos bucles que se muestran
tambien en el algoritmo desarrollado en serie, con la unica
Genera valores de A que sean diferentes de cero en
diferencia con este ultimo algoritmo cada columna es com-
la diagonal.
putada por un proceso y estos se comunican todos los pasos de
Genera valores de A que sean diferentes de cero en
actualizacion que puedan realizar en las entradas de la matriz.
las 6 sub-diagonales arriba y las 6 abajo, el resto
es cero.
Los valores en la diagonal deben ser mayores
en valor absoluto que los de las otras 12 sub-
diagonales.
3. El modelo de programacion paralela que se aplica esta
basado en la particion de data en este caso de las
columnas de la matriz:
La columna 0 los va ejecutar el proceso con
myRank = 0.
La columna 1 los va ejecutar el proceso con
myRank = 1
Y asi sucesivamente, siempre que la dimension de
la matriz sea divisible por el numero de procesos
(esto para que todos los procesos trabajen igual).

4. Acontinuación cada proceso trabaja sobre su correspon-

diente columna:
Estos son todos los elementos en la k−esima columna
debajo de la diagonal
UNI-CTIC 3

V. P RUEBA Matriz aleatoria de 240x240

Utilizamos una matriz de 4x4 para probar el programa. Número de procesadores = 1
matriz aleatoria de entrada:
  Prueba Tiempo(seg)
8 1 2 0 1 7.035414
 −2 10 1 −3 
  2 6.640708
 4 −4 7 2  3 6.566449
−5 4 −2 11
Número de procesadores = 2
Llevandolo a su forma diagonal triangular :
    Prueba Tiempo(seg)
8 1 2 0 8 1 2 0
−2 10 1 6.554764
1 −3 →
0 41/4 3/2 −3→

 4 −4 2 6.51030
7 2 0 −9/2 6 2
−5 4 −2 11 0 37/8 −6/8 11 3 6.277527
→ 
8 1 2 0 VII. C ONCLUSIONES
0 41/4
 3/2 −3   En este trabajo hemos analizado el algoritmo Eliminación
0 0 273/41 28/41  Gaussianaen su version en paralela, aprovechando los
0 0 117/82 −1013/82  procesadores más eficientemente..
8 1 2 0 Con el desarrollo del programa hecho con la herramienta
0 41/4 3/2 −3  MPI se pudo hallar valores aproximados del tiempo de
→ 
0
 →
0 273/41 28/41 procesado para hallar la matriz triangular superior y
 0 0 0 25/2 podemos notar que el tiempo de cómputo no mejora
8 1 2 0 considerablemente al usar 2 procesadores. Probablemente
0
 10,25 1,5 −3  este tiempo se reduce al usar más procesadores.
0 0 6,6585 0,6829 Es evidente la importancia del método de Eliminación
0 0 0 12,5 Gaussiana para resolver sistema de ecuaciones lineales,
ya que transforma en un sistema más simple de resolver.
Se puede mejorar el algoritmo aprovechando las car-
Obtenido por el programa eliminacion gaussiana.c obten-
acteristicas de una matriz particular para economizar
emos: 
8 1 2 0
 operaciones y espacio.
 0 10,25 1,5
 −3 

 0 0 6,658537 0,682927  R EFERENCIAS
0 0 0 12,5 [1] [MPI: A Message Passing Interface Standar ] http://www-
unix.mcs.anl.gov/mpi/mpi-standard/mpi-report-1.1/mpi-report.html
Para este caso nos resulta la misma matriz calculada, con error [2] [Blas Barney, Lawrence Livermore National Laboratory :MPI ]
cero. https://computing.llnl.gov/tutorials/mpi/
[3] [Wikipedia] http://es.wikipedia.org/wiki/Eliminación de Gauss-Jordan

VI. R ESULTADOS
Luego, hacemos las pruebas con dos matrices aleatorias
A de tamaño 120x120 y 240x240 cuyos únicos elementos
distintos de cero se encuentran en la diagonal principal y en
las subdiagonales arriba y las 6 debajo de la diagonal principal.
Los valores en la diagonal son mayores en valor absoluto que
los de las otras 12 sub-diagonales
Matriz aleatoria de 120x120
Número de procesadores = 1

Prueba Tiempo(seg)
1 0.294493
2 0.374795
3 0.304104
Número de procesadores = 2
Prueba Tiempo(seg)
1 0.419840
2 0.359263
3 0.308416
UNI-CTIC 4

A NEXO :C ÓDIGO UTILIZADO f o r ( i = 0 ; i <DIMENSION ; i ++){

eliminación gaussiana.c f o r ( k = 0 ; k<DIMENSION ; k ++) A s e r [ i ] [ k ] = A[ i ] [ k ] ;
}

f o r ( i = 0 ; i < DIMENSION ; i ++){

# include < s t d i o . h> f o r ( j = 0 ; j < DIMENSION ; j ++)
# include < s t d l i b . h> p r i n t f ( ” %f \ t ” , A [ i ] [ j ] ) ;
# include <t i m e . h> p r i n t f (”\ n ” ) ;
# include <math . h> }
# include <mpi . h> }
/ / p a s o 1 : e n v i a n d o c o l u m n a s de a l o s demas p r o c e s o s
# d e f i n e DIMENSION 10 i f ( my rank == 0 ) { / / p a r a e l p r o c e s o 0 .
# d e f i n e NUMDIAG 4 / / medir e l tiempo
s t a r t p a r = MPI Wtime ( ) ;
i n t main ( i n t a r g c , c h a r ∗ a r g v [ ] ) { f o r ( i = 0 ; i <DIMENSION ; i ++) {
MPI Status s t a t u s ; dest = i % p;
i n t p , my rank , i , j , k , d e s t ; i f ( d e s t != 0) {
d o u b l e ∗∗A, ∗∗ A s e r ; f o r ( j = 0 ; j <DIMENSION ; j ++) b u f f e r [ j ] = A[ j ] [ i ] ;
double ∗ b u f f e r ; / / enviando . . .
double l ; MPI Send ( b u f f e r , DIMENSION , MPI DOUBLE , d e s t ,
double s t a r t p a r , end par , s t a r t s e r , end ser , i , MPI COMM WORLD ) ;
s e r i a l t i m e , p a r a l l e l t i m e , speedup ; }
double diff , error ; }
}else{ // s i e l p r o c e s o e s d i f e r e n t e de c e r o
M P I I n i t (& a r g c , &a r g v ) ; f o r ( i = 0 ; i <DIMENSION ; i ++){
MPI Comm size (MPI COMM WORLD, &p ) ; i f ( i % p == my rank ) {
MPI Comm rank (MPI COMM WORLD, &my rank ) ; / / recibiendo . . .
MPI Recv ( b u f f e r , DIMENSION , MPI DOUBLE , 0 , i ,
i f ( DIMENSION % p != 0 ) { MPI COMM WORLD, & s t a t u s ) ;
i f ( my rank == 0 ) { / / g u a r d a n d o l o r e c i b i d o en l a i −e s i m a f i l a de A
p r i n t f ( ” ( %d ) no s e p u e d e d i v i d i r f o r ( j = 0 ; j <DIMENSION ; j ++) A[ j ] [ i ] = b u f f e r [ j ] ;
en un numero de p r o c e s o s ( %d ) \ n ” ,DIMENSION , p ) ; }
} }
fflush ( stdout ); }
fflush ( stderr );
M P I B a r r i e r (MPI COMM WORLD ) ; / / paso 2:
MPI Finalize ( ) ; f o r ( k = 0 ; k<DIMENSION−1;k ++) {
exit (1); i f ( my rank == k %p ) {
} f o r ( i =k + 1 ; i <DIMENSION ; i ++){
A[ i ] [ k ] = −1.0 ∗ A[ i ] [ k ] / A[ k ] [ k ] ;
/ / l l e n a a b u f f e r con e s t o s e l e m e n t o s
/ / r e s e r v a n d o memoria b u f f e r [ i − k − 1 ] = A[ i ] [ k ] ;
A = ( d o u b l e ∗ ∗ ) m a l l o c ( DIMENSION∗ s i z e o f ( d o u b l e ∗ ) ) ; }
f o r ( i = 0 ; i <DIMENSION ; i ++){ }
A[ i ] = ( d o u b l e ∗ ) m a l l o c ( DIMENSION∗ s i z e o f ( d o u b l e ) ) ; / / Difundimos todos l o s d a t o s desde r o o t
} / / a todos los procesos .
b u f f e r = ( d o u b l e ∗ ) m a l l o c ( DIMENSION ∗ s i z e o f ( d o u b l e ) ) ; MPI Bcast ( b u f f e r , DIMENSION−k −1,MPI DOUBLE ,
/ / e s t a i n i c i a l i z a n d o c a d a e l e m e n t o de l a m a t r i z A a 0 k %p , MPI COMM WORLD ) ;
f o r ( i = 0 ; i <DIMENSION ; i ++) { f o r ( j =k + 1 ; j <DIMENSION ; j ++) {
f o r ( k = 0 ; k<DIMENSION ; k ++) { f o r ( i =k + 1 ; i <DIMENSION ; i ++) {
A[ i ] [ k ] = 0 ; A[ i ] [ j ] += b u f f e r [ i −k −1] ∗ A[ k ] [ j ] ;
} }
} }
/ / esto lo r e a l i z a el proceso cero }
i n t tmp ;
i f ( my rank == 0 ) { i f ( my rank == 0 ) {
A s e r = ( d o u b l e ∗ ∗ ) m a l l o c ( DIMENSION∗ s i z e o f ( d o u b l e ∗ ) ) ; f o r ( i = 0 ; i <DIMENSION ; i ++) {
i f ( i %p != 0 ) {
f o r ( i = 0 ; i <DIMENSION ; i ++) MPI Recv ( b u f f e r , DIMENSION , MPI DOUBLE , i %p ,
A s e r [ i ] = ( d o u b l e ∗ ) m a l l o c ( DIMENSION∗ s i z e o f ( d o u b l e ) ) ; i ,MPI COMM WORLD,& s t a t u s ) ;
f o r ( j = 0 ; j <DIMENSION ; j ++) A[ j ] [ i ] = b u f f e r [ j ] ;
f o r ( i = 0 ; i < DIMENSION ; i ++){ }
f o r ( j = 0 ; j < DIMENSION ; j ++){ }
i f ( j >= i − NUMDIAG && j <= i + NUMDIAG) { f o r ( i = 1 ; i <DIMENSION ; i ++) {
f o r ( j = 0 ; j <i ; j ++) A[ i ] [ j ] = 0 . 0 ;
i f ( i == j ) { }
A[ i ] [ j ] = ( d o u b l e ) ( rand ( ) %1 0 0 0 0 ) + 5000 ; e n d p a r = MPI Wtime ( ) ;
}else{ }else{
A[ i ] [ j ] = ( d o u b l e ) ( rand ( ) %1 0 0 0 0 ) − 5000 ; f o r ( i = 0 ; i <DIMENSION ; i ++){
} i f ( my rank == i %p ) {
f o r ( j = 0 ; j <DIMENSION ; j ++) b u f f e r [ j ] = A[ j ] [ i ] ;
}else{ MPI Send ( b u f f e r , DIMENSION , MPI DOUBLE , 0 ,
A[ i ] [ j ] = 0.0; i ,MPI COMM WORLD ) ;
} }
} }
} }
UNI-CTIC 5

i f ( my rank == 0 ) {
s t a r t s e r = MPI Wtime ( ) ;
f o r ( k = 0 ; k<DIMENSION−1;k ++) {
f o r ( i =k + 1 ; i <DIMENSION ; i ++){
l = A ser [ i ] [ k ] / A ser [ k ] [ k ] ;
f o r ( j =k ; j <DIMENSION ; j ++)
A s e r [ i ] [ j ] −= l ∗ A s e r [ k ] [ j ] ;
}
}
f o r ( i = 1 ; i <DIMENSION ; i ++) {
f o r ( j = 0 ; j <i ; j ++) A s e r [ i ] [ j ] = 0 . 0 ;
}
p r i n t f ( ” d e s p u e s de l a e l i m i n a c i o n de g a u s s \n\n ” ) ;
f o r ( i = 0 ; i <DIMENSION ; ++ i ) {
f o r ( j = 0 ; j <DIMENSION ; ++ j )
p r i n t f ( ” %f \ t ” , A s e r [ i ] [ j ] ) ;
p r i n t f (”\ n ” ) ;
}
e n d s e r = MPI Wtime ( ) ;

s e r i a l t i m e = end ser − s t a r t s e r ;
p a r a l l e l t i m e = end par − s t a r t p a r ;
speedup = s e r i a l t i m e / p a r a l l e l t i m e ;

p r i n t f ( ” A p l i c a n d o e l i m i n a c i o n g a u s s i a n a en una
%dx %d−m a t r i x \n ” ,DIMENSION , DIMENSION ) ;
p r i n t f ( ” P a r a l l e l v e r s i o n : %e s e c o n d s \n ” , p a r a l l e l t i m e ) ;
p r i n t f ( ” S e r i a l v e r s i o n : %e s e c o n d s \n ” , s e r i a l t i m e ) ;

fflush ( stdout );
fflush ( stderr );
M P I B a r r i e r (MPI COMM WORLD ) ;
MPI Finalize ( ) ;
return 0;
}