Matrice Recursive Determinant Calculation

Hi i have problems calculating the determinant of more than a 2 x2 can anyone help

Code:

---

nt determinant(int matrix_temp[10][10],int size_matrice)  //Get the minor of the matrice
{
 int i,j,determinant_sum = 0;
 int matrice[10][10];//matrice[maximum][maximum]
 if(size_matrice==2)
  {                                        //basic step
        determinant_sum = matrix_temp[0][0]*matrix_temp[1][1] - matrix_temp[0][1]*matrix_temp[1][0];
        return determinant_sum;
  }
 for(int count=0;count<size_matrice;count++)
 {
  int h = 0,k = 0;
  for(i=1;i<size_matrice;i++)
  {
        for( j=0;j<size_matrice;j++)
        {
        if(j==count)
         
        matrice[h][k] = matrix_temp[i][j];
        k++;
        if(k == size_matrice-1)
          {
                h++;
                k = 0;
          }

        }
  }



//recursive formula
  determinant_sum = determinant_sum + matrix_temp[0][count]*pow(-1,count)*determinant(matrice,size_matrice-1);
  //Force the sum to return an "int" result
 
 }
 return determinant_sum;
}

---

It's not a maths forum.

http://en.wikipedia.org/wiki/Determinant

This a math problem? but what the hell yu say i told that i have problems with the recursive formula as it gives strange results for 3 x 3 matrice and more

Well good luck fixing it.

maybe like this (not tested for bigger matrix yet, sorry)

Code:

---

#include <stdio.h>

#define MY_FREE(x)  { free(x); x = NULL; }

typedef struct {
    unsigned int width;
    unsigned int height;
    float        *data;
} matrix;

/*
 * new_matrix : creates new matrix
 * w          : width (column)
 * h          : height (row)
 * returns    : newly allocated matrix (on success), NULL (otherwise)
 */
matrix *new_matrix (unsigned int w, unsigned int h)
{
    matrix *result = (matrix *)malloc(sizeof(matrix));

    if (result != NULL) {
        result->width  = w;
        result->height = h;
        result->data  = (float *)calloc(w * h, sizeof(float));
        if (result->data == NULL) {
            fprintf(stderr, "new_matrix() : out of memory.\n");
            MY_FREE(result);
        }
    }

    return(result);
}

/*
 * destroy_matrix : it's obvious
 */
void destroy_matrix (matrix *mat)
{
    if (mat != NULL) {
        MY_FREE(mat->data);
        MY_FREE(mat);
    }
}

/*
 * determinant : get the determinant of a matrix
 * mat    : matrix input
 * retval  : 1 (success), 0 (failed)
 * returns : determinant of matrix mat
 */
float determinant (const matrix *mat, int *retval)
{
    float result;

    if (mat->width != mat->height) {
        fprintf(stderr, "not a square matrix!\n");
        *retval = 0;        /* return false */
    } else {
        if (mat->width == 2) {
            /* det = ad - bc */
            result  = (mat->data[0] * mat->data[3]) - (mat->data[1] * mat->data[2]);
            *retval = 1;
        } else {
            matrix *tmp_mat = new_matrix(mat->width - 1, mat->height - 1);

            if (tmp_mat == NULL) {
                *retval = 0;
            } else {
                const float sign[2] = { 1.0, -1.0 };
                int        col, rc, x, y, xx, yy;
                float      tmp_det;

                result = 0.0;
                for (col = 0; col < mat->width; ++col) {
                    for (y = 1, yy = 0; y < mat->height; ++y, ++yy) {
                        for (x = 0, xx = 0; x < mat->width; ++x) {
                            if (x != col) {
                                tmp_mat->data[yy * tmp_mat->width + xx] = mat->data[y * mat->width + x];
                                ++xx;
                            }
                        }
                    }
                    tmp_det = determinant(tmp_mat, &rc);
                    if (rc) {        /* success */
                        result = result + (mat->data[col] * sign[col &#37; 2] * tmp_det);
                    } else {        /* failed */
                        *retval = 0;
                        destroy_matrix(tmp_mat);
                        break;
                    }
                }
                *retval = 1;
            }
        }
    }

    return result;
}

/* test program */
int main (void)
{
    matrix *mat1 = new_matrix(3, 3);
    int    x, y, rc;
    float  det;

    for (x = 0; x < mat1->width * mat1->height; ++x) {
        mat1->data[x] = (float)1;
    }
    mat1->data[4] = 5.0;
    mat1->data[6] = 13.0;
    det = determinant(mat1, &rc);
    if (rc) {
        printf("determinant : %f\n", det);
    }
    for (y = 0; y < mat1->width; ++y) {
        for (x = 0; x < mat1->height; ++x) {
            printf("%5.2f", mat1->data[y * mat1->width + x]);
        }
        printf("\n");
    }
    destroy_matrix(mat1);

    return(0);
}

---

Don't write complete code for people even if you have the time to kill. They won't learn this way. Worse still if it's homework question.