ALMACENAMIENTO DE MATRICES DISPERSAS ( CSR)

Cristian Damian 11, Pablo Piña 22, Franklin Zhiguisaca 33

Resumen
El estudio muestra la forma en la que se debe
almacenar una matriz dispersa en formato CSR
(Compressed Sparse Row) y se demuestra cómo es
la eficiencia y su evolución con respecto al método
antecesor coordenado.

Se muestra también la forma en la que se resuelve y

se ordena cada serie sin importar la dimensión de la
matriz ni tampoco la cantidad de ceros que tenga
puesto que el formato es una solución para esta
situación.
El formato CSR está más enlazado con lo que
es la programación por medio de una calculadora
para colaborar con el tiempo y con
el gasto computacional.
La programación para estas matrices es efectuada
por java, Matlab, force, se mostrara también un
ejemplo de la programación.

Palabras Clave: Compressed Sparse Row, resuelve, formato,

almacenar

1
Universidad Politécnica Salesiana de Cuenca 2
Facultad de ingeniería mecatrónica.
Autor para correspondencia: pablohcc10@hotmail.com

1
 1. Introducción
Una matriz dispersa consta de elementos que en
su mayoría son ceros y que al momento de
almacenarlos dentro de un formato o un lenguaje
de programación llevan demasiadas unidades de
programación es decir mas de las necesarias.
El informe muestra de forma detallada como se
ocupa el método de almacenamiento CSR
(Compressed Sparse Row) y su forma de aplicación.
Este formato se lo ocupa en su mayoría al momento
de empezar una programación o almacenamiento de
datos en un programa.
la utilización masiva de los ordenadores en los ´ ´ últimos
años y el aumento de su potencia y capacidad de cálculo,
han permitido que la ciencia, técnica e ingeniería utilicen
cada vez más modelos matemáticos para comprender,
simular y optimizar fenómenos de diversa complejidad, y
que esos modelos crezcan extraordinariamente en
magnitud y exactitud. Muchos de estos modelos conllevan
enfrentarse con matrices de un tamaño tal que hace solo
unos pocos años era casi inimaginable que se pudiesen
tratar (cientos de miles de filas y columnas) (O`Conor)
1.1 Optimizar el tiempo y generar menos
gasto computacional.
El formato CSR (Compressed Sparse Row), es una
evolución del método COO (Coordinado) ambas
ocupan un orden que consta de 3 series o array donde
el formato COO muestra la ubicación de cada valor
ocupando dos series y con la tercera fila enseña el
valor numérico de cada elemento. El formato CRS
muestra a la matriz con las dos series de los valores
y de las columnas igual a formato anterior pero la
diferencia está en el array de las filas, la mejorada
forma de almacenamiento muestra tan solo la
ubicación de los primeros elementos en el sentido de
las filas. Esta evolución es la que da un uso más
apropiado para problemas aplicables con matrices
dispersas.
2
1.2. Instrucciones para ocupar el método
de almacenamiento CRS(Compressed
Sparse Row)
El método de almacenamiento CRS es creado para
almacenar y/o resolver problemas de carácter
aplicativos, problemas que ocupan matrices dispersas,
es decir para poder realizar problemas y resolverlos
con operaciones matemáticas con ayuda de un
programa.
Se trata de ahorrar lo mayor posible el gasto
computacional que se produce al ejecutar el ejercicio
con la menor cantidad de bites ocupados ordenando la
información en tres vectores, este proceso se lo puede
mandar a ejecutar en un programa en donde se anoten
las matrices dispersas y de resultado nos de las tres
series con la información suficiente de la matriz.
Uno de los mayores problemas del COO es el
malgasto de memoria al guardar las columnas y
las filas. Para reducir este gasto el formato CSR
Propone reducir el array de filas.” (Medina,
2017)
1. Materiales y Métodos
Para almacenar una matriz dispersa en formato CRS
se lo organiza en tres series:
-La serie de valores:
Esta serie consta de los valores de cada elemento
tomándolo desde el valor de la primera fila y
primera columna y siguiendo la fila.
-La serie de filas o punteros:
Esta es la serie que diferencia al formato CSR
del comando COO, pues al momento en vez de
dar coordenada de cada elemento esta se centra
en decir los punteros o valores de cada fila
empezando desde la derecha. La siguiente tabla
nos muestra la forma de ahorro en términos de
 Apellido Autor et al / Titulo del Articulo

bytes en un ejercicio: En las siguientes imágenes se muestra lo forma

del almacenamiento de forma detallada del
método COO y el método CSR
respectivamente.

El siguiente programa fue desarrollado para un

máximo de una matriz de tres por tres.

Para poder demostrar la ubicación de los vectores se

ocupan matrices con ceros:

-La serie de columnas:

Esta serie nos muestra las coordenadas con

respecto a las columnas de cada elemento.

Ilustración 3 matriz tres por tres en el programa

Ilustración 1 método CSR

Las

Ilustración 4 segundo paso para obtener la matriz multiplicada

Ilustración 2 Formato COO

Ilustración 5 generación de vectores en la matriz A

3
 Apellido Autor et al / Titulo del Articulo

4. Referencias

O`Conor, J. L. (s.f.). TECNICAS DEL CALCULO PARA

SISTEMAS DE ECUACIONES. Madrid: reverté.

Peiro, D. G. (s.f.). Matrices dispersas. Valencia:

Universidad Politecnica de Valencia.

Verdes, J. C. (enero de 2011). Matrices DIspersas. coruna .

Ilustración 6 la matriz resultante de la multiplicación.

A una opción para programar y resolver una

multiplicación ejercicio que tenga de matrices
dispersas podría ser la siguiente:

2. Resultados y Discusión
El formato CSR para lograr almacenar una matriz
dispersa de una forma eficiente, aunque no tengamos
todavía el conocimiento para lograr programar un
ejercicio se logra diferenciar analógicamente el ahorro
de tiempo en el momento de realizar un ejercicio que
conste de matrices que en su mayoría son ceros.

3. Conclusiones
Los avances de la tecnología hacen que la información
cada vez sea más detallada y compleja. Las matrices
dispersas pueden convertirse en herramientas
computacionales muy útiles, pero su uso
indiscriminado puede empeorar el consumo de
memoria y los tiempos de procesamiento.

Cada representación tiene sus ventajas y desventajas

con respecto al consumo de memoria o el tiempo de
procesamiento debido a esto no existe una
representación universal que permita resolver todos
los posibles problemas y cada implementación debe
hacerse teniendo en cuenta que objetivos se quieren
lograr.

4
Apellido Autor et al / Titulo del Articulo

Anexos

5
 Apellido Autor et al / Titulo del Articulo

MATRICES *******/ void

tamano_vector(int H[M][M]) //
Cuenta el numero de elementos en la
Matriz
{
c = 0; // Variable Global que
se inicia con CERO para el conteo
for (i = 0;i<M; i++) {
for (j=0; j<M;j++)
{
if(H[i][j]!=0){
c = c+1;

}
}
}
Código de programación del programa: }

/* Declaración de Variables GLOBALES*/ /******PROCEDIMIENTO PARA CREAR LOS

int A[M][M], B[M][M], T[M][M]; VECTORES DATO COLUMNA Y POSICION
//Matrices Cuadradas para generar las *******/ void crea_vector(int
matrices dispersas int c, i, j, k, l, H[M][M], int Dat[M*M],int
m, cp; // variables para inciiar Col[M*M],int Pos[M*M])
contadores en los procesos repetitivos //Vectores Auxiliares)
int cero, lim, aux; int VR[M*M]; // Se { linea(); c= 0; k=0;
crea el Vector Resultado int limPA, cero = 0; cp=0; for
limPB; int ia,ib, j, ii, jj, ca, cb; (i=0;i<M; i++){ for
(j=0; j<M; j++) {
if (H[i][j] == 0){
/******PROCEDIMIENTO PARA DIBUJAR UNA cero = cero + 1;
LINEA PARA SEPARAR PROCESOS *******/ } else
void linea (){ printf("\n {
================================\n"); Dat[c] = H[i][j];
Col[c] = j;
} if (k == i){
Pos[cp]= c; k
/******PROCEDIMIENTO PARA PRESENTAR = k + 1; cp =
LOS ELEMENTOS DE UNA MATRIZ *******/ cp + 1; }
void presenta_m(int H[M][M]) // c = c+1;
Subrutina para Presentar }
{ linea(); for (i=0;i<M; }
i++){ for (j=0; j<M; }
j++) { Pos[cp]= c;
printf("%d\t",H[i][j]);
} } //Fin Crea Vector
printf("\n"); /******PROCEDIMIENTO PARA GENERAR LA
} TRANSPUESTA DE UNA MATRIZ *******/
void transpuesta(int H[M][M]){ int
} // Fin Presenta Matriz Auxiliar; for (i=0;i<M;i++) {
for (j=0;j<M;j++)
/******PROCEDIMIENTO PARA CONTAR LOS {
ELEMENTOS DIFERENTES DE CERO EN LAS Auxiliar = H[i][j];
T[j][i] = Auxiliar;
}
}
6
 Apellido Autor et al / Titulo del Articulo

Posicion A
} // Fin de Matriz Transpuesta
/**************************************
*****/ //Presenta los VECTORES DE GENERADOS
/****** INICIA EL PROGRAMA PRINCIPAL POR A printf("VECTORES GENERADOS DE
*******/ LA MATRIZ A\n"); linea();
/**************************************
*****/ int main( ) { // Variables
locales int cc1, cc2, cp1, cp2, // Presenta el Vector de Datos
limaux1, limaux2; printf ("\n VECTOR DATOS - Matriz A
\n");
printf("\n");
// Ingresamos los datos en la Matriz A for
printf("****** INGRESE LOS ELEMENTOS DE (i=0;i<c;i++) {
LA MATRIZ A ********\n"); for (i=0;i<M; printf("%d\t", VA[i]);
i++) { }
for (j=0; j<M; j++) { linea();
printf("A[%d][%d]\t",i,j); //
scanf("%d", &aux); Presenta
A[i][j]= aux; el Vector
} Columna
printf("\n"); printf
} ("\n
VECTOR
// Ingresamos los datos en la Matriz B COLUMNA -
printf("****** INGRESE LOS ELEMENTOS Matriz A
DE LA MATRIZ B ********\n"); for \n"); printf("\n");
(i=0;i<M; i++) { for (i=0;i<c;i++) {
for (j=0; j<M; j++) printf("%d\t", CA[i]);
{ } linea();
printf(" B[%d][%d]\t",i,j); // Presenta el Vector Posición de la
scanf("%d", &aux); Matriz A
B[i][j]= printf ("\n VECTOR POSICION - Matriz A
aux; } \n"); printf("\n"); for
printf("\n"); } (i=0;i<(M+1);i++) {
linea(); printf("%d\t", PA[i]);
} linea();
// Imprime la Matriz A printf("\n");
printf("********** DATOS DE LA MATRIZ getch();
A linea();
************\n"); presenta_m(A); //Presenta los datos de la Matriz B
tamano_vector(A); // LLama la printf(" ********** DATOS DE LA MATRIZ
subrutina para calcular los datos de B **********\n"); presenta_m(B); // llama
la Matriz A diferentes de cero a la matriz B y presenta sus datos
linea();
// Elimina los ceros de la Matriz A
int PA[M+1], CA[c], VA[c]; //Creamos //Ejecuta la Matriz transpuesta
los vectores auxiliares para que transpuesta(B); // Genera la matriz
almacenen los datos del METODO Transpuesta que es parte del metodo que
aplicado crea_vector(A, VA, CA, PA); se aplica linea(); printf("**********
// Llama la subrutina que crea los DATOS DE LA MATRIZ TRANSPUESTA B
vectores linea(); ********** \n"); presenta_m(T); //llama a
int TCA = c; // Tamaño de vector Datos los datos de la Matriz Transpuesta c=0;
y Columnas A tamano_vector(B); //Calcula el nuemro
int TPA = M+1; // Tamaño del Vector de elementos diferentes de cero de la
matriz Transpuesta B // Creamos las
7
 Apellido Autor et al / Titulo del Articulo

variables para los Vectores Datos, {

Columna y Posicion int VB[c]; int VR[i]= 0;
CB[c]; int PB[M+1]; } //
getch(
// Elimina los ceros de la Matriz );
TRANSPUESTA printf("INICIO DEL PROCESO DE
crea_vector(T, VB, CB, PB); // LLama la MULTIPLICACION DE MATRICES DISPERSAS");
subrutina para crear los vectores printf("\n");
auxiliares de la MAtriz B limPA = 0; limPB = 0; //Inicia los
int TPB = M+1; // Tamaño del limites para el reccrrido de los
Vector Posicion B vectores Columna A y B // Enceramos
int TCB = c; // Tamaño del vector Datos variables para el inicio del proceso de
y Columnas B calculo cp1=0;
ia=0; //Contador Vector posicion A ib=0;
//Contador Vector posicion B
// Presenta los VECTORES DE GENERADOS
POR TRANSPUESTA DE A
printf("VECTORES GENERADOS DE LA //Encuentra el valor del limite de
MATRIZ reccrrido de los Vectores Columna con la
TRANSPUESTA B \n"); información de los Vectores Posicion
linea(); limPA = limPA + (PA[ia+1]- PA[ia]); //
LimA ==> PA(i+1) - A(i) limPB = limPB +
(PB[ib+1]- PB[ib]); // LimB ==> PB(i+1) -
// Presenta el Vector de Datos de PB(i) ii=0; jj=0; c= 0; linea();
la Transpuesta de B printf("VECTOR
DATOS TRANSPUESTA B
\n"); for // Inicio del proceso de recorrido de
(i=0;i<c;i++) { los vectores posicion y columna para
printf("%d\t", VB[i]); aplicar el método while ((ia <
} TPA)||(ib < TPB))
linea(); { cc1=ii; //Inicia contador para
Vector Columna A while (cc1 <
limPA) {
// Presenta el Vector Columna de la cc2=jj; //Inicia contador Vector
Transpuesta de B Columna B while (cc2<limPB)
printf("VECTOR COLUMNA TRANSPUESTA B {
\n"); if (CA[cc1]==CB[cc2])
printf("\n"); {
for VR[c]= VR[c]+
(i=0;i<c;i++) { (VA[cc1]*VB[cc2]); } cc2
printf("%d\t", CB[i]); = cc2+1; } cc1= cc1+1; }
} c = c+1; if(cc2==TCB) {
linea(); if(cc1==TCA) { ia = TCA;
//Presenta el Vector Posicion de la ib = TCB; } else {
Transpuesta de B jj= 0; //Reinicia el contador columna B,
printf("VECTOR POSICION TRANSPUESTA B cuando el Columna A no a terminado
\n"); printf("\n"); ii = limPA; //Avanza en el vector columna
for A
(i=0;i<(M+1);i++) { ia= ia + 1; // Aumenta
printf("%d\t", PB[i]); el Contador del Vector Posicion A
} ib=0; // Reinicia el Contador
printf("\n"); Vector Posicion B limPB
= 0; //Reinicia el Contador para
//Proceso para ingresar con ceros el Vector Columna B
el vector resultado for (i=0; i< //Calculamos los nuevos limites de
(M*M); i++) los vectores posicion
limPA = limPA + (PA[ia+1]-

8
 Apellido Autor et al / Titulo del Articulo

PA[ia]); limPB = limPB

+ (PB[ib+1]-
PB[ib]);

}
}
else
{
if((cc1 <= TCA)) {
jj = limPB; //Avanza en vector
columna B ib = ib +1;
//Avanza el vector posicion de B
limPB = limPB + (PB[ib+1]- PB[ib]);
// Calculamos el nuevo limite del
Vector Posicion B
}
}
}
// Fin del Proceso para multiplicar las
Matrices Dispersas sobre la base de los
Vectores columna y posicion

linea
();
//Proceso para imprimir la Matriz
Resultante
printf("LA MATRIZ RESULTANTE ES: \n");
printf("\n"); linea(); linea();
printf("\n"); c = 0; for(j=0;j< M;j++){
printf("|\t"); for (i=0; i<M; i++)
{ printf("%d\t", VR[c]);
c = c+1; } printf("|\n"); }
getch(); return 0;