View source for Unum (number format)

{{Short description|Variant of floating-point numbers in computers}}
{{Use dmy dates|date=May 2019|cs1-dates=y}}
{{Use list-defined references|date=January 2022}}
'''Unums''' (''universal numbers''<ref name="Tichy_2016_1"/>) are a family of number formats and arithmetic for implementing [[real number]]s on a computer, proposed by [[John Gustafson (scientist)|John L. Gustafson]] in 2015.<ref name="Gustafson_2015"/> They are designed as an alternative to the ubiquitous [[IEEE 754|IEEE 754 floating-point standard]]. The latest version is known as ''posits''.<ref name="Gustafson_2017?_Posit"/>

{{Toclimit}}

== Type I Unum<span class="anchor" id="Unum I"></span> ==
The first version of unums, formally known as Type I unum, was introduced in Gustafson's book ''The End of Error'' as a superset of the IEEE-754 floating-point format.<ref name="Gustafson_2015" /> The defining features of the Type I unum format are:
* a variable-width storage format for both the [[significand]] and [[exponent]], and
* a ''u-bit'', which determines whether the unum corresponds to an exact number (''u''&nbsp;=&nbsp;0), or an [[interval (mathematics)|interval]] between consecutive exact unums (''u''&nbsp;=&nbsp;1). In this way, the unums cover the entire extended real number line [−∞,+∞].

For computation with the format, Gustafson proposed using [[interval arithmetic]] with a pair of unums, what he called a ''ubound'', providing the guarantee that the resulting interval contains the exact solution.

[[William M. Kahan]] and Gustafson debated unums at the ''[[Arith23]]'' conference.<ref name="ARITH23_2016"/><ref name="Great-Debate_2016"/><ref name="Kahan_2016"/><ref name="Gustafson_ARITH23"/>

== Type II Unum<span class="anchor" id="Unum II"></span> ==
Type II Unums were introduced in 2016<ref name="Tichy_2016_2" /> as a redesign of Unums that broke IEEE-754 compatibility : in addition to the sign bit and the interval bit mentioned earlier, the Type II unum uses a bit to indicate inversion. These three operations make it possible, starting from a finite set of points between one and infinity, to quantify the entire projective line except for four points: the two exceptions, 0 and ∞, and then 1 and -1. This set of points is chosen arbitrarily, and arithmetic operations involving them are not performed logically but rather by using a lookup table. The size of such a table becomes prohibitive for an encoding format spanning multiple bytes. This challenge necessitated the development of the Type III unum, known as the posit, discussed below.

== Posit (Type III Unum)<span class="anchor" id="Posit"></span><span class="anchor" id="Unum III"></span><span class="anchor" id="Type III Unum (posit and valid)"></span> ==
In February 2017, Gustafson officially introduced Type III unums (posits), for fixed floating-point-like values and valids for [[interval arithmetic]].<ref name="Gustafson_2017?_Posit" /> In March 2022, a standard was ratified and published by the Posit Working Group.<ref name="Posit_Standard_2022" />

