Inverse Matrix in C - Sanfoundry

This C program sorts a given array of integer numbers using Bubble Sort technique. The algorithm gets its name from the way smaller elements “bubble” to the top of the list. Because it only uses comparisons to operate on elements, it is a comparison sort. Time Complexity of this algorithm is O(n²).

Here is the source code of the C program to sort and display the integer array. The C program is successfully compiled and run on a Linux system. The program output is also shown below.

```
#include<stdio.h>
```
```
#include<math.h>
```
```
float determinant(float [][25], float);
```
```
void cofactor(float [][25], float);
```

void transpose(float [][25], float [][25], float);

```
int main()
```
```
{
```
```
  float a[25][25], k, d;
```
```
  int i, j;
```

  printf("Enter the order of the Matrix : ");

```
  scanf("%f", &k);
```

  printf("Enter the elements of %.0fX%.0f Matrix : \n", k, k);

```
  for (i = 0;i < k; i++)
```
```
    {
```
```
     for (j = 0;j < k; j++)
```
```
       {
```
```
        scanf("%f", &a[i][j]);
```
```
        }
```
```
    }
```
```
  d = determinant(a, k);
```
```
  if (d == 0)
```

   printf("\nInverse of Entered Matrix is not possible\n");

```
  else
```
```
   cofactor(a, k);
```
```
}
```
```
 
```

/*For calculating Determinant of the Matrix */

float determinant(float a[25][25], float k)

```
{
```
```
  float s = 1, det = 0, b[25][25];
```
```
  int i, j, m, n, c;
```
```
  if (k == 1)
```
```
    {
```
```
     return (a[0][0]);
```
```
    }
```
```
  else
```
```
    {
```
```
     det = 0;
```
```
     for (c = 0; c < k; c++)
```
```
       {
```
```
        m = 0;
```
```
        n = 0;
```
```
        for (i = 0;i < k; i++)
```
```
          {
```
```
            for (j = 0 ;j < k; j++)
```
```
              {
```
```
                b[i][j] = 0;
```
```
                if (i != 0 && j != c)
```
```
                 {
```
```
                   b[m][n] = a[i][j];
```
```
                   if (n < (k - 2))
```
```
                    n++;
```
```
                   else
```
```
                    {
```
```
                     n = 0;
```
```
                     m++;
```
```
                     }
```
```
                   }
```
```
               }
```
```
             }
```

          det = det + s * (a[0][c] * determinant(b, k - 1));

```
          s = -1 * s;
```
```
          }
```
```
    }
```
```
 
```
```
    return (det);
```
```
}
```
```
 
```

void cofactor(float num[25][25], float f)

```
{
```
```
 float b[25][25], fac[25][25];
```
```
 int p, q, m, n, i, j;
```
```
 for (q = 0;q < f; q++)
```
```
 {
```
```
   for (p = 0;p < f; p++)
```
```
    {
```
```
     m = 0;
```
```
     n = 0;
```
```
     for (i = 0;i < f; i++)
```
```
     {
```
```
       for (j = 0;j < f; j++)
```
```
        {
```
```
          if (i != q && j != p)
```
```
          {
```
```
            b[m][n] = num[i][j];
```
```
            if (n < (f - 2))
```
```
             n++;
```
```
            else
```
```
             {
```
```
               n = 0;
```
```
               m++;
```
```
               }
```
```
            }
```
```
        }
```
```
      }
```

      fac[q][p] = pow(-1, q + p) * determinant(b, f - 1);

```
    }
```
```
  }
```
```
  transpose(num, fac, f);
```
```
}
```
```
/*Finding transpose of matrix*/ 
```

void transpose(float num[25][25], float fac[25][25], float r)

```
{
```
```
  int i, j;
```
```
  float b[25][25], inverse[25][25], d;
```
```
 
```
```
  for (i = 0;i < r; i++)
```
```
    {
```
```
     for (j = 0;j < r; j++)
```
```
       {
```
```
         b[i][j] = fac[j][i];
```
```
        }
```
```
    }
```
```
  d = determinant(num, r);
```
```
  for (i = 0;i < r; i++)
```
```
    {
```
```
     for (j = 0;j < r; j++)
```
```
       {
```
```
        inverse[i][j] = b[i][j] / d;
```
```
        }
```
```
    }
```

   printf("\n\n\nThe inverse of matrix is : \n");

```
 
```
```
   for (i = 0;i < r; i++)
```
```
    {
```
```
     for (j = 0;j < r; j++)
```
```
       {
```
```
         printf("\t%f", inverse[i][j]);
```
```
        }
```
```
    printf("\n");
```
```
     }
```
```
}
```

$ gcc inverse_matrix.c -o inverse_matrix
$ ./inverse_matrix
 
Enter the order of the Square Matrix : 3
 
Enter the elements of 3X3 Matrix : 3 5 2 1 5  8 3 9 2
 
The inverse of matrix is : 
        0.704545       -0.090909    -0.340909
       -0.250000       -0.000000     0.250000
        0.068180        0.136364    -0.113636

Sanfoundry Global Education & Learning Series – 1000 C Programs.

Here’s the list of Best Books in C Programming, Data Structures and Algorithms.

« Prev - C Program to Perform Message Encoding Using Matrix Multiplication

» Next - Matrix Multiplication in C

Related Posts:

Recommended Articles: