Runtime error, NxN Matrix Inverse in C

Question

I am trying to write a function which gets a matrix and the dimension (square), and returns the inverse matrix in C. Further, I will use it in solving a least square matrix solution function!

I have got most of the ideas and algorithms from online sources and tried to change them according to my program. When I build and run it (in Code::Blocks and ideone.com online compiler) I get either runtime error or irrelevant results. Would be great if someone could help me.

Here is my code:

/* Inverse of NxN matrix */

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

double CalcDeterminant(int D, double matrix[D][D])
{
  /* Conversion of matrix to upper triangular */
int i, j, k;
double ratio, det=1;
for (I = 0; I < D; i++) {
    for(j = 0; j < D; j++){
        if(j>i){
            ratio = matrix[j][i]/matrix[i][i];
            for(k = 0; k < D; k++){
                matrix[j][k] -= ratio * matrix[i][k];
            }
        }
    }
 }

 for(i = 0; i < D; i++)
 {
    det *= matrix[i][i];
 }

 return det;
}


double ** MatrixInverse(int size, double matrix[size][size])
{
int p,q,m,n,i,j,k;
double det;
double **m_inverse = (double **) malloc(sizeof(int) * size);
for (k = 0; k < size; k++) {
 m_inverse[k] = (double *) malloc(sizeof(int) * size);
}

double **dummy = (double **) malloc(sizeof(int) * size);
for (k = 0; k < size; k++) {
dummy[k] = (double *) malloc(sizeof(int) * size);
}
 /////////////////////////
 for (q=0;q<size;q++)
 {
     for (p=0;p<size;p++)
     {
         m=0;
         n=0;
         for (i=0;i<size;i++)
         {
             for (j=0;j<size;j++)
             {
                 if (i != q && j != p)
                 {
                    dummy[m][n]=matrix[i][j];
                    if (n<(size-2))
                    {
                       n++;
                    }
                    else
                    {
                        n=0;
                        m++;
                    }
                 }
             }
         }
        det = CalcDeterminant(size-1, dummy);
        printf("%f\n", det);
        m_inverse[q][p]=pow(-1,(q+p))*det;
     }
  }
  for (i=0;i<size;i++)
 {
     for (j=0;j<size;j++)
     {
         dummy[i][j]=m_inverse[j][i];
     }
 }
   det=CalcDeterminant(size, matrix);
 for (i=0;i<size;i++)
 {
     for (j=0;j<size;j++)
     {
         m_inverse[i][j]= dummy[i][j] / det;
     }
  }


 for(i = 0; i < size; i++)
    free(dummy[i]);
 free(dummy);    

return m_inverse;

}


int main()
{
int i, j;
int D = 5;
 // just an example matrix
double A[5][5] = {{1,2,3,4,6},
                  {6,1,5,3,8},
                  {2,6,4,9,9},
                  {1,3,8,3,4},
                  {5,7,8,2,5}};

printf("Original matrix\n");
for(i=0; i<D; i++)
{
    for(j=0; j<D; j++)
    {   
    //  A[i][j] = i+j-5;
        printf("%f\t", A[i][j]);
    }
    printf("\n");
} 
double **A_inverse = MatrixInverse(D, A); 
printf("Inverse Matrix\n");
for(i=0; i<D; i++)
{
    for(j=0; j<D; j++)
    {   
        printf("%f\t", A_inverse[i][j]);
    }
    printf("\n");
}

det = CalcDeterminant(D, A);
printf("%f\n", det);
return 0;
}

Answer 1

This line contains a major error, one that will cause problems when sizeof(int) is not equal to sizeof(int *) (which is what usually happens on 64-bit platforms):

double **m_inverse = (double **) malloc(sizeof(int) * size);

Same with the allocation for dummy.

You are allocating an array of pointers to int, so the correct here would be

double **m_inverse = malloc(sizeof(int *) * size);

---

Later you have a problematic line here:

det = CalcDeterminant(size-1, dummy);

Normally a pointer-to-pointer to some type is not the same an array-of-arrays of some type (see e.g. this old answer of mine to help you understand why).

Answer 2

When allocating memory, always use the correct type for the size. You use sizeof(int) everywhere, even if double or pointer is required. Hint: use sizeof(*<pointer you assign the result to>). This way, you always use the correct size.

Note: Do not cast void * as returned by malloc & friends.