Message Boards Message Boards

GROUPS:

Try to beat these MRB constant records!

Posted 4 years ago
80836 Views
|
36 Replies
|
4 Total Likes
|

Map:

  • First we have these record number of digits of the MRB constant computations.
  • Then I have some hints for anyone serious about breaking my record
  • Next, we have speed records. -Then we have a program Richard Crandall wrote to check his code for computing record number of digits -Followed by a time that I started a 5,000,000 digits calculation
  • Then there is a conversation about whether Mathematica uses the same algorithm for computing MRB by a couple of different methods. ...
  • Then, for a few replies, we compute the MRB constant from Crandall's eta derivative formulas and see records there.
  • The latest reply is "NEW RECORD ATTEMPTS OF 4,000,000 DIGITS!" (at
    the end).

POSTED BY: Marvin Ray Burns .

MKB constant calculations,

enter image description here , have been moved to their own discussion at Calculating the digits of the MKB constant .

I think the following important point got buried near the end.

When it comes to mine and a few other people's passion to calculate many digits of constants and the dislike possessed by a few more people, it is all a matter telling us that minds work differently!

The MRB constant is defined below. See http://mathworld.wolfram.com/MRBConstant.html

$$\text{MRB}=\sum _{n=1}^{\infty } (-1)^n \left(n^{1/n}-1\right)$$

Here are some record computations. If you know of any others let me know..

  1. On or about Dec 31, 1998 I computed 1 digit of the (additive inverse of the) MRB constant with my TI-92's, by adding 1-sqrt(2)+3^(1/3)-4^(1/4) as far as I could and then by using the sum feature to compute $\sum _{n=1}^{1000 } (-1)^n \left(n^{1/n}\right).$ That first digit, by the way, is just 0.

  2. On Jan 11, 1999 I computed 3 digits of the MRB constant with the Inverse Symbolic Calculator.

  3. In Jan of 1999 I computed 4 correct digits of the MRB constant using Mathcad 3.1 on a 50 MHz 80486 IBM 486 personal computer operating on Windows 95.

  4. Shortly afterwards I computed 9 correct digits of the MRB constant using Mathcad 7 professional on the Pentium II mentioned below.

  5. On Jan 23, 1999 I computed 500 digits of the MRB constant with the online tool called Sigma.

  6. In September of 1999, I computed the first 5,000 digits of the MRB Constant on a 350 MHz Pentium II with 64 Mb of ram using the simple PARI commands \p 5000;sumalt(n=1,((-1)^n*(n^(1/n)-1))), after allocating enough memory.

  7. On June 10-11, 2003 over a period, of 10 hours, on a 450mh P3 with an available 512mb RAM: I computed 6,995 accurate digits of the MRB constant.

  8. Using a Sony Vaio P4 2.66 GHz laptop computer with 960 MB of available RAM, on 2:04 PM 3/25/2004, I finished computing 8000 digits of the MRB constant.

  9. On March 01, 2006 with a 3GH PD with 2GBRAM available, I computed the first 11,000 digits of the MRB Constant.

  10. On Nov 24, 2006 I computed 40, 000 digits of the MRB Constant in 33hours and 26min via my own program in written in Mathematica 5.2. The computation was run on a 32-bit Windows 3GH PD desktop computer using 3.25 GB of Ram.

  11. Finishing on July 29, 2007 at 11:57 PM EST, I computed 60,000 digits of MRB Constant. Computed in 50.51 hours on a 2.6 GH AMD Athlon with 64 bit Windows XP. Max memory used was 4.0 GB of RAM.

  12. Finishing on Aug 3 , 2007 at 12:40 AM EST, I computed 65,000 digits of MRB Constant. Computed in only 50.50 hours on a 2.66GH Core2Duo using 64 bit Windows XP. Max memory used was 5.0 GB of RAM.

  13. Finishing on Aug 12, 2007 at 8:00 PM EST, I computed 100,000 digits of MRB Constant. They were computed in 170 hours on a 2.66GH Core2Duo using 64 bit Windows XP. Max memory used was 11.3 GB of RAM. Median (typical) daily record of memory used was 8.5 GB of RAM.

  14. Finishing on Sep 23, 2007 at 11:00 AM EST, I computed 150,000 digits of MRB Constant. They were computed in 330 hours on a 2.66GH Core2Duo using 64 bit Windows XP. Max memory used was 22 GB of RAM. Median (typical) daily record of memory used was 17 GB of RAM.

  15. Finishing on March 16, 2008 at 3:00 PM EST, I computed 200,000 digits of MRB Constant using Mathematica 5.2. They were computed in 845 hours on a 2.66GH Core2Duo using 64 bit Windows XP. Max memory used was 47 GB of RAM. Median (typical) daily record of memory used was 28 GB of RAM.

  16. Washed away by Hurricane Ike -- on September 13, 2008 sometime between 2:00PM - 8:00PM EST an almost complete computation of 300,000 digits of the MRB Constant was destroyed. Computed for a long 4015. Hours (23.899 weeks or 1.4454*10^7 seconds) on a 2.66GH Core2Duo using 64 bit Windows XP. Max memory used was 91 GB of RAM. The Mathematica 6.0 code used follows:

    Block[{$MaxExtraPrecision = 300000 + 8, a, b = -1, c = -1 - d, 
     d = (3 + Sqrt[8])^n, n = 131 Ceiling[300000/100], s = 0}, a[0] = 1; 
     d = (d + 1/d)/2; For[m = 1, m < n, a[m] = (1 + m)^(1/(1 + m)); m++]; 
     For[k = 0, k < n, c = b - c; 
      b = b (k + n) (k - n)/((k + 1/2) (k + 1)); s = s + c*a[k]; k++]; 
     N[1/2 - s/d, 300000]]
    
  17. On September 18, 2008 a computation of 225,000 digits of MRB Constant was started with a 2.66GH Core2Duo using 64 bit Windows XP. It was completed in 1072 hours. Memory usage is recorded in the attachment pt 225000.xls, near the bottom of this post. .

  18. 250,000 digits was attempted but failed to be completed to a serious internal error which restarted the machine. The error occurred sometime on December 24, 2008 between 9:00 AM and 9:00 PM. The computation began on November 16, 2008 at 10:03 PM EST. Like the 300,000 digit computation this one was almost complete when it failed. The Max memory used was 60.5 GB.

  19. On Jan 29, 2009, 1:26:19 pm (UTC-0500) EST, I finished computing 250,000 digits of the MRB constant. with a multiple step Mathematica command running on a dedicated 64bit XP using 4Gb DDR2 Ram on board and 36 GB virtual. The computation took only 333.102 hours. The digits are at http://marvinrayburns.com/250KMRB.txt . The computation is completely documented in the attached 250000.pd at bottom of this post.

  20. On Sun 28 Mar 2010 21:44:50 (UTC-0500) EST, I started a computation of 300000 digits of the MRB constant using an i7 with 8.0 GB of DDR3 Ram on board.; But it failed due to hardware problems.

  21. I computed 299,998 Digits of the MRB constant. The computation began Fri 13 Aug 2010 10:16:20 pm EDT and ended 2.23199*10^6 seconds later | Wednesday, September 8, 2010. I used Mathematica 6.0 for Microsoft Windows (64-bit) (June 19, 2007) That is an average of 7.44 seconds per digit.. I used my Dell Studio XPS 8100 i7 860 @ 2.80 GH 2.80 GH with 8GB physical DDR3 RAM. Windows 7 reserved an additional 48.929 GB virtual Ram.

  22. I computed exactly 300,000 digits to the right of the decimal point of the MRB constant from Sat 8 Oct 2011 23:50:40 to Sat 5 Nov 2011 19:53:42 (2.405*10^6 seconds later). This run was 0.5766 seconds per digit slower than the 299,998 digit computation even though it used 16GB physical DDR3 RAM on the same machine. The working precision and accuracy goal combination were maximized for exactly 300,000 digits, and the result was automatically saved as a file instead of just being displayed on the front end. Windows reserved a total of 63 GB of working memory of which at 52 GB were recorded being used. The 300,000 digits came from the Mathematica 7.0 command

    Quit; DateString[]
    digits = 300000; str = OpenWrite[]; SetOptions[str, 
    PageWidth -> 1000]; time = SessionTime[]; Write[str, 
    NSum[(-1)^n*(n^(1/n) - 1), {n, \[Infinity]}, 
    WorkingPrecision -> digits + 3, AccuracyGoal -> digits, 
    Method -> "AlternatingSigns"]]; timeused = 
    SessionTime[] - time; here = Close[str]
    DateString[]
    
  23. 314159 digits of the constant took 3 tries do to hardware failure. Finishing on September 18, 2012 I computed 314159 digits, taking 59 GB of RAM. The digits are came from the Mathematica 8.0.4 code

    DateString[]
    NSum[(-1)^n*(n^(1/n) - 1), {n, \[Infinity]}, 
    WorkingPrecision -> 314169, Method -> "AlternatingSigns"] // Timing
    DateString[]
    

There I had 10 digits to round off. (The command NSum[(-1)^n*(n^(1/n) - 1), {n, [Infinity]}, WorkingPrecision -> big number, Method -> "AlternatingSigns"] tends to give about 3-5 digits of error to the right.)

The following records are due to the work of Richard Crandall found here.

  1. Sam Noble of Apple computed 1,000,000 digits of the MRB constant in 18 days 9 hours 11 minutes 34.253417 seconds

  2. Finishing on Dec 11, 2012 Ricard Crandall, an Apple scientist, computed 1,048,576 digits in a lighting fast 76.4 hours (probably processor time). That's on a 2.93 Ghz 8-core Nehalem. It took until the use of DDR4 to compute nearly that many digits in an absolute time that quick!!: In Aug of 2018 I computed 1,004,993 digits of the MRB constant in 53.5 hours with 10 processor cores! Search this post for "53.5" for documentation. Sept 21, 2018, I just now computed 1,004,993 digits of the MRB constant in 50.37 hours of absolute time (35.4 hours processor time) with 18 processor cores! Search this post for "50.37 hours" for documentation.**

  3. Previously, I computed a little over 1,200,000 digits of the MRB constant in 11 days, 21 hours, 17 minutes, and 41 seconds,( finishing on on March 31 2013). I used a six core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz 3.20 GHz.

  4. On May 17, 2013 I finished a 2,000,000 or more digit computation of the MRB constant, using only around 10GB of RAM. It took 37 days 5 hours 6 minutes 47.1870579 seconds. I used my six core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz 3.20 GHz.

  5. The present world record computation of the MRB constant was finished on Sun 21 Sep 2014 18:35:06. It took 1 month 27 days 2 hours 45 minutes 15 seconds.The processor time from the 3,014,991 digit computation was 22 days. I computed the 3,014,991 digits of the MRB constant with Mathematica 10.0. I Used my new version of Richard Crandall's code in the attached 3M.nb, optimized for my platform and large computations. I also used a six core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz 3.20 GHz with 64 GB of RAM of which only 16 GB was used. Can you beat it (in more number of digits, less memory used, or less time taken)? This confirms that my previous "2,000,000 or more digit computation" was actually accurate to 2,009,993 digits. they were used to check the first several digits of this computation. See attached 3M.nb for the full code and digits.

  6. 4,000,000 digits are presently being computed!! This is my sixth try; see the reply, "NEW RECORD ATTEMPTS OF 4,000,000 DIGITS!" (at the end of the post).

Here is my mini cluster of the fastest 3 computers mentioned below: The one to the left is my custom built extreme edition 6 core and later with a 8 core Zeon processor. The one in the center is my fast little 4 core Asus with 2400 MHz RAM. Then the one on the right is my fastest -- a six core Digital Storm 6 core overclocked to 4.7 GHz on all cores and with 3000 MHz RAM.

enter image description here

36 Replies

The following might help anyone serious about breaking my record.

Richard Crandall wrote about couple of new formulae for computing the MRB constant faster on pp 28 and 29 here. a true jewel of an expression Interestingly, as pointed out by J. Borwein,

By the way, I wrote Crandall about formula (44) -- it seems it should have a minus sign in front of it -- and he wrote back: enter image description here

The following email Crandall sent me before he died might be useful for anyone checking their results: enter image description here

Perhaps some of these speed records will be easier to beat

digits      seconds                  sec./digit
500          0.062                     0.000124

1000         0.1230                  0.000123

3000         0.8640                  0.000288

5000        2.4801                    0.00049602

10,000      9.8515                   0.00098515

20,000      47.6900668           0.0023845

30,000      121.3201698        0.00404401

40,000      233.3583473        0.00583396

50,193      363.7078029        0.00724619

100,493    2647.6114347      0.0263462

301,492    32075.94123     .  0.106391

The ultimate speed record to beat, though, is Crandall's 1,048,576 digits in a blistering fast 76.4 hours.

Sam Noble of Apple computed 1,000,000 digits of the MRB constant in 18 days 9 hours 11 minutes 34.253417 seconds

I found the following program Crandall wrote to check his code. (it gives the MRB constant to the desired level of precision.) It's hard to follow! But here it is:

