GeezerVison

The level-index (LI) representation of numbers, and its algorithms for arithmetic operations, were introduced by Charles Clenshaw and Frank Olver in 1984.^[1]

The symmetric form of the LI system and its arithmetic operations were presented by Clenshaw and Peter Turner in 1987.^[2]

Michael Anuta, Daniel Lozier, Nicolas Schabanel and Turner developed the algorithm for symmetric level-index (SLI) arithmetic, and a parallel implementation of it. There has been extensive work on developing the SLI arithmetic algorithms and extending them to complex and vector arithmetic operations.

The idea of the level-index system is to represent a non-negative real number X as

$X=e^{e^{e^{{\cdot }^{{\cdot }^{{\cdot }^{e^f}}}}}},$

where $0\le f<1$, and the process of exponentiation is performed ℓ times, with $\ell \ge 0$. ℓ and f are the level and index of X respectively. x = ℓ + f is the LI image of X. For example,

$X=1234567=e^{e^{e^{0.9711308}}},$

so its LI image is

$x=\ell +f=3+0.9711308=\mathrm{3.9711308.}$

The mapping function is called the generalized logarithm function. It is defined as

$\psi \left(X\right)=\{\begin{array}{cc}X& \text{if }0\le X<1,\\ 1+\psi (\ln X)& \text{if }X\ge 1,\end{array}$

and it maps $[0,\infty )$ onto itself monotonically, thus being invertible on this interval. The inverse, the generalized exponential function, is defined by

$\phi \left(x\right)=\{\begin{array}{cc}x& \text{if }0\le x<1,\\ e^{\phi (x-1)}& \text{if }x\ge 1.\end{array}$

The density of values X represented by x has no discontinuities as we go from level ℓ to ℓ + 1 (a very desirable property) since

${\frac{d\phi \left(x\right)}{dx}|}_{x=1}={\frac{d\phi \left(e^x\right)}{dx}|}_{x=0}.$

The generalized logarithm function is closely related to the iterated logarithm used in computer science analysis of algorithms.

A sign bit may also be used to allow negative numbers. One takes sgn(X) and stores it as a boolean s_X (0 only occurs when X = 0 so could be stored either way, +1 chosen here). Mathematically, this is equivalent to taking the negative (additive inverse) of a number, and finding the SLI image for that. Using one bit for the sign enables the representation of negative numbers.

The symmetric form is used to allow negative exponents, if the magnitude of X is less than 1. One takes sgn(log(X)) or sgn(|X| − |X|⁻¹) and stores it as a boolean r_X (0 only occurs when X = 1 so could be stored either way, +1 chosen here). Mathematically, this is equivalent to taking the reciprocal (multiplicative inverse) of a small-magnitude number, and finding the SLI image for that. Using one bit for the reciprocal sign enables the representation of extremely small numbers.

Formally, we can define the SLI representation for an arbitrary real X (not 0 or 1) as

$X=s_X\phi (x{)}^{r_X},$

where s_X is the sign (additive inversion or not) of X, and r_X is the reciprocal sign (multiplicative inversion or not) as in the following equations:

$s_X=\mathrm{sgn}\left(X\right),r_X=\mathrm{sgn}\left(\right|X|-|X{|}^{-1}),x=\psi (max\left(\right|X|,|X{|}^{-1}\left)\right)=\psi \left(s_X{X}^{r_X}\right),$

whereas for X = 0 or 1, we have

$s_0=+1,r_0=+1,x=0.0,$

$s_1=+1,r_1=+1,x=\mathrm{1.0.}$

For example,

$X=-\frac{1}{1234567}=-e^{-e^{e^{0.9711308}}},$

and its SLI representation is

$x=-\phi (3.9711308{)}^{-1}.$

Most arithmetic operations in LI can be easily reduced to addition due to the nature of logarithms.^[3] If we have some x, y, and z related by $\phi \left(z\right)=\phi (x{)}^{\phi \left(y\right)}$, taking the logarithm of both sides gives us $\phi (z-1)=\phi \left(y\right)\phi (x-1)$, and once more gives us $\phi (z-2)=\phi (y-1)+\phi (x-2)$. The only non-trivial operation left to define is addition.

The problem of addition is posed as being able to find some z, given an arbitrary x and y with $\phi \left(x\right)\ge \phi \left(y\right)$, such that $\phi \left(x\right)+\phi \left(y\right)=\phi \left(z\right)$. We also say that the levels of $\phi \left(x\right)$, $\phi \left(y\right)$, and $\phi \left(z\right)$ are l, m, and n, and their indices are f, g, and h. It is helpful to define these 3 sequences, each indexed with some j:

$\begin{array}{cc}& a_j=\frac{1}{\phi (x-j)}j=l-1,l-2,\mathrm{...},0\\ & b_j=\frac{\phi (y-j)}{\phi (x-j)}j=m-1,m-2,\mathrm{...},0\\ & c_j=\frac{\phi (z-j)}{\phi (x-j)}j=0,1,\mathrm{...}\end{array}$

With this defined, we can now state that z is equal to $j+\frac{c_j}{a_j}$ for the smallest j where $c_j<a_j$. To find the actual values in these sequences, we use a set of recursive definitions each with an initial condition:

$\begin{array}{cccc}{a}_{j-1}& =e^{-\frac{1}{a_j}}& a_{l-1}& =e^{-f}\\ b_{j-1}& =e^{-\frac{1-b_j}{a_j}}& b_{m-1}& =a_{m-1}{e}^g\\ c_j& =1+a_j\ln \left(c_{j-1}\right)& c_0& =1+b_0\end{array}$

This can also be used to implement subtraction by changing the initial condition for c to be $c_0=1-b_0$.

When using SLI, $\phi \left(x\right)+\phi \left(y\right)=\phi \left(z\right)$ is not the only case; $\phi \left(x\right)+{}^1/{}_{\phi \left(y\right)}=\phi \left(z\right)$ and ${}^1/{}_{\phi \left(x\right)}+{}^1/{}_{\phi \left(y\right)}={}^1/{}_{\phi \left(z\right)}$ should also be considered; typically called "large", "mixed", and "small" arithmetic. In mixed arithmetic, we replace the b sequence with ${\alpha }_j={}^1/{}_{\phi (y-j)}$ and define $c_0$ as $c_0=1+a_0{\alpha }_0$; and in small arithmetic we replace the b sequence with ${\beta }_j={}^{\phi (x-j)}/{}_{\phi (y-j)}$, and $c_0$ becomes $c_0={}^1/{}_{1+{\beta }_0}$

• Tetration
• Floating point (FP)
• Tapered floating point (TFP)
• Logarithmic number system (LNS)
• Level (logarithmic quantity)

• Clenshaw, Charles William; Olver, Frank William John; Turner, Peter R. (1989). "Level-index arithmetic: An introductory survey". Numerical Analysis and Parallel Processing (Conference proceedings / The Lancaster Numerical Analysis Summer School 1987). Lecture Notes in Mathematics (LNM). 1397: 95–168. doi:10.1007/BFb0085718. ISBN 978-3-540-51645-3.{{cite journal}}: CS1 maint: periodical has ISBN (link)
• Clenshaw, Charles William; Turner, Peter R. (1989-06-23) [1988-10-04]. "Root Squaring Using Level-Index Arithmetic". Computing. 43 (2). Springer-Verlag: 171–185. doi:10.1007/BF02241860. ISSN 0010-485X.
• Zehendner, Eberhard (Summer 2008). "Rechnerarithmetik: Logarithmische Zahlensysteme" (PDF) (Lecture script) (in German). Friedrich-Schiller-Universität Jena. pp. 21–22. Archived (PDF) from the original on 2018-07-09. Retrieved 2018-07-09.
• Hayes, Brian (September–October 2009). "The Higher Arithmetic". American Scientist. 97 (5): 364–368. doi:10.1511/2009.80.364. Archived from the original on 2018-07-09. Retrieved 2018-07-09. . Also reprinted in: Hayes, Brian (2017). "Chapter 8: Higher Arithmetic". Foolproof, and Other Mathematical Meditations (1 ed.). The MIT Press. pp. 113–126. ISBN 978-0-26203686-3. ISBN 0-26203686-X.

• sli-c-library (hosted by Google Code), "C++ Implementation of Symmetric Level-Index Arithmetic".