MAtrix

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


void openFile(FILE **fp, char **filename);
int readSize(FILE **fp);
void allocateMemory(int size, double ***matrix);
void readValues(int size, double **matrix, FILE *fp);
void printMatrix(int size, double **matrix);
double determineDeterminant(double **matrix, int size);
double determineDeterminant2x2(double **matrix);
void nextDet(int size, double **detmatrix, double **matrix, int column);
void freeMemory(int size, double ***matrix);


int main(int argc, char* argv[])
{
    FILE *fp;
    char* filename = argv[1];
    int size;
    double **matrix;
    openFile(&fp, &filename);
    size = readSize(&fp);
    allocateMemory(size, &matrix);
    readValues(size, matrix, fp);
    fclose(fp);
    printMatrix(size, matrix);
    double det = determineDeterminant(matrix, size);
    printf("\n\n Determinant = %f\n\n\n", det);
    freeMemory(size, &matrix);
    return 0;
}

void openFile(FILE **fp, char **filename)
{
    assert(fp);
    assert(filename);
    *fp = fopen(*filename, "r");
    if (*fp == NULL)
    {
        printf(" File can not be open! %s", *filename);
        exit(0);
    }
}


int readSize(FILE **fp)
{
    assert(fp);
    int size;
    int correct = fscanf(*fp, "%d", &size);
    if(!correct || size <= 0){
        printf("Incorret size \n");
        exit(0);
    }
    return size;
}


void allocateMemory(int size, double ***matrix)
{
    assert(matrix);
    *matrix = (double**)malloc(sizeof(double*) * size);
    if(!(*matrix))
    {
        abort();
    }
    int i;
    for(i=0; i<size; i++)
    {
        (*matrix)[i] = (double*)malloc(sizeof(double)*size);
        if(!(*matrix)[i])
        {
            abort();
        }
    }
}

void readValues(int size, double **matrix, FILE *fp)
{
    assert(matrix);
    assert(fp);
    for(int i = 0; i < size; i++)
    {
        for(int j = 0; j < size; j++)
        {
            if(!fscanf(fp, "%lf", &matrix[i][j]))
            {
                printf("Wrong Matrix!!\n");
                freeMemory(size, &matrix);
                exit(0);
            }
        }
    }
}


void printMatrix(int size, double **matrix)
{
    assert(matrix);
    printf("%d\n", size);
    for(int i = 0; i < size; i++)
    {
        for(int j = 0; j < size; j++)
        {
            printf(" %f  ", matrix[i][j]);
        }
        printf("\n");
    }
}


double determineDeterminant(double **matrix, int size)
{
    assert(matrix);
    if(size == 1)
    {
        return matrix[0][0];
    }
    if(size == 2)
    {
        return determineDeterminant2x2(matrix);
    }
    int sign = 1;
    double determinant = 0;
    double **detmatrix;
    for(int column = 0; column < size; column++)
    {
        allocateMemory(size - 1, &detmatrix);
        nextDet(size, detmatrix, matrix, column);
        determinant = sign * matrix[0][column] * determineDeterminant(detmatrix, size - 1) + determinant;
        sign *= -1;
        freeMemory(size - 1, &detmatrix);
    }
    return determinant;
}


double determineDeterminant2x2(double **matrix)
{
    assert(matrix);
    double det = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
    return det;
}


void nextDet(int size, double **detmatrix, double **matrix, int column)
{
    assert(detmatrix);
    assert(matrix);
    int biggermatrixcolumn = 0, smallermatrixcolumn = 0;
    while(biggermatrixcolumn < size){
        if(biggermatrixcolumn != column)
        {
            for(int i=1; i<size; i++){
                detmatrix[i-1][smallermatrixcolumn] = matrix[i][biggermatrixcolumn];
            }
            smallermatrixcolumn++;
        }
        biggermatrixcolumn++;
    }
}


void freeMemory(int size, double ***matrix)
{
    assert(matrix);
    for(int i = 0; i<size; i++){
        free((*matrix)[i]);
    }
    free(*matrix);
}