float det(float **data, unsigned int rc) {
    float deter = 0.0, z = 1.0;
    float ** dat = malloc(sizeof(*dat) * rc);
    for(int h = 0; h < rc; h++) {
        dat[h] = malloc(sizeof(dat) * rc); //line 248
    }
    int a, b, c, x, y;
    if(rc == 1) {
        return data[0][0];
    }
    else {
        deter = 0;
        for(a = 0; a < rc; a++) {
            x = 0;
            y = 0;
            for(b = 0; b < rc; b++) {
                for(c = 0; c < rc; c++) {
                    dat[b][c] = 0;
                    if((b != 0) && (c != a)) {
                        dat[x][y] = data[b][c];
                        if(y < (rc - 2)) {
                            y++;
                        }
                        else {
                            y = 0;
                            x++;
                        }
                    }
                }
            }
            deter = deter + z * (data[0][a] * det(dat, rc - 1));
            z = -1 * z;
        }
    }
    for(int n = 0; n < rc; n++)
        free(dat[n]);
    free(dat);
    return deter;
}

int power(int x, int y) {
    if (y == 0)
        return 1;
    else if (y%2 == 0)
        return power(x, y/2)*power(x, y/2);
    else
        return x*power(x, y/2)*power(x, y/2);
}
float** trans(float** data2, float** data3, int r, float dee) {
    //float d;
    float** inv = malloc(sizeof(*inv) * r);
    float** tra = malloc(sizeof(*tra) * r);
    for(int i = 0; i < r; i++) {
        inv[i] = malloc(sizeof(inv) * r);
        tra[i] = malloc(sizeof(tra) * r);
    }
    int a, b;
    for(a = 0; a < r; a++) {
        for(b = 0; b < r; b++) {
            tra[a][b] = data3[b][a];
        }
    }
    //d = det(data2, r);
    //printf("det - %f\n", d);
    for(a = 0; a < r; a++) {
        for(b = 0; b < r; b++) {
            inv[a][b] = tra[a][b]/dee;
        }
    }
    for(int m = 0; m < r; m++)
        free(tra[m]);
    free(tra);
    return inv;
}
float** getCofactor(float **data, int rc) {
    float **data2 = malloc(sizeof(*data2) * rc);
    float **data3 = malloc(sizeof(*data3) * rc);
    for(int i = 0; i < rc; i++) {
        data2[i] = malloc(sizeof(data2) * rc);
        data3[i] = malloc(sizeof(data3) * rc);
    }
    int a, b, c, d, x, y;
    for(c  = 0; c < rc; c++) {
        for(d = 0; d < rc; d++) {
            x = 0;
            y = 0;
            for(a = 0; a < rc; a++) {
                for(b = 0; b < rc; b++) {
                    if(a != c && b != d) {
                        data2[x][y] = data[a][b];
                        if(y < (rc - 2))
                            y++;
                        else {
                            y = 0;
                            x++;
                        }
                    }
                }
            }
            data3[c][d] = power(-1, c+d) * det(data2, rc - 1);
        }
    }
    float dee = det(data, rc);
            float **data4 = trans(data2, data3, rc, dee);
   for(int l = 0; l < rc; l++) {
       free(data2[l]);
       free(data3[l]);
       free(data[l]);
   }
    free(data2);
    free(data3);
    free(data);
    return data4;
        }




matrix* get_inverse_matrix(matrix* matrix_to_invert)
{
    if(matrix_to_invert -> nrows != matrix_to_invert -> ncols) {
        //printf("1");
        return NULL;
    }
    if(matrix_to_invert == NULL) {
        //printf("2");
        return NULL;
    }
    float deter = det(matrix_to_invert -> data, matrix_to_invert -> nrows);
    if(deter == 0) {
        return NULL;
    }
    matrix *mat = malloc(sizeof(matrix));
    mat -> nrows = matrix_to_invert -> nrows;
    mat -> ncols = matrix_to_invert -> ncols;
    mat -> data = getCofactor(matrix_to_invert -> data, matrix_to_invert -> nrows);

    return mat;
}


int main() {
    //matrix * matria = load_matrix_from_file("sample.bin");
    //printf("%u\n", matria -> nrows);
    //print_matrix(matria);
    matrix *mate = malloc(sizeof(matrix));
    mate -> nrows = 4;
    mate -> ncols = 4;
    float ** data = malloc(sizeof(*data) * 4);
    for(int i = 0; i < 4; i++)
        data[i] = malloc(sizeof(data) * 4);
    data[0][0] = 1;
    data[0][1] = 2;
    data[0][2] = 3;
    data[0][3] = 4;
    data[1][0] = 1;
    data[1][1] = 2;
    data[1][2] = 3;
    data[1][3] = 6;
    data[2][0] = 2;
    data[2][1] = 4;
    data[2][2] = 8;
    data[2][3] = 0;
    data[3][0] = 5;
    data[3][1] = 6;
    data[3][2] = 7;
    data[3][3] = 8;
    mate -> data = data;
    //printf("det %f", det(data, 4));

    //print_matrix(mate);
    //print_matrix(mate);
    //matrix * mat = get_product_matrix(matria, mate);
     //free(mat);
    //print_matrix(mat);
    matrix *ma = get_inverse_matrix(mate);
    print_matrix(ma);
    free_matrix(ma);


    return 0;
}