This is a book that I did not want to review. It went out to a volunteer. When doing a check on books whose reviews were missing I found this was one of them. In the end after my doing some chasing the review copy was returned to me. I suppose I owe it to the publisher and authors to give it my best shot.

The book has an excellent pedigree going back to the first German edition in 1974 where the implementation language was FORTRAN. It went through six further editions (the last four using FORTRAN 77). At that stage the publishers decided to produce an English edition and change the implementation language to ISO C. A new co-author was pulled in to provide the C code.

The change of computing language has no impact on the printed text other than an appendix that lists the prototypes for the functions. Quite correctly, all the implementation code is provided on a CD. The CD also includes a considerable amount of other material including versions of GNU C/C++ for most common platforms. I am a little concerned that the pure C compiler was not used because that would have made me feel happier that the code never accidentally relied on C++ extensions to C.

Now let me be frank, the text is fine for anyone whose mathematical skills are up to about first year undergraduate numerical methods. The content is not that demanding but the presentation is in a demanding style. This means that this book is not going to help those who need the algorithms but whose mathematical background is shaky.

Now let me turn to the code. This is written in a style that, to put it mildly, is unhelpful. I do not want to go into great detail but the coder liberally mixes value variables with pointers without giving any clear indication as to which is which (yes, he does document every variable name, but his choice of names is unhelpful to both mathematicians and to programmers.) Let me give a single example. In an algorithm to determine a root of a function between two values he calls the start value f1 but handles the end value as a pointer, which he calls f2. The result is that we get code like:

f1 = (*fct)(*x1);
*f2 = (*fct)(*x2);

and a bit later in the same function

if(*f2 * f3<= ZERO){

This is one of those places where C++ has a strong advantage in that we can bind a reference to a dereferenced pointer, or use a reference parameter so that variables doing similar tasks look similar. In general when I have looked closely at the code, it achieves what it claims to, but it would be so much more elegant if the coding style was less opaque.

If anyone would like to give a second look to this book they are welcome to the review copy in exchange for a second review.