Search in Book Reviews

This is one of two books I am reviewing this time that I found deeply disappointing. My first love was mathematics (and I still like to spend time travelling some of its byways even though I doubt that I will ever get a second contribution published in The Mathematical Gazette). The subtitle of this book, An Introduction to Computer Algebra using Object-Oriented Programming leapt at me from the Blackwell's Bookshop shelf that it was on. (Let me pay tribute to the excellent service Blackwell's computer department provides by allowing me to collect review copies direct from them when I have missed asking the publisher for one).

My first doubts began when I looked at a list of abstract data types and spot such entries as

Complex, ListandSet. Could it really be that the authors have provided their own versions of things that have been so carefully honed by all those responsible for the STL? The answer, I am afraid, is 'yes'. Worse still is that these implementations are clearly inferior to those of the STL. I can understand the temptation to redesign

vector

to be a mathematical vector with a cross and dot product, I am happy to see a

Matrix

template class, I can even understand the motivation for doing your own

String

template. Anyway, let me move on for now.

Chapter two gives a good summary of the mathematical entities that the author tackle. In a brief 48 pages we cover such things as rings and fields, differentiation and Kronecker Products. Mind you, I think you have to be pretty confident of your Algebras if you are not to run pale faced and screaming from this chapter. No need to worry, you can skip much of it.

Chapter three gives a quick overview of several purpose built applications such as Reduce, Mathematica and MuPAD. Possibly now is the time to put the book away and buy one of these if all you are interested in is computer algebra.

The next two chapters are largely misplaced. If you do not already have a fair concept about such things as Object-orientation, classes and operator overloading these chapters will just scare you. On the other hand, if you are sufficiently fluent in C++ to make sense of the code you will not need these chapters. I suppose I should also highlight that 20 pages are spent on Java, presumably to justify the back cover claim 'Extends the Java section.'

The next three chapters (220 pages) are the main meat of the book; here the authors cover their various classes. Somewhere in the earlier chapters the authors claim that this revised edition takes into consideration the ANSI C++ Standard (well, for an international text that should be ISO, but let that one go). To understand what makes me want my money back (OK, I did not pay in the first place) let me quote the first few lines on page 217:

The header file<complex.h> is available in the C++ library. However, the data type of the real and imaginary part is double. This is not sufficient for applications which require exact manipulation of complex numbers. This limitation has prompted us to construct another complex number class which uses the template.

How many errors and downright falsehoods can you identify in those few sentences? How much trust are you going to place on other aspects of the text? It is bad enough that the authors make statements like these, but any technical reviewer who let such pass is incompetent. Perhaps the technical reviewer did identify the problem and the authors wilfully ignored it, I do not know. What I do know is that a potentially interesting book has been completely devalued by someone's technical incompetence.

Chapter nine is plain bizarre. The first half of the chapter gives a brief introduction to LISP in the context of computer algebra while the second half seems to be some kind of attempt to implement a minimalist Lisp System in C++. My advice to anyone who is still with me is to forget it.

Finally we have the longest chapter of the book 200 pages of implementation listings. Why were these not on a CD?

I was bitterly disappointed by a book that promised so much and delivered so little. I was not expecting use of such advanced C++ technologies as expression templates but I would expect that a VeryLongInt to int conversion operator would throw an exception when the conversion failed to conserve value. Am I being unreasonable? I think not so I will not waste your time by offering the book for a second review (you can still volunteer if you want it)