Food for thought: Unums

[matthiaspaul]

Have you heard about ''unums'' (for "universal numbers") already?

This is a new number format and arithmetic environment proposed by John Gustafson since 2013. It is meant to be a superset of or long-term even a replacement for traditional floating point arithmetic as defined in IEEE 754 etc. It claims to address many of the shortcomings of floating point and interval arithmetic in general, while also being better suited for modern and future number crunching hardware (high integration, cheap transistors, parallel cores, but thermal and power limitations). One of the ideas is to use today's technology and progress to provide mathematically better solutions of limited precision with known accuracy, not necessarily more solutions per time or solutions with extreme precision but sometimes still only very limited accuracy.

Unums must be considered a work in progress. There are meanwhile two considerable different proposals, unum I and II. So far, there are a few software emulations (obviously very slow), but no hardware implementations.

The proposal has generated some heated discussions about the pros and cons of the format already (including one between Kahan and Gustafson). While I don't consider unums in their present form to be "the one-and-only solution", I find some of the underlying ideas very interesting and thought-provoking. While I love to push existing technologies to the limits, I also think it is important to reevaluate issues from new perspectives from time to time.

Well, since there are many people in this forum, who are interested in mathematics and computer sciences, some might be interested to learn about unums as well. I have therefore compiled a list of unum resources I am aware of.

What do you think about the unum proposal?

Greetings,

Matthias

Unum I presentations

• Gustafson, John L. (March 2013). "Right-Sizing Precision: Unleashed Computing: The need to right-size precision to save energy, bandwidth, storage, and electrical power" (PDF). http://www.johngustafson.net/presentatio...ision1.pdf
• Brueckner, Rich (2015-03-02). "Slidecast: John Gustafson Explains Energy Efficient Unum Computing". The Rich Report. Inside HPC. http://insidehpc.com/2015/03/slidecast-j...computing/
• Gustafson, John L. (2015). "The end of numerical error" (PDF). http://arith22.gforge.inria.fr/slides/06-gustafson.pdf
• Tichy, Walter F. (April 2016). "The End of (Numeric) Error: An interview with John L. Gustafson". Ubiquity - Information everywhere. Association for Computing Machinery. 2016 (April): 1–14. doi:10.1145/2913029. http://dx.doi.org/10.1145%2F2913029 http://ubiquity.acm.org/article.cfm?id=2913029
• Kahan, William M. (2016-07-15). "Prof. W. Kahan's Commentary on "THE END of ERROR — Unum Computing" by John L. Gustafson, (2015) CRC Press" (PDF). https://people.eecs.berkeley.edu/~wkahan/EndErErs.pdf
• Gustafson, John L. (2016-06-06). "An Energy-Efficient and massively parallel approach to valid numerics" (Powerpoint with comments). OCRAR Seminar. http://www.johngustafson.net/presentatio...minar.pptx (http://www.johngustafson.net/presentatio...eminar.pdf without comments)
  

Unum II presentations

• Gustafson, John L. (2016-06-03) [2016-02-22]. "A Radical Approach to Computation with Real Numbers - Unums version 2.0" (Powerpoint with comments). http://www.johngustafson.net/presentatio...ms2.0.pptx (http://www.johngustafson.net/presentations/Unums2.0.pdf without comments)
• Gustafson, John L. (2016). "A Radical Approach to Computation with Real Numbers" (PDF). SuperFri.org. http://www.johngustafson.net/pubs/RadicalApproach.pdf
• Kahan, William M. (2016-07-15). "Prof. W. Kahan's Comments on SORN Arithmetic" (PDF). https://people.eecs.berkeley.edu/~wkahan/SORNers.pdf
  

The Great Debate

• "Program: Special Session: The Great Debate: John Gustafson and William Kahan". Arith23: 23rd IEEE Symposium on Computer Arithmetic. Silicon Valley. 2016-07-12. http://arith23.gforge.inria.fr/program.html
• Gustafson, John L.; Kahan, William M. (2016-07-12). The Great Debate @ARITH23: John Gustafson and William Kahan (1:34:41 video). http://www.youtube.com/watch?v=LZAeZBVAz...e=youtu.be
• Kahan, William M. (2016-07-16) [2016-07-12]. "A Critique of John L. Gustafson's THE END of ERROR — Unum Computation and his A Radical Approach to Computation with Real Numbers". Santa Clara: IEEE Symposium on Computer Arithmetic, ARITH 23. http://people.eecs.berkeley.edu/~wkahan/UnumSORN.pdf http://arith23.gforge.inria.fr/slides/Kahan.pdf
• Gustafson, John L. (2016-07-12). ""The Great Debate": Unum arithmetic position paper". Santa Clara: IEEE Symposium on Computer Arithmetic, ARITH 23. https://groups.google.com/group/unum-com...f?part=0.1 http://arith23.gforge.inria.fr/slides/Gustafson.pdf
  

Book

• Gustafson, John L. (2016-02-04) [2015-02-05]. "The End of Error: Unum Computing". Chapman & Hall / CRC Computational Science. 24 (1st edition, 2nd corrected printing). CRC Press. ISBN 978-1-4822-3986-7. http://www.crcpress.com/The-End-of-Error...1482239867
  

[Vtile]

Really cool, way over my brains at times, but HP calculator spotted.
https://youtu.be/LZAeZBVAzVw?t=1h14m38s

Sorry, offtopic.

[Paul Dale]

Looks interesting!

- Pauli

[cruff]

There was some discussion of this in the Usenet comp.arch group a while back. You can search for "comp.arch unums" on Google to pick it up. Several people didn't seem to think it really solved anything, but I didn't follow the discussion closely.

[Claudio L.]

Really interesting. The first part has a few concepts that are already implemented in newRPL:
* Numbers use minimum storage needed, and auto promote themselves to larger storage only when needed: newRPL uses small integers in the range +/-130000 that only have a prolog and no storage, then auto-promoted to 64-bit integers (prolog+64-bits), then auto-promoted to arbitrary precision reals which only store the needed digits in packs of 8, so the number 1.5 only stores 1 pack of 8 digits even though precision might be set to 32.
* A bit to indicate if the quantity is exact or inexact.
* A "tag" to indicate the number of digits in the number.

But that's about where the similarities end, as newRPL sticks with the traditional floating point concept from there on.

Those "unums" are interesting, though I'm not sure how they would work in real problems. I particularly like the idea to represent "exactly" the inverses of all the integers in the fractional part of the number, so any integer number can be inverted back and forth with no loss of precision, ever (3 INV INV --> 3 is like a dream come true!).
But for general arithmetic I'm not so sure it's practical, I imagine a number that's an inverse of an integer:
1/13 + 1/23 --> Storing the result would need a storage system capable of storing the inverse of 13*23, and things can quickly escalate from there, requiring the use of large precision numbers very quickly. And what happens when you reach the maximum system precision? Then the result would be approximated (rounded? more like "snapped" into the grid of the uneven spacing of the discrete fractions that can be represented) much like in the current floating point but perhaps with a harder to determine bias.
So in the end it's a cool idea, I think it saves storage up to a point, then it just becomes the same thing (assuming you can't scale this up to massive amounts of digits), unless you are willing to work with those SORN (Sets-Of-Real-Numbers) which is a different animal.

Or have I misinterpreted their concept?