//Inverse Solve
#include 
#include 

void get_cofactor(float A[10][10], float temp[10][10], int p, int q, int n) {
    int i = 0, j = 0;
    for (int row = 0; row < n; row++) {
        for (int col = 0; col < n; col++) {
            if (row != p && col != q) {
                temp[i][j++] = A[row][col];
                if (j == n - 1) {
                    j = 0;
                    i++;
                }
            }
        }
    }
}

float determinant(float A[10][10], int n) {
    float D = 0;
    if (n == 1) return A[0][0];

    float temp[10][10];
    int sign = 1;

    for (int f = 0; f < n; f++) {
        get_cofactor(A, temp, 0, f, n);
        D += sign * A[0][f] * determinant(temp, n - 1);
        sign = -sign;
    }
    return D;
}

void adjoint(float A[10][10], float adj[10][10], int n) {
    if (n == 1) {
        adj[0][0] = 1;
        return;
    }

    float temp[10][10];
    int sign;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            get_cofactor(A, temp, i, j, n);
            sign = ((i + j) % 2 == 0) ? 1 : -1;
            adj[j][i] = sign * determinant(temp, n - 1);
        }
    }
}

void inverse(float A[10][10], float inverseA[10][10], int n) {
    float det = determinant(A, n);
    if (fabs(det) < 1e-9) {
        printf("Singular Matrix: Inverse does not exist.\n");
        return;
    }

    float adj[10][10];
    adjoint(A, adj, n);

    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            inverseA[i][j] = adj[i][j] / det;
}

int main() {
    int n;
    float A[10][10], InvA[10][10];

    printf("Enter the size of the square matrix (N): ");
    scanf("%d", &n);

    if (n > 10 || n < 1) return 1;

    printf("Enter elements of the matrix:\n");
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            scanf("%f", &A[i][j]);

    float det = determinant(A, n);
    if (fabs(det) < 1e-9) {
        printf("\nInverse does not exist (Determinant is zero).\n");
        return 0;
    }

    inverse(A, InvA, n);

    printf("\nInverse Matrix:\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++)
            printf("%.4f\t", InvA[i][j]);
        printf("\n");
    }

    return 0;
}

//det
#include 

#define N 3 // We fix the size to 3x3

// Function to get the sub-matrix by hiding row 'p' and col 'q'
void get_cofactor(float A[N][N], float temp[N][N], int p, int q, int n) {
    int i = 0, j = 0;
    for (int row = 0; row < n; row++) {
        for (int col = 0; col < n; col++) {
            // Copy element only if it is NOT in the hidden row/col
            if (row != p && col != q) {
                temp[i][j++] = A[row][col];
                // If row is full, move to next row
                if (j == n - 1) {
                    j = 0;
                    i++;
                }
            }
        }
    }
}

// Recursive function to find determinant
float determinant(float A[N][N], int n) {
    float D = 0;
    // Base case: if matrix is 1x1, the det is the number itself
    if (n == 1) return A[0][0];

    float temp[N][N]; // To store sub-matrix
    int sign = 1;     // To handle + - + sign pattern

    for (int f = 0; f < n; f++) {
        get_cofactor(A, temp, 0, f, n); // Hide row 0, col f
        D += sign * A[0][f] * determinant(temp, n - 1);
        sign = -sign; // Flip sign
    }
    return D;
}

int main() {
    float A[N][N];
    
    printf("Enter 3x3 Matrix elements:\n");
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            scanf("%f", &A[i][j]);
        }
    }

    // We pass 'N' (which is 3) to the function
    printf("Determinant: %.2f\n", determinant(A, N));

    return 0;
}

//Inv
#include 
#include  // For fabs()

#define N 3 // Fixed to 3x3

void get_cofactor(float A[N][N], float temp[N][N], int p, int q, int n) {
    int i = 0, j = 0;
    for (int row = 0; row < n; row++) {
        for (int col = 0; col < n; col++) {
            if (row != p && col != q) {
                temp[i][j++] = A[row][col];
                if (j == n - 1) {
                    j = 0;
                    i++;
                }
            }
        }
    }
}

float determinant(float A[N][N], int n) {
    float D = 0;
    if (n == 1) return A[0][0];

    float temp[N][N];
    int sign = 1;

    for (int f = 0; f < n; f++) {
        get_cofactor(A, temp, 0, f, n);
        D += sign * A[0][f] * determinant(temp, n - 1);
        sign = -sign;
    }
    return D;
}

// Function to calculate Adjoint
void adjoint(float A[N][N], float adj[N][N], int n) {
    if (n == 1) {
        adj[0][0] = 1;
        return;
    }

    float temp[N][N];
    int sign = 1;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            // Get sub-matrix for A[i][j]
            get_cofactor(A, temp, i, j, n);
            
            // Determine sign: positive if sum of indices is even
            sign = ((i + j) % 2 == 0) ? 1 : -1;
            
            // IMPORTANT: Assign to adj[j][i] (transpose happens here)
            adj[j][i] = sign * determinant(temp, n - 1);
        }
    }
}

// Function to calculate Inverse
void inverse(float A[N][N], float inv[N][N], int n) {
    float det = determinant(A, n);
    
    if (fabs(det) < 0.00001) {
        printf("Inverse impossible (Determinant is 0)\n");
        return;
    }

    float adj[N][N];
    adjoint(A, adj, n);

    // Inverse = Adjoint / Determinant
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            inv[i][j] = adj[i][j] / det;
}

int main() {
    float A[N][N], InvA[N][N];

    printf("Enter 3x3 Matrix elements:\n");
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            scanf("%f", &A[i][j]);

    // Calculate Inverse
    inverse(A, InvA, N);

    // Check if determinant was non-zero before printing
    if (fabs(determinant(A, N)) >= 0.00001) {
        printf("\nInverse Matrix:\n");
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++)
                printf("%.2f\t", InvA[i][j]);
            printf("\n");
        }
    }

    return 0;
}