C++ for Scientists - Technische Universität Dresden

54 CHAPTER 2. C++ BASICS
As a practical exercise, we now go step-by-step through the development process of a function
for matrix inversion. This is easier than it seems. 25 For it, we use the Matrix Template Library 4
— see http://www.mtl4.org. It already provides most of the functionality we need. 26
In the program development, we follow some principles of Extreme Programming, especially
writing tests first and implement the functionality afterwards. This has two significant advantages:
• It prevents you as programmer (to some extend) from featurism — the obsession to add
more features instead of finishing one thing after another. If you write down what you
want to achieve you work more directly towards this goal and accomplish it usually much
earlier. When writing the function call you specify the interface of the function you plan
implementing, when testing your results against expected values you say something about
the semantics of your function. Thus, tests are compilable documentation. The tests
might not tell everything about the functions and classes you are going to implement, but
what it says it does very precisely. Documentation in text can be much more detailed and
comprehensible but also much vaguer than tests.
• If you start writing tests after you finally finished the implementation — say on a late
Friday afternoon — You Do Not Want To See It Failing. You will write the test with your
nice data (whatever this means for the program in question) and minimize the risk that
it fails. You might decide going home and swear to God that you will test it on Monday.
For those reasons, you will be more honest if you write your tests first. Of course, you can
modify your tests later if you realize that something does not work or you changed the design
of some item or you want test more details. It goes without saying that verifying partial
implementations requires uncommenting parts of your test, temporarily.
Before we start implementing our inverse function and even the tests we have to choose an
algorithm. We can use determinants of sub-matrices, block algorithms, Gauß-Jordan, or LU
decomposition with or without pivoting. Let’s say we prefer LU factorization with column
pivoting so that we have
LU = P A,
with a unit lower triangular matrix L, an upper triangular matrix U, and a permutation matrix
P . Thus it is
A = P −1 LU
and
A −1 = U −1 L −1 P. (2.1)
We use the LU factorization from MTL4, implement the inversion of the lower and upper
triangular matrix and compose it appropriately.
Now we start with our test by defining an invertible matrix and printing it out.
int main(int argc, char∗ argv[])
{
const unsigned size= 3;
typedef dense2D Matrix;
Matrix A(size, size);
A= 4, 1, 2,
25 At least with the implementations we already have.
26 It actualy provides the inversion function inv already but we want to learn now how to get there.