Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· OpenAIAi2 WildChat-4.8M (AI2)

quero que faça as seguintes alterações no codigo abaixo: SparseMatrix* sum(SparseMatrix*…

  1. User

    quero que faça as seguintes alterações no codigo abaixo:

    SparseMatrix* sum(SparseMatrix* A, SparseMatrix* B); Essa função recebe como parâmetro as matrizes A e B, devolvendo uma matriz C que é a soma de A e B.

    SparseMatrix *multiply(SparseMatrix *A, SparseMatrix *B); Essa fuņçao recebe como parametro as matrizes A e B, devolvendo uma matriz C que é a multiplicação de A por B.

    ---------------------------------------main------------------------------------

    #include #include #include "SparseMatrix.h"

    SparseMatrix *lerMatrizEsparsa(std::string nome_arquivo) { std::ifstream arquivo(nome_arquivo);

    if (!arquivo)
    {
        std::cout << "Erro ao abrir o arquivo: " << nome_arquivo << std::endl;
        return nullptr;
    }
    
    int linhas, colunas;
    arquivo >> linhas >> colunas;
    
    SparseMatrix *matriz = new SparseMatrix(linhas, colunas);
    
    int linha, coluna;
    double valor;
    while (arquivo >> linha >> coluna >> valor)
    {
        matriz->inserir(linha, coluna, valor);
    }
    
    arquivo.close();
    return matriz;
    

    }

    SparseMatrix *soma(SparseMatrix *A, SparseMatrix *B) { if (A->getLinhas() != B->getLinhas() || A->getColunas() != B->getColunas()) { std::cout << "As matrizes devem ter as mesmas dimensões para realizar a soma." << std::endl; return nullptr; }

    SparseMatrix *resultado = new SparseMatrix(A->getLinhas(), A->getColunas());
    for (int i = 0; i < A->getLinhas(); i++)
    {
        for (int j = 0; j < A->getColunas(); j++)
        {
            double valorA = A->get(i, j);
            double valorB = B->get(i, j);
            resultado->inserir(i, j, valorA + valorB);
        }
    }
    
    return resultado;
    

    }

    SparseMatrix *multiplicacao(SparseMatrix *A, SparseMatrix *B) { if (A->getColunas() != B->getLinhas()) { std::cout << "O número de colunas da matriz A deve ser igual ao número de linhas da matriz B para realizar a multiplicação." << std::endl; return nullptr; }

    SparseMatrix *resultado = new SparseMatrix(A->getLinhas(), B->getColunas());
    for (int i = 0; i < A->getLinhas(); i++)
    {
        for (int j = 0; j < B->getColunas(); j++)
        {
            double valor = 0.0;
            for (int k = 0; k < A->getColunas(); k++)
            {
                valor += A->get(i, k) * B->get(k, j);
            }
            resultado->inserir(i, j, valor);
        }
    }
    
    return resultado;
    

    }

    int main() { // Exemplo de uso SparseMatrix *A = lerMatrizEsparsa("matrixA.txt"); SparseMatrix *B = lerMatrizEsparsa("matrixB.txt");

    if (A != nullptr && B != nullptr)
    {
        std::cout << "Matriz A:" << std::endl;
        A->imprimir();
    
        std::cout << "Matriz B:" << std::endl;
        B->imprimir();
    
        SparseMatrix *resultadoSoma = soma(A, B);
        if (resultadoSoma != nullptr)
        {
            std::cout << "Soma das matrizes:" << std::endl;
            resultadoSoma->imprimir();
            delete resultadoSoma;
        }
    
        SparseMatrix *resultadoMultiplicacao = multiplicacao(A, B);
        if (resultadoMultiplicacao != nullptr)
        {
            std::cout << "Multiplicação das matrizes:" << std::endl;
            resultadoMultiplicacao->imprimir();
            delete resultadoMultiplicacao;
        }
    }
    
    delete A;
    delete B;
    
    return 0;
    

    }

    -------------------------------------SparseMatrix.cpp----------------------------------------------- #include #include "SparseMatrix.h"

    SparseMatrix::SparseMatrix(int m, int n) { if (m <= 0 || n <= 0) { std::cout << "Dimensões inválidas para a matriz: " << m << " x " << n << std::endl; linhas = 0; colunas = 0; return; }

    linhas = m;
    colunas = n;
    vetorLinhas = new Node *[linhas]; // Correção: Aloque um vetor de ponteiros
    for (int i = 0; i < linhas; i++)
    {
        vetorLinhas[i] = nullptr; // Correção: Inicialize todos os ponteiros como nullptr
    }
    

    }

    SparseMatrix::~SparseMatrix() { // Liberar a memória alocada para a matriz esparsa for (int i = 0; i < linhas; i++) { Node *atual = vetorLinhas[i]; while (atual != nullptr) { Node *proximo = atual->proximo; delete atual; atual = proximo; } vetorLinhas[i] = nullptr; // Correção: Defina o ponteiro como nullptr após a exclusão } delete[] vetorLinhas; }

    void SparseMatrix::inserir(int i, int j, double valor) { if (i < 0 || i >= linhas || j < 0 || j >= colunas) { std::cout << "Célula inválida na matriz: (" << i << ", " << j << ")" << std::endl; return; }

    Node *novoNo = new Node(i, j, valor);
    novoNo->proximo = vetorLinhas[i];
    vetorLinhas[i] = novoNo;
    

    }

    double SparseMatrix::get(int i, int j) { if (i < 0 || i >= linhas || j < 0 || j >= colunas) { std::cout << "Célula inválida na matriz: (" << i << ", " << j << ")" << std::endl; return 0.0; }

    Node *atual = vetorLinhas[i];
    while (atual != nullptr)
    {
        if (atual->coluna == j)
        {
            return atual->valor;
        }
        atual = atual->proximo;
    }
    
    return 0.0; // Valor padrão para células não encontradas
    

    }

    void SparseMatrix::imprimir() { for (int i = 0; i < linhas; i++) { for (int j = 0; j < colunas; j++) { double valor = get(i, j); std::cout << valor << " "; } std::cout << std::endl; } }

    ---------------------------------------SparseMatrix.h--------------------------------------------- #ifndef MATRIZ_ESPARSA_H #define MATRIZ_ESPARSA_H

    #include "node.h" // Inclua o arquivo node.h

    class SparseMatrix { public: SparseMatrix(int m, int n); ~SparseMatrix(); void inserir(int i, int j, double valor); double get(int i, int j); void imprimir(); int getLinhas() { return linhas; } int getColunas() { return colunas; }

    private: int linhas; int colunas; Node **vetorLinhas; };

    #endif

    -----------------------------------------node.h------------------------------------------ #ifndef NODE_H #define NODE_H

    struct Node { int linha; int coluna; double valor; Node *proximo;

        Node(int l, int c, double v)
        : linha(l), coluna(c), valor(v), proximo(nullptr) {}
    

    };

    #endif

  2. Assistant

    As alterações solicitadas estão refletidas no código abaixo:

    // SparseMatrix.h
    #ifndef MATRIZ_ESPARSA_H
    #define MATRIZ_ESPARSA_H
    
    #include "node.h" // Inclua o arquivo node.h
    
    class SparseMatrix
    {
    public:
        SparseMatrix(int m, int n);
        ~SparseMatrix();
        void inserir(int i, int j, double valor);
        double get(int i, int j);
        void imprimir();
        int getLinhas() { return linhas; }
        int getColunas() { return colunas; }
    
        // Novas funções
        SparseMatrix* sum(SparseMatrix* A, SparseMatrix* B);
        SparseMatrix* multiply(SparseMatrix* A, SparseMatrix* B);
    
    private:
        int linhas;
        int colunas;
        Node **vetorLinhas;
    };
    
    #endif
    

    No arquivo SparseMatrix.cpp, adicione as seguintes definições de funções:

    SparseMatrix* SparseMatrix::sum(SparseMatrix* A, SparseMatrix* B)
    {
        if (A->getLinhas() != B->getLinhas() || A->getColunas() != B->getColunas())
        {
            std::cout << "As matrizes devem ter as mesmas dimensões para realizar a soma." << std::endl;
            return nullptr;
        }
    
        SparseMatrix *resultado = new SparseMatrix(A->getLinhas(), A->getColunas());
        for (int i = 0; i < A->getLinhas(); i++)
        {
            for (int j = 0; j < A->getColunas(); j++)
            {
                double valorA = A->get(i, j);
                double valorB = B->get(i, j);
                resultado->inserir(i, j, valorA + valorB);
            }
        }
    
        return resultado;
    }
    
    SparseMatrix* SparseMatrix::multiply(SparseMatrix* A, SparseMatrix* B)
    {
        if (A->getColunas() != B->getLinhas())
        {
            std::cout << "O número de colunas da matriz A deve ser igual ao número de linhas da matriz B para realizar a multiplicação." << std::endl;
            return nullptr;
        }
    
        SparseMatrix *resultado = new SparseMatrix(A->getLinhas(), B->getColunas());
        for (int i = 0; i < A->getLinhas(); i++)
        {
            for (int j = 0; j < B->getColunas(); j++)
            {
                double valor = 0.0;
                for (int k = 0; k < A->getColunas(); k++)
                {
                    valor += A->get(i, k) * B->get(k, j);
                }
                resultado->inserir(i, j, valor);
            }
        }
    
        return resultado;
    }
    

    Além disso, modifique o arquivo main.cpp para usar as novas funções e remover as antigas definições:

    int main()
    {
        // Exemplo de uso
        SparseMatrix *A = lerMatrizEsparsa("matrixA.txt");
        SparseMatrix *B = lerMatrizEsparsa("matrixB.txt");
    
        if (A != nullptr && B != nullptr)
        {
            std::cout << "Matriz A:" << std::endl;
            A->imprimir();
    
            std::cout << "Matriz B:" << std::endl;
            B->imprimir();
    
            // Usando a nova função
            SparseMatrix *resultadoSoma = A->sum(A, B);
            if (resultadoSoma != nullptr)
            {
                std::cout << "Soma das matrizes:" << std::endl;
                resultadoSoma->imprimir();
                delete resultadoSoma;
            }
    
            // Usando a nova função
            SparseMatrix *resultadoMultiplicacao = A->multiply(A, B);
            if (resultadoMultiplicacao != nullptr)
            {
                std::cout << "Multiplicação das matrizes:" << std::endl;
                resultadoMultiplicacao->imprimir();
                delete resultadoMultiplicacao;
            }
        }
    
        delete A;
        delete B;
    
        return 0;
    }
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.