Posits<ref name="Gustafson_2017?_Posit" /><ref name="Gustafson_2017_video" /><ref name="Gustafson_2017_Posit" /> are a hardware-friendly version of unum where difficulties faced in the original type I unum due to its variable size are resolved. Compared to IEEE 754 floats of similar size, posits offer a bigger dynamic range and more fraction bits for values with magnitude near 1 (but fewer fraction bits for very large or very small values), and Gustafson claims that they offer better accuracy.<ref name="Feldman_2019" /><ref name="Byrne_2016" /> Studies<ref name="conga_paper_lindstrom" /><ref name=Mallasen_2023 /> confirm that for some applications, posits with [[#Quire|quire]] out-perform floats in accuracy. Posits have superior accuracy in the range near one, where most computations occur. This makes it very attractive to the current trend in deep learning to minimize the number of bits used. It potentially helps any application to accelerate by enabling the use of fewer bits (since it has more fraction bits for accuracy) reducing network and memory bandwidth and power requirements.

The format of an ''n''-bit posit is given a label of "posit" followed by the decimal digits of ''n'' (e.g., the 16-bit posit format is "posit16") and consists of four sequential fields:

# [[sign bit|sign]]: 1 bit, representing an unsigned integer ''s''
# regime: at least 2 bits and up to (''n''&nbsp;−&nbsp;1), representing an unsigned integer ''r'' as described below
# [[exponent]]: generally 2 bits as available after regime, representing an unsigned integer ''e''
# [[Significand|fraction]]: all remaining bits available after exponent, representing a non-negative real [[dyadic rational]] ''f'' less than 1

The regime field uses [[unary coding]] of ''k'' identical bits, followed by a bit of opposite value if any remaining bits are available, to represent an unsigned integer ''r'' that is −''k'' if the first bit is 0 or ''k''&nbsp;−&nbsp;1 if the first bit is 1. The sign, exponent, and fraction fields are analogous to IEEE 754 sign, exponent, and significand fields (respectively), except that the posit exponent and fraction fields may be absent or truncated and implicitly extended with zeroes—an absent exponent is treated as <code>00</code><sub>2</sub> (representing 0), a one-bit exponent E<sub>1</sub> is treated as <code>E<sub>1</sub>0</code><sub>2</sub> (representing the integer 0 if E<sub>1</sub> is 0 or 2 if E<sub>1</sub> is 1), and an absent fraction is treated as 0. Negative numbers (''s'' is 1) are encoded as 2's complements.

The two encodings in which all non-sign bits are 0 have special interpretations:

* If the sign bit is 1, the posit value is <code>NaR</code> ("not a real")
* If the sign bit is 0, the posit value is 0 (which is unsigned and the only value for which the <code>sign</code> function returns 0)

Otherwise, the posit value is equal to <math display="inline">((1 - 3s) + f) \times 2^{(1 - 2s) \times (4r + e + s)}</math>, in which ''r'' scales by powers of 16, ''e'' scales by powers of 2, ''f'' distributes values uniformly between adjacent combinations of (''r'', ''e''), and ''s'' adjusts the sign symmetrically about 0.

=== Examples ===
{| class="wikitable"
|+
!type<br/>(posit''n'')
!Binary
!Value
!Notes
|-
| {{any}}
|<code><span style="color:#FF2000">1</span> <span style="color:#CC9933">0…</span></code>
|<code>NaR</code>
|anything not mathematically definable as a unique real number<ref name="Posit_Standard_2022" />
|-
| {{any}}
|<code><span style="color:#FF2000">0</span> <span style="color:#CC9933">0…</span></code>
| {{val|0}}
|
|-
| {{any}}
|<code><span style="color:#FF2000">0</span> <span style="color:#CC9933">10…</span></code>
| {{val|1}}
|
|-
| {{any}}
|<code><span style="color:#FF2000">1</span> <span style="color:#CC9933">10…</span></code>
| {{val|-1}}
|
|-
| {{any}}
|<code><span style="color:#FF2000">0</span> <span style="color:#CC9933">0</span><span style="color:#996633">1</span> <span style="color:#4080FF">11</span> 0…</code>
| {{val|0.5}}
|
|-
| {{any}}
|<code><span style="color:#FF2000">0</span> <span style="color:#CC9933">0…</span><span style="color:#996633">1</span></code>
|<math display="inline">2^{-4n + 8}</math>
|smallest positive value
|-
| {{any}}
|<code><span style="color:#FF2000">0</span> <span style="color:#CC9933">1…</span></code>
|<math display="inline">2^{4n - 8}</math>
|largest positive value
|-
|posit8
|<code><span style="color:#FF2000">0</span> <span style="color:#CC9933">000000</span><span style="color:#996633">1</span></code>
|<math display="inline">2^{-24} \approx 6.0 \times 10^{-8}</math>
|smallest positive value
|-
|posit8
|<code><span style="color:#FF2000">0</span> <span style="color:#CC9933">1111111</span></code>
|<math display="inline">2^{24} \approx 1.7 \times 10^{7}</math>
|largest positive value
|-
|posit16
|<code><span style="color:#FF2000">0</span> <span style="color:#CC9933">00000000000000</span><span style="color:#996633">1</span></code>
|<math display="inline">2^{-56} \approx 1.4 \times 10^{-17}</math>
|smallest positive value
|-
|posit16
|<code><span style="color:#FF2000">0</span> <span style="color:#CC9933">111111111111111</span></code>
|<math display="inline">2^{56} \approx 7.2 \times 10^{16}</math>
|largest positive value
|-
|posit32
|<code><span style="color:#FF2000">0</span> <span style="color:#CC9933">000000000000000000000000000000</span><span style="color:#996633">1</span></code>
|<math display="inline">2^{-120} \approx 7.5 \times 10^{-37}</math>
|smallest positive value
|-
|posit32
|<code><span style="color:#FF2000">0</span> <span style="color:#CC9933">1111111111111111111111111111111</span></code>
|<math display="inline">2^{120} \approx 1.3 \times 10^{36}</math>
|largest positive value
|}

'''Note''': 32-bit posit is expected to be sufficient to solve almost all classes of applications{{Citation needed|reason=There are many realistic problems which require more than 32 bits of information and thus would be impossible to solve using a 32-bit posit, no matter how detailed. For example, dealing with long-running times where nanosecond or greater accuracy is needed.|date=December 2018}}.

=== Quire ===
For each posit''n'' type of precision <math display="inline">n</math>, the standard defines a corresponding "quire" type quire''n'' of precision <math display="inline">16 \times n</math>, used to accumulate exact sums of products of those posits without rounding or overflow in [[Dot product|dot products]] for vectors of up to 2<sup>31</sup> or more elements (the exact limit is <math>2^{23 + 4n}</math>). The quire format is a [[two's complement]] signed integer, interpreted as a multiple of units of magnitude <math>2^{16 - 8n}</math> except for the special value with a leading sign bit of 1 and all other bits equal to 0 (which represents <code>NaR</code>). Quires are based on the work of [[Ulrich W. Kulisch]] and [[Willard L. Miranker]].<ref name="kulish_1986" />

== Valid ==
Valids are described as a Type III Unum mode that bounds results in a given range.<ref name="Gustafson_2017?_Posit" />

== Implementations ==
Several software and hardware solutions implement posits.<ref name="conga_paper_lindstrom" /><ref name="conga_paper_chung" /><ref name="conga_paper_hofstee" /><ref name="conga_paper_Lehoczky" /><ref name="paper_Langroudi" /> The first complete parameterized posit arithmetic hardware generator was proposed in 2018.<ref name="iccd_2018_paper" />

Unum implementations have been explored in [[Julia (programming language)|Julia]]<ref name="Julia_1" /><ref name="Julia_2" /><ref name="Julia_3" /><ref name="Julia_4" /><ref name="Pnums" /><ref name="Pivot_2019" /> and [[MATLAB]].<ref name="matlab" /><ref name="matlab_2" /> A [[C++]] version<ref name="Stillwater_2019" /> with support for any posit sizes combined with any number of exponent bits is available. A fast implementation in C, SoftPosit,<ref name="SoftPosit" /> provided by the NGA research team based on Berkeley SoftFloat adds to the available software implementations.
{| class="wikitable"
!Project
''author''
!Type
!Precisions
!Quire
Support?
!Speed
!Testing
!Notes
|-
|[https://vivid-sparks.com/ GP-GPU]
''VividSparks''
|World's first FPGA GPGPU
|32
| {{Yes}}
|~3.2&nbsp;TPOPS
| Exhaustive. No known bugs.
| RacEr GP-GPU has 512 cores
|-
|[https://gitlab.com/cerlane/SoftPosit SoftPosit]
''A*STAR''
|C library based on Berkeley SoftFloat
C++ wrapper to override operators
Python wrapper using SWIG of SoftPosit
|8, 16, 32 published and complete;
| {{Yes}}
|~60 to 110&nbsp;MPOPS on x86 core (Broadwell)
|8: Exhaustive;
16: Exhaustive except FMA, quire
32: Exhaustive test is still in progress.
No known bugs.
| {{Open source}} license. Fastest and most comprehensive C library for posits presently. Designed for plug-in comparison of IEEE floats and posits.
|-
|[https://posithub.org/khub_doc#posits4 posit4.nb]
''A*STAR''
|Mathematica notebook
|All
| {{Yes}}
|< 80&nbsp;KPOPS
|Exhaustive for low precisions. No known bugs.
| {{Open source}} (MIT license). Original definition and prototype. Most complete environment for comparing IEEE floats and posits. Many examples of use, including linear solvers
|-
|[https://github.com/cerlane/posit-javascript posit-javascript]
''A*STAR''
|JavaScript widget
|Convert decimal to posit 6, 8, 16, 32; generate tables 2–17 with es 1–4.
| {{N/A|N/A}}
| {{N/A|N/A;<br/>interactive widget}}
|Fully tested
|Table generator and conversion
|-
|[https://github.com/stillwater-sc/universal Universal]
Stillwater Supercomputing, Inc
|C++ template library
C library
Python wrapper
Golang library
|Arbitrary precision posit float valid (p)
Unum type 1 (p)
Unum type 2 (p)
|Arbitrary quire configurations with programmable capacity
|posit<4,0> 1&nbsp;GPOPS
posit<8,0> 130&nbsp;MPOPS
posit<16,1> 115&nbsp;MPOPS
posit<32,2> 105&nbsp;MPOPS
posit<64,3>
50&nbsp;MPOPS
posit<128,4>
1&nbsp;MPOPS
posit<256,5>
800&nbsp;KPOPS
|Complete validation suite for arbitrary posits
Randoms for large posit configs.
Uses induction to prove nbits+1 is correct
no known bugs
|{{Open source}}. MIT license.
Fully integrated with C/C++ types and automatic conversions.
Supports full C++ math library (native and conversion to/from IEEE).
Runtime integrations: MTL4/MTL5, Eigen, Trilinos, HPR-BLAS.
Application integrations: G+SMO, FDBB, FEniCS, ODEintV2, TVM.ai.
Hardware accelerator integration (Xilinx, Intel, Achronix).
|-
|[https://github.com/xman/sgpositpy Speedgo]
''Chung Shin Yee''
|Python library
|All
| {{No}}
|~20&nbsp;MPOPS
|Extensive; no known bugs
|{{Open source}} (MIT license)
|-
|[https://github.com/DavidThien/softposit-rkt softposit-rkt]
''David Thien''
|SoftPosit bindings for Racket
|All
| {{Yes}}
| {{Unknown}}
| {{Unknown}}
|
|-
|[https://pypi.org/project/sfpy/ sfpy]
''Bill Zorn''
|SoftPosit bindings for Python
|All
| {{Yes}}
|~20–45&nbsp;MPOPS on 4.9&nbsp;GHz Skylake core
| {{Unknown}}
|
|-
|[https://github.com/diegofgcoelho/positsoctave positsoctave]
''Diego Coelho''
|Octave implementation
|All
| {{No}}
| {{Unknown}}
|Limited Testing; no known bugs
|{{GPL-lic}}
|-
|[https://github.com/interplanetary-robot/SigmoidNumbers Sigmoid Numbers]
''Isaac Yonemoto''
|Julia library
|All <32, all ES
| {{Yes}}
| {{Unknown}}
|No known bugs (posits).
Division bugs (valids)
|Leverages Julia's templated mathematics standard library, can natively do matrix and tensor operations, complex numbers, FFT, DiffEQ. Support for valids
|-
|[https://github.com/Etaphase/FastSigmoids.jl FastSigmoid]
''Isaac Yonemoto''
|Julia and C/C++ library
|8, 16, 32, all ES
| {{No}}
| {{Unknown}}
|Known bug in 32-bit multiplication
|Used by [[Lawrence Livermore National Laboratory|LLNL]] in shock studies
|-
|[https://github.com/milankl/SoftPosit.jl#readme SoftPosit.jl]
''Milan Klöwer''
|Julia library
|Based on softposit;
8-bit (es=0..2)
16-bit (es=0..2)
24-bit (es=1..2)
32-bit
(es=2)
| {{Yes}}
|Similar to
A*STAR
"SoftPosit"
(Cerlane Leong)
|Yes:
Posit (8,0),
Posit (16,1),
Posit (32,2)
Other formats lack full functionality
|{{Open source}}. Issues and suggestions on GitHub.
This project was developed due to the fact that SigmoidNumbers and FastSigmoid by Isaac Yonemoto is not maintained currently.

Supports basic linear algebra functions in Julia (Matrix multiplication, Matrix solve, Elgen decomposition, etc.)
|-
|[https://github.com/mightymercado/PySigmoid PySigmoid]
''Ken Mercado''
|Python library
|All
| {{Yes}}
|< 20&nbsp;MPOPS
| {{Unknown}}
|{{Open source}} (MIT license). Easy-to-use interface. Neural net example. Comprehensive functions support.
|-
|[https://github.com/federicorossifr/cppposit cppPosit]
''Federico Rossi, Emanuele Ruffaldi''
|C++ library
|4 to 64 (any es value); "Template version is 2 to 63 bits"
| {{No}}
| {{Unknown}}
|A few basic tests
|4 levels of operations working with posits. Special support for [[NaN]] types (non-standard)
|-
|[https://github.com/libcg/bfp bfp:Beyond Floating Point]
''Clément Guérin''
|C++ library
| {{Any}}
| {{No}}
| {{Unknown}}
|Bugs found; status of fixes unknown
|Supports + – × ÷ √  reciprocal, negate, compare
|-
|[https://github.com/interplanetary-robot/Verilog.jl Verilog.jl]
''Isaac Yonemoto''
|Julia and Verilog
|8, 16, 32, ES=0
| {{No}}
| {{Unknown}}
|Comprehensively tested for 8-bit, no known bugs
|Intended for Deep Learning applications Addition, Subtraction and Multiplication only. A proof of concept matrix multiplier has been built, but is off-spec in its precision
|-
|[https://github.com/Lombiq/Arithmetics Lombiq Arithmetics]
''Lombiq Technologies''
|C# with Hastlayer for hardware generation
|8, 16, 32.
(64bits in progress)
| {{Yes}}
|10&nbsp;MPOPS
Click here for more
| {{Partial}}
|Requires Microsoft .Net APIs
|-
|[https://github.com/facebookresearch/deepfloat Deepfloat]''Jeff Johnson, Facebook''
|SystemVerilog
| {{Any}} (parameterized SystemVerilog)
| {{Yes}}
| {{N/A|N/A}}
(RTL for FPGA/ASIC designs)
|Limited
|Does not strictly conform to posit spec.
Supports +,-,/,*. Implements both logarithmic posit and normal, "linear" posits
License: CC-BY-NC 4.0 at present
|-
|''Tokyo Tech''
|FPGA
|16, 32, extendable
| {{No}}
|"2 GHz", not translated to MPOPS
| {{Partial}}; known rounding bugs
|Yet to be open-source
|-
|[https://github.com/manish-kj/PACoGen PACoGen: Posit Arthmetic Core Generator]''Manish Kumar Jaiswal''
|Verilog HDL for Posit Arithmetic
| {{Any}} precision.
Able to generate any combination of word-size (N) and exponent-size (ES)
| {{No}}
|Speed of design is based on the underlying hardware platform (ASIC/FPGA)
|Exhaustive tests for 8-bit posit.
Multi-million random tests are performed for up to 32-bit posit with various ES combinations
|It supports rounding-to-nearest rounding method.
|-
|Vinay Saxena, Research and Technology Centre, Robert Bosch, India (RTC-IN) and Farhad Merchant, RWTH Aachen University
|Verilog generator for VLSI, FPGA
|All
| {{No}}
|Similar to floats of same bit size
|N=8
- ES=2 | N=7,8,9,10,11,12
Selective (20000*65536) combinations for
- ES=1 | N=16
|To be used in commercial products. To the best of our knowledge.
<nowiki>***</nowiki>First ever integration of posits in RISC-V***
|-
|Posit-enabled RISC-V core
(Sugandha Tiwari, Neel Gala, Chester Rebeiro, V.Kamakoti, IIT MADRAS)
|BSV (Bluespec System Verilog) Implementation
|32-bit posit with (es=2) and (es=3)
| {{No}}
| {{N/A}}
|Verified against SoftPosit for (es=2) and tested with several applications for (es=2) and (es=3). No known bugs.
|First complete posit-capable RISC-V core. Supports dynamic switching between (es=2) and (es=3).
More info here.
|-
|[https://github.com/artecs-group/PERCIVAL PERCIVAL]
''David Mallasén''
|Open-Source Posit RISC-V Core with Quire Capability
| Posit<32,2> with 512-bit quire
| {{Yes}}
| Speed of design is based on the underlying hardware platform (ASIC/FPGA)
| Functionality testing of each posit instruction.
|Application-level posit-capable RISC-V core based on CVA6 that can execute all posit instructions, including the quire fused operations. PERCIVAL is the first work that integrates the complete posit ISA and quire in hardware. It allows the native execution of posit instructions as well as the standard floating-point ones simultaneously.
|-
|[https://github.com/ChrisLomont/LibPosit LibPosit]
''Chris Lomont''
|Single file C# MIT Licensed
|Any size
| {{No}}
|
|Extensive; no known bugs
| Ops: arithmetic, comparisons, sqrt, sin, cos, tan, acos, asin, atan, pow, exp, log
|-
|[https://github.com/REX-Computing/unumjl unumjl]
''REX Computing''
|FPGA version of the "Neo" VLIW processor with posit numeric unit
|32
| {{No}}
|~1.2&nbsp;GPOPS
|Extensive; no known bugs
|No divide or square root. First full processor design to replace floats with posits.
|-
|[https://calligotech.com/posit-numeric-unit-pnu-ip/ PNU: Posit Numeric Unit] 
''Calligo Tech''
|
* World's first posit-enabled ASIC with octa-core RISC-V processor and Quire implemented.
* PCIe accelerator card with this silicon will be ready June 2024 
* Fully software stack with compilers, debugger, IDE environment and math libraries for applications. C, C++, Python languages supported
* Applications tested successfully - image and video compression, more to come
*
|
* <32, 2> with Quire 512 bits support.
* <64, 3> 
| {{Yes|Yes - Fully supported.}}
|500 MHz * 8 Cores 
|Exhaustive tests completed for 32 bits and 64 bits with Quire support completed.
Applications tested and being made available for seamless adoption
www.calligotech.com
|Fully integrated with C/C++ types and automatic conversions. Supports full C++ math library (native and conversion to/from IEEE). Runtime integrations: GNU Utils, OpenBLAS, CBLAS. Application integrations: in progress. Compiler support extended: C/C++, G++, GFortran & LLVM (in progress).
|-
|[https://github.com/ChenJianyunp/Posit32-2-exact-multiply-accumulator IBM-TACC]
''Jianyu Chen''
|Specific-purpose FPGA
|32
| {{Yes}}
|16–64&nbsp;GPOPS
|Only one known case tested
|Does 128-by-128 matrix-matrix multiplication (SGEMM) using quire.
|-
|[https://github.com/RaulMurillo/deep-pensieve Deep PeNSieve]
''Raul Murillo''
|Python library (software)
|8, 16, 32
| {{Yes}}
| {{Unknown}}
| {{Unknown}}
|A DNN framework using posits
|-
|[https://gitlab.com/amfiremage/gosit/-/tree/master Gosit]
''Jaap Aarts''
| Pure Go library
| {{Clarify|date=October 2021|reason=In particular the notation 16/1 and 32/2. Also clarify the other cells. |text=16/1 32/2 (included is a generic 32/ES for ES<32)}}
| {{No}}
| 80 MPOPS for div32/2 and similar linear functions. Much higher for truncate and much lower for exp.
| Fuzzing against C softposit with a lot of iterations for 16/1 and 32/2. Explicitly testing edge cases found.
| (MIT license) The implementations where ES is constant the code is generated. The generator should be able to generate for all sizes {8,16,32} and ES below the size. However, the ones not included into the library by default are not tested, fuzzed, or supported. For some operations on 32/ES, mixing and matching ES is possible. However, this is not tested.
|}

=== SoftPosit ===
SoftPosit<ref name="SoftPosit"/> is a software implementation of posits based on Berkeley SoftFloat.<ref name="SoftFloat"/> It allows software comparison between posits and floats. It currently supports

* Add
* Subtract
* Multiply
* Divide
* Fused-multiply-add
* Fused-dot-product (with quire)
* Square root
* Convert posit to signed and unsigned integer 
* Convert signed and unsigned integer to posit
* Convert posit to another posit size
* Less than, equal, less than equal comparison
* Round to nearest integer

==== Helper functions ====
* convert double to posit
* convert posit to double
* cast unsigned integer to posit

It works for 16-bit posits with one exponent bit and 8-bit posit with zero exponent bit. Support for 32-bit posits and flexible type (2-32 bits with two exponent bits) is pending validation. It supports x86_64 systems. It has been tested on [[GNU]] gcc ([[SUSE Linux]]) 4.8.5 Apple [[LLVM]] version 9.1.0 (clang-902.0.39.2).

==== Examples ====
''Add with posit8_t''
<syntaxhighlight lang="c">
#include "softposit.h"

int main(int argc, char *argv[]) {
    posit8_t pA, pB, pZ;
    pA = castP8(0xF2);
    pB = castP8(0x23);
    pZ = p8_add(pA, pB);

    // To check answer by converting it to double
    double dZ = convertP8ToDouble(pZ);
    printf("dZ: %.15f\n", dZ);

    // To print result in binary (warning: non-portable code)
    uint8_t uiZ = castUI8(pZ);
    printBinary((uint64_t*)&uiZ, 8);

    return 0;
}
</syntaxhighlight>

''Fused dot product with quire16_t''
<syntaxhighlight lang="c">
// Convert double to posit
posit16_t pA = convertDoubleToP16(1.02783203125);
posit16_t pB = convertDoubleToP16(0.987060546875);
posit16_t pC = convertDoubleToP16(0.4998779296875);
posit16_t pD = convertDoubleToP16(0.8797607421875);

quire16_t qZ;

// Set quire to 0
qZ = q16_clr(qZ);

// Accumulate products without roundings
qZ = q16_fdp_add(qZ, pA, pB);
qZ = q16_fdp_add(qZ, pC, pD);

// Convert back to posit
posit16_t pZ = q16_to_p16(qZ);

// To check answer
double dZ = convertP16ToDouble(pZ);
</syntaxhighlight>

==Critique==
William M. Kahan, the principal architect of [[IEEE 754-1985]] criticizes type I unums on the following grounds (some are addressed in type II and type III standards):<ref name="Kahan_2016"/><ref name="Kahan_2016_Commentary"/>
* The description of unums sidesteps using calculus for solving physics problems.
* Unums can be expensive in terms of time and power consumption. 
* Each computation in unum space is likely to change the bit length of the structure. This requires either unpacking them into a fixed-size space, or data allocation, deallocation, and garbage collection during unum operations, similar to the issues for dealing with variable-length records in mass storage.
* Unums provide only two kinds of numerical exception, quiet and signaling [[NaN]] (Not-a-Number).
* Unum computation may deliver overly loose bounds from the selection of an algebraically correct but numerically unstable algorithm.
* The benefits of unum over [[Minifloat|short precision floating point]] for problems requiring low precision are not obvious.
* Solving differential equations and evaluating integrals with unums guarantee correct answers but may not be as fast as methods that usually work.

==See also==
* [[Karlsruhe Accurate Arithmetic]] (KAA)
* [[Q (number format)]]
* [[Significant figures]]
* [[Floating-point error mitigation]]
* [[Elias gamma coding|Elias gamma (γ) code]]<!-- equivalent to POSIT (0) -->
* [[Tapered floating point]] (TFP)

==References==
{{Reflist|refs=
<ref name="Gustafson_2015">{{cite book |author-last=Gustafson |author-first=John L. |author-link=John Gustafson (scientist) |title=The End of Error: Unum Computing |publisher=[[CRC Press]] |edition=2nd corrected printing, 1st |date=2016-02-04 |orig-date=2015-02-05 |isbn=978-1-4822-3986-7 |series=[[Chapman & Hall]] / [[CRC Computational Science]] |volume=24 |url=https://www.crcpress.com/The-End-of-Error-Unum-Computing/Gustafson/p/book/9781482239867 |access-date=2016-05-30}} [https://books.google.com/books?id=fZsXBgAAQBAJ] [http://www.crcpress.com/product/isbn/9781482239867]</ref>
<ref name="Pnums">{{cite web |url=https://github.com/jwmerrill/Pnums.jl |title=jwmerrill/Pnums.jl |work=Github.com |access-date=2017-01-30}}</ref>
<ref name="Julia_1">{{cite web |title=Implementing Unums in Julia |author-first=Simon |author-last=Byrne |date=2016-03-29 |url=http://juliacomputing.com/blog/2016/03/29/unums.html |access-date=2016-05-30}}</ref>
<ref name="Julia_2">{{cite web |title=Unum arithmetic in Julia: Unums.jl |website=[[GitHub]] |url=https://github.com/JuliaComputing/Unums.jl |access-date=2016-05-30}}</ref>
<ref name="Julia_3">{{cite web |title=Julia Implementation of Unums: README |website=[[GitHub]] |url=https://github.com/REX-Computing/unumjl |access-date=2016-05-30}}</ref>
<ref name="Julia_4">{{cite web |title=Unum (Universal Number) types and operations: Unums |website=[[GitHub]] |url=https://github.com/tbreloff/Unums.jl |access-date=2016-05-30}}</ref>
<ref name="matlab">{{cite web |title=Reducing Memory Footprints in Explicit Model Predictive Control using Universal Numbers. Submitted to the IFAC World Congress 2017 |author-first1=Deepak |author-last1=Ingole |author-first2=Michal |author-last2=Kvasnica |author-first3=Himeshi |author-last3=De Silva |author-first4=John L. |author-last4=Gustafson |author-link4=John Gustafson (scientist) |url=https://bitbucket.org/kvasnica/munum |access-date=2016-11-15}}</ref>
<ref name="matlab_2">{{cite web |title=MATLAB Prototype of unum (munum) |author-first1=Deepak |author-last1=Ingole |author-first2=Michal |author-last2=Kvasnica |author-first3=Himeshi |author-last3=De Silva |author-first4=John L. |author-last4=Gustafson |author-link4=John Gustafson (scientist) |url=https://bitbucket.org/kvasnica/munum |access-date=2016-11-15}}</ref>
<ref name="ARITH23_2016">{{cite web |title=Program: Special Session: The Great Debate: John Gustafson and William Kahan |work=[[Arith23]]: [[23rd IEEE Symposium on Computer Arithmetic]] |location=Silicon Valley, USA |date=2016-07-12 |url=http://arith23.gforge.inria.fr/program.html |access-date=2016-05-30 |url-status=live |archive-url=https://web.archive.org/web/20160530120059/http://arith23.gforge.inria.fr/program.html |archive-date=2016-05-30}}</ref>
<ref name="Great-Debate_2016">{{cite AV media |title=The Great Debate @ARITH23: John Gustafson and William Kahan (1:34:41) |type=video |author-first1=John L. |author-last1=Gustafson |author-link1=John Gustafson (scientist) |author-first2=William M. |author-last2=Kahan |author-link2=William Kahan |language=en |date=2016-07-12 |url=https://www.youtube.com/watch?v=LZAeZBVAzVw |access-date=2016-07-20}}</ref>
<ref name="Kahan_2016">{{cite web |title=A Critique of John L. Gustafson's ''THE END of ERROR — Unum Computation'' and his ''A Radical Approach to Computation with Real Numbers'' |author-first=William M. |author-last=Kahan |author-link=William Kahan |location=Santa Clara, CA, USA |publisher=[[IEEE Symposium on Computer Arithmetic]], [[ARITH 23]] |date=2016-07-16 |orig-date=2016-07-12 |url=http://people.eecs.berkeley.edu/~wkahan/UnumSORN.pdf |access-date=2016-07-25 |url-status=live |archive-url=https://web.archive.org/web/20160725181213/https://people.eecs.berkeley.edu/~wkahan/UnumSORN.pdf |archive-date=2016-07-25}} [http://arith23.gforge.inria.fr/slides/Kahan.pdf]<!-- Archived version: [https://web.archive.org/web/20160730210105/http://arith23.gforge.inria.fr/slides/Kahan.pdf] --></ref>
<ref name="Gustafson_ARITH23">{{cite web |title="The Great Debate": Unum arithmetic position paper |author-first=John L. |author-last=Gustafson |author-link=John Gustafson (scientist) |location=Santa Clara, CA, USA |publisher=[[IEEE Symposium on Computer Arithmetic]], [[ARITH 23]] |date=2016-07-12 |url=https://groups.google.com/group/unum-computing/attach/b9d9a10a1e53e/PositionSlides-builds.pdf?part=0.1 |access-date=2016-07-20}} [http://arith23.gforge.inria.fr/slides/Gustafson.pdf]<!-- [https://web.archive.org/web/20160730210001/http://arith23.gforge.inria.fr/slides/Gustafson.pdf] --></ref>
<ref name="Kahan_2016_Commentary">{{cite web |title=Prof. W. Kahan's Commentary on "THE END of ERROR — Unum Computing" by John L. Gustafson, (2015) CRC Press |date=2016-07-15 |author-first=William M. |author-last=Kahan |author-link=William Kahan |url=https://people.eecs.berkeley.edu/~wkahan/EndErErs.pdf |access-date=2016-08-01 |url-status=live |archive-url=https://web.archive.org/web/20160801162357/https://people.eecs.berkeley.edu/~wkahan/EndErErs.pdf |archive-date=2016-08-01}}</ref>
<ref name="Tichy_2016_1">{{cite journal |title=The End of (Numeric) Error: An interview with John L. Gustafson |author-first=Walter F. |author-last=Tichy |author-link=Walter F. Tichy |journal=Ubiquity – Information Everywhere |publisher=[[Association for Computing Machinery]] (ACM) |volume=2016 |number=April |date=April 2016 |pages=1–14 |doi=10.1145/2913029 |quote=JG: The word "unum" is short for "universal number," the same way the word "bit" is short for "binary digit." |doi-access=free}}</ref>
<ref name="Tichy_2016_2">{{cite web |author-last=Tichy |author-first=Walter F. |author-link=Walter F. Tichy |date=September 2016 |title=Unums 2.0: An Interview with John L. Gustafson |url=http://ubiquity.acm.org/article.cfm?id=3001758 |website=Ubiquity.ACM.org |access-date=2017-01-30 |quote=I started out calling them "unums 2.0," which seemed to be as good a name for the concept as any, but it is really not a "latest release" so much as it is an alternative.}}</ref>
<ref name="Gustafson_2017?_Posit">{{cite journal |title=Beating Floating Point at its Own Game: Posit Arithmetic |author-first1=John Leroy |author-last1=Gustafson |author-link1=John Leroy Gustafson |author-first2=Isaac |author-last2=Yonemoto |date=2017 <!-- plain error? Not "Dec." and wrong year?: |orig-date=2016-07-12 --> |journal=Supercomputing Frontiers and Innovations |volume=4 |number=2 |publisher=Publishing Center of South Ural State University, Chelyabinsk, Russia |doi=10.14529/jsfi170206 |url=http://superfri.org/superfri/article/download/137/232 |access-date=2017-11-04 |url-status=live |archive-url=https://web.archive.org/web/20171104234856/http://superfri.org/superfri/article/download/137/232 |archive-date=2017-11-04 |doi-access=free}}</ref>
<ref name="Gustafson_2017_Posit">{{cite web |title=Posit Arithmetic |author-first=John Leroy |author-last=Gustafson |author-link=John Leroy Gustafson |date=2017-10-10 |url=https://posithub.org/docs/Posits4.pdf |access-date=2017-11-04 |url-status=live |archive-url=https://web.archive.org/web/20171105001022/https://posithub.org/docs/Posits4.pdf |archive-date=2017-11-05}}</ref>
<ref name="Gustafson_2017_video">John L. Gustafson and I. Yonemoto. (February 2017) Beyond Floating Point: Next Generation Computer Arithmetic. [Online]. Available: https://www.youtube.com/watch?v=aP0Y1uAA-2Y</ref>
<ref name="conga_paper_lindstrom">{{cite conference |last1=Lindstrom |first1=Peter |last2=Lloyd |first2=Scott |last3=Hittinger |first3=Jeffrey |title=Universal Coding of the Reals: Alternatives to IEEE Floating Point |conference=Conference for Next Generation Arithmetic |date=March 2018 |publisher=ACM |article-number=5 |doi=10.1145/3190339.3190344}}</ref>
<ref name="conga_paper_chung">S. Chung, "Provably Correct Posit Arithmetic with Fixed-Point Big Integer." ACM, 2018.</ref>
<ref name="conga_paper_hofstee">J. Chen, Z. Al-Ars, and H. Hofstee, "A Matrix-Multiply Unit for Posits in Reconfigurable Logic Using (Open)CAPI." ACM, 2018.</ref>
<ref name="conga_paper_Lehoczky">Z. Lehoczky, A. Szabo, and B. Farkas, "High-level .NET Software Implementations of Unum Type I and Posit with Simultaneous FPGA Implementation Using Hastlayer." ACM, 2018.</ref>
<ref name="iccd_2018_paper">Rohit Chaurasiya, John Gustafson, Rahul Shrestha, Jonathan Neudorfer, Sangeeth Nambiar, Kaustav Niyogi, Farhad Merchant, Rainer Leupers, "[https://posithub.org/docs/iccd_submission_v1.pdf Parameterized Posit Arithmetic Hardware Generator.]"<!-- also see https://ieeexplore.ieee.org/document/8615707 --> ICCD 2018: 334-341.</ref>
<ref name="paper_Langroudi">S. Langroudi, T. Pandit, and D. Kudithipudi, "Deep Learning Inference on Embedded Devices: Fixed-Point vs Posit". In Energy Efficiency Machine Learning and Cognitive Computing for Embedded Applications (EMC), 2018. [Online]. Available: https://sites.google.com/view/asplos-emc2/program</ref>
<ref name="kulish_1986">{{cite journal |author-first1=Ulrich W. |author-last1=Kulisch |author-link1=Ulrich W. Kulisch |author-first2=Willard L. |author-last2=Miranker |author-link2=Willard L. Miranker |title=The Arithmetic of the Digital Computer: A New Approach |publisher=[[SIAM]] |journal=[[SIAM Rev.]] |volume=28 |number=1 |pages=1–40 |date=March 1986 |doi=10.1137/1028001}}</ref>
<ref name="Pivot_2019">{{cite web |url=https://github.com/ityonemo/Unum2 |title=GitHub - ityonemo/Unum2: Pivot Unums. |website=[[GitHub]] |date=2019-04-29}}</ref>
<ref name="Stillwater_2019">{{cite web |url=https://github.com/stillwater-sc/universal |title=GitHub - stillwater-sc/Universal: Universal Number Arithmetic |website=[[GitHub]] |date=2019-06-16}}</ref>
<ref name="SoftPosit">{{Cite web|url=https://gitlab.com/cerlane/SoftPosit|title=Cerlane Leong / SoftPosit · GitLab|website=GitLab}}</ref>
<ref name="SoftFloat">{{Cite web|url=http://www.jhauser.us/arithmetic/SoftFloat.html|title=Berkeley SoftFloat|website=www.jhauser.us}}</ref>
<ref name="Feldman_2019">{{cite web |url=https://www.nextplatform.com/2019/07/08/new-approach-could-sink-floating-point-computation/ |title=New Approach Could Sink Floating Point Computation |author-last=Feldman |author-first=Michael |date=2019-07-08 |website=www.nextplatform.com |language=en-US |access-date=2019-07-09}}</ref>
<ref name="Byrne_2016">{{cite web |url=https://www.vice.com/en_us/article/kb7zxa/a-new-number-format-for-computers-could-nuke-approximation-errors-for-good |title=A New Number Format for Computers Could Nuke Approximation Errors for Good |author-last=Byrne |author-first=Michael |date=2016-04-24 |website=Vice |language=en-US |access-date=2019-07-09}}</ref>
<ref name="Posit_Standard_2022">{{Cite web |title=Standard for Posit Arithmetic (2022) |author=Posit Working Group |date=2022-03-02 |url=https://posithub.org/docs/posit_standard-2.pdf |url-status=live |archive-url=https://web.archive.org/web/20220926071621/https://posithub.org/docs/posit_standard-2.pdf |archive-date=2022-09-26 |access-date=2022-12-21}}</ref>
<ref name="Mallasen_2023">{{Cite journal|author=David Mallasén |author2=Alberto A. Del Barrio |author3=Manuel Prieto-Matias |date=2024  |title=Big-PERCIVAL: Exploring the Native Use of 64-Bit Posit Arithmetic in Scientific Computing|journal=IEEE Transactions on Computers |volume=73 |issue=6 |pages=1472–1485 |doi=10.1109/TC.2024.3377890 |arxiv=2305.06946 }}</ref>
}}

==Further reading==
* {{cite web |author-first=John L. |author-last=Gustafson |author-link=John Gustafson (scientist) |title=Right-Sizing Precision: Unleashed Computing: The need to right-size precision to save energy, bandwidth, storage, and electrical power |date=March 2013 |url=http://www.johngustafson.net/presentations/Right-SizingPrecision1.pdf |access-date=2016-06-06 |url-status=live |archive-url=https://web.archive.org/web/20160606203112/http://www.johngustafson.net/presentations/Right-SizingPrecision1.pdf |archive-date=2016-06-06}}
* {{cite web |title=Slidecast: John Gustafson Explains Energy Efficient Unum Computing |date=2015-03-02 |author-first=Rich |author-last=Brueckner |publisher=Inside HPC |url=http://insidehpc.com/2015/03/slidecast-john-gustafson-explains-energy-efficient-unum-computing/ |work=The Rich Report |access-date=2016-06-10 |url-status=live |archive-url=https://web.archive.org/web/20160710220847/http://insidehpc.com/2015/03/slidecast-john-gustafson-explains-energy-efficient-unum-computing/ |archive-date=2016-07-10}}
* {{cite web |author-first=John L. |author-last=Gustafson |author-link=John Gustafson (scientist) |title=The end of numerical error |date=2015 |url=http://arith22.gforge.inria.fr/slides/06-gustafson.pdf |access-date=2016-06-06 |url-status=live |archive-url=https://web.archive.org/web/20160606203155/http://arith22.gforge.inria.fr/slides/06-gustafson.pdf |archive-date=2016-06-06}}
* {{cite web |author-first=John L. |author-last=Gustafson |author-link=John Gustafson (scientist) |title=A Radical Approach to Computation with Real Numbers – Unums version 2.0 |orig-date=2016-02-22 |date=2016-06-03 |url=http://www.johngustafson.net/presentations/Unums2.0.pptx |type=PPT |access-date=2016-07-10 |url-status=live |archive-url=https://web.archive.org/web/20160710194003/http://www.johngustafson.net/presentations/Unums2.0.pptx |archive-date=2016-07-10}} (NB. PDFs come without notes: [http://www.johngustafson.net/presentations/Unums2.0.pdf] [https://web.archive.org/web/20160710210430/http://www.johngustafson.net/presentations/Unums2.0.pdf])
* {{cite web |author-first=John L. |author-last=Gustafson |author-link=John Gustafson (scientist) |title=An Energy-Efficient and massively parallel approach to valid numerics |location=OCRAR Seminar |date=2016-06-06 |url=http://www.johngustafson.net/presentations/UnumArithmetic-ICRARseminar.pptx |type=PPT |access-date=2016-07-10 |url-status=live |archive-url=https://web.archive.org/web/20160710201955/http://www.johngustafson.net/presentations/UnumArithmetic-ICRARseminar.pptx |archive-date=2016-07-10}} [http://www.johngustafson.net/presentations/UnumArithmetic-ICRARseminar.pdf] [https://web.archive.org/web/20160710202036/http://www.johngustafson.net/presentations/UnumArithmetic-ICRARseminar.pdf]
* {{cite web |author-first=John L. |author-last=Gustafson |author-link=John Gustafson (scientist) |title=A Radical Approach to Computation with Real Numbers |date=2016 |publisher=SuperFri.org |url=http://www.johngustafson.net/pubs/RadicalApproach.pdf |access-date=2016-07-10 |url-status=live |archive-url=https://web.archive.org/web/20160710221518/http://www.johngustafson.net/pubs/RadicalApproach.pdf |archive-date=2016-07-10}}
* {{cite web |author-first=Ulrich W. |author-last=Kulisch |author-link=Ulrich W. Kulisch |title=Up-to-date Interval Arithmetic from closed intervals to connected sets of real numbers |date=2015 |type=preprint |publisher=Institut für Angewandte und Numerische Mathematik – [[Karlsruhe Institute of Technology]] (KIT), Germany |id=ID 15/02 |url=http://www.math.kit.edu/iwrmm/seite/preprints/media/preprint%20nr.%2015-02.pdf |access-date=2016-07-12 |url-status=live |archive-url=https://web.archive.org/web/20160712121728/http://www.math.kit.edu/iwrmm/seite/preprints/media/preprint%20nr.%2015-02.pdf |archive-date=2016-07-12}}
* {{cite web |author-first=Thomas |author-last=Risse |title=Unum – an expedient extension of IEEE 754 |publisher=Institute of Informatics & Automation (IIA), Faculty EEE & CS, [[Bremen University of Applied Sciences]], Germany |date=2016-03-10 |type=presentation |location=[[London South Bank University]] (LSBU), UK |url=http://www.weblearn.hs-bremen.de/risse/papers/LSBU/LSBU_Unum.pdf |access-date=2016-07-12 |url-status=live |archive-url=https://web.archive.org/web/20160712122236/http://www.weblearn.hs-bremen.de/risse/papers/LSBU/LSBU_Unum.pdf |archive-date=2016-07-12}}
* {{cite web |title=Prof. W. Kahan's Comments on SORN Arithmetic |date=2016-07-15 |author-first=William M. |author-last=Kahan |author-link=William Kahan |url=https://people.eecs.berkeley.edu/~wkahan/SORNers.pdf |access-date=2016-08-01 |url-status=live |archive-url=https://web.archive.org/web/20160801162751/https://people.eecs.berkeley.edu/~wkahan/SORNers.pdf |archive-date=2016-08-01}}
* {{cite thesis |author-last=Hunhold |author-first=Laslo |date=2016-11-08 |publisher=[[Universität zu Köln]], Mathematisches Institut |type=Bachelor thesis |title=The Unum Number Format: Mathematical Foundations, Implementation and Comparison to IEEE 754 Floating-Point Numbers |url=http://frign.de/publications/2016-11-08-the_unum_number_format.pdf |access-date=2016-10-23 |url-status=live |archive-url=https://web.archive.org/web/20170107142232/http://frign.de/publications/2016-11-08-the_unum_number_format.pdf |archive-date=2017-01-07 |arxiv=1701.00722v1}}
* {{cite book |author-first=Pat H. |author-last=Sterbenz |title=Floating-Point Computation |date=1974-05-01 |edition=1st |series=Prentice-Hall Series in Automatic Computation |publisher=[[Prentice Hall]] |location=Englewood Cliffs, New Jersey, USA |isbn=0-13-322495-3<!-- 978-0-13-322495-5 -->}}
* {{cite web |author-first=Skip |author-last=Cave |title=J Programming Language Implementation of 3-bit, 4-bit, 8-bit and 16-bit Precision Unums |date=2016-08-17 |url=https://groups.google.com/d/msg/unum-computing/6A2V7CdHp8A/bLc8KuXABQAJ |access-date=2017-05-03}} (Roger Stokes' download link: [http://www.learningj.com/unumslab.zip])
* {{cite thesis |author-last=Ingole |author-first=Deepak |date=2017-09-28 |publisher=[[Slovak University of Technology in Bratislava]], Slovakia |type=PhD Thesis |title=Embedded Implementation of Explicit Model Predictive Control |url=http://www.kirp.chtf.stuba.sk/assets/publication_info.php?id_pub=1865}}

==External links==
* {{cite web |title=Conference for Next Generation Arithmetic (CoNGA) |date=2017 |url=https://posithub.org |access-date=2017-11-04 |url-status=live |archive-url=https://web.archive.org/web/20171104235925/https://posithub.org/ |archive-date=2017-11-04}}
* {{cite web |title=SoftPosit |date=2018 |url=https://gitlab.com/cerlane/SoftPosit |access-date=2018-06-13}}
* {{cite web |title=Community Source Code Contribution |date=2018 |url=https://posithub.org/khub_community |access-date=2018-06-13}}
* {{cite web |url=https://www.johndcook.com/blog/2018/04/11/anatomy-of-a-posit-number/ |title=Anatomy of a posit number |date=2018-04-11 |access-date=2019-08-09}}

[[Category:Floating point types]]
[[Category:Articles with example C code]]