Sparse Matrix Sum

sparse_matrix_sum.cpp

#include <vector>
#include <utility>
#include <algorithm>
#include <iostream>

class SparseMatrix {
public:
    void setElement(int i, int j, double value) {
        auto element_iter = findElement(i,j);
        bool is_zero = (value==0.0);
        if(element_iter != entries_.end()) {
            if(is_zero) {
                // Remove this element.
                entries_.erase(element_iter);
            } else {
                // Update the element.
                element_iter->e = value;
            }
        } else {
            // No existing element.
            if(!is_zero) {
                entries_.emplace_back(Entry{i,j,value});
            }
        }
    }

    double getElement(int i, int j) {
        auto element_iter = findElement(i,j);
        if(element_iter == entries_.end()) {return 0.0;}
        return element_iter->e;
    }

    SparseMatrix operator+(SparseMatrix& other) {
        SparseMatrix result;
        for(const auto& e : entries_) {
            result.setElement(e.i, e.j, e.e + other.getElement(e.i, e.j));
        }
        for(const auto& e : other.entries_) {
            auto entry_iter = findElement(e.i, e.j);
            if(entry_iter == entries_.end()) {
                result.setElement(e.i, e.j, e.e);
            }
        }
        return result;
    }

    friend std::ostream& operator<<(std::ostream& s, const SparseMatrix& m) {
        for(const auto& e : m.entries_) {
            s << "(" << e.i << ", " << e.j << "): " << e.e << "\n";
        }
        return s;
    }
private:

    struct Entry {
        int i,j;
        double e;
    };

    std::vector<Entry>::iterator findElement(int i, int j) {
        return std::find_if(entries_.begin(), entries_.end(),
            [=](const Entry& entry){ return entry.i == i && entry.j == j;});
    }

    std::vector<Entry> entries_;
};

int main(int, char**) {
    SparseMatrix m;
    m.setElement(0,0, 1.0);
    m.setElement(10,0, 10.0);
    m.setElement(0,10, -10.0);
    m.setElement(5,5, 0.0);

    SparseMatrix m2;
    m2.setElement(0,0, 1.0);
    m2.setElement(10,0, 10.0);
    m2.setElement(10,10, -10.0);

    std::cerr << "M\n" << m << std::endl;
    std::cerr << "\nM2\n" << m2 << std::endl;
    std::cerr << "sum:\n" << m+m2 << std::endl;

    return 0;
}