a

/* COGNOM1: PASCUAL
 * COGNOM2: MIRALLES
 * NOM : NICOLÁS
 * DNI :47942665-Q
 * Exercici 3.
 */

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

int main (void){
    carregarMatriu();
  return 0;
}

void carregarMatriu(void){
    int n, i, j, variable;
    double **A, **B, tol, **C;
    //demanem la dimensio de la matriu
    printf("doneu la dimensio de la matriu, (n) =\n");
    variable= scanf("%d", &n);
    //demanem la tolerancia
    printf("introdueix la tolerancia:");
    variable= scanf("%lf", &tol);
    //introduim els valors de la matriu A
    printf("introduiu els valors de la matriu A: \n");
    A= (double **)malloc(n*sizeof(double*));    //reservem memoria per A
    if (A== NULL){
      printf("No hi ha prou memoria");
      exit(1);
    }
    //llegim fila per fila
    for (i=0; i<n; ++i){
      A[i] = (double*)malloc(n*sizeof(double));
      if(A[i]== NULL) {
    exit(2);
      }
        for (j=0; j<n; ++j){     //llegim columna per columna
            variable= scanf("%lf", &A[i][j]);  //escanejem el valor i l'adjudiquem a A[i][j]
            if(fabs(A[i][j])<= tol){  // si el nombre introduit es mes petit que la tolerancia donada
                A[i][j]=0.000;          //el nombre serà igual a 0.
            }
        }
    }
    //creem la matriu identitat amb 1 a la diagonal
    printf("la matriu B es: \n");
    B= (double **)malloc(n*sizeof(double*));
    for(i=0; i<n; i++){
        B[i] = (double*)malloc(n*sizeof(double));
        for (j=0; j<n; j++){
            if(j==i){
                B[i][j]=1;
            } else {
                B[i][j]=0;
            }
        }
    }
    printf("\n Matriu A: \n");
    mostraMatriu(n, A);
    printf("Matriu B: \n");
    mostraMatriu(n,B);
    inversaA(n,A,B,tol);
    C= (double **)malloc((n)*sizeof(double*));
    prodMatMat(n, A,B,C);
  }

  //creem un metode per imprimir la matriu
  void mostraMatriu(int n, double **A){
      int i,j;
      for(i=0; i<n; ++i){
          for(j=0; j<n; ++j){
              printf("%16.7e ", A[i][j]);
          }
          printf("\n");
      }
  }

  //creem un metode per imprimir la matriu
  void mostraMatriu2(int n, int k, double **A){
      int i,j;
      for(i=0; i<n; ++i){
          for(j=0; j<k; ++j){
              printf("%16.7e ", A[i][j]);
          }
          printf("\n");
      }
  }
  //creem un metode per imprimir un vector
  void mostraVector(int n, double *b){
      int i;
      for(i=0; i<n; ++i){
          printf("%16.7e ", b[i]);
      }
      printf("\n");
  }

  int inversaA(int n, double **A, double **B, double tol){
    double **AB;
    double r, mult, negat;
    int j, j2, i, k, aux, i2, aux2, cicle, j3, contador, contador2;
    //k sera la dimensio de la nova matriu
    k=n+n;
    //reservem memoria per la matriu AB
    AB= (double **)malloc((n+n)*sizeof(double*));
    //recorrem les files
    for(i=0; i<n; i++){
        AB[i]= (double *)malloc(k*sizeof(double));
        for(j=0; j<n; j++){ //recorrem les columnes
            AB[i][j]= A[i][j];  //copiem en AB la part que volem de A
            AB[i][n+j]= B[i][j];    //copiem en AB despres de A, la matriu identitat
          }
      }
      printf("Matriu AB: \n");
      mostraMatriu2(n,k, AB);
      printf("\n \n");
      // fins aqui la creacio de la matriu AB #######################
      // ara busquem començar a fer gauss amb 1 en la diagonal#######
      cicle=0;    //inicialitzem diverser variables que farem servir mes endavant
      j=0;
      aux=0;
      for (j3= 0; j3<n; j3++){  //recorrem les columnes
        for (i=aux; i<n; i++){  //baixem en diagonal
              mult= (1/(AB[i][j3])); //guardem l'invers de la posicio que ens interessa
              if(AB[i][j3]!=1){ //si no es un 1 entrem en el bucle
                  for(j2=0; j2<k; j2++){ //per cada columna de tota la matriu AB
                      AB[i][j2]= mult* (AB[i][j2]);     //multipliquem la fila per l'invers
                  }
              }
              aux++; //incrementem el contador per anar en diagonal en el bucle
          }
      aux2=cicle;
          for (i=cicle; i<n-1; i++){
              for(j=0; j<k;j++){
                  AB[i+1][j]= (AB[i+1][j])-(AB[aux2][j]);   //agafem i fem la resta i ho guardem en la posicio
          }
        }
      cicle= cicle++;
      aux= cicle;
      }
      // aqui ja hem conseguit els 0 en el triangle inferior##############################
      /// Ara anem a posar 0 en el triangle superior #####################################
    contador=0; //inicialitzem un contador
    for(j=1; j<n; j++){     //iterem per columnes començant per la 2na
        contador++;         // incrementem el contador
        for(i=0; i<contador; i++){  //baixem en diagonal les i
            i2=contador;            //igualem i2 el contador
            negat= 0-(AB[i][j]);    //agafem en una variable l'invers a multiplicar
            for(j2=j; j2<k; j2++){  //per totes les variables de la matriu en columnes
            AB[i][j2]= AB[i][j2]+(AB[i2][j2]*negat);  //multipliquem el valor de la columna i sumem l'altre
           }
         }
    }
    printf("La matriu resultant es: \n");
    mostraMatriu2(n,k,AB);
    printf("############################### \n");

    //un cop tenim AB anem a agafar la matriu que ens interessa i guardarla en B
    for(i=0; i<n; i++){
        aux=0;
        for(j=n; j<k; j++){
            B[i][aux]= AB[i][j];
            aux++;
        }
    }
    printf("\n la matriu inversa es: \n");
    mostraMatriu2(n,aux,B);
  }


  void prodMatMat (int n, double **A, double **B, double **C){
      int i,j;
      double k;

    for(i=0; i<n; i++){
        C[i]= (double *)malloc(n*sizeof(double));
        k=0.0;
          for(j=0; j<n; j++){
              k= k+ (A[i][j]*B[j][i]);
          }
        C[i][j]= k;
      }
      printf("el vector C es: \n");
      mostraMatriu(n,C);
  }

  void prodMatVec(int n, double **A, double *x, double *y){
    int i, j;
    double k;

    for (i=0; i<n; i++){                    //recorrem fila per fila
        k=0.0;                              //igualem una variable a 0 cada cop que cambiem de fila
        for(j=0; j<n; j++){                 //recorrem columna per columna
            k= k+ (A[i][j]*x[j]);           // fem la multiplicacio i sumem la fila

        }
        y[i]= k;                            //guardem el valor en el vector y

    }


    printf("el vector y es: \n");
    mostraVector(n, y);                     // cridem a mostrar vector

}