t1 = 1/2 (2 EulerGamma Log[2] - Log[2]^2); t2 = 
 1/24 (\[Pi]^2 Log[2]^2 - 
    2 \[Pi]^2 Log[
      2] (EulerGamma + Log[2] - 12 Log[Glaisher] + Log[\[Pi]]) - 
    6 (Zeta^\[Prime]\[Prime])[2]);
FLAG = 1;

prec = 200;
$MaxPrecision = Infinity;
expM[pr_] := Module[{a, d, s, k, b, c}, n = Floor[1.3 pr]; Print[n];
   d = N[(3 + Sqrt[8])^n, prec]; d = 1/2 (d + 1/d);

   {b, c, s} = {-1, -d, 0};
   T0 = T00 = SessionTime[];
   Do[c = b - c;
     s = s + 
      c*N[E^(Log[k + 1]/(k + 1)) - 1 - 
         FLAG * (Log[k + 1]/(k + 1) + 1/2! Log[k + 1]^2/(k + 1)^2), 
        pr]; 
    (* s=s+c*N[(k+1)^(1/(k+1))-1,pr]; *)
    b = (k + n) (k - n) b/((k + 1) (k + 1/2));
    If[Mod[k, 1000] == 0, Print[{k, SessionTime[] - T0}];
     T0 = SessionTime[]], {k, 0, n - 1}];
   N[-s/d, pr]];

(*Begin test to given precision.*)
(*t1=Timing[MRBtrue=NSum[(-1)^n*(n^(1/n)-1),{n,1,Infinity},\
WorkingPrecision\[Rule]prec,Method\[Rule]"AlternatingSigns"];];*)

t3 = Timing[MRBtest = expM[prec];]
SessionTime[] - T00
MRBtest +  FLAG * (t1 + t2)

Tue 22 May 2018

I started a 5,000,000 digits calculation on my 4 core ASUS Intel Core i7 7700 Desktop computer K31CD-DS71, 32 GB DDR4 ram running at 2400 MHz in Windows 10 Pro using a version of my Burns-Crandall hybrid code supercharged with 4 iterations of my 4th order convergence subroutine. See attached 5 million digits for the exact code. It would have taken 120 days! I decided to work on some smaller computations first!

Attachments:

It is hard to be certain that c1 and c2 are correct to 77 digits even though they agree to that extent. I'm not saying that they are incorrect and presumably you have verified this. Just claiming that whatever methods NSum may be using to accelerate convergence, there is really no guarantee that they apply to this particular computation. So c1 aand c2 could agree to that many places because they are computed in a similar manner without all digits actually being correct.

For c1 I used a method for alternating series to get a very precise sum approximation: That is from the "AlternatingSigns" option.

C1, the approximation to enter image description hereand a special case of enter image description here, is computed correctly by Henri Cohen, Fernando Rodriguez Villegas, and Don Zagier,s Convergence Acceleration of Alternating Series as found next.

enter image description hereenter image description here

Below it is computed by that method to at least 1000 decimals.

  (* Newer loop with Newton interior. *)
 prec = 1000;(*Number of required decimals.*)
 expM[pr_] := Module[{a, d, s, k, b, c}, n = Floor[1.32 pr];
   Print["Iterations required: ", n];
   d = N[(3 + Sqrt[8])^n, pr + 10];
   d = Round[1/2 (d + 1/d)];
   {b, c, s} = {-1, -d, 0};
   T0 = SessionTime[];
   Do[c = b - c;
    x = N[E^(Log[k + 1]/(k + 1)), iprec = Ceiling[prec/128]];
    pc = iprec;
    Do[nprec = Min[2 pc, pr];
     x = SetPrecision[x, nprec];(*Adjust precision*)
     x = N[x - x/(k + 1) + 1/x^k, nprec];
     pc *= 2;
     If[nprec >= pr, Break[]], {ct, 1, 19}];
    s += c*(x - 1);
    b *= 2 (k + n) (k - n)/((k + 1) (2 k + 1));
    If[Mod[k, 1000] == 0, 
     Print["Iterations: ", k, "    Cumulative time (sec): ", 
       SessionTime[] - T0];], {k, 0, n - 1}];
   N[-s/d, pr]];

 MRBtest2 = expM[prec]

During evaluation of In[17]:= Iterations required: 1320

During evaluation of In[17]:= Iterations: 0 Cumulative time (sec): 0.*10^-8

During evaluation of In[17]:= Iterations: 1000 Cumulative time (sec): 0.1872004

Out[18]= 0. 1878596424620671202485179340542732300559030949001387861720046840894772 3156466021370329665443310749690384234585625801906123137009475922663043 8929348896184120837336626081613602738126379373435283212552763962171489 3217020762820621715167154084126804483635416719985197680252759893899391 4457983505561350964852107120784442309586812949768852694956420425558648 3670441042527952471060666092633974834103115781678641668915460034222258 8380025455396892947114212218910509832871227730802003644521539053639505 5332203470627551159812828039510219264914673176293516190659816018664245 8249506972033819929584209355151625143993576007645932912814517090824249 1588320416906640933443591480670556469280678700702811500938060693813938 5953360657987405562062348704329360737819564603104763950664893061360645 5280675151935082808373767192968663981030949496374962773830498463245634 7931157530028921252329181619562697369707486576547607117801719578736830 0965902260668753656305516567361288150201438756136686552210674305370591 0397357561914891

                 c1 = NSum[(-1)^n*(n^(1/n) - 1), {n, 1, \[Infinity]}, 
                   Method -> "AlternatingSigns", WorkingPrecision -> 100, 
                   PrecisionGoal -> 100]

0.18785964246206712024851793405427323005590309490013878617200468408947 723156466021370329665443310750

Above where Cohen said,

enter image description here

the coefficients of the numerators are furthered below. I know the pattern for the first and last coefficient of each line, but can you figure out a simple pattern for the rest of them? My hat's off to you if you can!

2
16, 8
98, 80, 32
576, 544, 384, 128
3362, 3312, 2912, 1792, 512
19600, 19528, 18688, 15104, 8192, 2048
114242, 114144, 112576, 103168, 76288, 36864, 8192
665856, 665728, 663040, 641536, 557056, 376832, 163840, 32768
3880898, 3880736, 3876416, 3832064, 3603968, 2945024, 1826816, 720896, 131072 

One more record, Richard Crandall was the first one to compute 319,000 digits of the MRB constant in one day*, as early as Nov 24, 2012. Here is a portion of his email:

enter image description here

*He may have been counting CPU time alone (from the Timing[] comand which is an under estimate of the actual time taken).. My personal records are in actual time taken.

Tue 24 Apr 2018

Here are some timings from version 11.3 and my first custom built computer with it's two separate processors:

enter image description here[41]

Sat 28 Apr 2018

Chapter 3 in the paper at https://www.sciencedirect.com/science/article/pii/0898122189900242 , gives a 4th degree convergence rate algorithm for the nth root of x, which I used to add a new interior to my version of Crandall's MRB constant computation program, making it a hybrid. As the paper describes the algorithm, it is best used for getting many digits from a sufficiently precise initial term. (I used Crandall's 3rd degree convergence interior to get the sufficiently precise term.) This algorithm better optimizes my program for large calculations a little according to the following:

Here is a table of the results so far, which also show that RAM speed is the most important factor in a computer for computing the MRB constant!:

enter image description here

Here are a timing table with All MRB method, Crandall's method and a hybrid of the two on this 4 core ASUS Intel Core i7 7700 Desktop computer K31CD-DS71, 32 GB ram DDR4, 2TB SATA in Windows 10 Pro:

table

Here are the 3 programs referenced in the above table:

All MRB:

 Print["Start time is " "Start time is ", ds = DateString[], "."];
 prec = 10000;
 (**Number of required decimals.*.*)ClearSystemCache[];
 T0 = SessionTime[];
 expM[pre_] := 
   Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4*
     number of physical cores*), tsize = 2^7, chunksize, start = 1, ll,
      ctab, pr = Floor[1.0002 pre]}, chunksize = cores*tsize;
    n = Floor[1.32 pr];
    end = Ceiling[n/chunksize];
    Print["Iterations required: ", n];
    Print["Will give ", end, 
     " time estimates, each more accurate than the previous."];
    Print["Will stop at ", end*chunksize, 
     " iterations to ensure precsion of around ", pr, 
     " decimal places."]; d = ChebyshevT[n, 3];
    {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
    iprec = pr/2^6;
    Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l;
         x = N[E^(Log[ll]/(ll)), iprec];
         pc = iprec;


         While[pc < pr, pc = Min[4 pc, pr];
          x = SetPrecision[x, pc];
          xll = x^ll; z = (ll - xll)/xll;
          t = 2 ll - 1; t2 = t^2;
          x ![=][4] 
     !![enter image description here][5][enter image description here][6]      x*(1 + SetPrecision[4.5, pc] (ll - 1)/
                t2 + (ll + 1) z/(2 ll t) - 
              SetPrecision[13.5, 
                2 pc] ll (ll - 1)/ (3 ll t2 + t^3 z))];(**N[Exp[Log[
         ll]/ll],pr]**)


         x, {l, 0, tsize - 1}], {j, 0, cores - 1}, 
        Method -> 
         "EvaluationsPerKernel" -> 
          16(*a power of 2 commensurate with available RAM*)]];
     ctab = ParallelTable[Table[c = b - c;
        ll = start + l - 2;
        b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
        c, {l, chunksize}], 
       Method -> 
        "EvaluationsPerKernel" -> 
         16(*a power of 2 commensurate with processor strength*)];
     s += ctab.(xvals - 1);
     start += chunksize;
     st = SessionTime[] - T0; kc = k*chunksize;
     ti = (st)/(kc + 10^-10)*(n)/(3600)/(24);
     If[kc > 1, 
      Print[kc, " iterations done in ", N[st - stt, 4], " seconds.", 
       " Should take ", N[ti, 4], " days or ", ti*3600*24, 
       "s, finish ", DatePlus[ds, ti], "."], 
      Print["Denominator computed in  " , stt = st, "s."]];, {k, 0, 
      end - 1}];
    N[-s/d, pr]];
 t2 = Timing[MRBtest2 = expM[prec];]; Print["Finished on ", 
  DateString[], ". Processor and total time were ", 
  t2[[1]], " and ", st, " s respectively."];
 (*Print[*)MRBtest2(*]*)(*Remove (**) or enter MRBtest2 to print \
 output*); Print["Enter MRBtest2 to print ", 
  Floor[Precision[
    MRBtest2]], " digits"]; Print["If you saved m3M, the difference \
 between this and 3,014,991 known digits is ", N[MRBtest2 - m3M, 10]]

Crandall

Print["Start time is ", ds = DateString[], "."];
prec = 100000;
(**Number of required decimals.*.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] := 
  Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 32(*=4*
    number of physical cores*), tsize = 2^7, chunksize, start = 1, ll,
     ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize;
   n = Floor[1.32 pr];
   end = Ceiling[n/chunksize];
   Print["Iterations required: ", n];
   Print["Will give ", end, 
    " time estimates, each more accurate than the previous."];
   Print["Will stop at ", end*chunksize, 
    " iterations to ensure precsion of around ", pr, 
    " decimal places."]; d = ChebyshevT[n, 3];
   {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
   iprec = Ceiling[pr/27];
   Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l;
        x = N[E^(Log[ll]/(ll)), iprec];
        pc = iprec;
        While[pc < pr, pc = Min[3 pc, pr];
         x = SetPrecision[x, pc];
         y = x^ll - ll;
         x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(**N[Exp[Log[ll]/
        ll],pr]**)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, 
       Method -> 
        "EvaluationsPerKernel" -> 
         64(*a power of 2 commensurate with processor strength*)]];
    ctab = ParallelTable[Table[c = b - c;
       ll = start + l - 2;
       b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
       c, {l, chunksize}], 
      Method -> 
       "EvaluationsPerKernel" -> 
        16(*a power of 2 commensurate with processor strength*)];
    s += ctab.(xvals - 1);
    start += chunksize;
    st = SessionTime[] - T0; kc = k*chunksize;
    ti = (st)/(kc + 10^-4)*(n)/(3600)/(24);
    If[kc > 1, 
     Print[kc, " iterations done in ", N[st, 3], " seconds.", 
      " Should take ", N[ti, 2], " days or ", N[ti*24*3600, 2], 
      "s, finish ", DatePlus[ds, ti], "."]];, {k, 0, end - 1}];
   N[-s/d, pr]];
t2 = Timing[MRBtest2 = expM[prec];]; Print["Finished on ", 
 DateString[], ". Processor time was ", 
 t2[[1]], " s. Actual time was ", SessionTime[] - T0, "."];
(*Print[*)MRBtest2(*]*)(*Remove (**) or enter MRBtest2 to print \
output*); Print["Enter MRBtest2 to print ", 
 Floor[Precision[
   MRBtest2]], " digits"]; Print["If you saved m3M, the difference \
between this and 3,014,991 known digits is ", N[MRBtest2 - m3M, 10]]

