matrizes

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

typedef vector<vector<double>> Matriz;

Matriz criarMatriz(int n) {
    return Matriz(n, vector<double>(n, 0));
}

void imprimirMatriz(const Matriz& A) {
    for (const auto& linha : A) {
        for (double elemento : linha) {
            cout << elemento << " ";
        }
        cout << endl;
    }
}

double calcularTraço(const Matriz& A) {
    double traço = 0;
    for (int i = 0; i < A.size(); ++i) {
        traço += A[i][i];
    }
    return traço;
}

Matriz obterTransposta(const Matriz& A) {
    int n = A.size();
    Matriz transposta = criarMatriz(n);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            transposta[j][i] = A[i][j];
        }
    }
    return transposta;
}

double calcularDeterminante(const Matriz& A);

Matriz obterCofatores(const Matriz& A) {
    int n = A.size();
    Matriz cofatores = criarMatriz(n);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            Matriz menor = criarMatriz(n - 1);
            for (int k = 0; k < n; ++k) {
                if (k == i) continue;
                for (int l = 0; l < n; ++l) {
                    if (l == j) continue;
                    menor[k < i ? k : k - 1][l < j ? l : l - 1] = A[k][l];
                }
            }
            cofatores[i][j] = pow(-1, i + j) * calcularDeterminante(menor);
        }
    }
    return cofatores;
}

double calcularDeterminante(const Matriz& A) {
    int n = A.size();
    if (n == 1) return A[0][0];
    if (n == 2) return A[0][0] * A[1][1] - A[0][1] * A[1][0];
    double determinante = 0;
    for (int j = 0; j < n; ++j) {
        Matriz menor = criarMatriz(n - 1);
        for (int k = 1; k < n; ++k) {
            for (int l = 0; l < n; ++l) {
                if (l == j) continue;
                menor[k - 1][l < j ? l : l - 1] = A[k][l];
            }
        }
        determinante += pow(-1, j) * A[0][j] * calcularDeterminante(menor);
    }
    return determinante;
}

Matriz obterAdjunta(const Matriz& A) {
    return obterTransposta(obterCofatores(A));
}

Matriz obterInversa(const Matriz& A) {
    double det = calcularDeterminante(A);
    if (det == 0) throw runtime_error("Matriz não inversível");
    Matriz adjunta = obterAdjunta(A);
    int n = A.size();
    Matriz inversa = criarMatriz(n);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            inversa[i][j] = adjunta[i][j] / det;
        }
    }
    return inversa;
}

Matriz somarMatrizes(const Matriz& A, const Matriz& B) {
    int n = A.size();
    Matriz soma = criarMatriz(n);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            soma[i][j] = A[i][j] + B[i][j];
        }
    }
    return soma;
}

Matriz multiplicarMatrizes(const Matriz& A, const Matriz& B) {
    int n = A.size();
    Matriz produto = criarMatriz(n);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            for (int k = 0; k < n; ++k) {
                produto[i][j] += A[i][k] * B[k][j];
            }
        }
    }
    return produto;
}

Matriz dividirMatrizes(const Matriz& A, const Matriz& B) {
    return multiplicarMatrizes(A, obterInversa(B));
}

Matriz elevarMatriz(const Matriz& A, int expoente) {
    int n = A.size();
    Matriz resultado = criarMatriz(n);
    for (int i = 0; i < n; ++i) {
        resultado[i][i] = 1;
    }
    Matriz base = A;
    while (expoente > 0) {
        if (expoente % 2 == 1) {
            resultado = multiplicarMatrizes(resultado, base);
        }
        base = multiplicarMatrizes(base, base);
        expoente /= 2;
    }
    return resultado;
}

int main() {
    int n;
    cout << "Digite o tamanho da matriz (n): ";
    cin >> n;

    Matriz A = criarMatriz(n);
    cout << "Digite os elementos da matriz A:" << endl;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            cin >> A[i][j];
        }
    }

    cout << "Matriz A:" << endl;
    imprimirMatriz(A);

    cout << "Traço: " << calcularTraço(A) << endl;
    cout << "Determinante: " << calcularDeterminante(A) << endl;

    Matriz cofatores = obterCofatores(A);
    cout << "Matriz dos Cofatores:" << endl;
    imprimirMatriz(cofatores);

    Matriz transposta = obterTransposta(A);
    cout << "Matriz Transposta:" << endl;
    imprimirMatriz(transposta);

    Matriz adjunta = obterAdjunta(A);
    cout << "Matriz Adjunta:" << endl;
    imprimirMatriz(adjunta);

    try {
        Matriz inversa = obterInversa(A);
        cout << "Matriz Inversa:" << endl;
        imprimirMatriz(inversa);
    } catch (const runtime_error& e) {
        cout << e.what() << endl;
    }

    Matriz B = criarMatriz(n);
    cout << "Digite os elementos da matriz B:" << endl;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            cin >> B[i][j];
        }
    }

    cout << "Matriz B:" << endl;
    imprimirMatriz(B);

    Matriz soma = somarMatrizes(A, B);
    cout << "Soma de A e B:" << endl;
    imprimirMatriz(soma);

    Matriz produto = multiplicarMatrizes(A, B);
    cout << "Produto de A e B:" << endl;
    imprimirMatriz(produto);

    try {
        Matriz divisao = dividirMatrizes(A, B);
        cout << "Divisão de A por B:" << endl;
        imprimirMatriz(divisao);
    } catch (const runtime_error& e) {
        cout << e.what() << endl;
    }

    int expoente;
    cout << "Digite o expoente para elevar a matriz A: ";
    cin >> expoente;
    Matriz potencia = elevarMatriz(A, expoente);
    cout << "A^" << expoente << ":" << endl;
    imprimirMatriz(potencia);

    return 0;
}