Revisting my accelerated slog solution using Abel matrix inversion

[sheldonison]

Anyway, remarkably this all works and generates superbly accurate results ...

Here is my pari-gp code which is hopefully semi understandable with the help of my other posts in this thread. It doesn't have my Kneser slog(z) approximation, and instead generates the two 1-cyclic theta mappings, \( \theta_{Sj}(z);\;\;\theta_{Rj}(z) \).  With this example, I started with a  120 term jaytaylor series giving jayslog(z) accurate to about 16.5 decimal digits, and then generated a pair of theta mappings, so that the resulting jayslogtht is accurate to ~57 decimal digits over the entire complex plane!!!

  jpost.gp (Size: 391.12 KB / Downloads: 1,084)

Code:

\r jpost.gp
/* helpjpost(); other stuff in jpost.gp after you try the example below      */
\p 77                    /* default value; set higher if desired             */
...
/***** here is an example you can try, with results accurate to 10^-57   *****/
computejslog(120);       /* compute jtaylor with 77 decimal digits           */
jslog(z); jslog(0.5);    /* jay's slog accurate to about 16.5 decimal digits */
/* calcthts computes fourier series of jslog(complex-superfunction)          */
z0rgt=0.9455+0.4824*I;   /* default value for right edge of fourier series   */
/* first, compute fourier series of jslog(isuperf(z)) w/out thtr mapping     */
/* calcthts(thtr,n,z0rgt); thtJr=0; 80 samples, z0rgt printout abs(thts)     */
/* calcthts computes fourier series of jslog(complex-superfunction)          */
/* calcthtr(termstocancel,n,z0rgt); termstocancel based on printout above    */
/* calcthtr also calls and computes thts; enables slogthtr and slogthts      */
calcthts(0,80,z0rgt);    /* test run! 80 samples, to estimate terms of thtr  */
calcthtr(28,80,z0rgt);   /* calculates thtr with 28 terms and 80 samples     */
slogthtr(0.5)            /* jslog(z)+thtr(jslog(z)); >59 decimal digits      */
slogthtr(0.25+0.1*I)     /* accurate to greater           >59 decimal digits */
slogthtr(z0rgt)          /* accurate to greater           >56 decimal digits */
slogthts(0.7*I)          /* isuperf(z)+thts(isuperf(z)); >58 decimal digits  */
jslogtht(z);       /* if imag(isuperf(z))>Imag(isuperf(z0rgt)) use slogthts  */
jslogtht(z);       /* if imag(isuperf(z))<Imag(isuperf(z0rgt)) use slogthtr  */

The code in jpost.gp was mostly borrowed from my fatou.gp code here online at math.eretrandre.  I stripped out  anything I didn't need including the slog (kneser slog approximation), but kept things like the formal Schroder function and its inverse (called by initSchroder), and the fixed point point routine (called CalcFixed), and the complex valued Abel function and its compliment (isuperf(z) and superf(z)), \( \alpha(z);\;\alpha^{-1}(z) \).  The computejslog(i) creates jtaylor which is used by the jslog(z) routine which both came from ... JayDFox a long time ago.  I had incorporated computejslog int fatou.gp in earlier much less complete experiments on the 1-cyclic mapping between jslog and Kneser's slog.

This example samples the complex plane along the dotted line green line, and by a reflection, the complex conjugate in the lower half of the complex plane.  I have chosen z0rgt so that these samples optimize the accuracy over the unusual peanut shaped convergence of jslog(z) that previous posts have discussed.  Here, z0rgt is the rightmost point of the set of points represented by the green dotted line.  These are equally spaced samples of the complex valued superfunction \( \alpha^{-1}(\alpha(\text{z0rgt})-1)...\text{z0rgt} \).  

\( \theta_{Sj}(z)\approx\text{jslog}(\alpha^{-1}(z))+\theta_{Rj}\left(\text{jslog}(\alpha^{-1}(z))\right)-z;\;\; \) equation for thts sample approximation points using thtr
   

The region of convergence matches the peanut shaped convergence of the 
\( \text{slogthtr(z)}=\text{jslog}(z)+\theta_{Rj}(\text{jslog}(z)) \)
Here is a plot from -1 to +2 real comparing with Kneser's slog \( \frac{10^{-57}}{\text{kslog}(z)-\text{slogthtr(z)} \)
   

This is  the region of convergence of slogthts, which uses the thts \( \theta_{Sj} \) theta mapping we just calculated.  It converges best where slogthtr(z) doesn't converge as well, in the upper part of the complex plane.  
\( \text{slogthts(z)}=\alpha(z)+\theta_{Sj}(\alpha(z)); \) 

Here is a plot from -1 to +2 real, +1.3imag to imag(0) of \( \frac{10^{-57}}{\text{kslog}(z)-\text{slogthts(z)} \)
   

These two function, slogthtr near the real axis, and slogthts in the upper part of the complex plane can be stitchted together.  I call this function jslogtht(z), which also extends  slogthtr near the real axis by using the approximation slogthtr(z)~=slogthtr(exp(z))-1 and slogthtr(z)=slogthtr(log(z))+1.  Then by using the Schwarz reflection over the real axis, we have extended the original jslog accurate to 16.5 decimal digits to a very accurate slog accurate to  8E-57 over the entire complex plane!!!  Moreover, this function is mostly accurate to better than 57 decimal digits everywhere in the complex plane except near the z0rgt stiching.  In the plot, you can see the theta mappings of both approximations where the two functions are stitched together.  My program calls this function "jslogtht".  Here is a plot from -1 to +2 real, +1.3imag to to -1.3imag of
\( \frac{10^{-57}}{\text{kslog}(z)-\text{jslogtht(z)} \)
   

I also did some higher precision calculations with up to computejslog(360), which does require more memory.  The routine is spending slightly more time on the theta mapping then on the original computejslog routine, but they both take approximately the same amount of time.  With this mapping results are accurate to within 1E-153 over the entire complex plane for jslogtht(z).
\p 250
computejslog(360);  /* 6.1 seconds */
calcthtr(92,190,z0rgt); /* 6.3 seconds */
jslogtht(0.5) /* accurate to within 2E-157 */
jslogtht(z0rgt) /* accurate to 1E-153 at z0rgt stitching; within 2E-155 or better everywhere else in the complex plane */

In general, the precision of the resulting slog is limited by the error term:

\( \text{jslog}(\text{z0rgt})-\text{jslog}(\ln(\text{z0rgt}))-1 \)
For computejslog(120), this limiting value is  4E-57; for computejslog(360) the limiting value is 4E-154.  For the 800 term 450 decimal digit series Jay posted, I use a different z0rgt that is on the same line as above but optimized around slog(0) instead of using the peanut shaped region.  Accuracy is limited to 2E-244, and my program generated such a thtr result too, which was also verified.