ORIANA

#include <stdio.h>
#include<pthread.h>
#include <time.h>
#include <unistd.h>
#include<stdlib.h>
#include <sys/time.h>
/* Time in seconds from some point in the past */

/*****************************************************************/



double dwalltime()
{
    double sec;
    struct timeval tv;

    gettimeofday(&tv,NULL);
    sec = tv.tv_sec + tv.tv_usec/1000000.0;
    return sec;
}

//FIN de calcular tiempo


int N = 4;
/*Variables pertenecientes a los hilos*/
int P=0;
pthread_mutex_t s=PTHREAD_MUTEX_INITIALIZER;
/*Variables a reemplazar por argumentos*/
int Min=999;
int Max=-1;
int check = 1;

/*matriz A por fila y por columnas*/
int *Af,*Ac,*L,*U,*A,*At,*AU,*AL,*AA ,*AAt,*RESULT;
double timetick;










//funcion para poder visualizar matriz
void vermatriz(int* m,int modo){
/*LE DA EL FORMATO A LA COLUMNA*/
        printf(" \t Columna |\t");
        for(int k=0;k<N;k++){
            printf(" %d \t",k);
        }
        printf("\n");
        printf("\t -------------------------------------------");
        printf("\n");

        printf("\t");
        for(int i=0;i<N;i++){
            printf(" Fila %d  |\t",i);
               for(int j=0;j<N;j++){
                    if(modo = 0){
                        printf(" %d \t",m[i*N+j] );//recorre por fila
                    }
                    else{
                        printf(" %d \t",m[i+j*N] );//recorre por columna
                        }
                }
                printf("\n \t");
           }

}


//funcion que hace la tarea de forma secuencial
void resultadoSecuencial(){

        /*OPERACION  L*A  */


    for(int i=0;i<N;i++){
           for(int j=0;j<N;j++){
                 for(int k=0;k<N;k++) {
                   AL[j*N+i] = ( A[i*N+k] * L[k+j*N] ) + AL[j*N+i];


    //SE MUEVE POR  COLUMNA         FILA        COLUMNA
                 }
               }
            }


        /*OPERACION  A*At  */


        for(int i=0;i<N;i++){
              for(int j=0;j<N;j++){
                for(int k=0;k<N;k++) {
                  AAt[i*N+j]+= A[i*N+k] * At[i*N+k];
    //SE MUEVE POR  FILA        FILA        COLUMNA
                }
              }
            }


        /*OPERACION  U*A  */



        for(int i=0;i<N;i++){
              for(int j=0;j<N;j++){
                for(int k=0;k<N;k++) {
                  AU[i*N+j]+= U[i*N+k] * Ac[k+j*N];
    //SE MUEVE POR  FILA        FILA        COLUMNA
                }
              }
            }


// vamos a hacer esteeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee!!!!!!!!!!!

        /*OPERACION DE MAXIMO Y MINIMO  forma secuencial*/

/*
        for(int i=0;i<N;i++){
                for(int j=0;j<N;j++){
                        if(AU[i*N+j]>max){
                                max=AU[i*N+j];
                        }
                        else{
                            if(AU[i*N+j]<min)
                              {
                                min=AU[i*N+j];
                              }
                        }
                }
            }
            */


}

/*Paralelizamos!!!!!!!!!!!!!!!!!!!!!!!!!!!!! :D:D:D:D::D:D */

/*Funcion para */
void * Funcion_maxmin(void * arg){


    int tid = *(int*) arg;
    int ini= tid*(P);
    int fin= (tid+1)*(P);
    int min=999;  int max=-1;  // es mejor calcular los minimos y maximos de manera local
    // y al final pasarselos a una variable global minimo y maximo. Esto es debido a la rapidez
    printf(" \n ");
    printf(" \n ");
    printf(" ESTOY EN LA FUNCION DE H %d",tid);
    printf(" \n ");
    printf(" \n ");
    printf(" INI %d FIN  %d",ini,fin);
    printf(" \n ");
    printf(" \n ");

    for(int i=ini;i<fin;i++){
            printf(" \n ");
            printf(" \n ");
            printf(" FILA %d ",i);
            printf(" \n ");
            printf(" \n ");
           for(int j=ini;j<fin;j++){
            printf(" \n ");
            printf(" \n ");
            printf(" COLUMNA %d ",j);
            printf(" \n ");
            printf(" \n ");
                if(AU[i*fin+j]<min){

                        min=AU[i*N+j];

                }
                if(AU[i*fin+j]>max){

                        max=AU[i*N+j];

                }
            }
    }
    // se lo pasamos a la variable global

        pthread_mutex_lock(&s);
            if(min<Min){
                Min=min;
            }
        pthread_mutex_unlock(&s);


    pthread_mutex_lock(&s);
            if(max>Max){
                Max=max;
            }

    pthread_mutex_unlock(&s);
    pthread_exit(NULL); //finalizacion del hilo

}