Hybrid

Print["Start time is ", ds = DateString[], "."];
prec = 300000;
(**Number of required decimals.*.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] := 
  Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4*
    number of physical cores*), tsize = 2^7, chunksize, start = 1, ll,
     ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize;
   n = Floor[1.32 pr];
   end = Ceiling[n/chunksize];
   Print["Iterations required: ", n];
   Print["Will give ", end, 
    " time estimates, each more accurate than the previous."];
   Print["Will stop at ", end*chunksize, 
    " iterations to ensure precsion of around ", pr, 
    " decimal places."]; d = ChebyshevT[n, 3];
   {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
   iprec = Ceiling[pr/27];
   Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l;
        x = N[E^(Log[ll]/(ll)), iprec];
        pc = iprec;
        While[pc < pr/4, pc = Min[3 pc, pr/4];
         x = SetPrecision[x, pc];
         y = x^ll - ll;
         x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(**N[Exp[Log[ll]/
        ll],pr/4]**)x = SetPrecision[x, pr];
        xll = x^ll; z = (ll - xll)/xll;
        t = 2 ll - 1; t2 = t^2;
        x = 
         x*(1 + SetPrecision[4.5, pr] (ll - 1)/
              t2 + (ll + 1) z/(2 ll t) - 
            SetPrecision[13.5, pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**
        N[Exp[Log[ll]/ll],pr]**)x, {l, 0, tsize - 1}], {j, 0, 
        cores - 1}, 
       Method -> 
        "EvaluationsPerKernel" -> 
         32(*a power of 2 commensurate with available RAM*)]];
    ctab = ParallelTable[Table[c = b - c;
       ll = start + l - 2;
       b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
       c, {l, chunksize}], 
      Method -> 
       "EvaluationsPerKernel" -> 
        16(*a power of 2 commensurate with processor strength*)];
    s += ctab.(xvals - 1);
    start += chunksize;
    st = SessionTime[] - T0; kc = k*chunksize;
    ti = (st)/(kc + 10^-4)*(n)/(3600)/(24);
    If[kc > 1, 
     Print[kc, " iterations done in ", N[st, 4], " seconds.", 
      " Should take ", N[ti, 4], " days or ", N[ti*24*3600, 4], 
      "s, finish ", DatePlus[ds, ti], "."]];, {k, 0, end - 1}];
   N[-s/d, pr]];
t2 = Timing[MRBtest2 = expM[prec];]; Print["Finished on ", 
 DateString[], ". Proccessor time was ", t2[[1]], " s."];
(*Print[*)MRBtest2(*]*)(*Remove (**) or enter MRBtest2 to print \
output*); Print["Enter MRBtest2 to print ", 
 Floor[Precision[
   MRBtest2]], " digits"]; Print["If you saved m3M, the difference \
between this and 3,014,991 known digits is ", N[MRBtest2 - m3M, 10]]

Aug 8 2018

I've been having great success with the Wolfram Lightweight Grid and "threadpriority," like in the following:

 In[23]:= Needs["SubKernels`LocalKernels`"]
 Block[{$mathkernel = $mathkernel <> " -threadpriority=2"}, 
  LaunchKernels[]]

 Out[24]= {"KernelObject"[43, "burns"], "KernelObject"[44, "burns"], 
  "KernelObject"[45, "burns"], "KernelObject"[46, "burns"], 
  "KernelObject"[47, "burns"], "KernelObject"[48, "burns"], 
  "KernelObject"[49, "burns"], "KernelObject"[50, "burns"], 
  "KernelObject"[51, "local"], "KernelObject"[52, "local"], 
  "KernelObject"[53, "local"], "KernelObject"[54, "local"], 
  "KernelObject"[55, "local"], "KernelObject"[56, "local"]}

.

I just now computed 1,004,754 digits of the MRB constant in 58 hours of absolute time!

I think that worked because my computer with the local kernels is the faster one.

See attached "58 hour million."

Aug 9, 2018, I just now computed 1,004,993 digits of the MRB constant in 53.5 hours of absolute time! Summarized below.

Print["Start time is ", ds = DateString[], "."];
prec = 1000000;
(**Number of required decimals.*.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] := 
  Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4*
    number of physical cores*), tsize = 2^7, chunksize, start = 1, ll,
     ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize;
   n = Floor[1.32 pr];
   end = Ceiling[n/chunksize];
   Print["Iterations required: ", n];
   Print["Will give ", end, 
    " time estimates, each more accurate than the previous."];
   Print["Will stop at ", end*chunksize, 
    " iterations to ensure precsion of around ", pr, 
    " decimal places."]; d = ChebyshevT[n, 3];
   {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
   iprec = Ceiling[pr/6912];
   Do[xvals = Flatten[Parallelize[Table[Table[ll = start + j*tsize + l;
         x = N[E^(Log[ll]/(ll)), iprec];


         pc = iprec;
         While[pc < pr/1024, pc = Min[3 pc, pr/1024];
          x = SetPrecision[x, pc];
          y = x^ll - ll;
          x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];
         (**N[Exp[Log[ll]/ll],pr/1024]**)


         x = SetPrecision[x, pr/256];
         xll = x^ll; z = (ll - xll)/xll;
         t = 2 ll - 1; t2 = t^2;
         x = 
          x*(1 + SetPrecision[4.5, pr/256] (ll - 1)/
               t2 + (ll + 1) z/(2 ll t) - 
             SetPrecision[13.5, 
               pr/256] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[
         ll]/ll],pr/256]*)

         x = SetPrecision[x, pr/64];
         xll = x^ll; z = (ll - xll)/xll;
         t = 2 ll - 1; t2 = t^2;
         x = 
          x*(1 + SetPrecision[4.5, pr/64] (ll - 1)/
               t2 + (ll + 1) z/(2 ll t) - 
             SetPrecision[13.5, 
               pr/64] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[
         ll]/ll],pr/64]**)

         x = SetPrecision[x, pr/16];
         xll = x^ll; z = (ll - xll)/xll;
         t = 2 ll - 1; t2 = t^2;
         x = 
          x*(1 + SetPrecision[4.5, pr/16] (ll - 1)/
               t2 + (ll + 1) z/(2 ll t) - 
             SetPrecision[13.5, 
               pr/16] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[
         ll]/ll],pr/16]**)

         x = SetPrecision[x, pr/4];
         xll = x^ll; z = (ll - xll)/xll;
         t = 2 ll - 1; t2 = t^2;
         x = 
          x*(1 + SetPrecision[4.5, pr/4] (ll - 1)/
               t2 + (ll + 1) z/(2 ll t) - 
             SetPrecision[13.5, 
               pr/4] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[
         ll]/ll],pr/4]**)


         x = SetPrecision[x, pr];
         xll = x^ll; z = (ll - xll)/xll;
         t = 2 ll - 1; t2 = t^2;
         x = 
          x*(1 + SetPrecision[4.5, pr] (ll - 1)/
               t2 + (ll + 1) z/(2 ll t) - 
             SetPrecision[13.5, 
               pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ll]/
         ll],pr]*)

         x, {l, 0, tsize - 1}], {j, 0, cores - 1}]]];
    ctab = ParallelTable[Table[c = b - c;
       ll = start + l - 2;
       b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
       c, {l, chunksize}], Method -> "Automatic"];
    s += ctab.(xvals - 1);
    start += chunksize;
    st = SessionTime[] - T0; kc = k*chunksize;
    ti = (st)/(kc + 10^-4)*(n)/(3600)/(24);
    Print[kc, " iterations done in ", N[st, 4], " seconds.", 
     " Should take ", N[ti, 4], " days or ", N[ti*24*3600, 4], 
     "s, finish ", DatePlus[ds, ti], "."], {k, 0, end - 1}];
   N[-s/d, pr]];
t2 = Timing[MRBtest2 = expM[prec];]; Print["Finished on ", 
 DateString[], ". Proccessor time was ", 
 t2[[1]], " s."]; Print["Actual time was ", st];
(*Print[*)MRBtest2(*]*)(*Remove (**) or enter MRBtest2 to print \
output*); Print["Enter MRBtest2 to print ", 
 Floor[Precision[
   MRBtest2]], " digits"]; Print["If you saved m3M, the difference \
between this and 3,014,991 known digits is ", N[MRBtest2 - m3M, 10]]

Start time is Wed 8 Aug 2018 14:09:15.

Iterations required: 1326598

Will give 648 time estimates, each more accurate than the previous.

Will stop at 1327104 iterations to ensure precsion of around 1004999 decimal places.

0 iterations done in 259.9 seconds. Should take 3.991*10^7 days or 3.448*10^12s, finish Fri 24 Dec 111294 02:34:55.

2048 iterations done in 523.6 seconds. Should take 3.926 days or 3.392*10^5s, finish Sun 12 Aug 2018 12:22:00.

4096 iterations done in 790.2 seconds. Should take 2.962 days or 2.559*10^5s, finish Sat 11 Aug 2018 13:14:46.

6144 iterations done in 1058. seconds. Should take 2.645 days or 2.285*10^5s, finish Sat 11 Aug 2018 05:38:01.

8192 iterations done in 1329. seconds. Should take 2.490 days or 2.152*10^5s, finish Sat 11 Aug 2018 01:55:27.

10240 iterations done in 1602. seconds. Should take 2.402 days or 2.075*10^5s, finish Fri 10 Aug 2018 23:47:32.

12288 iterations done in 1875. seconds. Should take 2.343 days or 2.024*10^5s, finish Fri 10 Aug 2018 22:22:49.

14336 iterations done in 2151. seconds. Should take 2.304 days or 1.990*10^5s, finish Fri 10 Aug 2018 21:26:34.

16384 iterations done in 2424. seconds. Should take 2.272 days or 1.963*10^5s, finish Fri 10 Aug 2018 20:41:04.

18432 iterations done in 2700. seconds. Should take 2.250 days or 1.944*10^5s, finish Fri 10 Aug 2018 20:08:36.

20480 iterations done in 2977. seconds. Should take 2.232 days or 1.928*10^5s, finish Fri 10 Aug 2018 19:42:40.

22528 iterations done in 3256. seconds. Should take 2.219 days or 1.917*10^5s, finish Fri 10 Aug 2018 19:24:31.

24576 iterations done in 3533. seconds. Should take 2.207 days or 1.907*10^5s, finish Fri 10 Aug 2018 19:07:43.

26624 iterations done in 3811. seconds. Should take 2.198 days or 1.899*10^5s, finish Fri 10 Aug 2018 18:53:53.
 ...


1320960 iterations done in 1.921*10^5 seconds. Should take 2.232 days or 1.929*10^5s, finish Fri 10 Aug 2018 19:43:46.

1323008 iterations done in 1.923*10^5 seconds. Should take 2.232 days or 1.929*10^5s, finish Fri 10 Aug 2018 19:43:28.

1325056 iterations done in 1.926*10^5 seconds. Should take 2.232 days or 1.928*10^5s, finish Fri 10 Aug 2018 19:43:08.

Finished on Fri 10 Aug 2018 19:39:26. Proccessor time was 122579. s.

Actual time was 192609.7247443

Enter MRBtest2 to print 1004992 digits

If you saved m3M, the difference between this and 3,014,991 known digits is 0.*10^-1004993

Sept 21, 2018, I just now computed 1,004,993 digits of the MRB constant in 50.37 hours of absolute time (35.4 hours processor time)! See attached "50 hour million."

Here is a table of my speed progress in computing the MRB constant since 2012:

top bottom

See attached "kernel priority 2 computers.nb" and "3 fastest computers together.nb" for some documentation of the timings in the last 2 columns, respectively. See "3million 2 computers" for the estimated time of 24 days for computing 3,000,000 digits.

What Richard Crandall and maybe others did to come up with that method is really good and somewhat mysterious. I still don't really understand the inner workings, and I had shown him how to parallelize it. So the best I can say is that it's really hard to compete against magic. (I don't want to discourage others, I'm just explaining why I myself would be reluctant to tackle this. Someone less familiar might actually have a better chance of breaking new ground.)

In a way this should be good news. Should it ever become "easy" to compute, the MRB number would lose what is perhaps its biggest point of interest. It just happens to be on that cusp of tantalizingly "close" to easily computable (perhaps as sums of zeta function and derivatives thereof), yet still hard enough that it takes a sophisticated scheme to get more than a few dozen digits.

Daniel Lichtblau,
Which one do you not understand? how he derived the eta' formula:enter image description here from enter image description here?

Or is it how and why he added the extra loop to Cohen's method:`

