This is my attempt to define UNAN for non-integer values of the base and iterator. (I'm not going to try with numbers inside the brackets.)

I was partly inspired by PsiCubed's letter notation, which some of the definitions I used are based on.

note: a[#]b is always increasing only for a > 2. For a <= 2, there will be odd behaviors sometimes, as explained below.

## Basic arrays

In normal UNAN, the three main rules are:

- a[0]b = a*b
- a[n]1 = a
- a[n+1]b+1 = a[n]a[n+1]b

Generalizing them to nonintegers is easy. NOte that I explicitly state that a[1]b = a^b, rather than it following the standard rules - this is just to preserve the standard definition of continuous exponentiation, whereas if we did it the other wy, we'd get 10[1]1.5 = 10[0]1[1]0.5 = 10[0]10[0]0.5 = 50, which I'd rather not have.

- a[0]b = a*b, a[1]b = a^b
- a[n]b = a[1]b for 0 < x <= 1
- a[n+1]b+1 = a[n]a[n+1]b for b > 1

Note: The function a[n]b only increases without bound for x > e^{1/e}. For smaller values of a, the tetration is generally known to either converge or alternate between 0 and 1. I haven't looked into what happens for pentation and higher, but I'm fairly sure for a > 1 it will still be an increasing function, just converging to one number.

## Two-entry arrays

Two-entry arrays with the first entry in the brackets > 0 expand similar to the last rule above. Now, we just need to handle cases of type a[0,n]b.

- a[0,n+1]b = a[1,n]a
^{b}for 0 < b <= 1 - a[0,n+1]b = a[roundup(b),n](2*(a/2)
^{frac(b)}

Where roundup(x) is x rounded up to the nearest integer if it is not an integer already.

If that last expression looks compicated, here's what it does. first, it decrease the second entry by 1, as would be done in normal UNAN. The first entry is replaced by the iterator rounded up to the next integer. The very last expression is just a way to interpolate from 2 to the base, since a[m#]a = a[m+1#]2.

Note that for b <= 2, a[0,1]x (and similar things, behave oddly. For a = 2, we get 2[0,1]x = 4 for b >= 1, leading to 2[#]b becoming 4 for # stronger than 0,1 and b >= 1. For values of a < 2, the function a[0,1]b actually decreases after b = 1, since the iterator will decrease from 2 to a.

On another note, while, say, 10[1,1]1 = 10 on normal UNAN, it is equal to 10,000,000,000 on this version. This is just to make things more consistent for this version and avoid an odd jump that would otherwise result.