Implement the "unum" representation in D ?

[Nick B via Digitalmars-d]

On Thursday, 20 February 2014 at 10:10:13 UTC, Nick B wrote:
>
> Hi everyone.
>

> John Gustafson Will be presenting a Keynote on Thursday 27th 
> February at 11:00 am
>
> The abstract is here:  
> http://openparallel.com/multicore-world-2014/speakers/john-gustafson/
>
> There is also a excellent background paper, (PDF - 64 pages) 
> which can be found here:
>

FYI

John Gustafson book is now out:

It can be found here:

http://www.amazon.com/End-Error-Computing-Chapman-Computational/dp/1482239868/ref=sr_1_1?s=books&ie=UTF8&qid=1436582956&sr=1-1&keywords=John+Gustafson&pebp=1436583212284&perid=093TDC82KFP9Y4S5PXPY


Here is one of the reviewers comments:

9 of 9 people found the following review helpful

This book is revolutionary
By David Jefferson on April 18, 2015

This book is revolutionary. That is the only way to describe it. 
I have been a professional computer science researcher for almost 
40 years, and only once or twice before have I seen a book that 
is destined to make such a profound change in the way we think 
about computation. It is hard to imagine that after 70 years or 
so of computer arithmetic that there is anything new to say about 
it, but this book reinvents the subject from the ground up, from 
the very notion of finite precision numbers to their bit-level 
representation, through the basic arithmetic operations, the 
calculation of elementary functions, all the way to the 
fundamental methods of numerical analysis, including completely 
new approaches to expression calculation, root finding, and the 
solution of differential equations. On every page from the 
beginning to the end of the book there are surprises that just 
astonished me, making me re-think material that I thought had 
been settled for decades.

The methods described in this book are profoundly different from 
all previous treatments of numerical methods. Unum arithmetic is 
an extension of floating point arithmetic, but mathematically 
much cleaner. It never does rounding, so there is no rounding 
error. It handles what in floating point arithmetic is called 
"overflow" and "underflow" in a far more natural and correct way 
that makes them normal rather than exceptional. It also handles 
exceptional values (NaN, +infinity, -infinity) cleanly and 
consistently. Those contributions alone would have been a 
profound contribution. But the book does much more.

One of the reasons I think the book is revolutionary is that 
unum-based numerical methods can effortlessly provide provable 
bounds on the error in numerical computation, something that is 
very rare for methods based on floating point calculations. And 
the bounds are generally as tight as possible (or as tight as you 
want them), rather than the useless or trivial bounds as often 
happens with floating point methods or even interval arithmetic 
methods.

Another reason I consider the book revolutionary is that many of 
the unum-based methods are cleanly parallelizable, even for 
problems that are normally considered to be unavoidably 
sequential. This was completely unexpected.

A third reason is that in most cases unum arithmetic uses fewer 
bits, and thus less power, storage, and bandwidth (the most 
precious resources in today’s computers) than the comparable 
floating point calculation. It hard to believe that we get this 
advantage in addition to all of the others, but it is amply 
demonstrated in the book. Doing efficient unum arithmetic takes 
more logic (e.g. transistors) than comparable floating point 
arithmetic does, but as the author points out, transistors are so 
cheap today that that hardly matters, especially when compared to 
the other benefits.

Some of the broader themes of the book are counterintuitive to 
people like me advanced conventional training, so that I have to 
re-think everything I “knew” before. For example, the discussion 
of just what it means to “solve” an equation numerically is 
extraordinarily thought provoking. Another example is the 
author’s extended discussion of how calculus is not the best 
inspiration for computational numerical methods, even for 
problems that would seem to absolutely require calculus-based 
thinking, such as the solution of ordinary differential equations.

Not only is the content of the book brilliant, but so is the 
presentation. The text is so well written, a mix of clarity, 
precision, and reader friendliness that it is a pure pleasure to 
read, rather then the dense struggle that mathematical textbooks 
usually require of the reader. But in addition, almost every page 
has full color graphics and diagrams that are completely 
compelling in their ability to clearly communicate the ideas. I 
cannot think of any technical book I have ever seen that is so 
beautifully illustrated all the way through.

I should add that I read the Kindle edition on an iPad, and for 
once Amazon did not screw up the presentation of a technical 
book, at least for this platform. It is beautifully produced, in 
full color and detail, and with all of the fonts and graphics 
reproduced perfectly.

Dr. Gustafson has also provided a Mathematica implementation of 
unums and of the many numerical methods discussed in the book. 
Let us hope that in the next few years there will be 
implementations in other languages, followed by hardware 
implementations. Over time there should be unum arithmetic units 
alongside of floating point arithmetic units on every CPU and GPU 
chip, and in the long run unums should replace floating point 
entirely. The case the author makes for this is overwhelming.

If you are at all interested in computer arithmetic or numerical 
methods, read this book. It is destined to be a classic.