ll = start + l - 2; b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1)); ?`

I've been asking for a proof of the eta formula derivation. I think it could become the foundation to a great paper.

If the extra loop changes Cohen's method for enter image description here to a method for enter image description hereI think the code in that loop could help prove the derivation.

I can't say I understand either. My guess is the Eta stuff comes from summing (-1)^k*(Log[k]/k)^n over k, as those are the terms that appear in the double sum you get from expanding k^(1/k)-1 in powers of Log[k]/k (use k^(1/k)=Exp[Log[k]/k] and the power series for Exp). Even if it does come from this the details remain elusive..

Daniel Lichtblau and others, Richard Crandall did intend to explian his work on the MRB constant and his program to compute it. When I wrote him with a possible small improvement to his program he said, "It's worth observing when we write it up." See screenshot: enter image description here

Crandall is not using his eta formulas directly!!!!!!! He computes Sum[(-1)^k*(k^(1/k) - 1), {k, 1, Infinity}] directly!

Going back to Crandall's code:

(*Fastest (at RC's end) as of 30 Nov 2012.*)prec = 500000;(*Number of \
required decimals.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] := 
  Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 4, 
    tsize = 2^7, chunksize, start = 1, ll, ctab, 
    pr = Floor[1.02 pre]}, chunksize = cores*tsize;
   n = Floor[1.32 pr];
   end = Ceiling[n/chunksize];
   Print["Iterations required: ", n];
   Print["end ", end];
   Print[end*chunksize];
   d = N[(3 + Sqrt[8])^n, pr + 10];
   d = Round[1/2 (d + 1/d)];
   {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
   iprec = Ceiling[pr/27];
   Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l;
        x = N[E^(Log[ll]/(ll)), iprec];
        pc = iprec;
        While[pc < pr, pc = Min[3 pc, pr];
         x = SetPrecision[x, pc];
         y = x^ll - ll;
         x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(*N[Exp[Log[ll]/ll],
        pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, 
       Method -> "EvaluationsPerKernel" -> 1]];
    ctab = Table[c = b - c;
      ll = start + l - 2;
      b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
      c, {l, chunksize}];
    s += ctab.(xvals - 1);
    start += chunksize;
    Print["done iter ", k*chunksize, " ", SessionTime[] - T0];, {k, 0,
      end - 1}];
   N[-s/d, pr]];

t2 = Timing[MRBtest2 = expM[prec];];
MRBtest2 - MRBtest3

x = N[E^(Log[ll]/(ll)), iprec]; Gives k^(1/k) to only 1 decimal place; they are either 1.0, 1.1, 1.2, 1.3 or 1.4 (usually 1.1 or 1.0).. On the other hand,

While[pc < pr, pc = Min[3 pc, pr];
 x = SetPrecision[x, pc];
 y = x^ll - ll;
 x = x (1 - 2 y/((ll + 1) y + 2 ll ll));],

takes the short precision x and gives it the necessary precision and accuracy for k^(1/k) (k Is ll there.) It actually computes k^(1/k). Then he remarks, "(N[Exp[Log[ll]/ll], pr])."

After finding a fast way to compute k^(1/k) to necessary precision he uses Cohen's algorithm 1 (See a screenshot in a previous post.) to accelerate convergence of Sum[(-1)^k*(k^(1/k) - 1), {k, 1, Infinity}]. That is his secret!!

As I mentioned in a previous post the "MRBtest2 - MRBtest3" is for checking with a known-to-be accurate approximation to the MRB constant, MRBtest3

I'm just excited that I figured it out! as you can tell.

Nice work. Worth a bit of excitement, I' d say.

Richard Crandall might of had some help in developing his method. He wrote one time:

"Marvin I am working on a highly efficient method for your constant, and I've been in touch with other mathematics scholars.

Please be patient...

rec

Sent from my iPhone."

The result of k^(1/k) from the iteration in Crandall's code grows like the following example of 123^(1/123)..

Timing[ll = 123; x = 1 + 1/10; 
 Table[Block[{$MaxExtraPrecision = Infinity}, 
   x = SetPrecision[x, 20 + a^6]; y = x^ll - ll; 
   x = x (1 - 2 y/((ll + 1) y + 2 ll ll)); 
   N[ll^(1/ll) - x, a + 20]], {a, 1, 13}]]

That gives the following timing and accuracies per iteration.

  {8.829657, {-0.04239426367665370783, -0.02519017014329854597401, \
  -0.0097174389047505410455275, -0.000933400633967433388167272, \
  -9.456045144810702667437515*10^-7, \
  -9.8570302819631224677862339*10^-16, \
  -1.11649387558952636447488240*10^-42, \
  -1.622508976729293063326569833*10^-123, \
  -4.9794273187141078980478269830*10^-366, \
  -1.43931637321260733551982880202*10^-1093, \
  -3.476056847637409626605825363818*10^-3276, \
  -4.8964202322309104109089811118496*10^-9824, \
  -1.36852937628135955635109182098985*10^-29467}}

Here is a more extreme example from my big computer where we get about 64,000,000 digits of accuracy of 123^(1/123) in only 20 iterations!

In[47]:= Timing[ll = 123; x = 1 + 1/10;
 Table[Block[{$MaxExtraPrecision = Infinity}, 
   x = SetPrecision[x, 20 + a^6]; y = x^ll - ll;
   x = x (1 - 2 y/((ll + 1) y + 2 ll ll));
   N[ll^(1/ll) - x, a + 20]], {a, 1, 20}]]

Out[47]= {210.180147, {-0.04239426367665370783, \
-0.02519017014329854597401, -0.0097174389047505410455275, \
-0.000933400633967433388167272, -9.456045144810702667437515*10^-7, \
-9.8570302819631224677862339*10^-16, \
-1.11649387558952636447488240*10^-42, \
-1.622508976729293063326569833*10^-123, \
-4.9794273187141078980478269830*10^-366, \
-1.43931637321260733551982880202*10^-1093, \
-3.476056847637409626605825363818*10^-3276, \
-4.8964202322309104109089811118496*10^-9824, \
-1.36852937628135955635109182098985*10^-29467, \
-2.987998984519890677800153644718129*10^-88398, \
-3.1099929855547029560727524646233719*10^-265190, \
-3.50668133180579791324881778853196092*10^-795566, \
-5.026977910888395698424738167604170974*10^-2386694, \
-1.4809452514436132712292881458571004047*10^-7160077, \
-3.78647491015226246115034702337662410645*10^-21480228, 
  0.*10^-64000020}}

Furthermore this process can compute 6,379,358,787 digits of the Sqrt[2], from an initial guess of machine precision, in 18 iterations:

In[90]:= Timing[ll = 2; x = 2.^(1/2);
 Table[Block[{$MaxExtraPrecision = Infinity}, 
   x = SetPrecision[x, 20 + a^7.5]; y = x^ll - ll;
   x = x (1 - 2 y/((ll + 1) y + 2 ll ll));
   N[ll^(1/ll) - x, a + 20]], {a, 1, 18}]]

Out[90]= {1913.882668, {0.*10^-21, -1.800462644283455490473*10^-148, \
-7.2956225729359623776786*10^-445, \
-4.85397000370369097837099*10^-1334, \
-1.429556345255675471801415*10^-4001, \
-3.6518576944392011682818847*10^-12004, \
-6.08767627470915271802076570*10^-36012, \
-2.820100999650988078782491560*10^-108035, \
-2.8035222068968058313783728204*10^-324105, \
-2.75436831997714080172674040062*10^-972315, \
-2.612017346393607427831858236332*10^-2916945, \
-2.2276049962448401256762035120120*10^-8750835, \
-1.38173437723345455709717486529180*10^-26252505, \
-3.297491628267321222864512567028780*10^-78757516, \
-4.4818892212256882776648121052875660*10^-236272548, \
-1.12536490316593766234907240580868063*10^-708817643, 
  0.*10^-1073741813, 0.*10^-1073741813}}

The above pattern is 3 times the previous number of accurate digits per iteration.. `708817643 * 3^2= 6379358787`

I believe it will only take 191+16 = 207 iterations to compute a google digits of the Sqrt[2]:

In[55]:= Log[10.^100/708817643]/Log[3]

Out[55]= 191.04

Jan 2015

How about computing the MRB constant from Crandall's eta derivative formulas? They are mentioned in a previous post but here they are again:

enter image description here

I computed and checked 500 digits, using the first eta derivative formula in 38.6 seconds. How well can you do? Can you improve my program? (It is a 51.4% improvement of one of Crandall's programs.) I would like a little competition in some of these records! (That formula takes just 225 summands, compared to 10^501 summands using -1^(1/1)+2^(1/2)-3^(1/3)+.... See http://arxiv.org/pdf/0912.3844v3.pdf for more summation requirements for other summation methods.)

In[37]:= mm = 
  0.187859642462067120248517934054273230055903094900138786172004684089\
4772315646602137032966544331074969038423458562580190612313700947592266\
3043892934889618412083733662608161360273812637937343528321255276396217\
1489321702076282062171516715408412680448363541671998519768025275989389\
9391445798350556135096485210712078444230958681294976885269495642042555\
8648367044104252795247106066609263397483410311578167864166891546003422\
2258838002545539689294711421221891050983287122773080200364452153905363\
9505533220347062755115981282803951021926491467317629351619065981601866\
4245824950697203381992958420935515162514399357600764593291281451709082\
4249158832041690664093344359148067055646928067870070281150093806069381\
3938595336065798740556206234870432936073781956460310476395066489306136\
0645528067515193508280837376719296866398103094949637496277383049846324\
5634793115753002892125232918161956269736970748657654760711780171957873\
6830096590226066875365630551656736128815020143875613668655221067430537\
0591039735756191489093690777983203551193362404637253494105428363699717\
0244185516548372793588220081344809610588020306478196195969537562878348\
1233497638586301014072725292301472333336250918584024803704048881967676\
7601198581116791693527968520441600270861372286889451015102919988536905\
7286592870868754254925337943953475897035633134403826388879866561959807\
3351473990256577813317226107612797585272274277730898577492230597096257\
2562718836755752978879253616876739403543214513627725492293131262764357\
3214462161877863771542054231282234462953965329033221714798202807598422\
1065564890048536858707083268874877377635047689160983185536281667159108\
4121934201643860002585084265564350069548328301205461932`1661.\
273833491444;

In[30]:= Timing[
 etaMM[m_, pr_] := 
  Module[{a, d, s, k, b, c}, a[j_] := Log[j + 1]^m/(j + 1)^m;
   n = Floor[1.32 pr];
   d = Cos[n ArcCos[3]];
   {b, c, s} = {-1, -d, 0};
   Do[c = b - c;
    s = s + c a[k];
    b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
   N[s/d, pr] (-1)^m];
 eta[s_] := (1 - 2^(1 - s)) Zeta[s];
 eta1 = Limit[D[eta[s], s], s -> 1];
 MRBtrue = mm;
 prec = 500;
 MRBtest = 
  eta1 - Sum[(-1)^m etaMM[m, prec]/m!, {m, 2, Floor[.45 prec]}];
 MRBtest - MRBtrue]

Out[30]= {36.831836, 0.*10^-502}

Here is a short table of computation times with that program:

Digits      Seconds

500        36.831836
1000       717.308198
1500       2989.759165
2000       3752.354453

I just now retweaked the program. It is now

Timing[etaMM[m_, pr_] := 
  Module[{a, d, s, k, b, c}, 
   a[j_] := N[(-PolyLog[1, -j]/(j + 1))^m, pr];
   n = Floor[1.32 pr];
   d = Cos[n ArcCos[3]];
   {b, c, s} = {-1, -d, 0};
   Do[c = b - c;
    s = s + c a[k];
    b = N[(k + n) (k - n) b/((k + 1) (k + 1/2)), pr], {k, 0, n - 1}];
   Return[N[s/d, pr] (-1)^m]];
 eta[s_] := (1 - 2^(1 - s)) Zeta[s];
 eta1 = Limit[D[eta[s], s], s -> 1];
 MRBtrue = mm;
 prec = 1500;
 MRBtest = 
  eta1 - Sum[(-1)^m etaMM[m, prec]/Gamma[m + 1], {m, 2, 
     Floor[.45 prec]}, Method -> "Procedural"];
 MRBtest - MRBtrue]

Feb 2015

Here are my best eta derivative records:

Digits        Seconds
 500          9.874863
 1000        62.587601
 1500        219.41540
 2000       1008.842867
 2500       2659.208646
 3000       5552.902395
 3500       10233.821601

That is using V10.0.2.0 Kernel. Here is a sample

Timing[etaMM[m_, pr_] := 
          Module[{a, d, s, k, b, c}, 
           a[j_] := N[(-PolyLog[1, -j]/(j + 1))^m, pr];
           n = Floor[1.32 pr];
           d = Cos[n ArcCos[3]];
           {b, c, s} = {-1, -d, 0};
           Do[c = b - c;
            s = s + c a[k];
            b = N[(k + n) (k - n) b/((k + 1) (k + 1/2)), pr], {k, 0, n - 1}];
           Return[N[s/d, pr] (-1)^m]];
         eta[s_] := (1 - 2^(1 - s)) Zeta[s];
         eta1 = Limit[D[eta[s], s], s -> 1];
         MRBtrue = mm;
         prec = 500;
         MRBtest = 
          eta1 - Sum[(-1)^m etaMM[m, prec]/Gamma[m + 1], {m, 2, 
             Floor[.45 prec]}];
        ]
         N::meprec: Internal precision limit $MaxExtraPrecision = 50. reached while evaluating 
             -Cos[660 ArcCos[3]].

         N::meprec: Internal precision limit $MaxExtraPrecision = 50. reached while evaluating 
             -Cos[660 ArcCos[3]].

         N::meprec: Internal precision limit $MaxExtraPrecision = 50. reached while evaluating 
             -Cos[660 ArcCos[3]].

         General::stop: Further output of N::meprec will be suppressed during this calculation.

         Out[1]= {9.874863, Null}

Aug 2016

enter image description here

V 11 has a significant improvement in my new most recently mentioned fastest program for calculating digits of the MRB constant via the eta formula, Here are some timings:

Digits           seconds

1500                42.6386632

2000             127.3101969

3000             530.4442911

4000           1860.1966540

5000           3875.6978162

6000           8596.9347275



 10,000        53667.6315476

From an previous message that starts with "How about computing the MRB constant from Crandall's eta derivative formulas?" here are my first two sets of records to compare with the just mentioned ones. You can see that I increased time efficiency by 10 to 29 to even 72 fold for select computations! In the tests used in that "previous message," 4000 or more digit computations produced a seemingly indefinitely long hang-on.

Digits      Seconds

500        36.831836
1000       717.308198
1500       2989.759165
2000       3752.354453


Digits        Seconds
 500          9.874863
 1000        62.587601
 1500        219.41540
 2000       1008.842867
 2500       2659.208646
 3000       5552.902395
 3500       10233.821601

Comparing first of the just mentioned 2000 digit computations with the "significant improvement" one we get the following.

3752/127 ~=29.

And from the slowest to the fastest 1500 digit run we get

2989/42 ~=72,

Talking about the eta formula for the MRB constant

Search 8/13/2017 in the above for this reply's place in Que. I placed it here to make it easy to find on this late of a date.

Here is another great improvement in calculating digits of MRB though this first Crandall eta formula found in the psu.edu paper Unified algorithms for polylogarithm, L-series, and zeta variants

enter image description here

From an even earlier message that starts with "How about computing the MRB constant from Crandall's eta derivative formulas?" here are my first two sets of records to compare with the just mentioned ones. You can see that I increased time efficiency by 10 to 29 to even 72 fold for select computations! In the tests used in that "previous message," 4000 or more digit computations produced a seemingly indefinitely long hang-on.

Digits      Seconds

500        36.831836
1000       717.308198
1500       2989.759165
2000       3752.354453


Digits        Seconds
 500          9.874863
 1000        62.587601
 1500        219.41540
 2000       1008.842867
 2500       2659.208646
 3000       5552.902395
 3500       10233.821601

Comparing first of the just mentioned 2000 digit computations with the "significant improvement" one, we get the following.

3752/127 ~=29.

And from the slowest to the fastest 1500 digit run we get

2989/42 ~=72,

Here is an example calculating 1500 digits in less than 23 seconds. First calculate known accurate digits:

mTrue = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, 
   Method -> "AlternatingSigns", WorkingPrecision -> 2000];

