By the way, that tetration was so easily extended to base e should be a very strong indicator that all bases greater than eta can be solved by this method. The exact solution is very slow to converge, requiring ridiculous iteration counts, and double precision math is out of the question if you want more than a handful of digits.
However, I've already found some "helper" functions that reduce the number of iterations necessary, and for values of eta-check just above e, i.e., e(1+delta), we can program iterated exponential functions (base eta) for powers of 2 for the iteration counts:
\( \Large \eta^{\small(2^m)}(e(1+\delta))\ =\ e\ \times\ \sum_{n=0}^k \frac{a_{\small m,n} \delta^n}{n!} \)
Notice that when you're iterating, you pull the factor of e out, and you don't put it back in, because each time you iterate, you're going to have to pull it out again anyway.
The cutoff value k could be determined algorithmically, and the constants a_m,n could be calculated once on startup. Similar helper functions could be written for iterated logarithms. And depending on the accuracy you require, it's not out of the question to have helper functions up to 16 or 32 iterations, more if you've got a good math library. I'm currently trying to write 1, 2, 4, 8, and 16-iteration helper functions for eta^y and log_eta(y), using GMP. My time will be limited this weekend, so I suspect I won't finish that project for a few weeks.
An interpolation function for eta-check(-n), for large n, could be used to overcome the need to iterate a ridiculous number of times to get to the point where linear interpolation is accurate. Peter Walker's paper has a function which might be the correct one, or a good second-order approximation anyway. It needs to be transformed, because he was solving for the superlog.
A second order approximation can take 5 digits of accuracy up to 15, reducing the iteration count from 10^15 to just 10^5. (I know, "just" 10^5 iterations, is that all?) I get about 11-12 digits of accuracy using an 8000-iteration variant, which works out to about 1 part in 8000^3. I get about an extra digit compared to a 4000-iteration variant. I have the constants calculated in a table, sufficient to go up to 32000 iterations, but I don't have the patience to wait for it. But in theory, that one should give me 13-14 digits of accuracy, almost sufficient for subsequent manipulation with double precision math. Once I have my 16-count iteration functions written, I should be able to push my work out to 20 digits of accuracy.
For the interpolation function, I'll most likely end up using polynomial interpolation, with the degree of the polynomial limited by the iteration count. The good news is, with sufficient iterations, you should be able to get good third-order precision, which could extend 6 digits to 24 ("only" a million iterations, but with helper functions, this can be reduce to a few tens of thousands). I'm not sure who needs more than 24 digits accuracy, but if you do, well, it's going to take a few minutes to crunch the numbers.
Luckily, we can probably find very precise answers over a very short interval, and use those to figure out the first few derivatives. Even though accuracy might be limited to 24 digits, for example, precision over a short interval of length 0.001 should easily be 27-30 digits. For a large one-time cost, a distributed effort could even get 50-100 digits or more, with each computer calculating just one point. A large collection of points could be used to build a table of, say, all 999 points in the interval -1 to 0 with a spacing of 0.001, plus all 21 points in the interval [-0.00001, -0.00001] with spacing 0.000001.
And I'm leaving out that possibility that better helper functions are available to speed up convergence by another few factors. Anyway, lots to think about, but I need to get back to my mad scientist "lab".
However, I've already found some "helper" functions that reduce the number of iterations necessary, and for values of eta-check just above e, i.e., e(1+delta), we can program iterated exponential functions (base eta) for powers of 2 for the iteration counts:
\( \Large \eta^{\small(2^m)}(e(1+\delta))\ =\ e\ \times\ \sum_{n=0}^k \frac{a_{\small m,n} \delta^n}{n!} \)
Notice that when you're iterating, you pull the factor of e out, and you don't put it back in, because each time you iterate, you're going to have to pull it out again anyway.
The cutoff value k could be determined algorithmically, and the constants a_m,n could be calculated once on startup. Similar helper functions could be written for iterated logarithms. And depending on the accuracy you require, it's not out of the question to have helper functions up to 16 or 32 iterations, more if you've got a good math library. I'm currently trying to write 1, 2, 4, 8, and 16-iteration helper functions for eta^y and log_eta(y), using GMP. My time will be limited this weekend, so I suspect I won't finish that project for a few weeks.
An interpolation function for eta-check(-n), for large n, could be used to overcome the need to iterate a ridiculous number of times to get to the point where linear interpolation is accurate. Peter Walker's paper has a function which might be the correct one, or a good second-order approximation anyway. It needs to be transformed, because he was solving for the superlog.
A second order approximation can take 5 digits of accuracy up to 15, reducing the iteration count from 10^15 to just 10^5. (I know, "just" 10^5 iterations, is that all?) I get about 11-12 digits of accuracy using an 8000-iteration variant, which works out to about 1 part in 8000^3. I get about an extra digit compared to a 4000-iteration variant. I have the constants calculated in a table, sufficient to go up to 32000 iterations, but I don't have the patience to wait for it. But in theory, that one should give me 13-14 digits of accuracy, almost sufficient for subsequent manipulation with double precision math. Once I have my 16-count iteration functions written, I should be able to push my work out to 20 digits of accuracy.
For the interpolation function, I'll most likely end up using polynomial interpolation, with the degree of the polynomial limited by the iteration count. The good news is, with sufficient iterations, you should be able to get good third-order precision, which could extend 6 digits to 24 ("only" a million iterations, but with helper functions, this can be reduce to a few tens of thousands). I'm not sure who needs more than 24 digits accuracy, but if you do, well, it's going to take a few minutes to crunch the numbers.
Luckily, we can probably find very precise answers over a very short interval, and use those to figure out the first few derivatives. Even though accuracy might be limited to 24 digits, for example, precision over a short interval of length 0.001 should easily be 27-30 digits. For a large one-time cost, a distributed effort could even get 50-100 digits or more, with each computer calculating just one point. A large collection of points could be used to build a table of, say, all 999 points in the interval -1 to 0 with a spacing of 0.001, plus all 21 points in the interval [-0.00001, -0.00001] with spacing 0.000001.
And I'm leaving out that possibility that better helper functions are available to speed up convergence by another few factors. Anyway, lots to think about, but I need to get back to my mad scientist "lab".