int main(int argc,char*argv[]){
    int H=2; // es un valor por defecto en el caso de que no se
    // introduzca ningun valor por consola.

 //Controla los argumentos al programa
    if ((argc != 3) || ((N = atoi(argv[1])) <= 0) || ((H = atoi(argv[2])) <= 0) )
    {
        printf("\nUsar: %s n\n  h: cant hilos  \n", argv[0]);
        exit(1);
    }


    /*Declarar e inicializaciones*/
    N=atoi(argv[1]); // Inicializa valor de mi arreglo de N elementos
    H=atoi(argv[2]); //incializar valor de hilos


    //calculamos la proporcion
    P=N/H;

    // ejemplo  a = (double *) malloc(n*n*sizeof(double));
        /*matriz A por fila y por columnas*/
        Af = (int*)malloc(N*N*sizeof(int));
        Ac = (int*)malloc(N*N*sizeof(int));
        /*Matrices triangular superior e inferiror*/
        L = (int*)malloc(N*N*sizeof(int));
        U = (int*)malloc(N*N*sizeof(int));
        /*Matriz A original*/
        A = (int*)malloc(N*N*sizeof(int));
        /*almacena la matriz transpuesta de A, el producto de tri sup por A y tri inf por A*/
        At = (int*)malloc(N*N*sizeof(int));
        AU = (int*)malloc(N*N*sizeof(int));
        AL = (int*)malloc(N*N*sizeof(int));
        AA = (int*)malloc(N*N*sizeof(int));
        AAt = (int*)malloc(N*N*sizeof(int));
        /*almacena en la variable resultado */
        RESULT = (int*)malloc(N*N*sizeof(int));




    /*---- iniialisa por filas---*/

    /*---- iniialisa por columnas---*/
 //iniializa los valores de la matriz A cuadrada
    for(int i=0;i<N;i++){
       for(int j=0;j<N;j++){
            A[i*N+j]= 1;
            Ac[i+j*N]=1;
            Af[i*N+j]=1;
            AU[i*N+j]=0;
            AL[i*N+j]=0;
            AAt[j*N+i]=0;
        }
    }

//iniializa la matriz L
    for(int i=0;i<N;i++){
       for(int j=0;j<N;j++){
            if (i>=j)
            {
                L[i+j*N]= 1;
            }
            else
            {
                L[i+j*N]= 0;   // ori estuvo aca era 0
            }

       }
      }

//iniializa la matriz U
      for(int i=0;i<N;i++){
       for(int j=0;j<N;j++){
            if (i>=j)
            {
                U[i*N+j]= 1;
            }
            else
            {
                U[i*N+j]= 0;
            }

       }
      }
//--------------------------------
// trabajamos con los hilos


    //Reservo memoria para el vector de hilos
    pthread_t* tid = (pthread_t*)(malloc(sizeof(pthread_t)*H)); // por esto me daba error!
    int* threads_ids =  (int*)(malloc(sizeof(int)*H));
    pthread_mutex_init(&s,NULL); // inicializacion s

 //Realiza el tiempo inicial para la busqueda y calclulo

timetick = dwalltime();
for (int t = 0; t < H; t++)
{
    threads_ids[t]=t;
    pthread_create(&tid[t],NULL,Funcion_maxmin,(void *)&threads_ids[t]);

}
for (int t = 0; t < H; t++)
{
    pthread_join(tid[t],NULL);

}
//Destruccion de s
    pthread_mutex_destroy(&s);
//-----------------------------------


//calculo la matriz transpuesta de A
    for(int i=0;i<N;i++){
       for(int j=0;j<N;j++){
            At[j*N+i]=A[i*N+j];
        }
    }


//Realiza el tiempo iniial para la busqueda y calclulo
timetick = dwalltime();
    // algoritmo secuencial
    resultadoSecuencial();

printf("Tiempo en segundos %f\n", dwalltime() - timetick);

/*NOTA fila = 0 ; columna = 1; */
    /*printf(" \n ");
    printf(" \n ");
    printf(" La matriz U es: ");
    printf(" \n ");
    printf(" \n ");
    vermatriz(U,0);
    printf(" \n ");
    printf(" \n ");
*/
    printf(" \n ");
    printf(" \n ");
    printf(" La matriz U es: ");
    printf(" \n ");
    printf(" \n ");
    vermatriz(U,0);
    printf(" \n ");
    printf(" \n ");

    printf(" \n ");
    printf(" \n ");
    printf(" La matriz A es: ");
    printf(" \n ");
    printf(" \n ");
    vermatriz(A,0);
    printf(" \n ");
    printf(" \n ");

    printf(" \n ");
    printf(" \n ");
    printf(" La matriz AU es: ");
    printf(" \n ");
    printf(" \n ");
    vermatriz(AU,0);
    printf(" \n ");
    printf(" \n ");


int i, j;
//Verifica el resultado
  for(i=0;i<N;i++){
   for(j=0;j<N;j++){
    check=check&&( AU[i*N+j]<=N);
    printf("Multiplicacion (%d, %d) = %d da %d \n",  i , j, AU[i*N+j], check);



   }
  }

  if(check){
   printf("Multiplicacion de matrices resultado correcto\n");
  }else{
   printf("Multiplicacion de matrices resultado erroneo\n");
  }
  printf("resultado max es: %d \n",Max );
  printf("resultado min es: %d \n",Min );

/*matriz A por fila y por columnas*/
free(Af);
free(Ac);

/*Matrices triangular superior e inferiror*/
free(L);
free(U);

/*Matriz A original*/
free(A);

/*almacena la matriz transpuesta de A, el producto de tri sup por A y tri inf por A*/
free(At);
free(AU);
free(AL);
free(AA);
free(AAt);

/*almacena en la variable resultado */
free(RESULT);


return(0);
}


//NOTA AVERIGUAR POR QUE SE DESBORDA