Then use this program:

prec = 1500;
to = SessionTime[];
etaMM[m_, pr_] := 
  Module[{a, s, k, b, c}, a[j_] := (Log[j + 1]/(j + 1))^m;
   {b, c, s} = {-1, -d, 0};
   Do[c = b - c;
    s = s + c a[k];
    b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
   Return[N[s/d, pr] (-1)^m]];
eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec]; n = 
 Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
MRBtest = 
  eta1 - ParallelSum[(Cos[Pi m]) etaMM[m, prec]/
      N[Gamma[m + 1], prec], {m, 2, Floor[.365 prec]}];
Print[mTrue - MRBtest]; SessionTime[] - to

The larger prec (precission) you want to choose, the smaller number you can replace .365 with in
ParallelSum[(Cos[Pi m]) etaMM[m, prec]/N[Gamma[m + 1], prec], {m, 2, Floor[.365 prec]}. For prec=5000, change .365 to .31 (approximately). This advantage for smaller upper limits being needed in the sum is due to the Gamma (!) in the denominator. On my big computer 4000 digits now gives a timing of around 1800 seconds (1/2 an hour). See message above the previous occurrence of 8/13/2017 for previous records and records before those.

V 11 has a significant improvement in my new most recently mentioned fastest program for calculating digits of the MRB constant via the eta formula, Here are some timings:

Digits           seconds

1500                42.6386632

2000             127.3101969

3000             530.4442911

4000           1860.1966540

5000           3875.6978162

6000           8596.9347275

10,000        53667.6315476

UPDATE 5/30/2018

I made some programming improvements to my code for the eta formula computation of the MRB constant.

Here is the new code:

In[88]:= mTrue = 
  NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, 
   Method -> "AlternatingSigns", WorkingPrecision -> 5000];

In[82]:= prec = 1500;
to = SessionTime[];
etaMM[m_, pr_] := 
  Block[{a, s, k, b, c}, 
   a[j_] := (SetPrecision[Log[j + 1], prec]/(j + 1))^m;
   {b, c, s} = {-1, -d, 0};
   Do[c = b - c;
    s = s + c a[k];
    b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
   Return[N[s/d, pr] (-1)^m]];
eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec]; n = 
 Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
MRBtest = 
  eta1 - ParallelSum[(Cos[Pi m]) etaMM[m, prec]/
      N[Gamma[m + 1], prec], {m, 2, Floor[.365 prec]}];
Print[mTrue - MRBtest]; SessionTime[] - to

During evaluation of In[82]:= 0.*10^-1500

Out[87]= 15.4875433

Here is a comparison of my eta formula speed records:

enter image description here

Here is the code for 10,000 digits:

prec = 10000;
to = SessionTime[];
etaMM[m_, pr_] := 
  Block[{a, s, k, b, c}, 
   a[j_] := (SetPrecision[Log[j + 1], prec]/(j + 1))^m;
   {b, c, s} = {-1, -d, 0};
   Do[c = b - c;
    s = s + c a[k];
    b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
   Return[N[s/d, pr] (-1)^m]];
eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec]; n = 
 Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
MRBtest = 
  eta1 - ParallelSum[(Cos[Pi m]) etaMM[m, prec]/
      N[Gamma[m + 1], prec], {m, 2, Floor[.295 prec]}];
Print[mTrue - MRBtest]; SessionTime[] - to
0.*10^-9999

20621.99102

I tried a little something I got from the Mathematica documentation center. It speed the calculations up just a little more. My newest sample code as of 5/31/2018:

prec = 1500;
to = SessionTime[];
etaMM[m_, pr_] := 
  Block[{a, s, k, b, c}, 
   a[j_] := (SetPrecision[Log[j + 1], prec]/(j + 1))^m;
   {b, c, s} = {-1, -d, 0};
   Do[c = b - c;
    s = s + c a[k];
    b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
   Return[N[s/d, pr] (-1)^m]];
eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec]; n = 
 Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
MRBtest = 
  eta1 - ParallelSum[(Cos[Pi m]) etaMM[m, prec]/
      N[Gamma[m + 1], prec], {m, 2, Floor[.365 prec]}, 
    Method -> "CoarsestGrained"];
Print[mTrue - MRBtest]; SessionTime[] - to

That leads to the following table.

enter image description here

See attached "eta may 31 2018.nb" for the work.

enter image description here

May 31 2018 | 9:00PM EST

I tried this form using the ParallelCombine command:

prec = 1500;
to = SessionTime[];
etaMM[m_, pr_] := 
  Block[{a, s, k, b, c}, 
   a[j_] := (SetPrecision[Log[j + 1], prec]/(j + 1))^m;
   {b, c, s} = {-1, -d, 0};
   Do[c = b - c;
    s = s + c a[k];
    b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
   Return[N[s/d, pr] (-1)^m]];
eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec]; n = 
 Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
MRBtest = eta1 -
   Total[ParallelCombine[((Cos[Pi #]) etaMM[#, prec]/
         N[Gamma[# + 1], prec]) &, Range[2, Floor[.365 prec]], 
     Method -> "CoarsestGrained"]];
Print[mTrue - MRBtest];

SessionTime[] - to

, which lead to this remarkable set of results from my fast 4 core machine with 2400 MHz DDR4 RAM:

2a

The code and computations from Crandall's original code and my first improvement of it can be found by searching for the post above that begins with

"How about computing the MRB constant from Crandall's eta derivative formulas?"

See eta may 31 2018.nb attachment for more work.

UPDATE 2:51PM, June 1, 2018

**Last night at about 9:30PM EST, I started a 20,000 digit calculation of the digits of the MRB constant via eta derivatives using the "Combine" method.

UPDATE

The 20,000 digits finished at Fri 1 Jun 2018 21:11:49 -- it took 83728.3439962 sec -- see attached 20 k eta style.nb .

That timing of 83728.3439962 sec for 20,000 digits fits perfectly with a pattern compared of previous timings. approx 5000 digits took 548sec. 10000 digits took 6806sec.

6806sec(6806sec/548sec) = 84528.532* sec.

That surprises me because my choice in the multiple of prec, as in Floor[.365 prec] for prec=20000 was only a guess. (I used 0.285.) which means the program took 5700 iterations. (It got 3.5 digits per iteration.) My plan was to always use the minimum number of iterations to get a desired number of digits.

As I wrote above:

The larger prec (precission) you want to choose, the smaller number you can replace .365 with in ParallelSum[(Cos[Pi m]) etaMM[m, prec]/N[Gamma[m + 1], prec], {m, 2, Floor[.365 prec]}. For prec=5000, change .365 to .31 (approximately). This advantage for smaller upper limits being needed in the sum is due to the Gamma (!) in the denominator. On my big computer 4000 digits now gives a timing of around 1800 seconds (1/2 an hour). See message above the previous occurrence of 8/13/2017 for previous records and records before those.

WARNING

I posted some about 12 kernels:

I hoped to produce some extra success by lying to Kernel Configuration as follows:

A big Lie!

Which did lead to the following, great results:

enter image description here

Here is a sample:

prec = 10000;
to = SessionTime[];
etaMM[m_, pr_] := 
  Block[{a, s, k, b, c}, 
   a[j_] := (SetPrecision[Log[j + 1], prec]/(j + 1))^m;
   {b, c, s} = {-1, -d, 0};
   Do[c = b - c;
    s = s + c a[k];
    b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
   Return[N[s/d, pr] (-1)^m]];
eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec]; n = 
 Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
MRBtest = 
  eta1 - Total[
    ParallelCombine[((Cos[Pi #]) etaMM[#, prec]/
         N[Gamma[# + 1], prec]) &, Range[2, Floor[.295 prec]], 
     Method -> "CoarsestGrained"]];
Print[mTrue - MRBtest];

SessionTime[] - to

During evaluation of In[52]:= 0.*10^-10000

Out[58]= 3413.3092082

See attached 16 socalled cores.nb.

There is an example of the results for using more and more kernels on my 8 duel core Zeon: -- in attached "more and more kernels effect.nb ."

I would be absolutely delighted if anyone with a larger kernel limit license could run it and show us what your results are!!!

Here is a sample of using more and more kernels on my 8 duel core Zeon:

 Quit[];
mTrue =  0.18785964246206712024851793405427323005590309490013878617200468408947\
7231564660213703296654433107496903842345856258019061231370094759226630\
4389293488961841208373366260816136027381263793734352832125527639621714\
8932170207628206217151671540841268044836354167199851976802527598938993\
9144579835055613509648521071207844423095868129497688526949564204255586\
4836704410425279524710606660926339748341031157816786416689154600342222\
5883800254553968929471142122189105098328712277308020036445215390536395\
0553322034706275511598128280395102192649146731762935161906598160186642\
4582495069720338199295842093551516251439935760076459329128145170908242\
4915883204169066409334435914806705564692806787007028115009380606938139\
3859533606579874055620623487043293607378195646031047639506648930613606\
4552806751519350828083737671929686639810309494963749627738304984632456\
3479311575300289212523291816195626973697074865765476071178017195787368\
3009659022606687536563055165673612881502014387561366865522106743053705\
9103973575619148909369077798320355119336240463725349410542836369971702\
4418551654837279358822008134480961058802030647819619596953756287834812\
3349763858630101407272529230147233333625091858402480370404888196767676\
0119858111679169352796852044160027086137228688945101510291998853690572\
8659287086875425492533794395347589703563313440382638887986656195980733\
5147399025657781331722610761279758527227427773089857749223059709625725\
6271883675575297887925361687673940354321451362772549229313126276435732\
1446216187786377154205423128223446295396532903322171479820280759842210\
6556489004853685870708326887487737763504768916098318553628166715910841\
2193420164386000258508426556435006954832830120546193205155935040023508\
3512613359217408970073297842771289673651619602250771173880842623256978\
8546537869046222708567487474709306935732666859085616282375386551243297\
5647464914619179575869342996208149878536663170197264534260468378010759\
0551486787190395783150604524441907570445113820585333984692194828794764\
8657593178595816527492977822095977440911371434216929624593175324537340\
1299593995004917912983680848547143925846704238528608320053664510586678\
1511964596760791964317343076715344983004971288694016566004270621110790\
5316472150455632994388400521115239016877311545696102836920503689610880\
6031603660382896533239383524154510137534165673472607464891120088099838\
1520466954150263770355732835929966306427173051589721163519991611359546\
7031540872528724399819787250274679738863889705686743537785798105855619\
2492185716949135673462704077491448799682065482817465880642236348160780\
9507770579393134958298066028252721284916888092303252902700599177550596\
1583591999319086939303973661164651485821997292533710676873868623504791\
5879737968269847878082223410618789674667450680064404065553875213281494\
9807002098581322206201090112659034497174108010632475647128346095492843\
7006514745021822612041564393030885982642625682812609249113673396723593\
3714534216902560140050169469983875907342920361729301531400405936246406\
78140077947561307736973240992352946479458077816460769624086460;
Quiet[Table[LaunchKernels[1]; prec = 3000;
  to = SessionTime[];
  etaMM[m_, pr_] := 
   Block[{a, s, k, b, c}, 
    a[j_] := (SetPrecision[Log[j + 1], prec]/(j + 1))^m;
    {b, c, s} = {-1, -d, 0};
    Do[c = b - c;
     s = s + c a[k];
     b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
    Return[N[s/d, pr] (-1)^m]];
  eta1 = N[EulerGamma Log[2] - Log[2]^2/2, prec]; 
  n = Floor[132/100 prec]; d = N[ChebyshevT[n, 3], prec];
  MRBtest = 
   eta1 - Total[
     ParallelCombine[((Cos[Pi #]) etaMM[#, prec]/
          N[Gamma[# + 1], prec]) &, Range[2, Floor[.365 prec]], 
      Method -> "CoarsestGrained"]];
  Print["Error was ", mTrue - MRBtest, ", using"];

  Print[xx, "  kernels, and gave a time of ", SessionTime[] - to, 
   " s."], {xx, 1, 16}]]
  Error was 0.*10^-3000, using

1  kernels, and gave a time of 477.9303673 s.

Error was 0.*10^-3000, using

2  kernels, and gave a time of 257.3167709 s.

Error was 0.*10^-3000, using

3  kernels, and gave a time of 181.8228406 s.

Error was 0.*10^-3000, using

4  kernels, and gave a time of 147.4913411 s.

Error was 0.*10^-3000, using

5  kernels, and gave a time of 118.8902094 s.

Error was 0.*10^-3000, using

6  kernels, and gave a time of 103.5240060 s.

Error was 0.*10^-3000, using

7  kernels, and gave a time of 92.3546592 s.

Error was 0.*10^-3000, using

8  kernels, and gave a time of 85.5143638 s.

Error was 0.*10^-3000, using

9  kernels, and gave a time of 75.6869920 s.

Error was 0.*10^-3000, using

10  kernels, and gave a time of 72.1320176 s.

Error was 0.*10^-3000, using

11  kernels, and gave a time of 68.4291460 s.

Error was 0.*10^-3000, using

12  kernels, and gave a time of 62.7524163 s.

Error was 0.*10^-3000, using

13  kernels, and gave a time of 63.8671114 s.

Error was 0.*10^-3000, using

14  kernels, and gave a time of 61.3992399 s.

Error was 0.*10^-3000, using

15  kernels, and gave a time of 61.0743278 s.

Error was 0.*10^-3000, using

16  kernels, and gave a time of 60.1936369 s.

I just updated the attachment, "more and more kernels effect.nb ."

UPDATE July 29, 2018

Here are some new stats:

enter image description here

Links

As mentioned a few times above Richard Crandall made the following observations about the MRB constant: enter image description here

His last comment is that we might find some algorithm advantages by focusing on the fixed argument of 0 for the eta derivatives. He gives Chapter 3 as a possible source to find the algorithm advantages. (Here is another link to his paper: http://marvinrayburns.com/UniversalTOC25.pdf .)

Here is what he was looking for.

c[0] = 0; 
c[1] = Log[2]; Table[
c[n] = -2*Derivative[n - 1][Zeta][0], {n, 2, 22}]; 
l = CoefficientList[Normal[Series[Exp[(-x)*E^x], {x, 0, 21}]], 
x]; N[-Sum[
l[[n + 1]]*((-1)^
n*(Sum[(-1)^x*(c[x + 1]*Binomial[n, x]*c[1]^(n - x)), {x, 1, 
n - 1}] + c[1]^n + 
c[0]) + 1/2 c[n + 1]), {n, 1, 17}]]

Mathematica still has trouble with higher zeta derivatives of 0, however. I'm going to look for a procedure for computing them better.

[Edit]

I computed the zeta derivatives of 0 by

   zeta0[p_] := (-1)^p Sum[StieltjesGamma[p + k]/k!, {k, 0, Infinity}] - 
     p!

and got the same results Mathematica got for the higher zeta derivatives of 0.

I also checked the CoefficientList of

CoefficientList[Normal[Series[Exp[(-x)*E^x], {x, 0, 21}]]

by the following, and haven't found where Mathematica is having trouble!

c[0] = 0; c[1] = Log[2]; Table[c[n] = -2*Derivative[n - 1][Zeta][0], 
{n, 2, 
18}]; N[-Sum[(Sum[(-1)^d*d^(n - d)*Binomial[n, d], {d, 1, n}]*
((-1)^
n*(Sum[(-1)^x*(c[x + 1]*Binomial[n, x]*c[1]^(n - x)), 
{x, 1, n - 1}] + c[1]^n + c[0]) + (1/2)*
c[n + 1]))/n!, {n, 1, 17}]]

I even checked the binomials by their formula. Also the StieltjesGamma and Derivative[n ][Zeta][0]] results appear smooth for discrete operations:

 Table[N[Derivative[n ][Zeta][0]], {n, 10, 25}]

and

 N[Table[StieltjesGamma[x], {x, 1, 30}]]

.

[Edit]

I found the problem as to why Mathematica doesn't increase its accuracy in the above formula after 17 iterations: Mathematica will give a numeric solution to many zeta derivatives of 0, only to machine precision!

For machine precision:

  Table[N[Derivative[n ][Zeta][0]], {n, 1, 30}]

gives the machine sized numeric to many derivatives:

 {-0.918939, -2.00636, -6.00471, -23.9971, -120., -720.001, \
-5040., -40320., -362880., -3.6288*10^6, -3.99168*10^7, \
-4.79002*10^8, -6.22702*10^9, -8.71783*10^10, -1.30767*10^12, \
-2.09228*10^13, -3.55687*10^14, -6.40237*10^15, -1.21645*10^17, \
-2.4329*10^18, -5.10909*10^19, -1.124*10^21, -2.5852*10^22, \
-6.20448*10^23, -1.55112*10^25, -4.03291*10^26, -1.08889*10^28, \
-3.04888*10^29, -8.84176*10^30, -2.65253*10^32}.

Then

   Table[N[Derivative[n][Zeta][0], 10], {n, 1, 30}]

gives the high precision numeric for only the first 3 derivatives:

{-0.91893853320467274178032973640561763986`10., \
-2.0063564559085848512101000267299604382`10., 
   -6.0047111668622544478`10., Derivative[4][Zeta][0], 
 Derivative[5][Zeta][0], Derivative[6][Zeta][0], 
   Derivative[7][Zeta][0], Derivative[8][Zeta][0], 
 Derivative[9][Zeta][0], Derivative[10][Zeta][0], 
   Derivative[11][Zeta][0], Derivative[12][Zeta][0], 
 Derivative[13][Zeta][0], Derivative[14][Zeta][0], 
   Derivative[15][Zeta][0], Derivative[16][Zeta][0], 
 Derivative[17][Zeta][0], Derivative[18][Zeta][0], 
   Derivative[19][Zeta][0], Derivative[20][Zeta][0], 
 Derivative[21][Zeta][0], Derivative[22][Zeta][0], 
   Derivative[23][Zeta][0], Derivative[24][Zeta][0], 
 Derivative[25][Zeta][0], Derivative[26][Zeta][0], 
   Derivative[27][Zeta][0], Derivative[28][Zeta][0], 
 Derivative[29][Zeta][0], Derivative[30][Zeta][0]}.

With some confidence I can say

formula

I fixed it!!!

I forced Mathematica to give up the needed digits of the zeta derivatives.

My new program does not really compete with the previously mentioned record-breakers. But it is a fairly efficient use of Crandall's formula (44). First it calculates many digits on MRB the old fashion way to use as a check. So here is my new program:

m = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, 
   Method -> "AlternatingSigns", WorkingPrecision -> 120];

Block[{$MaxExtraPrecision = 1000}, s = 100(*number of terms*);
 c[1] = Log[2];
 c[n_] := N[1 - 2*Derivative[n - 1][Zeta][0], Floor[3/2 s]] - 1;
 mtest = (-Sum[(Sum[(-1)^d*d^(n - d)*Binomial[n, d], {d, 1, 
          n}]*((-1)^
            n*(Sum[(-1)^x*(c[x + 1]*Binomial[n, x]*c[1]^(n - x)), {x, 
               1, n - 1}] + c[1]^n) + (1/2)*c[n + 1]))/n!, {n, 1, 
      s}])]; Print[s, " terms give ", mtest, ", and the error is ", 
 m - mtest]

100 terms give 0.18785964486341229249700337222, and the error is -2.40134517224848543816*10^-9

Changing s to 200 shows all correct digits:

200 terms give 0.187859642465, and the error is -3.*10^-12

I figured out how to rapidly compute AND CHECK a computation of the MRB constant! (The timing given is in processor time [for computing and checking] only. T0 can be used with another SessionTime[] call at the end to figure out all time expired during running of the program.) I used both of Crandall's methods for computing it and used for a check, the nontrivial identityenter image description here ,where gamma is the Euler constant and M is the MRB constant.

Below is my first version of the code with results. If nothing else, I thought, the code pits Crandall's 2 methods against each other to show if one is wrong they both are wrong. (So it is not a real proof.) But these are two totally different methods! (the first of which has been proven by Henry Cohen to be theoretically correct here). For a second check mm is a known approximation to the constant; over 3 million non checked (as of now) digits are found in the attached file 3M.nb. (You will have to change the Format/Style to Input to use the digits.)

In[15]:= (*MRB constant computation with verification! The constant's \
decimal approximation is saved as MRBtest*)prec = 5000;(*Number of \
required decimals.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] := 
 Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 4, 
   tsize = 2^7, chunksize, start = 1, ll, ctab, pr = Floor[1.02 pre]},
   chunksize = cores*tsize;
  n = Floor[1.32 pr];
  end = Ceiling[n/chunksize];
  d = N[(3 + Sqrt[8])^n, pr + 10];
  d = Round[1/2 (d + 1/d)];
  {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
  iprec = Ceiling[pr/27];
  Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l;
        x = N[E^(Log[ll]/(ll)), iprec];
        pc = iprec;
        While[pc < pr, pc = Min[3 pc, pr];
         x = SetPrecision[x, pc];
         y = x^ll - ll;
         x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(*N[Exp[Log[ll]/ll],
        pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, 
       Method -> "EvaluationsPerKernel" -> 1]];
    ctab = Table[c = b - c;
      ll = start + l - 2;
      b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
      c, {l, chunksize}];
    s += ctab.(xvals - 1);
    start += chunksize;, {k, 0, end - 1}];
  etaMs = N[-s/d - (EulerGamma Log[2] - Log[2]^2/2), pr]]; t2 = 
 Timing[MRBtest2 = expM[prec];];
Print["The MRB constant was computed and checked to ", prec, " digits \
in ", t1 = t2[[1]] + Timing[eta[s_] := (1 - 2^(1 - s)) Zeta[s];
     eta1 = Limit[D[eta[s], s], s -> 1];
     MRBtrue = mm;
     MRBtest = eta1 + etaMs;
     check = MRBtest - MRBtrue][[1]], " seconds"]; check

During evaluation of In[15]:= The MRB constant was computed and checked to 5000 digits in 2.12161 seconds

Out[18]= 0.*10^-5000

In[19]:= MRBtest - mm

Out[19]= 0.*10^-5000
Attachments:

The identity in question is straightforward. Write n^(1/n) as Exp[Log[n]/n], take a series expansion at 0, and subtract the first term from all summands. That means subtracting off Log[n]/n in each summand. This gives your left hand side. We know it must be M - the sum of the terms we subtracted off. Now add all of them up, accounting for signs.

Expand[Sum[(-1)^n*Log[n]/n, {n, 1, Infinity}]]

(* Out[74]= EulerGamma Log[2] - Log[2]^2/2 *)

So we recover the right hand side.

I have not understood whether this identity helps with Crandall's iteration. One advantage it confers, a good one in general, is that it converts a conditionally convergent alternating series into one that is absolutely convergent. From a numerical computation point of view this is always good.

Daniel Lichtblau and others, I just deciphered an Identity Crandall used for checking computations of the MRB constant just before he died. It is used in a previous post about checking, where I said it was hard to follow. The MRB constant is B here. B=`enter image description here In input form that is

   B= Sum[(-1)^(k + 1)*(-1 + (1 + k)^(1/(1 + k)) - Log[1 + k]/(1 + k) - 
         Log[1 + k]^2/(2*(1 + k)^2)), {k, 0, Infinity}] + 
     1/24 (\[Pi]^2 Log[2]^2 - 
        2 \[Pi]^2 Log[
          2] (EulerGamma + Log[2] - 12 Log[Glaisher] + Log[\[Pi]]) - 
        6 (Zeta^\[Prime]\[Prime])[2]) + 
     1/2 (2 EulerGamma Log[2] - Log[2]^2)

For 3000 digit numeric approximation, it is

B=NSum[((-1)^(
    k + 1) (-1 + (1 + k)^(1/(1 + k)) - Log[1 + k]/(1 + k) - 
      Log[1 + k]^2/(2 (1 + k)^2))), {k, 0, Infinity}, 
  Method -> "AlternatingSigns", WorkingPrecision -> 3000] + 
 1/24 (\[Pi]^2 Log[2]^2 - 
    2 \[Pi]^2 Log[
      2] (EulerGamma + Log[2] - 12 Log[Glaisher] + Log[\[Pi]]) - 
    6 (Zeta^\[Prime]\[Prime])[2]) + 
 1/2 (2 EulerGamma Log[2] - Log[2]^2)

It is anylitaclly straight forward too because

Sum[(-1)^(k + 1)*Log[1 + k]^2/(2 (1 + k)^2), {k, 0, Infinity}]

gives

1/24 (-\[Pi]^2 (Log[2]^2 + EulerGamma Log[4] - 
      24 Log[2] Log[Glaisher] + Log[4] Log[\[Pi]]) - 
   6 (Zeta^\[Prime]\[Prime])[2])

That is enter image description here I wonder why he chose it?

The new sum is this.

Sum[(-1)^(k + 1)*(-1 + (1 + k)^(1/(1 + k)) - Log[1 + k]/(1 + k) - 
         Log[1 + k]^2/(2*(1 + k)^2)), {k, 0, Infinity}] 

That appears to be the same as for MRB except now we subtract two terms from the series expansion at the origin of k^(1/k). For each k these terms are Log[k]/k + 1/2*(Log[k]/k)^2. Accounting for the signs (-1)^k and summing, as I did earlier for just that first term, we get something recognizable.

Sum[(-1)^(k)*(Log[k]/(k) + Log[k]^2/(2*k^2)), {k, 1, Infinity}]

(* Out[21]= 1/24 (24 EulerGamma Log[2] - 2 EulerGamma \[Pi]^2 Log[2] - 
   12 Log[2]^2 - \[Pi]^2 Log[2]^2 + 24 \[Pi]^2 Log[2] Log[Glaisher] - 
   2 \[Pi]^2 Log[2] Log[\[Pi]] - 6 (Zeta^\[Prime]\[Prime])[2]) *)

So what does this buy us? For one thing, we get even better convergence from brute force summation, because now our largest terms are O((logk/k)^3) and alternating (which means if we sum in pairs it's actually O~(1/k^4) with O~ denoting the "soft-oh" wherein one drops polylogarithmic factors).

How helpful is this? Certainly it cannot hurt. But even with 1/k^4 size terms, it takes a long time to get even 40 digits, let alone thousands. So there is more going on in that Crandall approach.

If you copy and paste the code for Zeta''[2] you get a non evaluable input!

I get the following results comparing two methods:

In[655]:= 
Timing[MRBtrue = 
   NSum[(-1)^n*(n^(1/n) - 1), {n, 1, Infinity}, 
    WorkingPrecision -> prec, Method -> "AlternatingSigns"]][[1]]

Out[655]= 8.049652

In[656]:= 
Timing[B = 
   NSum[((-1)^(k + 1) (-1 + (1 + k)^(1/(1 + k)) - Log[1 + k]/(1 + k) -
          Log[1 + k]^2/(2 (1 + k)^2))), {k, 0, Infinity}, 
     Method -> "AlternatingSigns", WorkingPrecision -> 3000] + 
    1/24 (\[Pi]^2 Log[2]^2 - 
       2 \[Pi]^2 Log[
         2] (EulerGamma + Log[2] - 12 Log[Glaisher] + Log[\[Pi]]) - 
       6 (Zeta''[2])) + 1/2 (2 EulerGamma Log[2] - Log[2]^2)][[1]]

Out[656]= 12.277279

Daniel Lichtblau,

Notice Log[k]/(k) and Log[k]^2/(2k^2) are of the form Log[k]^n/(nk^n). We can take that summing of Log[k]/(k) + Log[k]^2/(2*k^2)+... to its end and write B=enter image description here or compute

NSum[(-1)^(k)*(k^(1/k) - 1 + 
     Sum[Log[k]^n/(n*k^n), {n, 1, Infinity}]), {k, 1, Infinity}, 
  WorkingPrecision -> 1000, Method -> "AlternatingSigns"] - 
 NSum[(-1)^(1 + k) Log[(k - Log[k])/k], {k, 1, Infinity}, 
  WorkingPrecision -> 1000, Method -> "AlternatingSigns"]

Simplified,.B=enter image description here,

What does that do to our "better convergence from brute force summation?"

P.S. I only used 2 terms in my sample data, so I might not have the correct pattern for Log[k]/(k) + Log[k]^2/(2*k^2)+... .

The reason that I suspect that I've got the wrong pattern is, in the following code the summands Log[k]/(k) and Log[k]^2/(2k^2) give 0 where the Log[k]^n/(nk^n).for n>2 does not. (etaMM[m, n] Gives a numeric approximation for the mth derivative of m.)

   etaMM[m_, pr_] := 
  Module[{a, d, s, k, b, c}, a[j_] := Log[j + 1]^m/(j + 1)^m;
   n = Floor[1.32 pr];
   d = Cos[n ArcCos[3]];
   {b, c, s} = {-1, -d, 0};
   Do[c = b - c;
    s = s + c a[k];
    b = (k + n) (k - n) b/((k + 1) (k + 1/2)), {k, 0, n - 1}];
   Return[N[s/d, pr] (-1)^m]]; Table[-Sum[(-1)^m*etaMM[m, 30]/m!, {m, 
      1, a}] - 
   Sum[(-1)^(k)*(Sum[Log[k]^n/(n*k^n), {n, 1, a}]), {k, 1, 
     Infinity}], {a, 1, 15}]

I could really use your opinions here! If your getting tired of my posts let me know.

Power towers are defined below. See http://mathworld.wolfram.com/PowerTower.html .

enter image description here ;;;enter image description here

How about breaking my record for computing the infinite power tower of the MRB constant. Here's how I have to go about computing n digits of it: I compute a decimal expansion of the MRB constant, which I save as m. Then I compute l = Log[m]; N[-ProductLog[-l]/l, n]. My record is 3 million digits, in which I used my 3,014,991 digit computation of the MRB constant (mentioned in the first post of this thread) for m.

It would be EXTREMELY helpful if anyone could find a way to compute the exact power tower without first computing the MRB constant! Such a revelation would be synonymous with finding a closed for solution to the MRB constant! I've been trying to find the exact power tower, lately, with no success. Even a high precision approximation to the power tower would generate a nearly equally precise approximation to the MRB constant. (Let ll be the infinite power tower of m, then ll^(1/ll)=m)

Attached are 3 million digits of the power tower.

The next active post starts out with

"NEW RECORD ATTEMPTS OF 4,000,000 DIGITS!"

The MRB constant is now a Scholar subject:

https://scholar.google.com/scholar?q=%22MRB+constant%22

MKB constant calculations have been moved to their own discussion at http://community.wolfram.com/groups/-/m/t/1323951?ppauth=W3TxvEwH .

enter image description here

Attachments are still here, though.

Try to beat these MRB constant records!

Posted 9 months ago

nice system!

NEW RECORD ATTEMPTS OF 4,000,000 DIGITS!

.

.

First effort, Sep 04, 2015

At 10:00 PM Friday Sept 04, 2015 I started the 4,000,000 run of the MRB constant proper. Does anyone want to work on it with me?

Here is the code I am using:

(*Fastest (at MRB's end) as of 24 dEC 2014.*)
Block[{$MaxExtraPrecision = 50}, 
 prec = 4000000;(*Number of required decimals.*)ClearSystemCache[];
 T0 = SessionTime[];
 expM[pre_] := 
  Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 16, 
    tsize = 2^7, chunksize, start = 1, ll, ctab, 
    pr = Floor[1.005 pre]}, chunksize = cores*tsize;
   n = Floor[1.32 pr];
   end = Ceiling[n/chunksize];
   Print["Iterations required: ", n];
   Print["end ", end];
   Print[end*chunksize]; d = Cos[n ArcCos[3]];
   {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
   iprec = Ceiling[pr/27];
   Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l;
        h = Log[ll]/ll; x = N[Exp[h], iprec];
        pc = iprec;
        While[pc < pr, pc = Min[3 pc, pr];
         x = SetPrecision[x, pc];
         y = x^ll - ll;
         x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(*N[Exp[Log[ll]/ll],
        pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, 
       Method -> "EvaluationsPerKernel" -> 4]];
    ctab = ParallelTable[Table[c = b - c;
       ll = start + l - 2;
       b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
       c, {l, chunksize}], Method -> "EvaluationsPerKernel" -> 2];
    s += ctab.(xvals - 1);
    start += chunksize;
    Print["done iter ", k*chunksize, " ", SessionTime[] - T0];, {k, 0,
      end - 1}];
   N[-s/d, pr]];
 t2 = Timing[MRBtest2 = expM[prec];]; 
 Print["Difference from 3014991 known digits is ", MRBtest2 - m3M];
 MRBtest2]

3014991 digits are saved as m3M.

I will post several updates as edits here as I go.

EDIT: As of Sat, Sept 5, 2015, the program is indicating that the run will take 3.3 months.

EDIT: Having to run the program for over 3 months, there is a chance that I would suffer a power outage longer than the 15 minutes or so that my battery backup will run my computer! Of course I'll keep you posted if that happens. (I've tried calculations that took longer than that before!)

...Updates were installed closing Mathematica..

Second effort, Sept 10, 2015

EDIT I didn't know that upgrading to Windows 10 caused my Windows update option to read, automatically install updates, so my computer restarted. I started the 4,000,000 digit run again at 8:34 PM, Thursday Sept 10, 2015. This time I made sure the deffer updates option was chosen!!

EDIT As of Sept 19,2015, the program says it will take 94 more days to complete the 4 million digit run.

EDIT As of Sept 23,2015, 9:20 PM, the program says it will take 90.9563 more days to complete the 4 million digit run.

EDIT As of Sept 27,2015, 9:20 PM, the program says it will take 86.9283 more days to complete the 4 million digit run

...Updates were installed closing Mathematica..

Third effort, Sept 28,2015

Well I started the 4 million digit search again. This time I installed the Windows 10 Fall Creators Update to try to avoid the automatic restarts! Per my habit above I will post updates in this message. The code I'm using is the same mentioned twice above that starts with

The Windows 10 Fall Creators Update restarted my machine on Thursday, Nov 16, 2017 at 5:33 pm!

Fourth effort, Sat 14 Apr 2018

I optimized my program to calculating 4019999 digits with my new system in Mathematica v. 11.3 (not kernel version).

Posted below. On my new Zeon system, this optimized version gives V11.3 (not kernel version) a slight advantage over 11.2 (not kernel version)!

Print["Start time is ", ds = DateString[], "."];
prec = 4000000;
(**Number of required decimals.*.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] := 
  Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 32(*=4*number of physical cores*), 
    tsize = 2^7, chunksize, start = 1, ll, ctab, 
    pr = Floor[1.005 pre]}, chunksize = cores*tsize;
   n = Floor[1.32 pr];
   end = Ceiling[n/chunksize];
   Print["Iterations required: ", n];
   Print["Will give ", end, 
    " time estimates, each more accurate than the previous."];
   Print["Will stop at ", end*chunksize, 
    " iterations to ensure precsion of around ", pr, 
    " decimal places."]; d = ChebyshevT[n, 3];
   {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
   iprec = Ceiling[pr/27];
   Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l;
        x = N[E^(Log[ll]/(ll)), iprec];
        pc = iprec;
        While[pc < pr, pc = Min[3 pc, pr];
         x = SetPrecision[x, pc];
         y = x^ll - ll;
         x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(**N[Exp[Log[ll]/
        ll],pr]**)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, 
       Method -> "EvaluationsPerKernel" -> 16(* a power of 2 commensurate with processor strength*)]];
    ctab = ParallelTable[Table[c = b - c;
       ll = start + l - 2;
       b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
       c, {l, chunksize}], Method -> "EvaluationsPerKernel" -> 16(* a power of 2 commensurate with processor strength*)];
    s += ctab.(xvals - 1);
    start += chunksize;
    st = SessionTime[] - T0; kc = k*chunksize; 
    ti = (st)/(kc + 10^-4)*(n)/(3600)/(24);
    If[kc > 1, 
     Print[kc, " iterations done in ", N[st, 3], " seconds.", 
      " Should take ", N[ti, 2], " days or ", N[ti*24*3600, 2], 
      "s, finish ", DatePlus[ds, ti], "."]];, {k, 0, end - 1}];
   N[-s/d, pr]];
t2 = Timing[MRBtest2 = expM[prec];]; Print["Finished on ", 
 DateString[], ". Proccessor time was ", t2[[1]], " s."];
(*Print[*)MRBtest2(*]*)(*Remove (**) or enter MRBtest2 to print \
output*); Print["Enter MRBtest2 to print ", 
 Floor[Precision[
   MRBtest2]], " digits"]; Print["If you saved m3M, the difference \
between this and 3,014,991 known digits is ", N[MRBtest2 - m3M, 10]]

I'm going to play around with it an see what my patience and my computer's endurance amounts to.

Here is the result:

Start time is Sat 14 Apr 2018 14:00:33.

Iterations required: 5306398

Will give 1296 time estimates, each more accurate than the previous.

Will stop at 5308416 iterations to ensure precsion of around 4019999 decimal places.

4096 iterations done in 1.1810^4 seconds. Should take 1.810^2 days or 1.5*10^7s, finish Tue 9 Oct 2018 01:49:36.

...

2789376 iterations done in 4.21*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 07:21:24.

That is 43.92 days from now (9:15:15 am EDT | Saturday, June 2, 2018).

...

My computer crashed!

Fifth effort, Dec 19, 2017

I applied some new update policies via LogMeIn, for windows to download but not apply updates. That should work!

The new run looks like

  1 : 15 : 58 pm EST | Sunday, December 17, 2017
   ...  done iter 96256 165140.1164436.

Then

  (165140.1164436) sec/(96256 iterations) (5306880 iterations)/(3600sec/hour)/(24 hour/day)

gives 105.378 day.

Entering "December 17, 2017+106 days" into Wolfram Alpha tells us the computation should be done around Monday, April 2, 2018.

My computer went to sleep sometime between 10:15:51 pm EST | Thursday, December 28, 2017 and 9:22:00 am EST | Sunday, December 31, 2017 .

Sixth effort, Jan 09, 2018

The output starts out with

"Sun 7 Jan 2018 15:14:50"

Iterations required: 5306398

 end 3455

 5306880

 done iter 0     2374.6810043.

The latest result is done iter 92160 153642.6180409.

Entering

 (153642.6180409) sec/(92160 iterations) (5306880iterations)/(3600 sec/hour)/(24 hour/day)

gives

102.399 day or 3.4 months for the computation to run.

Here is the latest output: done iter 3048960 5.1636602440434*10^6.

N[3048960/5306880*100] says the computation is 57.453% done.

... My computer failed on 3/11/2018 at 8:30 am. I will break the program up, where it does a little at a time and saves a file with what progress has been made!

Seventh! effort 27 Aug 2018

I started another 4 million digit run with my 3.7 GH overclocked up to 4.7 GH, Intel 6core and 6 kernels at 3000MH RAM, w/ 4 cores and 8 kernels of 3.6 GH at 2400MH RAM with optimized use of kernel priority.

It is ultra fast!!!!!! Instead of around 100 days it says it will be done in less than 50 days.

Here are the results thus far:

Print["Start time is ", ds = DateString[], "."];
prec = 4000000;
(**Number of required decimals.*.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] := 
  Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16(*=4*
    number of physical cores*), tsize = 2^7, chunksize, start = 1, ll,
     ctab, pr = Floor[1.005 pre]}, chunksize = cores*tsize;
   n = Floor[1.32 pr];
   end = Ceiling[n/chunksize];
   Print["Iterations required: ", n];
   Print["Will give ", end, 
    " time estimates, each more accurate than the previous."];
   Print["Will stop at ", end*chunksize, 
    " iterations to ensure precsion of around ", pr, 
    " decimal places."]; d = ChebyshevT[n, 3];
   {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};
   iprec = Ceiling[pr/24768];
   Do[xvals = Flatten[Parallelize[Table[Table[ll = start + j*tsize + l;
         x = N[E^(Log[ll]/(ll)), iprec];



         pc = iprec;
         While[pc < pr/4096, pc = Min[3 pc, pr/4096];
          x = SetPrecision[x, pc];
          y = x^ll - ll;
          x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];
         (**N[Exp[Log[ll]/ll],pr/4096]**)

         x = SetPrecision[x, pr/1024];
         xll = x^ll; z = (ll - xll)/xll;
         t = 2 ll - 1; t2 = t^2;
         x = 
          x*(1 + SetPrecision[4.5, pr/1024] (ll - 1)/
               t2 + (ll + 1) z/(2 ll t) - 
             SetPrecision[13.5, 
               pr/1024] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[
         ll]/ll],pr/1024]*)

         x = SetPrecision[x, pr/256];
         xll = x^ll; z = (ll - xll)/xll;
         t = 2 ll - 1; t2 = t^2;
         x = 
          x*(1 + SetPrecision[4.5, pr/256] (ll - 1)/
               t2 + (ll + 1) z/(2 ll t) - 
             SetPrecision[13.5, 
               pr/256] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[
         ll]/ll],pr/256]*)

         x = SetPrecision[x, pr/64];
         xll = x^ll; z = (ll - xll)/xll;
         t = 2 ll - 1; t2 = t^2;
         x = 
          x*(1 + SetPrecision[4.5, pr/64] (ll - 1)/
               t2 + (ll + 1) z/(2 ll t) - 
             SetPrecision[13.5, 
               pr/64] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[
         ll]/ll],pr/64]**)

         x = SetPrecision[x, pr/16];
         xll = x^ll; z = (ll - xll)/xll;
         t = 2 ll - 1; t2 = t^2;
         x = 
          x*(1 + SetPrecision[4.5, pr/16] (ll - 1)/
               t2 + (ll + 1) z/(2 ll t) - 
             SetPrecision[13.5, 
               pr/16] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[
         ll]/ll],pr/16]**)

         x = SetPrecision[x, pr/4];
         xll = x^ll; z = (ll - xll)/xll;
         t = 2 ll - 1; t2 = t^2;
         x = 
          x*(1 + SetPrecision[4.5, pr/4] (ll - 1)/
               t2 + (ll + 1) z/(2 ll t) - 
             SetPrecision[13.5, 
               pr/4] ll (ll - 1) 1/(3 ll t2 + t^3 z));(**N[Exp[Log[
         ll]/ll],pr/4]**)


         x = SetPrecision[x, pr];
         xll = x^ll; z = (ll - xll)/xll;
         t = 2 ll - 1; t2 = t^2;
         x = 
          x*(1 + SetPrecision[4.5, pr] (ll - 1)/
               t2 + (ll + 1) z/(2 ll t) - 
             SetPrecision[13.5, 
               pr] ll (ll - 1) 1/(3 ll t2 + t^3 z));(*N[Exp[Log[ll]/
         ll],pr]*)

         x, {l, 0, tsize - 1}], {j, 0, cores - 1}]]];
    ctab = ParallelTable[Table[c = b - c;
       ll = start + l - 2;
       b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));
       c, {l, chunksize}], Method -> "Automatic"];
    s += ctab.(xvals - 1);
    start += chunksize;
    st = SessionTime[] - T0; kc = k*chunksize;
    ti = (st)/(kc + 10^-4)*(n)/(3600)/(24);
    Print[kc, " iterations done in ", N[st, 4], " seconds.", 
     " Should take ", N[ti, 4], " days or ", N[ti*24*3600, 4], 
     "s, finish ", DatePlus[ds, ti], "."], {k, 0, end - 1}];
   N[-s/d, pr]];
t2 = Timing[MRBtest2 = expM[prec];]; Print["Finished on ", 
 DateString[], ". Proccessor time was ", 
 t2[[1]], " s."]; Print["Actual time was ", st];
(*Print[*)MRBtest2(*]*)(*Remove (**) or enter MRBtest2 to print \
output*); Print["Enter MRBtest2 to print ", 
 Floor[Precision[
   MRBtest2]], " digits"]; Print["If you saved m3M, the difference \
between this and 3,014,991 known digits is ", N[MRBtest2 - m3M, 10]]

Start time is Mon 27 Aug 2018 17:22:11.

Iterations required: 5306398

Will give 2592 time estimates, each more accurate than the previous.

Will stop at 5308416 iterations to ensure precsion of around 4019999 decimal places.

0 iterations done in 1408. seconds. Should take 8.646*10^8 days or 7.470*10^13s, finish Sun 25 Jul 2369306 03:19:20.

2048 iterations done in 2831. seconds. Should take 84.90 days or 7.335*10^6s, finish Tue 20 Nov 2018 14:58:22.

4096 iterations done in 4261. seconds. Should take 63.90 days or 5.521*10^6s, finish Tue 30 Oct 2018 14:52:54.

6144 iterations done in 5752. seconds. Should take 57.49 days or 4.967*10^6s, finish Wed 24 Oct 2018 05:12:32.

8192 iterations done in 7237. seconds. Should take 54.26 days or 4.688*10^6s, finish Sat 20 Oct 2018 23:35:31.
...

210944 iterations done in 1.513*10^5 seconds. Should take 44.06 days or 3.807*10^6s, finish Wed 10 Oct 2018 18:53:41.

212992 iterations done in 1.528*10^5 seconds. Should take 44.06 days or 3.807*10^6s, finish Wed 10 Oct 2018 18:49:24.

215040 iterations done in 1.543*10^5 seconds. Should take 44.06 days or 3.807*10^6s, finish Wed 10 Oct 2018 18:48:16.

217088 iterations done in 1.558*10^5 seconds. Should take 44.07 days or 3.808*10^6s, finish Wed 10 Oct 2018 19:04:29.

219136 iterations done in 1.573*10^5 seconds. Should take 44.07 days or 3.808*10^6s, finish Wed 10 Oct 2018 19:07:25.


...



548864 iterations done in 3.954*10^5 seconds. Should take 44.24 days or 3.822*10^6s, finish Wed 10 Oct 2018 23:06:24.

550912 iterations done in 3.968*10^5 seconds. Should take 44.24 days or 3.822*10^6s, finish Wed 10 Oct 2018 23:08:05.

552960 iterations done in 3.983*10^5 seconds. Should take 44.24 days or 3.822*10^6s, finish Wed 10 Oct 2018 23:09:03.

...

782336 iterations done in 5.655*10^5 seconds. Should take 44.40 days or 3.836*10^6s, finish Thu 11 Oct 2018 02:52:31.

784384 iterations done in 5.671*10^5 seconds. Should take 44.40 days or 3.836*10^6s, finish Thu 11 Oct 2018 03:00:20.

786432 iterations done in 5.685*10^5 seconds. Should take 44.40 days or 3.836*10^6s, finish Thu 11 Oct 2018 02:58:41.

...
907264 iterations done in 6.568*10^5 seconds. Should take 44.46 days or 3.841*10^6s, finish Thu 11 Oct 2018 04:26:21.

909312 iterations done in 6.583*10^5 seconds. Should take 44.46 days or 3.842*10^6s, finish Thu 11 Oct 2018 04:29:41.

911360 iterations done in 6.598*10^5 seconds. Should take 44.47 days or 3.842*10^6s, finish Thu 11 Oct 2018 04:33:53.


...

1028096 iterations done in 7.454*10^5 seconds. Should take 44.53 days or 3.848*10^6s, finish Thu 11 Oct 2018 06:07:13.

1030144 iterations done in 7.470*10^5 seconds. Should take 44.53 days or 3.848*10^6s, finish Thu 11 Oct 2018 06:11:43.

1032192 iterations done in 7.485*10^5 seconds. Should take 44.54 days or 3.848*10^6s, finish Thu 11 Oct 2018 06:12:48.

A long-term power outage stopped this computation!

I so dearly want to see more digits of the MRB constant: Please, anyone, please help here!!

Would anyone let me know how this comes out on your computer?

Here is a link to my Nov 16, 2018 update of calculating 4 million digits of MRB: HERE.

Here is a link to my Nov 18, 2018 update of calculating 4 million digits of MRB: HERE.

Here is a link to my Nov 19, 2018 update of calculating 4 million digits of MRB: HERE,

Here is a link to my Nov 20, 2018 update of calculating 4 million digits of MRB: HERE

Here is a link to my Nov 21, 2018 update of calculating 4 million digits of MRB: HERE

Here is a link to my Nov 22, 2018 update of calculating 4 million digits of MRB: HERE.

Here is a link to my Nov 24, 2018 update of calculating 4 million digits of MRB: HERE.

Here is a link to my Nov 27, 2018 update of calculating 4 million digits of MRB: HERE.

Here is a link to my Dec 05, 2018 update of calculating 4 million digits of MRB: HERE.

Here is a link to my Dec 10, 2018 update of calculating 4 million digits of MRB: HERE.

Reply to this discussion
Community posts can be styled and formatted using the Markdown syntax.
Reply Preview
Attachments
Remove
or Discard

Group Abstract Group Abstract