C++ for Scientists - Technische Universität Dresden

60 CHAPTER 2. C++ BASICS
we need smaller unit vectors now and only sub-matrices of A. This can nicely be expressed with
ranges:
Inv= 0;
for (unsigned k= 0; k < n; ++k)
Inv[irange(0, k+1)][k]= upper trisolve(A[irange(0, k+1)][irange(0, k+1)], unit vector(k, k+1));
Admittedly, the irange makes the expression hard to read. Although it looks like a function,
irange is a type and we just created objects on the fly and passed them to passed them to the
operator[]. As we use the same range 3 times, it is shorter to create a variable (or a constant).
for (unsigned k= 0; k < n; ++k) {
const irange r(0, k+1);
Inv[r][k]= upper trisolve(A[r][r], unit vector(k, k+1));
}
This does not only make the second line shorter, it is also easier to see that this is all the same
range.
Another observation: after shortening the unit vectors they all have the one in the last entry.
Thus, we only need the size of the vector and the position of the one is implied:
dense vector inline last unit vector(unsigned n)
{
dense vector v(n, 0.0);
v[n−1]= 1;
return v;
}
We choose a different name to reflect the different meaning. Nonetheless, we wonder if we really
want such a function. How is the probability to need this ever again? Charles H. Moore,
the creator of the programming language Forth once said that “The purpose of functions is not
to hash a program into tiny pieces but to create highly reusable entities.” All this said, we
prefer the more general function that is much more likely to be useful later.
After all these modifications, we are now satisfied with the implementation and go to the next
function. We still might change something at a later point in time but having it made clearer
and better structured will make the later modification much easier for us or somebody else.
The more experience you gain, the less steps you will need to achieve the implementation that
makes you happy. And it goes without saying that we tested the inverse upper repeatedly while
modifying it.
Now that we know how to invert triangular matrices we can do the same for the lower triangular
accordingly. Alternatively we can just transpose the input and output:
dense2D inline inverse lower(dense2D const& A)
{
dense2D T(trans(A));
return dense2D(trans(inverse upper(T)));
}
Ideally this implementation should look like this:
dense2D inline inverse lower(dense2D const& A)
{
return trans(inverse upper(trans(T)));
}