Practica Multiplicacion Matrices

INSTITUTO POLITÉCNICO NACIONAL

ESCUELA SUPERIOR

DE

CÓMPUTO

UNIDAD DE APRENDIZAJE:

ANALISIS DE ALGORITMOS

PROFESORA: GARCIA MENDOZA CONSUELO VARINIA

ALUMNOS: BENITEZ CRUZ DANIELA

OLIVARES REYES CARLOS ALBERTO SAAVEDRA PALESTINA ROBERTO

PRACTICA 3:

Multiplicación de Matrices

GRUPO: 3CM4

Introducción

Producto de matrices

Dadas dos matrices A y B, su producto es otra matriz P cuyos elementos se obtienen multiplicando las filas de A por las columnas de B. De Es evidente que el número de columnas de A debe coincidir con el número de filas de B. Si A tiene dimensión m x n y B dimensión n x p, la matriz P será de orden m x p:

La división en submatrices sugiere una estrategia recursiva de divide y vencerás, que puede ser especialmente ventajoso en sistemas de memoria compartida. La ventaja de esta estrategia es que en cada paso de recursión, los datos transmitidos son más pequeños y están más localizados.

Algoritmo de StrassenEn la disciplina matemática del álgebra lineal, el algoritmo de Strassen, llamado así por Volker Strassen, es un algoritmo usado para la multiplicación de matrices. Es asintóticamente más rápido que el algoritmo de multiplicación de matrices estándar, pero más lento que el algoritmo más rápido conocido, y es útil en la práctica para matrices grandes.

Dadas dos matrices:

Podemos poner……

Entonces el producto queda:

Este procedimiento requiere 7 multiplicaciones para calcular el producto de A y B (pero más sumas que el método tradicional).

Algoritmo de multiplicación de StrassenSi reemplazamos cada elemento de A y B por una matriz de n x n, las fórmulas anteriores nos dan una forma de multiplicar dos 2n X 2n matrices.

A partir de esto tenemos un método recursivo para calcular el producto de matrices con n Algoritmo de multiplicación de Strassen potencia de 2.

Este método se puede generalizar también a matrices cuyas dimensiones no sean de la forma 2n

Objetivos

Realizar un programa para dar solución al problema de la multiplicación de matrices, mediante el método divide y vencerás, y por medio de Strassen.

Programa

MULTIPLICACION DE MATRICES CON DIVIDE Y VENCERAS.

CODIGO:

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

int max(int,int);

int **multiplicamatriz(int **,int **,int); // Funci?n recursiva que multiplica matrices

int **suma(int **,int **,int); // suma de matrices

int **resta(int **,int **,int);// Resta de matrices

void libera(int **,int); // Libera memoria

int max(int a,int b)

{

return((a>b)?a:b);

}

int **multiplicamatriz(int **mapa1,int **mapa2,int num)

