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

Faça a implementação em c++ (Não deve ser alocado arrays, apenas nós.)…

  1. User

    Faça a implementação em c++ (Não deve ser alocado arrays, apenas nós.)

    Classe SparseMatrix_____

    • SparseMatrix(int m, int n); <- deve ser separada da main Construtor da classe. Inicializa uma matriz esparsa vazia com capacidade para m linhas e n colunas. Essa função deve checar se os valores passados são válidos (se são inteiros positivos, ou seja m > 0 e n > 0); se não forem, uma exceção deve ser lançada

    • SparseMatrix(); Destrutor. Libera toda a memória que foi alocada dinamicamente para a matriz

    • void insert(int i, int j, double value); Esta função-membro faz o valor na célula (i, j) da matriz ser igual a value, onde i é a linha e “j” é a coluna. Se já houver um valor nessa posição, ele é atualizado para esse novo valor. Essa função deve checar se os índices i, j passados por parâmetro são válidos; se não forem válidos, uma exceção deve ser lançada. Atenção: No caso em que o valor do argumento value for igual a zero, a função deve desconsiderar e não fazer nada neste caso. Ou seja, chamadas desta função passando o valor 0 não terão efeito algum.

    • double get(int i, int j); Devolve o valor na célula (i, j) da matriz, onde “i” é a linha e “j” é a coluna. Essa função deve checar se os índices passados são válidos; se não forem válidos, uma exceção deve ser lançada.

    • void print(); Esta função imprime a matriz A no terminal, inclusive os elementos iguais a zero.

    Além da classe SparseMatrix, você deve implementar três funções adicionais no arquivo main.cpp (não são funções-membro da SparseMatrix, são funções externas à classe)

    Arquivo main.cpp_

    • SparseMatrix* readSparseMatrix(std::string nome do arquivo); Essa função lê, de um arquivo de entrada, os elementos diferentes de zero de uma matriz esparsa e monta a estrutura especificada anteriormente, devolvendo um ponteiro para a SparseMatrix alocada dinamicamente. Considere que a primeira linha do arquivo de entrada consiste dos valores m e n (número de linhas e de colunas da matriz), e as demais linhas do arquivo sao constitúıdas de triplas (i, j, valor) para Os elementos diferentes de zero da matriz. Por exemplo, para a matriz A anterior, o contéudo do arquivo de entrada seria:

    --matriz.txt---- 4 4 1 1 50.0 2 1 10.0 2 3 20.0 4 1 -30.0 4 3 -60.0 4 4 -5.0

    você pode usar a biblioteca fstream, que possibilita ler arquivos e escrever neles, arquivos-texto

    ATENÇÃO: As matrizes podem ter até 30000 linhas e 30000 colunas.

    • 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.

    É obrigat́orio o uso de alocação dinâmica de memória para implementar as listas de adjacência que representam as matrizes

  2. Assistant
    #include <iostream>
    #include <stdexcept>
    #include <fstream>
    #include <string>
    
    class Node {
    public:
        int row, col;
        double value;
        Node *next;
    
        Node(int r, int c, double v, Node *n = nullptr)
            : row(r), col(c), value(v), next(n) {}
    };
    
    class SparseMatrix {
    private:
        int m, n;
        Node **rows;
    
    public:
        SparseMatrix(int m, int n) {
            if (m <= 0 || n <= 0) {
                throw std::invalid_argument("Invalid matrix dimensions");
            }
    
            this->m = m;
            this->n = n;
            rows = new Node *[m]();
        }
    
        ~SparseMatrix() {
            for (int i = 0; i < m; i++) {
                Node *node = rows[i];
                while (node != nullptr) {
                    Node *temp = node;
                    node = node->next;
                    delete temp;
                }
            }
    
            delete[] rows;
        }
    
        void insert(int i, int j, double value) {
            if (i < 0 || i >= m || j < 0 || j >= n) {
                throw std::out_of_range("Invalid matrix indices");
            }
    
            if (value == 0) {
                return;
            }
    
            Node *node = rows[i];
            while (node != nullptr && node->col < j) {
                node = node->next;
            }
    
            if (node != nullptr && node->col == j) {
                node->value = value;
            } else {
                Node *newNode = new Node(i, j, value, node);
                if (rows[i] == nullptr) {
                    rows[i] = newNode;
                } else {
                    Node *prev = rows[i];
                    while (prev->next != node) {
                        prev = prev->next;
                    }
                    prev->next = newNode;
                }
            }
        }
    
        double get(int i, int j) {
            if (i < 0 || i >= m || j < 0 || j >= n) {
                throw std::out_of_range("Invalid matrix indices");
            }
    
            Node *node = rows[i];
            while (node != nullptr && node->col != j) {
                node = node->next;
            }
    
            return (node != nullptr) ? node->value : 0.0;
        }
    
        void print() {
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    std::cout << get(i, j) << " ";
                }
                std::cout << std::endl;
            }
        }
    
        int num_rows() const { return m; }
        int num_cols() const { return n; }
    };
    
    SparseMatrix *readSparseMatrix(std::string filename) {
        std::ifstream inputFile(filename);
        int m, n;
        inputFile >> m >> n;
    
        SparseMatrix *matrix = new SparseMatrix(m, n);
    
        int i, j;
        double value;
        while (inputFile >> i >> j >> value) {
            matrix->insert(i - 1, j - 1, value);
        }
    
        inputFile.close();
        return matrix;
    }
    
    SparseMatrix *sum(SparseMatrix *A, SparseMatrix *B) {
        if (A->num_rows() != B->num_rows() || A->num_cols() != B->num_cols()) {
            throw std::invalid_argument("Matrix dimensions must agree");
        }
    
        SparseMatrix *C = new SparseMatrix(A->num_rows(), A->num_cols());
    
        for (int i = 0; i < A->num_rows(); i++) {
            for (int j = 0; j < A->num_cols(); j++) {
                double result = A->get(i, j) + B->get(i, j);
                if (result != 0) {
                    C->insert(i, j, result);
                }
            }
        }
    
        return C;
    }
    
    SparseMatrix *multiply(SparseMatrix *A, SparseMatrix *B) {
        if (A->num_cols() != B->num_rows()) {
            throw std::invalid_argument("Matrix dimensions must agree");
        }
    
        SparseMatrix *C = new SparseMatrix(A->num_rows(), B->num_cols());
    
        for (int i = 0; i < A->num_rows(); i++) {
            for (int j = 0; j < B->num_cols(); j++) {
                double result = 0;
                for (int k = 0; k < A->num_cols(); k++) {
                    result += A->get(i, k) * B->get(k, j);
                }
                if (result != 0) {
                    C->insert(i, j, result);
                }
            }
        }
    
        return C;
    }
    
    int main() {
        SparseMatrix *A = readSparseMatrix("matriz.txt");
        SparseMatrix *B = readSparseMatrix("matriz.txt");
    
        SparseMatrix *C = sum(A, B);
        C->print();
    
        SparseMatrix *D = multiply(A, B);
        D->print();
    
        delete A;
        delete B;
        delete C;
        delete D;
    
        return 0;
    }
    
  3. Assistant

    Se você tiver alguma dúvida em relação ao código ou desejar fazer alguma alteração ou otimização, por favor, sinta-se à vontade para pedir!

    Se encontrar algum erro ao compilar ou executar o código, por favor me avise para que eu possa corrigi-lo ou ajudá-lo a solucionar o problema.

    Caso contrário, se estiver satisfeito com a solução, espero que ela seja útil para o seu projeto ou aprendizado. Desejo-lhe sucesso e estou à disposição para ajudar com outras dúvidas futuras!