elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Guía rápida para descarga de herramientas gratuitas de seguridad y desinfección


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  multiplicar matrices con pipes
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: multiplicar matrices con pipes  (Leído 3,515 veces)
SO

Desconectado Desconectado

Mensajes: 1


Ver Perfil
multiplicar matrices con pipes
« en: 10 Octubre 2010, 07:18 am »

Hola!! Necesito ayuda, mi programa debe multiplicar dos matrices utilizando pipes pero la verdad no tengo idea de como hacerlo , he avanzado un poco pero aun falta mucho por hacer... Espero me puedan ayudar a completar mi codigo...

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>


int m,n,p; /*Variables que contendran las dimensiones de las matrice*/
int **matdfA,**matdfB;
int **matA,**matB,*matresultado;



/*-----------------------Funciones----------------------*/

/*La funcion cerrarpipe permitira como bien dice su nombre
cerrar las entradas no utilizadas*/
void cerrarpipe(int a){  /*el parametro i es la pipe utilizada*/
    int j;
    for(j=0;j<m;j++){
        if(j!=a){
            close(matdfA[j][0]);  /*cerramos tanto la parte de lectura como de escritura de las pipes no utilizadas*/
            close(matdfA[j][1]);
            //close(matdfA[j]);
            close(matdfB[j][0]);
            close(matdfB[j][1]);
            //close(matdfB[j]);
        }

    }
}
void padre_parte_envia_matriz(){

    /* Creacion del buffer*/
    int j,k, *bufr;
    for(j=0;j>m;j++){
        for(k=0;k<n;k++){
            //bufr[k]=matA[j][k];
            bufr[k]=matA[j][k];
        }
        write(matdfA[j][1],bufr,sizeof(bufr));
    }

}
/*Leeremos los datos y asignaremos estos al buffer*/
void hijo_recibe(int i){
    int *bufr,*resultado;
    read(matdfA
  • ,bufr,sizeof(bufr));
    /*Procesamiento del buffer*/
    write(matdfB[1],resultado,sizeof(resultado));
}
/*Creacion de las matrices iniciales aleatoriamente e impresion*/
void crear_matrices(int m, int n, int p){
    int i,j;
    //matA=(int *)malloc(sizeof(int*)*m);
    //for(i=0;i<m;i++){
    //    matA=(int *)malloc(sizeof(int*)*n);
    //}
    for(i=0;i<m;i++){
        for(j=0;j<n;j++){
            matA[j]=rand()%9;
            }
    }
    for(i=0;i<n;i++){
        for(j=0;j<p;j++){
            matB[j]=rand()%9;
            }
    }
    printf("********Matriz A********");
    for(i=0;i<m;i++){
        for(j=0;j<n;j++){
            printf("%d",matA[j]);
        }
        printf("\n");
    }
    printf("********Matriz B********");
    for(i=0;i<n;i++){
        for(j=0;j<p;j++){
            printf("%d",matB[j]);
        }
        printf("\n");
    }

}
void padre_obtiene_datos(){
    fd_set fd;
    int mayor;
    int cont,j,i;
    mayor=matdfB[0][0];
    for(i=1;i<m;i++){
        if(mayor<matdfB
  • ){
            mayor=matdfB
  • ;
        }
    }
    do{
            FD_ZERO(&fd);
            for(j=0;j<m;j++){
            FD_SET(matdfB[j][0],&fd);
            }
            if(select(mayor+1,&fd,NULL,NULL,NULL)){
                perror("Select");
            }
            else{
                for(j=0;j<m;j++){
                        if(FD_ISSET(matdfB[j][0],&fd)){
                            /* ..........*/
                        }
                        else{
                        read(matdfB[j][0],matresultado,sizeof(matresultado));
                        cont++;
                        }
                }
            }
    }while(cont<m);
}

int main(){

    int i;
    int j;
    /*Peticion de las dimensiones para la creacion de matrices */
    printf("De el numero de columnas en de la Matriz A: ");
    scanf("%d",&n);
    printf("\n De el numero de filas en de la Matriz A: ");
    scanf("%d",&m);
    printf("\n De el numero de filas en de la Matriz B: ");
    scanf("%d",&p);
        matdfA=(int **)malloc(sizeof(int *)*m);
   
    for(i=0;i<m;i++){
        matdfA=(int *)malloc(sizeof(int)*2);
        matdfB=(int *)malloc(sizeof(int)*2);
        for(j=0;j<m;j++){
            if(pipe(matdfA[j]<0) || pipe(matdfB[j]<0)){
                perror("Error creando pipes");
                exit(0);
            }
        }
    }
/* Creacion de los hijos con las caracteriasticas necesarias*/
    for(i=0;i<m;i++){
        if(fork()==0){
            cerrarpipe(i);
            hijo_recibe(i);
            exit(0);
        }
    }
    crear_matrices(m,n,p);
    padre_parte_envia_matriz();
    padre_obtiene_datos();


}


En línea

Oblivi0n


Desconectado Desconectado

Mensajes: 392

Odio las ranas.


Ver Perfil
Re: multiplicar matrices con pipes
« Respuesta #1 en: 10 Octubre 2010, 16:04 pm »