{

int **sol,**M[8],**f1,**f2,**f3,**f4,**f5,**f6,**f7,**f8,**f9,**f10,**aux,**aux2;

int **A[2][2],**B[2][2],**C[2][2];

int a,q,w,r,b;

sol=(int **)malloc(sizeof(int *)*num);

for(a=0;a<num;a++){

sol[a]=(int *)malloc(sizeof(int)*num);

}

if(num==1)

{

sol[0][0]=mapa1[0][0]*mapa2[0][0];

return(sol);

}

else{

// Crear las submatrices de A y B.

for(q=0;q<2;q++)

{

for(w=0;w<2;w++)

{

A[q][w]=(int **)malloc(sizeof(int *)*(num/2));

for(a=0;a<num/2;a++)

{

A[q][w][a]=(int *)malloc(sizeof(int)*(num/2));

for(r=0;r<num/2;r++){

A[q][w][a][r]=mapa1[a+(num/2)*q][r+(num/2)*w];

}

}

B[q][w]=(int **)malloc(sizeof(int *)*(num/2));


{

B[q][w][a]=(int *)malloc(sizeof(int)*(num/2));


B[q][w][a][r]=mapa2[a+(num/2)*q][r+(num/2)*w];

}

}

}

}

// Hallar las matrices M.

f1=resta(B[0][1],B[1][1],num/2);

f2=suma(A[0][0],A[0][1],num/2);

f3=suma(A[1][0],A[1][1],num/2);

f4=resta(B[1][0],B[0][0],num/2);

f5=suma(A[0][0],A[1][1], num/2);

f6=suma(B[0][0],B[1][1],num/2);

f7=resta(A[0][1],A[1][1],num/2);

f8=suma(B[1][0],B[1][1],num/2);

f9=resta(A[0][0],A[1][0],num/2);

f10=suma(B[0][0],B[0][1],num/2);

M[1]=multiplicamatriz(A[0][0],f1,num/2);

M[2]=multiplicamatriz(f2,B[1][1],num/2);

M[3]=multiplicamatriz(f3,B[0][0],num/2);

M[4]=multiplicamatriz(A[1][1],f4,num/2);

M[5]=multiplicamatriz(f5,f6,num/2);



// Hallar las submatrices de C.

C[0][0]=suma(M[5],M[4],num/2);

aux=C[0][0];

C[0][0]=resta(C[0][0],M[2],num/2);

aux2=C[0][0];

C[0][0]=suma(C[0][0],M[6],num/2);

libera(aux,num/2);

libera(aux2,num/2);

C[0][1]=suma(M[1],M[2],num/2);

C[1][0]=suma(M[3],M[4],num/2);

C[1][1]=suma(M[1],M[5],num/2);

aux=C[1][1];

C[1][1]=resta(C[1][1],M[3],num/2);

aux2=C[1][1];

C[1][1]=resta(C[1][1],M[7],num/2);

libera(aux,num/2);

libera(aux2,num/2);

for(a=1;a<=7;a++){

libera(M[a],num/2);

}

// Unir las submatrices de matrices C en sol.

for(q=0;q<num;q++){

for(w=0;w<num;w++){

sol[q][w]=C[q/(num/2)][w/(num/2)][q%(num/2)][w%(num/2)];

}

}

// Liberar las submatrices de A, B y C.

/*for(q=0;q<2;q++){

for(w=0;w<2;w++)

{

libera(A[q][w],num/2);

libera(B[q][w],num/2);

libera(C[q][w],num/2);

}

}*/

}

return(sol);

}

int **multiplicaDyV(int **mapa1,int **mapa2,int num)

{

int **sol,**M[8],**f1,**f2,**aux,**aux2;

int **A[2][2],**B[2][2],**C[2][2];

int a,q,w,r,b;


for(a=0;a<num;a++){


}

if(num==1)

{

sol[0][0]=mapa1[0][0]*mapa2[0][0];

return(sol);

}

// Crear las submatrices de A y B.

for(q=0;q<2;q++)

{

for(w=0;w<2;w++)

{

A[q][w]=(int **)malloc(sizeof(int *)*(num/2));


{

A[q][w][a]=(int *)malloc(sizeof(int)*(num/2));


A[q][w][a][r]=mapa1[a+(num/2)*q][r+(num/2)*w];

}

}

B[q][w]=(int **)malloc(sizeof(int *)*(num/2));


{

B[q][w][a]=(int *)malloc(sizeof(int)*(num/2));


B[q][w][a][r]=mapa2[a+(num/2)*q][r+(num/2)*w];

}

}

}

}

// Hallar las matrices M.

M[0]=multiplicaDyV(A[0][0],B[0][0],num/2);








// Hallar las submatrices de C.

C[0][0]=suma(M[0],M[1],num/2);

C[0][1]=suma(M[2],M[3],num/2);

C[1][0]=suma(M[4],M[5],num/2);

C[1][1]=suma(M[6],M[7],num/2);

for(a=0;a<=7;a++){

libera(M[a],num/2);

}

// Unir las submatrices de matrices C en sol.

for(q=0;q<num;q++){

for(w=0;w<num;w++){

sol[q][w]=C[q/(num/2)][w/(num/2)][q%(num/2)][w%(num/2)];

}

}

// Liberar las submatrices de A, B y C.

/*for(q=0;q<2;q++){

for(w=0;w<2;w++)

{

libera(A[q][w],num/2);

libera(B[q][w],num/2);

libera(C[q][w],num/2);

}

}*/

return(sol);

}

int **suma(int **mapa1,int **mapa2,int num)

{ // sumar mapa1 y mapa2.

int a,b;

int **sol;


for(a=0;a<num;a++)

{


for(b=0;b<num;b++){

sol[a][b]=mapa1[a][b]+mapa2[a][b];

//printf("suma sol : %d\n", sol[a][b]);

}

}

return(sol);

}

int **resta(int **mapa1,int **mapa2,int num)

{ // Restar mapa2 de mapa1.

int **sol;

int a,b;


for(a=0;a<num;a++)

{


for(b=0;b<num;b++){

sol[a][b]=mapa1[a][b]-mapa2[a][b];

//printf("resta sol : %d\n", sol[a][b]);

}

}

return(sol);

}

void libera(int **mapa,int num)

{

int a;

for(a=0;a<num;a++) // Liberar la tabla din?mica de 2D.

free(mapa[a]);

free(mapa);

}

int main()

{

int **mapa1,**mapa2,**sol, **sol1;

int f1,c1,f2,c2,a,b,m,m1;

printf("Introduce el tama?o de la columna de la primer matriz:\n");

scanf("%d",&f1);

printf("Introduce el tama?o de la fila de la primer matriz:\n");

scanf("%d",&c1);

//scanf(" %d %d",&f1,&c1); // Tama?o de la primera matriz

printf("Introduce el tama?o de la columna de la segunda matriz:\n");

scanf("%d",&f2);

printf("Introduce el tama?o de la fila de la segunda fila:\n");

scanf("%d",&c2);

//scanf(" %d %d",&f2,&c2); // Tama?o de la segunda matriz

m1=max(f1,max(c1,max(f2,c2)));

for(m=1;m<m1;m*=2); // El tama?o de las matrices cuadradas a multiplicar

//debe ser de la forma 2k, si no se completan con ceros.

mapa1=(int **)malloc(sizeof(int *)*m); // Se crea la primera matriz

for(a=0;a<m;a++)

{

mapa1[a]=(int *)malloc(sizeof(int)*m);

memset(mapa1[a],0,sizeof(int)*m);

}

puts("Datos primer matriz\n");

for(a=0;a<f1;a++){ // Se cogen los datos de la primera matriz.

for(b=0;b<c1;b++){

//printf("Introduce los valores del elemento (%d , %d) de la primera matriz:", a+1 , b+1);

scanf(" %d",&mapa1[b][a]);

//printf("valor %d , %d = %d\n",b,a,mapa1[b][a]);

}

}

for(a=0;a<m;a++){

for(b=0;b<m;b++){

printf("%d", mapa1[a][b]);

}printf("\n");

}

mapa2=(int **)malloc(sizeof(int *)*m); // Se crea la sedunda matriz.

for(a=0;a<m;a++)

{

mapa2[a]=(int *)malloc(sizeof(int)*m);

memset(mapa2[a],0,sizeof(int)*m);

}

puts("Datos segunda matriz\n");

for(a=0;a<f2;a++){ // Se cogen los datos de la segunda matriz.

for(b=0;b<c2;b++){

//printf("Introduce los valores del elemento (%d , %d) de la segunda matriz:", a+1 , b+1);

scanf(" %d",&mapa2[b][a]);

//printf("valor %d , %d = %d\n",b,a,mapa2[b][a]);

}

}

for(a=0;a<m;a++){

for(b=0;b<m;b++){

printf("%d", mapa2[a][b]);

}printf("\n");

}

sol=multiplicaDyV(mapa1,mapa2,m); // Se multiplican.

sol1=multiplicamatriz(mapa1,mapa2,m);

printf("Solucion DyV: \n");

for(a=0;a<m;a++) // Se imprime el resultado.

{ for(b=0;b<m;b++){

printf(" %d ",sol[a][b]);

} printf("\n");

}

printf("Solucion Strassen: \n");

for(a=0;a<m;a++) // Se imprime el resultado.

{ for(b=0;b<m;b++){

printf(" %d ",sol1[a][b]);

} printf("\n");

}

system("pause");

return(0);

}

Conclusiones

Con esta práctica observamos que el problema de multiplicación de matrices se puede resolver de diferentes formas, por medio de divide y vencerás y el método de Strassen, con esto aprendimos que para este problema en particular la técnica divide y vencerás es más lenta, aunque no quedo muy claro ya que las matrices que utilizamos no fueron lo suficientemente grandes como para observar completamente esta diferencia.

Referencias

http://es.wikipedia.org/wiki/Algoritmo_de_Strassen

http://www.ing.ula.ve/~aguilar/actividad-docente/AYDA/Clase7MiniSem.pdf

http://www.ing.ula.ve/~aguilar/actividad-docente/AYDA/Clase7MiniSem.pdf

http://es.wikipedia.org/wiki/Algoritmo_de_Strassen

Practica Multiplicacion Matrices

Documents

Transcript of Practica Multiplicacion Matrices