Customer Reviews

Elementary Functions:: Algorithms and Implementation

5 star:		(5)
4 star:		(0)
3 star:		(0)
2 star:		(0)
1 star:		(0)

 

 

Most people use floating point arithmetic in a fairly cavalier way. They treat double precision numbers as exact. And, although people use commercial libraries for transcendentals and the like, they seem unconcerned when they need to implement an offbeat function or approximation. Everyone knows the Taylor series for exp(x), for example, so how hard could it be to code that up? (Answer: easy to code, and equally easy to do very badly.)

In fact, IEEE standard arithmetic can not even represent 1/3 exactly. (If that's news to you, or if you think the difference doesn't matter, you should back off and find some introductory material before attacking this book). Also, orthogonal polynomials will give better accuracy and more controllable error than Taylor series, for polynomial approximations of given degree - over a decimal digit more accuracy, in a project I worked on recently. The first three chapters go over those basics, then get into the book's real content.

The next chapters address table-based methods - and tables appear at one point or another in many implementations.Then the author presents iterative techniques for square roots (and 1/sqrt, which is often more convenient), logs exponentials, and trig functions. Although accuracy is paramount, these algorithms also emphasize fast convergence using inexpensive operations. The next section, on shift-and-add algorithms, presents advanced, accurate, efficient algorithms including CORDIC. This section requires close attention, since this book is about principles rather than cut-and-paste coding, so people without immediate implementation needs might come back to it to give it the effort it requires. The book's last section deals with range reduction, i.e. converting the problem to a more tightly bounded one, where the algorithm's behavior can be better undestood and controlled. It also deals with rounding and other quirky cases in floating point arithmetic.

This book isn't for everyone - in fact, not many people these days need to implement "library" functions on their own. As a result, knowledge of implementing them well is increasingly scarce. If you end up in the unusual position of having to implement them yourself, possibly using an exotic computing technology, then this book will help you get the last possible bit of accuracy, and to get it as fast as possible.

-- wiredweird

The book clearly explains the most important algorithms used by computers to compute many mathematical functions, with plenty of actual examples.
It is not a list of algorithms and tables, but rather a recipe book; actual computation of values and tables is left to the reader, better equipped with some numerical analysis package.
Despite the title, the methods can be applied (with some effort) to a broad set of functions (including many that are not usually considered "elementary", like Bessel or Gudermannian functions).
An extensive bibliography is included.
A must for those who are involved in designing and implementing such functions for a computer, but also an enjoyable reading for those who wonder how some functions can be computed.

There are many figures and math equations in this book, and the way the book was digitized, many of them are difficult to read. Portions of letters and numbers are missing, equations are not always in the proper order with their associated text, and figures look blurry. It's as if you're referencing a bad photocopy. The content of the book is excellent, however, thus the 5-star review. Just get the paper version and avoid the Kindle version.

This book is an example of the best writing about topics in computer science and engineering. Just the topics covered make it an excellent survey of the various approaches to computing elementary functions in hardware and software. What sets it apart from much other technical writing is the clarity of it's succinct and easy to read style. No words are wasted, and the reader is shown how to reason and expand on the approach being discussed. Detailed proofs are sometimes left to the reference material listed in an excellent bibliography, but enough rigor remains in the text so that the reader is left with a excellent grasp of methods being discussed.

The truth is that computing elementary functions is something of a specialist topic, and I would not describe the subject as one that would set most reader's hearts racing. However it is a true credit to the author that even a mildly curious reader with some mathematical intuition should find this book approachable and enlightening. If you have any interest in the subject I can strongly recommend starting with this book! A serious implementor would need to follow up with the bibliography (this is not a "cookbook" text), but I cannot imagine a better starting point.

For those interested in computer arithmetics this is the right book to start with...Excelent references to the state of the art and related work.