Seria bueno que metieses el codigo en las etiquetas correspondientes...
Código
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <unistd.h>
  4.  
  5.  
  6. int m,n,p; /*Variables que contendran las dimensiones de las matrice*/
  7. int **matdfA,**matdfB;
  8. int **matA,**matB,*matresultado;
  9.  
  10.  
  11.  
  12. /*-----------------------Funciones----------------------*/
  13.  
  14. /*La funcion cerrarpipe permitira como bien dice su nombre
  15. cerrar las entradas no utilizadas*/
  16. void cerrarpipe(int a){  /*el parametro i es la pipe utilizada*/
  17.    int j;
  18.    for(j=0;j<m;j++){
  19.        if(j!=a){
  20.            close(matdfA[j][0]);  /*cerramos tanto la parte de lectura como de escritura de las pipes no utilizadas*/
  21.            close(matdfA[j][1]);
  22.            //close(matdfA[j]);
  23.            close(matdfB[j][0]);
  24.            close(matdfB[j][1]);
  25.            //close(matdfB[j]);
  26.        }
  27.  
  28.    }
  29. }
  30. void padre_parte_envia_matriz(){
  31.  
  32.    /* Creacion del buffer*/
  33.    int j,k, *bufr;
  34.    for(j=0;j>m;j++){
  35.        for(k=0;k<n;k++){
  36.            //bufr[k]=matA[j][k];
  37.            bufr[k]=matA[j][k];
  38.        }
  39.        write(matdfA[j][1],bufr,sizeof(bufr));
  40.    }
  41.  
  42. }
  43. /*Leeremos los datos y asignaremos estos al buffer*/
  44. void hijo_recibe(int i){
  45.    int *bufr,*resultado;
  46.    read(matdfA
  47. ,bufr,sizeof(bufr));
  48.    /*Procesamiento del buffer*/
  49.    write(matdfB[1],resultado,sizeof(resultado));
  50. }
  51. /*Creacion de las matrices iniciales aleatoriamente e impresion*/
  52. void crear_matrices(int m, int n, int p){
  53.    int i,j;
  54.    //matA=(int *)malloc(sizeof(int*)*m);
  55.    //for(i=0;i<m;i++){
  56.    //    matA=(int *)malloc(sizeof(int*)*n);
  57.    //}
  58.    for(i=0;i<m;i++){
  59.        for(j=0;j<n;j++){
  60.            matA[j]=rand()%9;
  61.            }
  62.    }
  63.    for(i=0;i<n;i++){
  64.        for(j=0;j<p;j++){
  65.            matB[j]=rand()%9;
  66.            }
  67.    }
  68.    printf("********Matriz A********");
  69.    for(i=0;i<m;i++){
  70.        for(j=0;j<n;j++){
  71.            printf("%d",matA[j]);
  72.        }
  73.        printf("\n");
  74.    }
  75.    printf("********Matriz B********");
  76.    for(i=0;i<n;i++){
  77.        for(j=0;j<p;j++){
  78.            printf("%d",matB[j]);
  79.        }
  80.        printf("\n");
  81.    }
  82.  
  83. }
  84. void padre_obtiene_datos(){
  85.    fd_set fd;
  86.    int mayor;
  87.    int cont,j,i;
  88.    mayor=matdfB[0][0];
  89.    for(i=1;i<m;i++){
  90.        if(mayor<matdfB
  91. ){
  92.            mayor=matdfB
  93. ;
  94.        }
  95.    }
  96.    do{
  97.            FD_ZERO(&fd);
  98.            for(j=0;j<m;j++){
  99.            FD_SET(matdfB[j][0],&fd);
  100.            }
  101.            if(select(mayor+1,&fd,NULL,NULL,NULL)){
  102.                perror("Select");
  103.            }
  104.            else{
  105.                for(j=0;j<m;j++){
  106.                        if(FD_ISSET(matdfB[j][0],&fd)){
  107.                            /* ..........*/
  108.                        }
  109.                        else{
  110.                        read(matdfB[j][0],matresultado,sizeof(matresultado));
  111.                        cont++;
  112.                        }
  113.                }
  114.            }
  115.    }while(cont<m);
  116. }
  117.  
  118. int main(){
  119.  
  120.    int i;
  121.    int j;
  122.    /*Peticion de las dimensiones para la creacion de matrices */
  123.    printf("De el numero de columnas en de la Matriz A: ");
  124.    scanf("%d",&n);
  125.    printf("\n De el numero de filas en de la Matriz A: ");
  126.    scanf("%d",&m);
  127.    printf("\n De el numero de filas en de la Matriz B: ");
  128.    scanf("%d",&p);
  129.        matdfA=(int **)malloc(sizeof(int *)*m);
  130.  
  131.    for(i=0;i<m;i++){
  132.        matdfA=(int *)malloc(sizeof(int)*2);
  133.        matdfB=(int *)malloc(sizeof(int)*2);
  134.        for(j=0;j<m;j++){
  135.            if(pipe(matdfA[j]<0) || pipe(matdfB[j]<0)){
  136.                perror("Error creando pipes");
  137.                exit(0);
  138.            }
  139.        }
  140.    }
  141. /* Creacion de los hijos con las caracteriasticas necesarias*/
  142.    for(i=0;i<m;i++){
  143.        if(fork()==0){
  144.            cerrarpipe(i);
  145.            hijo_recibe(i);
  146.            exit(0);
  147.        }
  148.    }
  149.    crear_matrices(m,n,p);
  150.    padre_parte_envia_matriz();
  151.    padre_obtiene_datos();
  152.  
  153.  
  154. }
  155.  


En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Ayuda.Error. Intentando multiplicar dos matrices.
Programación C/C++
sofi1 2 3,255 Último mensaje 22 Agosto 2011, 04:11 am
por sofi1
Multiplicar en pascal
Programación General
_Rainbow_ 1 2,409 Último mensaje 28 Febrero 2014, 15:29 pm
por engel lex
Ayuda con este programa para multiplicar matrices!!
Java
Berman 4 2,654 Último mensaje 25 Junio 2016, 08:14 am
por hectornunezrivas
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines