C++ for Scientists - Technische Universität Dresden

126 CHAPTER 4. GENERIC PROGRAMMING
private:
Matrix& ref;
};
In contrast to the previous maps it contains a mutable reference and another operator for setting
a value.
To test our implementation we create matrix A:
coo matrix A(3, 5);
A.insert(0, 0, 2.3);
A.insert(0, 3, 3.4);
A.insert(1, 2, 4.5);
and define the three property maps:
coo col col(A);
coo row row(A);
coo value value(A);
A read-only traversal of all non-zero entries reads:
for (nz cursor c= nz begin(A), end= nz end(A); c != end; ++c)
std::cout ≪ ”A[” ≪ row(∗c) ≪ ”][” ≪ col(∗c) ≪ ”] = ” ≪ value(∗c) ≪ ”\n”;
Scaling all non-zero elements can be achieved similarly:
for (nz cursor c= nz begin(A), end= nz end(A); c != end; ++c)
value(∗c, 2.0 ∗ value(∗c));
Note that we did not used all property maps in the last algorithm. In fact, this is one of the
motivation for property maps. Only data really needed in the algorithm must be provided. In
today’s computer landscape, this can make a significant difference in performance since reading
and writing data is much more time-consuming than most numeric computations. Or if data is
only available implicitly and needs recomputation.
Another advantage of this approach is the easier realization of nested traversals. Say we have
an algorithm that iterates over rows and within each row over the non-zero entries. In this case,
we need other cursor type(s) but can reuse the property maps — if our new cursor derefer to
the same key type. First we need a cursor to iterate over all rows of a matrix:
template
struct row cursor
{
row cursor(int r, const Matrix& ref) : r(r), ref(ref) {}
row cursor& operator++() { r++; return ∗this; }
row cursor operator++(int) { row cursor tmp(∗this); r++; return tmp; }
bool operator!=(const row cursor& other) { return r != other.r; }
nz cursor begin() const { return nz cursor(ref.begin row(r)); }
nz cursor end() const { return nz cursor(ref.begin row(r+1)); }
protected:
int r;
const Matrix& ref;
};