C++ for Scientists - Technische Universität Dresden

2.11. REAL-WORLD EXAMPLE: MATRIX INVERSION 61
This does not work yet for technical reasons but will in the future.
You may argue that the transpostions and passing the matrix and the vector once more takes
more time. More importantly, we know that the lower matrix has a unit diagonal and we did
not explore this property, e.g. for avoiding the divisions in the triangular solver. We could
even ignore or omit the diagonal and treat this implicitly in the algorithms. This is all true.
However, we prioritized the simplicity and clarity of the implementation and the reusability
aspect higher than performance here. 28
We have now all we need to put the matrix inversion together. As above we start we checking
the squareness.
dense2D inline inverse(dense2D const& A)
{
const unsigned n= num rows(A);
assert(num cols(A) == n); // Matrix must be square
Then we perform the LU factorization. For performance reasons this function does not return
the result but takes its arguments as mutable references and factorizes in place. Thus, we need
a copy of a matrix to pass and a permutation vector of appropriate size.
dense2D PLU(A);
dense vector Pv(n);
lu(PLU, Pv);
The upper triangular factor PU of the permuted A is stored in the upper triangle of PLU. The
lower triangular factor PL is partly stored in the strict lower triangle of PLU while the unit
diagonal is omitted. We therefore need to add it before inversion (or alternatively handle the
unit diagonal implicitly in the inversion).
dense2D PU(upper(PLU)), PL(strict lower(PLU) + matrix::identity(n, n));
The inversion of a square matrix according to Equation (2.1) can then be performed in one
single line: 29
return dense2D(inverse upper(PU) ∗ inverse lower(PL) ∗ permutation(Pv));
During this section you have seen that you have always alternatives to implement the same
behavior, most likely you already made this experience before. Despite we suggested for every
choice we made that it is the most appropriate, there is not always THE single best solution and
even while trading off pro and cons of the alternatives, one might not come to a final conclusion
and just pick one. We also illustrated that the choices depend on the goals, for instance the
implementation would look different if performance were the primary goal.
The section shall show as well that that non-trivial programs are not written in a single sweep
by an ingenious mind — exceptions might prove the rule — but are the result of a gradually
improving development. Experience will make this journey shorter and directer but we will not
write the perfect program at the first glance.
28 People that care about performance do not use matrix inversion in the first place.
29 The explicit conversion can probably be omitted in later versions of MTL4.