Inversa de una Matriz

La inversa de una matriz por método de Gauss-Jordan.

Un pequeño programa hecho en C, que utiliza este método. Antes que veamos el código veamos un poco de teoría...

Dada una matriz A, ¿Podremos encontrar otra matriz B tal que A·B=B·A=I?

Esta matriz B existe aunque no siempre, de existir se le llama matriz inversa de A y se nota A-1. Para que exista la inversa de A, ésta tiene que ser cuadrada pues de lo contrario no se podría hacer el producto por la izquierda y por la derecha, luego cuando hablamos de matrices invertibles estamos hablando de matrices cuadradas.

Condición necesaria y suficiente para que una matriz sea invertible es que no sea singular, es decir, que su determinante sea no nulo |A| ≠ 0

Cálculo de la matriz inversa

Método de Gauss-Jordan

Este método consiste en colocar junto a la matriz de partida (A) la matriz identidad (I) y hacer operaciones por filas, afectando esas operaciones tanto a A como a I, con el objeto de transformar la matriz A en la matriz identidad, la matriz resultante de las operaciones sobre I es la inversa de A (A-1).

Las operaciones que podemos hacer sobre las filas son:

a) Sustituir una fila por ella multiplicada por una constante, por ejemplo, sustituimos la fila 2 por ella multiplicada por 3.

b) Permutar dos filas

c) Sustituir una fila por una combinación lineal de ella y otras.



Utilizando este ejemplo. mostraré el código y su posterior ejecución. :-)

#include<stdio.h>
#include<conio.h>
#include<alloc.h>
#include<math.h>

/*********************************** imprime matriz **********************/
void desplegar(int n, double **A) {
  int i,j,f,c;
  for(i=1; i<=n; i++) {
    f=(i+1)+12;
    for(j=1; j<=(2*n); j++) {
      c=(j+1)*9;
      gotoxy(c,f);
      cprintf("  %.2f",A[i][j]);
    }
  }
}

/**************************************** captura valor ******************/
double LeeValor(void) {
  double valor;
  scanf("%lf",&valor);
  return valor;
}

/*********************************************************************/
void main() {
  int n,f,c,i,renglon;
  double **A,grande,temp,p,cero;

  clrscr();
  printf("\n Cuantas filas tiene el sistema?: ");
  scanf("%d",&n);

  printf("\n f=%d, c=%d.\n",n,(2*n));

  /******************************** Asigno memoria ***********************/
  A=(double **)calloc(n,sizeof(double *));
  for(i=0; i<n; i++) {
    A[i]=(double *)calloc((2*n),sizeof(double));
  }
  /********************************************************************/

  for(f=1; f<=n; f++) {
    printf("\n fila %d\n",f);
    for(c=1; c<=n; c++) {
      printf("columna %d= ",c);
      A[f][c]=LeeValor();
      A[f][n+c]=0;
    }
    A[f][n+f]=1;
  }
  /********************************************************************/

  for(f=1; f<=n; f++) {
    grande=fabs(A[f][f]);
    renglon=f;

    for(c=f+1; c<=n; c++) {
      if(grande < fabs(A[c][f])) {
grande=fabs(A[c][f]);
        renglon=c;
      }
    } //FIN DEL FOR

    if(grande==0) {
      printf("\n No tiene solucion");
    } //FIN DEL IF

    if(renglon!=f) {
      for(c=1; c<=(2*n); c++) {
temp=A[f][c];
A[f][c]=A[renglon][c];
        A[renglon][c]=temp;
      }
    } //FIN DEL IF

    p=A[f][f];
    for(c=1; c<=(2*n); c++) {
      A[f][c]/=p;
    } //FIN DEL FOR

    for(renglon=1; renglon<=n; renglon++) {
      if(renglon!=f) {
cero=A[renglon][f];
for(c=1; c<=(2*n); c++) {
          A[renglon][c]-=cero*A[f][c];
        }
      }
    } //FIN DEL FOR
  } //FIN DEL FOR
  desplegar(n,A);

  /**************************** Libero memoria *****************************/
  for(i=0; i<n; i++) {
    free(A[i]);
  }
  free(A);
  /*********************************************************************/

  getch();
}

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

Y bueno este es la ejecución.

Créditos:
Prof. Luis Real
http://www.ematematicas.net

Algo más, si quieres donar a mi blog, se le agradecería mucho, ya que me animaría a publicar más programas hecho por este servidor. Gracias.