# Try to beat these MRB constant records!

GROUPS:
 Marvin Ray Burns 2 Votes POSTED BY: Marvin Ray Burns .MKB constant calculations, , 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 and the dislike possessed by a few more people: it is all a matter telling us that the "universal human mind" is multi faceted in giving passion, to person a for one task, and to person b for another task!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.. 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}^{10000 } (-1)^n \left(n^{1/n}\right).$ That first digit, by the way, is just 0. On Jan 11, 1999 I computed 3 digits of the MRB constant with the Inverse Symbolic Calculator. 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. Shortly afterwards I computed 9 correct digits of the MRB constant using Mathcad 7 professional on the Pentium II mentioned below. On Jan 23, 1999 I computed 500 digits of the MRB constant with the online tool called Sigma. 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. 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. 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. On March 01, 2006 with a 3GH PD with 2GBRAM available, I computed the first 11,000 digits of the MRB Constant. 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. 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. 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. 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. 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. 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. 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]]  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. . 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. 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. 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. 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. 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[]  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[]  Where I have 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 digits of error to the right.)The following records are due to the work of Richard Crandall found here. Sam Noble of Apple computed 1,000,000 digits of the MRB constant in 18 days 9 hours 11 minutes 34.253417 seconds Finishing on Dec 11, 2012 Ricard Crandall, an Apple scientist, computed 1,048,576 digits in a lighting fast 76.4 hours. That's on a 2.93 Ghz 8-core Nehalem. (This was most likely processor time, which is in accordance to the following record and hardware used.) 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. 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 a six core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz 3.20 GHz. Finally, I would like to announce a new unofficial world record computation of the MRB constant that was finished on Sun 21 Sep 2014 18:35:06. It took 1 month 27 days 2 hours 45 minutes 15 seconds. I computed 3,014,991 digits of the MRB constant with Mathematica 10.0. I Used my new version of Richard Crandall's code, below, 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 as MRBtest2M.)  (**Fastest (at MRB's end) as of 25 Jul 2014*.*) DateString[] prec = 3000000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 12, 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 = 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" -> 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];]; DateString[] Print[MRBtest2] MRBtest2 - MRBtest2M  t2 From the computation was {1.961004112059*10^6, Null}.Here are a couple of graphs of my record computations in max digits/ year: Attachments: Answer 4 years ago 78 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. 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: Answer 4 years ago  The following email Crandall sent me before he died might be useful for anyone checking their results: Answer 4 years ago  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 Answer 4 years ago  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) 
3 years ago
 The MRB constantIt is easy to compute the MRB constant using the LHS, but how about computing it from the RHS, ?How many correct digits can you compute using the using it? Here's how one can compute 173 accurate digits using it. First compute known correct digits. Then compute using the LHS using NSumTerms -> 2^22 and compare.  c1 = NSum[(-1)^n*(n^(1/n) - 1), {n, 1, Infinity}, Method -> "AlternatingSigns", WorkingPrecision -> 200, PrecisionGoal -> 200]; c2 = NSum[(2 k)^(1/(2 k)) - (2 k - 1)^(1/(2 k - 1)), {k, 1, Infinity}, WorkingPrecision -> 600, PrecisionGoal -> 600, NSumTerms -> 2^22]; c1 - c2 gives -6.6444030376101061743388604*10^-173While, if you try it naively, NSum[(-1)^n*(n^(1/n) - 1), {n, 1, \[Infinity]}, Method -> "AlternatingSigns", WorkingPrecision -> 100, PrecisionGoal -> 100] - N[Sum[(2 k)^(1/(2 k)) - (2 k - 1)^(1/(2 k - 1)), {k, 1, \[Infinity]}], 100] you get 8.65025879128817600921262272409653679780852599347660397129681915033728\ 91*10^-28, with only 28 digits of accuracy! Attachments:
3 years ago
 Daniel Lichtblau 1 Vote 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.
3 years ago
 For c1 I used a method for alternating series to get a very precise sum approximation: That is from the "AlternatingSigns" option.
3 years ago
 C1, the approximation to and a special case of , is computed correctly by Henri Cohen, Fernando Rodriguez Villegas, and Don Zagier,s Convergence Acceleration of Alternating Series as found next. 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: 1320During evaluation of In[17]:= Iterations: 0 Cumulative time (sec): 0.*10^-8During evaluation of In[17]:= Iterations: 1000 Cumulative time (sec): 0.1872004Out[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
3 years ago
 Above where Cohen said, 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 
3 years ago
 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:*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.
3 years ago
 OK, you might think I'm real vain for saying the following! Nonetheless, here you go. The ultimate record to break: Richard Mathar and Richard Crandall both wrote 1 scholarly article that talks about the MRB constant to a good extent. Can you break that record and publish a full article or two about the MRB constant? (You might have to come up with some new ideas.) Mathar's and Crandall's papers can be found on Google Scholar: https://scholar.google.com/scholar?q=%22MRB+constant%22 Steven R Finch, Eric W.Weisstein,and i have written some about it in other genres.
3 years ago
 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.
3 years ago
 Daniel Lichtblau, Which one do you not understand? how he derived the eta' formula: from ?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 to a method for I think the code in that loop could help prove the derivation.
3 years ago
 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..
3 years ago
 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:
3 years ago
 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, MRBtest3I'm just excited that I figured it out! as you can tell.
3 years ago
 Nice work. Worth a bit of excitement, I' d say.
3 years ago
 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...recSent from my iPhone."
3 years ago
 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  Answer 3 years ago  How about computing the MRB constant from Crandall's eta derivative formulas? They are mentioned in a previous post but here they are again: 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\ 41219342016438600025850842655643500695483283012054619321661.\ 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] 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} 
3 years ago
 OOPS! I did believe for a little while that I figured out how to rapidly compute AND CHECK a computation of the MRB constant! but it wasn't quite a good check! (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 identity ,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.)I at least did hope that I did more than to only show == , but I'm afraid I didn't! 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:
3 years ago
 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.
3 years ago
 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= 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 I wonder why he chose it?
3 years ago
 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.
3 years ago
 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 
3 years ago
 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= 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=,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}] 
3 years ago

## Update Mar 13, 2018

In celebration of 72600 views, this reply moved to what is presently the bottom of the Que. It contains many updates and will gain even more.

3 years ago
 Going back to the Crandall equations for the MRB constant: In particular, this time we will work on equation 44, which should have a negative sign in front.The naive approach is about as good as any other, so far:: Clear[a, c]; eta[s_] := (1 - 2^(1 - s)) Zeta[s]; a[i_] := Derivative[i][eta][0]; c[j_] := Sum[Binomial[j, d]*(-1)^d*d^(j - d), {d, 1, j}]; -N[Sum[c[m]/m!*a[m], {m, 1, 40}], 6] giving, after some warning, 0.187859 Nonetheless, I found a shortcut for computing the m'th derivatives of the eta function( with an argument of 0). For an example below you can replace 70 with any other n>3. Timing[Derivative[70][DirichletEta][0]]] can be computed in a lot less time by a = EulerGamma^2/2 - Pi^2/24 - (1/2)*(Log[2] + Log[Pi])^2 + StieltjesGamma[1]; b = EulerGamma^3 + (3/2)*EulerGamma^2*Log[2*Pi] - (1/8)*Pi^2* Log[2*Pi] - (1/2)*Log[2*Pi]^3 + 3*EulerGamma*StieltjesGamma[1] + 3*Log[2*Pi]*StieltjesGamma[1] + (3*StieltjesGamma[2])/2 - Zeta[3]; Timing[((-1)^n*Log[2]^n + (-1)^(n + 1)*n*Log[2]^(n - 1)* Log[2*Pi] + (-1)^(n + 1)*n*(n - 1)*Log[2]^(n - 2)*a) + (-1)^n*2*Binomial[n, 3]*Log[2]^(n - 3)* b - (Derivative[n][Zeta][0] + Sum[(-1)^x*2* Binomial[n, x]*(Derivative[n - x][Zeta][0]*Log[2]^x), {x, 1, n - 4}]) /. n -> 70] . That shortcut leads to the following raw program to compute the MRB constant. (Unfortunately, it is severely limited in its precision due to Mathematica's refusal to give high precision results for zeta derivatives of order >3 with argument of 0. For example try N[Derivative[4][Zeta][0], 40] ).Be careful reading the program. (There is a dot product in it. And it could use a lot of cleanup!) a = EulerGamma^2/2 - Pi^2/24 - (1/2)*(Log[2] + Log[Pi])^2 + StieltjesGamma[1]; b = EulerGamma^3 + (3/2)*EulerGamma^2*Log[2*Pi] - (1/8)*Pi^2* Log[2*Pi] - (1/2)*Log[2*Pi]^3 + 3*EulerGamma*StieltjesGamma[1] + 3*Log[2*Pi]*StieltjesGamma[1] + (3*StieltjesGamma[2])/2 - Zeta[3]; -N[With[{prec = 40}, (c = CoefficientList[Series[Exp[(-x)*Exp[x]], {x, 0, prec}], x])[[2 ;; 4]] . Table[Derivative[n][DirichletEta][0], {n, 1, 3}] + c[[5 ;; prec]] . Table[((-1)^n*Log[2]^n + (-1)^(n + 1)*n*Log[2]^(n - 1)* Log[2*Pi] + (-1)^(n + 1)*n*(n - 1)*Log[2]^(n - 2)*a) + (-1)^ n*2*Binomial[n, 3]*Log[2]^(n - 3)*b - (N[Derivative[n][Zeta][0], prec] + Sum[(-1)^x*2* Binomial[n, x]*(N[Derivative[n - x][Zeta][0], prec]*Log[2]^x), {x, 1, n - 4}]), {n, 4, prec - 1}]], 40] Does anyone care to work on this?The zeta derivatives of order n with argument of 0 do have exact forms not involving the zeta function.(I just haven't figured out the pattern to them.) For examples, Derivative[6][Zeta][0] is the same as Limit[D[2 (2 Pi)^(s - 1) Sin[Pi*s/2] Gamma[1 - s] Zeta[1 - s], {s, 6}], s -> 0] which gives the following that doesn't use zeta. (1/2688)*(6720*EulerGamma^6 + 5040*EulerGamma^4*Pi^2 + 1596*EulerGamma^2*Pi^4 - 275*Pi^6 + 32256*EulerGamma^5*Log[2*Pi] + 13440*EulerGamma^3*Pi^2*Log[2*Pi] + 60480*EulerGamma^4*Log[2*Pi]^2 + 10080*EulerGamma^2*Pi^2*Log[2*Pi]^2 - 1596*Pi^4*Log[2*Pi]^2 + 53760*EulerGamma^3*Log[2*Pi]^3 + 20160*EulerGamma^2*Log[2*Pi]^4 - 1680*Pi^2*Log[2*Pi]^4 - 1344*Log[2*Pi]^6 - 53760*EulerGamma^3*PolyGamma[2, 1] - 80640*EulerGamma^2*Log[2*Pi]*PolyGamma[2, 1] + 6720*Pi^2*Log[2*Pi]*PolyGamma[2, 1] + 26880*Log[2*Pi]^3*PolyGamma[2, 1] - 13440*PolyGamma[2, 1]^2 + 8064*Log[2*Pi]*PolyGamma[4, 1] + 40320*EulerGamma^4*StieltjesGamma[1] + 20160*EulerGamma^2*Pi^2*StieltjesGamma[1] + 3192*Pi^4*StieltjesGamma[1] + 161280*EulerGamma^3*Log[2*Pi]*StieltjesGamma[1] + 40320*EulerGamma*Pi^2*Log[2*Pi]*StieltjesGamma[1] + 241920*EulerGamma^2*Log[2*Pi]^2*StieltjesGamma[1] + 20160*Pi^2*Log[2*Pi]^2*StieltjesGamma[1] + 161280*EulerGamma*Log[2*Pi]^3*StieltjesGamma[1] + 40320*Log[2*Pi]^4*StieltjesGamma[1] - 161280*EulerGamma*PolyGamma[2, 1]*StieltjesGamma[1] - 161280*Log[2*Pi]*PolyGamma[2, 1]* StieltjesGamma[1] + 80640*EulerGamma^3*StieltjesGamma[2] + 20160*EulerGamma*Pi^2*StieltjesGamma[2] + 241920*EulerGamma^2*Log[2*Pi]*StieltjesGamma[2] + 20160*Pi^2*Log[2*Pi]*StieltjesGamma[2] + 241920*EulerGamma*Log[2*Pi]^2*StieltjesGamma[2] + 80640*Log[2*Pi]^3*StieltjesGamma[2] - 80640*PolyGamma[2, 1]*StieltjesGamma[2] + 80640*EulerGamma^2*StieltjesGamma[3] + 6720*Pi^2*StieltjesGamma[3] + 161280*EulerGamma*Log[2*Pi]*StieltjesGamma[3] + 80640*Log[2*Pi]^2*StieltjesGamma[3] + 40320*EulerGamma*StieltjesGamma[4] + 40320*Log[2*Pi]*StieltjesGamma[4] + 8064*StieltjesGamma[5]) In traditional form that result isEven Derivative[8][Zeta][0] is the same as Limit[D[2 (2 Pi)^(s - 1) Sin[Pi*s/2] Gamma[1 - s] Zeta[1 - s], {s, 8}], s -> 0] gives -(Pi^8/4608) + (1/6)* ... (an exact form not involving zeta). Derivative[n][Zeta][0] is approximately -n!Try In[656]:= ss = Table[N[Limit[ D[2 (2 Pi)^(s - 1) Sin[Pi*s/2] Gamma[1 - s] Zeta[1 - s], {s, n}], s -> 0] + n!, 20], {n, 1, 9}] Out[656]= {0.081061466795327258220, -0.0063564559085848512101, \ -0.0047111668622544477611, 0.0028968119862920410128, \ -0.00023290755845472453599, -0.00093682513005092950428, \ 0.00084982376500166915171, -0.00023243173551155958286, \ -0.00033058966361229644526}, so we can switch them in our ugly program to compute the MRB constant and get a rapidly converging rough approximation as follows. a = EulerGamma^2/2 - Pi^2/24 - (1/2)*(Log[2] + Log[Pi])^2 + StieltjesGamma[1]; b = EulerGamma^3 + (3/2)*EulerGamma^2*Log[2*Pi] - (1/8)*Pi^2* Log[2*Pi] - (1/2)*Log[2*Pi]^3 + 3*EulerGamma*StieltjesGamma[1] + 3*Log[2*Pi]*StieltjesGamma[1] + (3*StieltjesGamma[2])/2 - Zeta[3]; -N[With[{prec = 50}, (c = CoefficientList[Series[Exp[(-x)*Exp[x]], {x, 0, prec}], x])[[2 ;; 4]].Table[ Derivative[n][DirichletEta][0], {n, 1, 3}] + c[[5 ;; prec]].Table[((-1)^n*Log[2]^n + (-1)^(n + 1)*n* Log[2]^(n - 1)*Log[2*Pi] + (-1)^(n + 1)*n*(n - 1)* Log[2]^(n - 2)*a) + (-1)^n*2*Binomial[n, 3]*Log[2]^(n - 3)* b - (-n! + Sum[(-1)^x*2*Binomial[n, x]*(-(n - x)!*Log[2]^x), {x, 1, n - 4}]), {n, 4, prec - 1}]], 40] , which unfortunately is off from the true value of the MRB constant by about 0.00112931. Does anyone have suggestions on how to adjust this new program to give a better rapidly converging approximation to the MRB constant? or how to proceed from here?
3 years ago
 Marvin Ray Burns 1 Vote 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 . ;;; 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. Attachments:
3 years ago
 Using the same programs to compute the MRB constant, MMA V10.1 is a little slower than 10.0.0.Here is a sample of such programs: (*Fastest (at MRB's end) as of 24 Dec 2014.*) prec = 10000;(*Number of required decimals.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 12, 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];]; MRBtest2 I'm in the process of tweaking that program to perform better in V 10.1.I tweaked the program a little. I computed 301493 digits in 31266 seconds, or 8 hours 41 minutes 6 seconds. (See attachment.) It's pretty hard to tweak without loosing accuracy!!!Some other 10.1 records: digits seconds 10,000 9.7 20,000 44 30,000 119 40,000 228 50,193 360 100,493 2573 301,493 31266  Attachments:
3 years ago
 MKB constant calculations have been moved to their own discussion at http://community.wolfram.com/groups/-/m/t/1323951?ppauth=W3TxvEwH .
3 years ago

## Update Mar 13, 2018

In celebration of 72600 views, this reply moved.

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

3 years ago
 MKB constant calculations have been moved to their own discussion at http://community.wolfram.com/groups/-/m/t/1323951?ppauth=W3TxvEwH .Attachments are still here, though. Attachments:
3 years ago

## These few erased messages dealt with the integral analog of the MRB constant. .

MKB constant calculations have been moved to their own discussion at

Attachments:
3 years ago

## These few erased messages dealt with the integral analog of the MRB constant. .

MKB constant calculations have been moved to their own discussion at

Attachments are still here, though.

Attachments:
3 years ago

## These few erased messages dealt with the integral analog of the MRB constant. .

They are moved to the present bottom of the post. Attachments are still here, though..

Attachments:
3 years ago

## These few erased messages dealt with the integral analog of the MRB constant. .

They are moved to the present bottom of the post.

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

## Update Mar 13, 2018

In celebration of 72600 views, this reply moved to what is presently the bottom of the Que. It contains many updates and will gain even more.

3 years ago

## Update Mar 13, 2018

In celebration of 72600 views, this reply moved to what is presently the bottom of the Que. It contains many updates and will gain even more.

3 years ago

## These few erased messages dealt with the integral analog of the MRB constant. .

MKB constant calculations have been moved to their own discussion at

2 years ago
 I am waiting for an improvement in Mathematica to try to break any new records, especially because the goal of 4,000,000 digits of the MRB constant requires, in the neighborhood of, 3 months worth of computing time with the best version so far! Also, I thought I would take advantage of this opportunity to introduce this discussion to any new members, that they too may learn or be encouraged by its voluminous replies, as manifold experienced members have -- and a few have added to it-- contributing to its success. Thank you all!In this post we have listed record calculations of the MRB constant (MRB) and its integral analog (MKB); found new formulas for computing each (many, many formulas for computing MKB with each more complicated and powerful that the previous like ); looked at records using only special formulas for MRB; and looked at a few related constants, like the infinite power tower of MRB. I haven't decided whether to start a new post when I try my next record, or not; if i decide to start a new one I will post a link to it here. Please feel free to continue to use this post for your contributions or questions!
2 years ago
 I've been working on Crandall's code for many digits of the MRB constant. On my big computer Windows 10 is just a little slower than Windows 7 was. This new code runs on Windows 10 at the same speed the my last mention in this blog program did in Windows 7.Here it is in input form: Quiet[prec = 30000; 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 = (1/2)*(3 + 2*Sqrt[2])^n*(1 + (3 + 2*Sqrt[2])^ (-2*n)); {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[ll^(1/ll), iprec]; pc = iprec; While[pc < pr, pc = Min[3*pc, pr]; x = SetPrecision[x, pc]; y = x^ll - ll; x = x - (2*x*y)/(y + ll*(2*ll + y))]; 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^2 - n^2))/ (1 + 3*ll + 2*ll^2); 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]; ]; MRBtest2] Also, here is my new fastest program for calculating digits of the MRB constant via the eta formula, This program is nearly twice as fast as the one in I gave "best eta timings" for, above.. prec = 1500; to = SessionTime[]; etaMM[m_, pr_] := Module[{a, d, s, k, b, c}, a[j_] := N[(Log[j + 1]/(j + 1))^m, pr]; n = Floor[132 /100 pr]; d = N[(1/2)*(3 + 2*Sqrt[2])^n*(1 + (3 + 2*Sqrt[2])^(-2*n)), prec]; {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]; MRBtest = eta1 - ParallelSum[(Cos[Pi m]) etaMM[m, prec]/ N[Gamma[m + 1], prec], {m, 2, Floor[.40 prec]}]; Print[MRBtest]; SessionTime[] - to gives (* During evaluation of In[188]:= 0.18785964246206712024851793405427323005590309490013878617200468408947723156466021370329665443310749690384234585625801906123137009475922663043892934889618412083733662608161360273812637937343528321255276396217148932170207628206217151671540841268044836354167199851976802527598938993914457983505561350964852107120784442309586812949768852694956420425558648367044104252795247106066609263397483410311578167864166891546003422225883800254553968929471142122189105098328712277308020036445215390536395055332203470627551159812828039510219264914673176293516190659816018664245824950697203381992958420935515162514399357600764593291281451709082424915883204169066409334435914806705564692806787007028115009380606938139385953360657987405562062348704329360737819564603104763950664893061360645528067515193508280837376719296866398103094949637496277383049846324563479311575300289212523291816195626973697074865765476071178017195787368300965902260668753656305516567361288150201438756136686552210674305370591039735756191489093690777983203551193362404637253494105428363699717024418551654837279358822008134480961058802030647819619596953756287834812334976385863010140727252923014723333362509185840248037040488819676767601198581116791693527968520441600270861372286889451015102919988536905728659287086875425492533794395347589703563313440382638887986656195980733514739902565778133172261076127975852722742777308985774922305970962572562718836755752978879253616876739403543214513627725492293131262764357321446216187786377154205423128223 Out[192]= 105.7159526*) 
2 years ago
 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 get2989/42 ~=72,
1 year ago

# Reply starts with UPDATE on 8/13/2017 below.

Search 8/13/2017 below for where this reply was placed.

11 months ago
 On a recent post, I derived a bunch of approximations of the MRB constant.It was MRB constant approximations using TranscendentalRecognize -- http://community.wolfram.com/groups/-/m/t/819837?p_p_auth=m7XRds7k.Some of the last ones consist of arbitrary approximations to any n digits, while still using small coefficients, compared with the thousand of digits of the target. I wonder if anyone could show me how to extract the coefficient like terms which come before the summations, in a list like this:So someone could find a closed form consisting of those coefficient like terms
2 years ago

## Repeated on top of first message

When it comes to mine and a few more educated people's passion to calculate many digits and the dislike of a few more educated people; it is all a matter telling us that the human mind is multi faceted in giving passion, to person a, for one task and to person b for another task!

2 years ago
 My plan in the previous was to find a numeric list to dot product(.) a set of sums that equal the MRB constant, list or at least gave an improvable result. In the postI have made several numeric list and sums that are inner products, but I haven't found any good pattern to the numeric lists!Below is a sample of what I want to investigating with just a sample value for a, b , c..So from  m = NSum[(-1)^n*(n^(1/n) - 1), {n, 1, Infinity},Method -> "AlternatingSigns", WorkingPrecision -> 1000] N[m - (-129858773922357615372945307143544254 - 332618118135196201861563173048187520*3^(1/5) + 360989141074787715535168098417020609*2^(2/5)*3^(1/5))/ 261711912538111957032871243762602971, 200] Out[116]= 0.*10^-99 you could have In[112]:= a = {-129858773922357615372945307143544254, 332618118135196201861563173048187520, 360989141074787715535168098417020609}; In[113]:= b = {1, -3^(1/5), 2^(2/5) 3^(1/5)}; In[114]:= c = 261711912538111957032871243762602971; In[115]:= N[m - (a.b/c), 200] Out[115]= 0.*10^-99 If only there was a formula for the elements of a,b, and c; up to the precision given by TranscendentalRecognize in a polynomial like from,you could derive a,b,c without TranscendentalRecognize getting arbitrary digits of m of the simple formula of a.b/c .
2 years ago
 I just reasoned a great reason to compute the MRB constant!As we saw above at https://web.archive.org/web/20130430193005/http://www.perfscipress.com/papers/UniversalTOC25.pdf , Richard Crandall wrote about Unified algorithms for polylogarithm, L-series, and zeta variants. Since this paper was cited 8 times in its first year (how much longer he lived), I believe this paper is suitable for an introduction to most of what is said in the subject mentioned above. In chapter 7 i.e. "Key fundamental constants." I searched for the meaning of Key fundamental constants, on google and found it referred to different constants, all depending on the subject that uses the constant. So a whole section of that chapter was called The MRB constant. So I wonder does considering the MRB constant to be a "Key fundamental constants." make to calculating of its digits any more interesting? Even if you don't want to use all of the computer power to break a record here, If anyone can find a faster algorithm that I could use, that would bee terrific!
2 years ago
 I think this article might be starting a second life for,since the efficient analysis of equation 44 is missing:http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.695.5959&rep=rep1&type=pdf <- New occasionally working reference, so subject not dead! This reference, on my site, is up a little more: http://www.marvinrayburns.com/UniversalTOC25.pdf .We touched formula 44 but didn't dig out any of the good stuff that Crandall believed to be in it!Here B is the MRB constant. Plus Crandall acknowledged that there should be a negative sign before first summation.
2 years ago
 MKB constant calculations have been moved to their own discussion at http://community.wolfram.com/groups/-/m/t/1323951?ppauth=W3TxvEwH .
2 years ago
 MKB constant calculations have been moved to their own discussion at http://community.wolfram.com/groups/-/m/t/1323951?ppauth=W3TxvEwH .
1 year ago
 I have two versions of MRB constant code that I presently use, a short one (non-parallel) and a long one. Both are given below.Short (*Newer loop with Newton interior.*)prec = 5000;(*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] Long  (**Fastest (at MRB's end) as of 25 Jul 2014*.*)DateString[] prec = 7000; (**Number of required decimals.*.*)ClearSystemCache[]; T0 = SessionTime[]; expM[pre_] := Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 12, 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 = 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" -> 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];]; DateString[] Print[MRBtest2] MRBtest2 - MRBtest3 
1 year ago
 Try to beat these MRB constant records!
1 year ago

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

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.

## 

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}]]


.

## 

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.9189385332046727417803297364056176398610., \
-2.006356455908584851210100026729960438210.,
-6.004711166862254447810., 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

1 year ago
 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^-9Changing s to 200 shows all correct digits:200 terms give 0.187859642465, and the error is -3.*10^-12 Answer 1 year ago  I noticed that accuracy is not directly related to the number of terms used in the programs of Crandall's formula (44).I made a slight improvement in my program that computes Crandall's eta derivative of 0 formula (44):First compute a known value of the MRB constant:  m = NSum[(-1)^n (n^(1/n) - 1), {n, 1, Infinity}, Method -> "AlternatingSigns", WorkingPrecision -> 120]; followed by  Block[{$MaxExtraPrecision = 1000}, s = 129(*number of terms*); sc[t_] := StieltjesGamma[ t];(*-Pi/(2 n+2) NIntegrate[Log[1/2+I x]^(n+1)/Cosh[Pi \ x]^2,{x,-Infinity,Infinity},WorkingPrecision\[Rule]50];*) zeta0[p_] := N[(-1)^p Sum[sc[p + k]/k!, {k, 0, Infinity}] - p!, 3/2 s]; c[1] = Log[2]; c[n_] := N[1 - 2*zeta0[n - 1], 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] producing129 terms give 0.187859642466672738539355017, and the error is -4.605618290837083*10^-12.
1 year ago

# UPDATE on 8/13/2017

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

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 5000 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.

11 months ago

## Update Feb 12, 2018

In celebration of 72000 views, this reply moved to what is presently the bottom of the Que. It contains many updates and will gain even more.

8 months ago

## Update Mar 13, 2018

In celebration of 72600 views, this reply moved to what is presently the bottom of the Que. It contains many updates and will gain even more.

7 months ago

## December ‎08, ‎2017

I just calculated 100,500 digits of the MRB constant in 2,359 seconds and a processor time (from the Timing[] command) of 1,196 seconds in V11.2. Here is a copy of an email from the late Richard Crandall showing his best timing for 100,000 digits (3600 s) using V9.0.0:

Re: 100,000 digits Richard Crandall crandall@reed.edu 11/30/12 at 11:00 PM To Marvin Burns Message body Something is really awry... On my humble Mac Book (2.2 GHz, Intel Core i7, 4 GB RAM) the attached program---my best so far takes 3600 seconds. That's right, 100K digitsw in one hour.

What timing do you get for the attached? (If you again get like 8000 seconds, tell me what kind of RAM etc. you have...)

-r

(* Fastest (at RC's end) as of 30 Nov 2012. *)

prec = 100000; (* 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

(*===============*)


On Nov 30, 2012, at 5:29 PM, Marvin Burns wrote:

On my 6 core AMD: 8511 seconds Error: 1.83506*10^-101989

----- Forwarded Message ---- From: Marvin Burns marvin@marvinrayburns.com To: Richard Crandall crandall@reed.edu Sent: Fri, November 30, 2012 6:09:09 PM Subject: Re: 100,000 digits

It took 8777 seconds. I have my laptop set not to go to sleep.

Error:1.83506*10^-101989.


I will try it on my 6 core AMD. From: Richard Crandall crandall@reed.edu To: Marvin Burns marvin@marvinrayburns.com Sent: Fri, November 30, 2012 2:49:26 AM Subject: Re: 100,000 digits

You report 8500 seconds on your 100K-digit run. Can you please try this version, to see how long it takes? (The output format is different, but it should have the same 100K-digit accuracy...

-r

PS. This has parallism but of a different style that might work well on your machine...

<MRB100Ktest[6 core AMD].nb>

My AMD 6 core was actually a 3 X dual core from 2010. Mathematica only saw and used 3 cores. I think it only has DDR2 RAM. I just got it back from my ex-wife and it is as slow as it ever was, but it still runs!

I would like to beat Crandall's million+ digit run. But I won't be able to right away. I am computing a fresh million+ digits using V 11.2, but it will take about 5 days vs. Crandall's 3.18 days. At least that's better than my first run which took 7.9 days and was started on ‎Tuesday, ‎January ‎22, ‎2013, ‏‎6:53:42 PM. It is attached as "1M." I used a Dec 2012 custom made Extreme Edition true 6 X dual core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz 3.20 GHz and V9.0.

## EDIT

1004993 digits finished in 496,777.. sec or 5.7 days! Processor time was 188,939 sec or 2.18679 days. I used the same Dec 2012 custom made Extreme Edition true 6 X dual core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz 3.20 GHz and V9.0. See attached 1M2017.

Here is the code and results:

(*Fastest (at MRB's end) as of 06 Jan 2013.*)
prec = 1000000;(*Number of required decimals.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] :=
Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 6,
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 = 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 -> "CoarsestGrained"]];
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 -> "CoarsestGrained"];
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


Iterations required: 1326598

end 1728

1327104

done iter 0 242.4565419

done iter 768 497.7741675

done iter 1536 756.1617379

done iter 2304 1011.7153119

done iter 3072 1272.6273355

...

done iter 1324800 496209.7830825

done iter 1325568 496492.1827471

done iter 1326336 496777.0044999

0.187859642462067...

Attachments:
6 months ago

## Sep 04, 2015

I think I've reached an impasse in calculating more digits of the integral analog of the MRB constant. So I believe my best bet in setting a new record is to compute 4,000,000 digits of the MRB constant proper!

Here is the data of my previous records on my big computer, the six core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz 3.20 GHz with 64 GB of RAM.

(Digits are rounded down, slightly.)

1.2 million in 120,360 seconds

2 million 1,870,579 second

3 million 4,15,7400 seconds

Remarkably they are very linear; so using the Fit command as shown next,

Fit[data, {1, x}, x]


I get

y, in seconds, = -2.5894022213114775*10^6 + 2.2446041393442626 x.

Substituting 4,000,000 for x gives 6,389,014;seconds or almost 2 and a half months. (I would round that to 3 months to be safe!)

Before I start, I will listen to your suggestions, or encouragement; if you have any, (I do get lonely when I don't get any feedback.)

EDIT:

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!)

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

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

## UPDATE

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

## 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.

## Jan 02, 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 . It seems that my system needs someone to visit every other day. Otherwise it falls into a sleep that requires a restart. Does that make any sense? I have the settings for it to never sleep.

## Jan 07, 2018

I always remote into my big computer with my laptop and the big computer was registering "offline." I thought it had gone to sleep because I couldn't remote on to it. It wasn't asleep!

I hooked up a working monitor to it and found it only needed to be logged on to. So, that is another lesson for me!

With that learned I'm trying the 4 million digit again. I'll post some stats soon.

## 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.

Entering "Sun 7 Jan 2018 15:14:50 EST+103 days" into Wolfram Alpha tells us the computation should be done around 3:14:50 pm EST | Friday, April 20, 2018. That is 101 days from now.

## Jan 17, 2018, 10:00 pm

Here is the latest output: done iter 531456 888255.5435780.

N[531456/5306880*100] says the computation is 1/10th of the way done!!!

## Jan 20, 2018, 5:39 am

Here is the latest output: done iter 654336 1.0955238835298*10^6.

Then

  (1.0955238835298*10^6 sec) /(654336 iterations) (5306880 iterations)/(3600 sec/hour)/(24 hour/day)


gives 102.836 day.

Entering "Sun 7 Jan 2018 15:14:50 EST+102.836 days" into Wolfram Alpha tells us the computation should be done around "11:18:40 pm EST | Friday, April 20, 2018". That is 90.14 days from now.

## Feb 04, 2018,8:04 am

Here is the latest output: done iter done iter done iter 1420800 2.3920453426489*10^6.

Then

  (2.3920453426489*10^6 sec) /(1420800 iterations) (5306880iterations)/(3600 sec/hour)/(24 hour/day)


gives 103.41 day.

Entering "7 Jan 2018 15:14:50 EST+103.41 days" into Wolfram Alpha tells us the computation should be done around "1:05:14 am EST | Saturday, April 21, 2018". That is 75.71 days from now.

## Feb 11, 2018, 8:13 am

Here is the latest output: done iter 1778688 2.9979034719762*10^6.

N[1778688/5306880*100] says the computation is more than 1/3 done!!!

## Feb 16, 2018,8:20 am

Here is the latest output: done iter 2032128 3.4292035877594*10^6.

Then

 (3.4292035877594*10^6 sec) /(2032128 iterations) (5306880 iterations)/(3600 sec/hour)/(24 hour/day)


gives 103.65 day

Entering "7 Jan 2018 15:14:50 EST+103.65 days" into Wolfram Alpha tells us the computation should be done around "6:50:50 am EST | Saturday, April 21, 2018". That is 63.94 days from now.

## Feb 20, 2018, 5:06 am

Here is the latest output: done iter 2228736 3.7632326187330*10^6.

N[2228736/5306880*100] says the computation is 42% done.

## Feb 24, 2018, 11:10 am

Here is the latest output: done iter 2443776 4.1295732917069*10^6.

Then

(4.1295732917069*10^6 sec) /(2443776 iterations) (5306880 iterations)/(3600 sec/hour)/(24 hour/day) gives 103.793 day.

Entering "7 Jan 2018 15:14:50 EST+103.793 days" into Wolfram Alpha tells us the computation should be done around "10:16:45 am EST | Saturday, April 21, 2018".

That is 55.97 days from now.

## Feb 28, 2018, 1:00 pm

Here is the latest output: done iter 2651136 4.4847945582592*10^6.

N[2651136/5306880*100] says the computation is 1/2 done.

## Mar 04, 2018, 8:00 am

Here is the latest output: done iter 2843136 4.8117075999279*10^6.

Then

(4.8117075999279*10^6 sec) /(2843136 iterations) (5306880 iterations)/(3600 sec/hour)/(24 hour/day)


gives 103.951 day.

Entering "7 Jan 2018 15:14:50 EST+103.951 days" into Wolfram Alpha tells us the computation should be done around "2:04:16 pm EST | Saturday, April 21, 2018". That is 48.26 days from now.

## Mar 08, 2018, 9:49 am

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

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

4 months ago
 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!
3 months ago
 MKB constant calculations have been moved to their own discussion at http://community.wolfram.com/groups/-/m/t/1323951?ppauth=W3TxvEwH . Attachments:
3 months ago

## Sat 24 Mar 2018

Well, I installed my new 8 core Zeon processor, a Intel Xeon E5-2687W v2, to replace my six core Intel(R) Core(TM) i7-3930K. Here are some comparison timings in computing the MRB constant. (The digits produced and algorithms used are exactly the same for both processors.)

Only difference is 11.3 kernel was used by the Zeon and 11.2 kernel by the Intel

.

.

At 22% complete the Zeon is 22.4% faster on the 1,004,992 digit run than the i7..

At 44% complete the Zeon is 22.7% faster on the 1,004,992 digit run than the i7.

At 66% complete the Zeon is 23.0% faster on the 1,004,992 digit run than the i7.

At 88% complete the Zeon is 22.6% faster on the 1,004,992 digit run than the i7.

Using my 6 core processor Intel Extreme edition, the computer went to sleep after unpredictably long times. I wonder if that was a problem from the processor instead of Windows 10? After I get the timing for the 8 core Zeon's 1,004,992 digits, I might go back to calculating 4,000,000+ digits. I tried breaking the 4,000,000 digits computation into small parts, but there is no way that I see to time the total computation. (And it would take significantly longer!) So you just might get to watch me count down to a new record attempt. I hope that don't get old!

## 8:59:25 am EDT | Sunday, April 8, 2018

The 1,004,992 digit run should finish sometime in the narrow window of 7:22 pm and 7:29 pm, Monday, April 9, 2018. I say that because, seeing that the computation is slowing down by 14.4 minutes/ day and the results from the program says the computation will take approximately 4.39522 days in total. It stared 255566.2941093 seconds before giving the total of days. Entering " 255570 seconds ago + 4.39 days " into Wolfram Alpha gives 7:07:58 pm EDT | Monday, April 9, 2018.

## 5:04 pm EDT | Sunday, April 8, 2018

The 1,004,992 digit run definitely should finish sometime in the narrow window of 8:50 pm and 9:00 pm, Monday, April 9, 2018. I say that because the program says the computation will take approximately 4.46343 days in total. It stared 371499.3390441 seconds before giving the total of days. Entering " 371600 seconds ago + 4.46 days " into Wolfram Alpha gives 8:52:16 pm EDT | Monday, April 9, 2018.

The computation finished, gave 1,004,999 correct digits, and the timing is in the following table. The processor time was a lightning fast 191,412 seconds (53.17 hours).

2 months ago

## Mon 9 Apr 2018

The next 4000000+ digit run will have an output in the following format.

 Start time is Mon 9 Apr 2018 20:14:00.

Iterations required: 26530

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

Will stop at 28672 iterations to ensure precsion of around 20099 decimal places.

0 iterations done in 11.3141845 seconds. Should complete on Tue 23 May 2113 04:46:27.

4096 iterations done in 23.3131819 seconds. Should complete on Mon 9 Apr 2018 20:16:31.

8192 iterations done in 35.4301759 seconds. Should complete on Mon 9 Apr 2018 20:15:54.

12288 iterations done in 47.8206730 seconds. Should complete on Mon 9 Apr 2018 20:15:43.

16384 iterations done in 60.4314836 seconds. Should complete on Mon 9 Apr 2018 20:15:37.

20480 iterations done in 73.1805789 seconds. Should complete on Mon 9 Apr 2018 20:15:34.

24576 iterations done in 85.9045514 seconds. Should complete on Mon 9 Apr 2018 20:15:32.

Finished on Mon 9 Apr 2018 20:15:26.

2 months ago

## Wed 11 Apr 2018

Attached is my new notebook for calculating and checking digits of the MRB constant. Follow instructions, and if you have any questions, please ask me!

Here is a sample of it:

Clear[m3M]

Clear[m3M];

(*You may evaluate the next cell for over 3 million digits to check \
results with.
If you delete it, you can get the digits back by clicking this cell,
removing the quotes, and then evaluate the \
command*)Import["http://marvinrayburns.com/3M.txt"]

Print["Start time is ", ds = DateString[], "."];
prec = 20000;
(**Number of required decimals.*.*)ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] :=
Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 32,
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" -> 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;
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]]

Start time is Wed 11 Apr 2018 14:25:43.

Iterations required: 26530

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

Will stop at 28672 iterations to ensure precsion of around 20099 decimal places.

4096 iterations done in 25.4 seconds. Should take 0.0019 days or 1.6*10^2s, finish Wed 11 Apr 2018 14:28:27.

8192 iterations done in 39.1 seconds. Should take 0.0015 days or 1.3*10^2s, finish Wed 11 Apr 2018 14:27:49.

12288 iterations done in 54.9 seconds. Should take 0.0014 days or 1.2*10^2s, finish Wed 11 Apr 2018 14:27:41.

16384 iterations done in 69.8 seconds. Should take 0.0013 days or 1.1*10^2s, finish Wed 11 Apr 2018 14:27:36.

20480 iterations done in 84.0 seconds. Should take 0.0013 days or 1.1*10^2s, finish Wed 11 Apr 2018 14:27:31.

24576 iterations done in 97.9 seconds. Should take 0.0012 days or 1.1*10^2s, finish Wed 11 Apr 2018 14:27:28.

Finished on Wed 11 Apr 2018 14:27:21. Proccessor time was 51.2188 s.

Enter MRBtest2 to print 20093 digits

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

Attachments:
2 months ago

## Monday, April 16, 2018

Using V. 11.2 kernel, and my new processor, early estimates say 4019999 decimal places would take only 98 days: That's almost a week quicker than the i7!

Here is the result from the i7 at the same level of completion:

     "done iter ", 49152,  84220.2211678

In[6]:= (84220.2211678) sec/( 49152  iterations) (5306880 iterations)/(3600 sec/hour)/(24 hour/ day)

Out[6]= 105.245 day

In[7]:= 105 - 98

Out[7]= 7


Later estimates showed that the i7 would finish in only 100 days total. So take another 5 days off the new processor's time, to get only "93 days" for a probable later estimate of completion time.

I'm not going to complete it, but this will be a good reference to judge a future computation, in some new version, by.

2 months ago
 l van Veen 1 Vote nice system!
2 months ago
 This reply was an ongoing computation. I moved it closer to the bottom.
2 months ago

## Tue 24 Apr 2018

Here are some timings from a new computer and version 11.3 non kernel version for 4 core and kernel for 8 core, as they seem to have best results that way:

2 months ago

## 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:

The hybrid program:

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 = 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" ->
8(*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]]


Attached is the notebook, M. R. Burns interior.nb, used for the 100K and the first 300K runs, the notebook used for a second 350 K run with the same timing,.and the one (in progress) of the million digit run. I will try to update it daily.

Attachments:
2 months ago

## Sun 6 May 2018

I finally came up with my very own program to calculate digits of the MRB constant which is sometimes faster than Richard Crandall's!!!!

The notebook is attached. Here it is with results of 10,000 digits in 7.5 s and 20,000 digits in 34.0 s:

Print[ "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 =
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]]

Start time is Sun 6 May 2018 08:45:42.

Iterations required: 13202

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

Will stop at 14336 iterations to ensure precsion of around 10002 decimal places.

Denominator computed in  1.1155632s.

2048 iterations done in 1.081 seconds. Should take 0.0001639 days or 14.156946s, finish Sun 6 May 2018 08:45:56.

4096 iterations done in 2.166 seconds. Should take 0.0001224 days or 10.577535s, finish Sun 6 May 2018 08:45:52.

6144 iterations done in 3.277 seconds. Should take 0.0001092 days or 9.438089s, finish Sun 6 May 2018 08:45:51.

8192 iterations done in 4.377 seconds. Should take 0.0001025 days or 8.852246s, finish Sun 6 May 2018 08:45:50.

10240 iterations done in 5.443 seconds. Should take 0.00009787 days or 8.4555849s, finish Sun 6 May 2018 08:45:50.

12288 iterations done in 6.453 seconds. Should take 0.00009412 days or 8.1320232s, finish Sun 6 May 2018 08:45:50.

Finished on Sun 6 May 2018 08:45:50. Processor and total time were 6.46875 and 7.5690275 s respectively.

Enter MRBtest2 to print 9997 digits

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

Print[ "Start time is ", ds = DateString[], "."];
prec = 20000;
(**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 =
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]]

Start time is Sun 6 May 2018 08:47:31.

Iterations required: 26405

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

Will stop at 26624 iterations to ensure precsion of around 20004 decimal places.

Denominator computed in  2.4963526s.

2048 iterations done in 2.541 seconds. Should take 0.0007518 days or 64.951484s, finish Sun 6 May 2018 08:48:35.

4096 iterations done in 5.093 seconds. Should take 0.0005662 days or 48.923174s, finish Sun 6 May 2018 08:48:19.

6144 iterations done in 7.744 seconds. Should take 0.0005094 days or 44.010388s, finish Sun 6 May 2018 08:48:15.

8192 iterations done in 10.26 seconds. Should take 0.0004759 days or 41.118632s, finish Sun 6 May 2018 08:48:12.

10240 iterations done in 12.81 seconds. Should take 0.0004567 days or 39.460971s, finish Sun 6 May 2018 08:48:10.

12288 iterations done in 15.33 seconds. Should take 0.0004434 days or 38.312869s, finish Sun 6 May 2018 08:48:09.

14336 iterations done in 17.99 seconds. Should take 0.0004368 days or 37.741573s, finish Sun 6 May 2018 08:48:08.

16384 iterations done in 20.77 seconds. Should take 0.0004340 days or 37.498549s, finish Sun 6 May 2018 08:48:08.

18432 iterations done in 23.49 seconds. Should take 0.0004309 days or 37.230689s, finish Sun 6 May 2018 08:48:08.

20480 iterations done in 26.12 seconds. Should take 0.0004270 days or 36.8938561s, finish Sun 6 May 2018 08:48:07.

22528 iterations done in 28.75 seconds. Should take 0.0004238 days or 36.6182626s, finish Sun 6 May 2018 08:48:07.

24576 iterations done in 31.48 seconds. Should take 0.0004225 days or 36.5068233s, finish Sun 6 May 2018 08:48:07.

Finished on Sun 6 May 2018 08:48:05. Processor and total time were 28.1563 and 33.9780984 s respectively.

Enter MRBtest2 to print 19998 digits

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


## UPDATE

Having a little trouble with the accuracy of my very own program with 30,000 digits and more. And as I start to fix the accuracy problem my program's benchmarks, vs those of Crandall's, begin to fall. I'm just glad to have gotten my very own program to work as good as it does! I'll probably come back to it later. For now, thinking I will stick with Crandall's program for future records.

My next big step will be adding a matching 2400 MH DDR4 16 GB DIMM to my new quad core's single "Dual Ranked" DIMM . Hopefully that will speed up my timings!

My great goal in those timings was to calculate 7000 accurate digits in 3.6 second or less. I chose 7000 digits because one of my first records set in 2003, mentioned in the first post of this discussion, was to calculate roughly 7000 digits in a 10 hour period.

3.6 seconds represents a 10,000 fold increase in total MRB constant technology:

10 hours*(3600 s/hours)/(3.6 s) = 10,000.

Here is my present timing for around 7,000 accurate digits (2.53 s):

  Mathematica 11.3.0 Kernel for Microsoft Windows (64-bit)

In[1]:= (*Newer loop with Newton interior.*)prec = 5000;(*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 = 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]];

In[2]:=
In[2]:= MRBtest2 = expM[prec]
Iterations required: 6600
Iterations: 0    Cumulative time (sec): 0.0009972
Iterations: 1000    Cumulative time (sec): 0.3650443
Iterations: 2000    Cumulative time (sec): 0.7619830
Iterations: 3000    Cumulative time (sec): 1.1828568
Iterations: 4000    Cumulative time (sec): 1.6226791
Iterations: 5000    Cumulative time (sec): 2.0654949
Iterations: 6000    Cumulative time (sec): 2.5262617


I got my very own program to work to many differing ammounts of digits, finally!

It is now a little slower than Crandall's program, but uses only my 4th order convergence (4 digits per iteration) interior instead of Crandall's 3rd order. Here it is:

Print[ "Start time is ", ds = DateString[], "."];
prec =15000;
ClearSystemCache[];
T0 = SessionTime[];
expM[pre_] :=
Module[{a, d, s, k, bb, c, end, iprec, xvals, x, pc, cores = 16, tsize = 2^7, chunksize, start = 1, ll,
ctab, pr = Floor[7000/6795  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 =
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))];

x, {l, 0, tsize - 1}], {j, 0, cores - 1},
Method ->
"EvaluationsPerKernel" ->
16]];
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];
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."];
MRBtest2; 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 -m7k, 10]]


Use this link to use it on the Wolfram cloud.

https://www.wolframcloud.com/objects/bmmmburns/published/All MRB

Attachments:
1 month ago

## Tue 22 May 2018

I started a 5,000,000 digits calculation on my faster 4 core ASUS Intel Core i7 7700 Desktop computer K31CD-DS71, 32 GB ram DDR4, 2TB SATA in Windows 10 Pro using a version of my Burns-Crandall hybrid code supercharged with 4 iterations of my 4th order convergence subroutine, 4 iterations is exactly what is required to minimize the timing for 5 million digits.(4 iterations will reduce the timing of a 5 million digit computation by 1.84% from 1 iteration, so instead of a probable 120 days, it should take 118 days. Let's see...)

To further substantiate that guess, the overall timing should be approximately 1/2 * the first non "0 iteration" time estimate the program gives, [Edit 5/23/18: which is also 118 days]. (The first time estimate will be in a matter of thousands of years because of dividing by near 0 in ti = (st)/(kc + 10^-4)*(n)/(3600)/(24) where kc is 0.)

For a comparison of recent advances, search for the message that begins with, "I think I've reached an impasse" and see that my original computed completion time for my first 4 million digit try was 106 days! That was on my six core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz 3.20 GHz with 64 GB of RAM. The 4,000,000 digit calculation on my new 8 core Zeon processor, a Intel Xeon E5-2687W v2, system, (an upgrade for the six core),is ongoing; its results are being posted in 2 replies below this one.

Print["Start time is ", ds = DateString[], "."];
prec = 5000000;
(**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/2304];
Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l;
x = N[E^(Log[ll]/(ll)), iprec];

pc = iprec;
While[pc < pr/256, pc = Min[3 pc, pr/256];
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/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},
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);
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 Tue 22 May 2018 01:02:37.

Iterations required: 6632998

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

Will stop at 6633472 iterations to ensure precsion of around 5024999 decimal places.

0 iterations done in 3301. seconds. Should take 2.534*10^9 days or 2.189*10^14s, finish Mon 11 Nov 6939709 17:32:23.

2048 iterations done in 6503. seconds. Should take 243.8 days or 2.106*10^7s, finish Sun 20 Jan 2019 19:11:08.

4096 iterations done in 9721. seconds. Should take 182.2 days or 1.574*10^7s, finish Tue 20 Nov 2018 05:57:47.

6144 iterations done in 1.295*10^4 seconds. Should take 161.8 days or 1.398*10^7s, finish Tue 30 Oct 2018 21:15:01.

8192 iterations done in 1.623*10^4 seconds. Should take 152.1 days or 1.314*10^7s, finish Sun 21 Oct 2018 03:44:45.

10240 iterations done in 1.964*10^4 seconds. Should take 147.3 days or 1.272*10^7s, finish Tue 16 Oct 2018 07:34:30.

12288 iterations done in 2.312*10^4 seconds. Should take 144.4 days or 1.248*10^7s, finish Sat 13 Oct 2018 11:43:37.

14336 iterations done in 2.667*10^4 seconds. Should take 142.8 days or 1.234*10^7s, finish Thu 11 Oct 2018 20:49:04.

16384 iterations done in 2.998*10^4 seconds. Should take 140.5 days or 1.214*10^7s, finish Tue 9 Oct 2018 12:13:43.

18432 iterations done in 3.326*10^4 seconds. Should take 138.5 days or 1.197*10^7s, finish Sun 7 Oct 2018 13:48:39.

To get done in 118 days, the program got off on the wrong foot there. That last output ought to have read something like

18432 iterations done in 3.259*10^4 seconds....

or less.

The slowdown might have something to do with too recent of an upgrade to Widows 10 Pro without a good restart for the purpose of removing clutter!

I gave my computer a restart and am starting the program again. (If that slowdown would have been allowed to continue, no telling how badly it would affect the timing of the final result.

Nonetheless, this 5,000,000 digit run shouldn't be thought of as an attempt at a speed record; its main purpose is to check the 4 million digit calculation with a totally different method of calculating x^(1/x). I will be able to say 4,000,000 digits or more have been calculated and verified! I have a new program to run that will check the 5 million digit run without calculating more digits. (It is just a little slower than the computation program. If anyone wants to run it, just ask!)

## The following results are much more promising of a quick computation:

Start time is Tue 22 May 2018 12:12:05.

Iterations required: 6632998

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

Will stop at 6633472 iterations to ensure precsion of around 5024999 decimal places.

0 iterations done in 3143. seconds. Should take 2.413*10^9 days or 2.085*10^14s, finish Fri 30 Jul 6609143 07:09:38.

2048 iterations done in 6312. seconds. Should take 236.6 days or 2.044*10^7s, finish Mon 14 Jan 2019 02:24:11.

4096 iterations done in 9525. seconds. Should take 178.5 days or 1.542*10^7s, finish Sat 17 Nov 2018 00:48:13.

6144 iterations done in 1.272*10^4 seconds. Should take 158.9 days or 1.373*10^7s, finish Sun 28 Oct 2018 10:48:50.

8192 iterations done in 1.592*10^4 seconds. Should take 149.2 days or 1.289*10^7s, finish Thu 18 Oct 2018 17:50:46.

10240 iterations done in 1.917*10^4 seconds. Should take 143.7 days or 1.242*10^7s, finish Sat 13 Oct 2018 05:31:09.

12288 iterations done in 2.239*10^4 seconds. Should take 139.9 days or 1.209*10^7s, finish Tue 9 Oct 2018 09:17:47.

14336 iterations done in 2.562*10^4 seconds. Should take 137.2 days or 1.185*10^7s, finish Sat 6 Oct 2018 16:59:33.

16384 iterations done in 2.885*10^4 seconds. Should take 135.2 days or 1.168*10^7s, finish Thu 4 Oct 2018 16:46:38.

18432 iterations done in 3.209*10^4 seconds. Should take 133.6 days or 1.155*10^7s, finish Wed 3 Oct 2018 03:47:19.

## ...

94208 iterations done in 1.543*10^5 seconds. Should take 125.7 days or 1.086*10^7s, finish Tue 25 Sep 2018 05:08:31.

96256 iterations done in 1.576*10^5 seconds. Should take 125.7 days or 1.086*10^7s, finish Tue 25 Sep 2018 05:24:27.

98304 iterations done in 1.609*10^5 seconds. Should take 125.7 days or 1.086*10^7s, finish Tue 25 Sep 2018 04:18:10.

## ...

194560 iterations done in 3.179*10^5 seconds. Should take 125.4 days or 1.084*10^7s, finish Mon 24 Sep 2018 22:38:33.

196608 iterations done in 3.212*10^5 seconds. Should take 125.4 days or 1.084*10^7s, finish Mon 24 Sep 2018 22:06:00.

198656 iterations done in 3.245*10^5 seconds. Should take 125.4 days or 1.083*10^7s, finish Mon 24 Sep 2018 21:45:09.

200704 iterations done in 3.278*10^5 seconds. Should take 125.4 days or 1.083*10^7s, finish Mon 24 Sep 2018 21:32:59.

## ...

299008 iterations done in 4.88910^5 seconds. Should take 125.5 days or 1.08510^7s, finish Tue 25 Sep 2018 00:50:29.

301056 iterations done in 4.923*10^5 seconds. Should take 125.5 days or 1.085*10^7s, finish Tue 25 Sep 2018 00:55:32.

303104 iterations done in 4.956*10^5 seconds. Should take 125.5 days or 1.085*10^7s, finish Tue 25 Sep 2018 00:55:45.

305152 iterations done in 4.990*10^5 seconds. Should take 125.5 days or 1.085*10^7s, finish Tue 25 Sep 2018 01:03:55.

307200 iterations done in 5.023*10^5 seconds. Should take 125.5 days or 1.085*10^7s, finish Tue 25 Sep 2018 01:07:30.

## UPDATE

Notice the timing is slowing down! I think the processor might be throttling down.

I fined tuned my very own 4h degree convergence only code so that it is on par with the speed of Crandall's program. I'm going to get a liquid cooler for this fast 4-core -- it was running hot -- and try a different large calculation to check the 4 million digit with, (probably another 4 million using only my 4th degree convergent method).

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:

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 =
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]]


The 4,000,000 digit calculation on my new 8 core Zeon processor, a Intel Xeon E5-2687W v2, system, (an upgrade for the six core Intel Extreme edition),is ongoing; its results are being posted in 2 replies below this one.

1 month ago
 Here are some new speed records on my new computer in seconds compared to old records on my original big computer setup, using Crandall's program on small n in sum(n^(1/n)), (i.e sum(exp(ln(n)/n)) as written in the programs). However, on some larger calculations, I used a hybrid program of my special 4th order convergence interior and Crandall's program, since my interior is faster with large n as explained at https://www.sciencedirect.com/science/article/pii/0898122189900242.Note reads Estimated by 6.03110^522247.1460271/(3.933*10^4): 22247.1460271 was actual time for 300K+ digits, (3.933*10^4) was initial time estimate from program calculating 300K+ digits, 6.03110^522247 was initial time estimate from program calculating 1M+ digits. This formula proven good to over 99.9% accuracy for 50K to 300K computations. Look for the yellow background in notebook!The notebook,showing the new records is attached and the old records are all found in the previous messages. Attachments:
1 month ago

## 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.

8192 iterations done in 1.8010^4 seconds. Should take 1.410^2 days or 1.2*10^7s, finish Mon 27 Aug 2018 16:15:20.

12288 iterations done in 2.4710^4 seconds. Should take 1.210^2 days or 1.1*10^7s, finish Thu 16 Aug 2018 03:46:47.

16384 iterations done in 3.0810^4 seconds. Should take 1.210^2 days or 1.0*10^7s, finish Wed 8 Aug 2018 02:08:08.

20480 iterations done in 3.6910^4 seconds. Should take 1.110^2 days or 9.6*10^6s, finish Fri 3 Aug 2018 03:50:30.

24576 iterations done in 4.2910^4 seconds. Should take 1.110^2 days or 9.3*10^6s, finish Mon 30 Jul 2018 20:51:24.

28672 iterations done in 4.9010^4 seconds. Should take 1.110^2 days or 9.1*10^6s, finish Sat 28 Jul 2018 14:03:36.

32768 iterations done in 5.5110^4 seconds. Should take 1.010^2 days or 8.9*10^6s, finish Thu 26 Jul 2018 20:07:09.

36864 iterations done in 6.1210^4 seconds. Should take 1.010^2 days or 8.8*10^6s, finish Wed 25 Jul 2018 12:32:28.

40960 iterations done in 6.7410^4 seconds. Should take 1.010^2 days or 8.7*10^6s, finish Tue 24 Jul 2018 17:15:36.

45056 iterations done in 7.3610^4 seconds. Should take 1.010^2 days or 8.7*10^6s, finish Mon 23 Jul 2018 21:57:54.

49152 iterations done in 7.9710^4 seconds. Should take 1.010^2 days or 8.6*10^6s, finish Mon 23 Jul 2018 04:10:30.

53248 iterations done in 8.5810^4 seconds. Should take 99. days or 8.610^6s, finish Sun 22 Jul 2018 13:20:21.

57344 iterations done in 9.1910^4 seconds. Should take 98. days or 8.510^6s, finish Sun 22 Jul 2018 00:30:24.

61440 iterations done in 9.8010^4 seconds. Should take 98. days or 8.510^6s, finish Sat 21 Jul 2018 13:59:39.

65536 iterations done in 1.0410^5 seconds. Should take 98. days or 8.410^6s, finish Sat 21 Jul 2018 03:42:28.

69632 iterations done in 1.1010^5 seconds. Should take 97. days or 8.410^6s, finish Fri 20 Jul 2018 21:57:47.

73728 iterations done in 1.1610^5 seconds. Should take 97. days or 8.410^6s, finish Fri 20 Jul 2018 14:10:58.

77824 iterations done in 1.2310^5 seconds. Should take 97. days or 8.410^6s, finish Fri 20 Jul 2018 07:33:59.

81920 iterations done in 1.2910^5 seconds. Should take 96. days or 8.310^6s, finish Fri 20 Jul 2018 01:10:58.

## ...

122880 iterations done in 1.9110^5 seconds. Should take 96. days or 8.310^6s, finish Thu 19 Jul 2018 03:24:24.

126976 iterations done in 1.9710^5 seconds. Should take 95. days or 8.210^6s, finish Thu 19 Jul 2018 00:09:18.

## ...

188416 iterations done in 2.9010^5 seconds. Should take 95. days or 8.210^6s, finish Wed 18 Jul 2018 02:16:18.

192512 iterations done in 2.9610^5 seconds. Should take 94. days or 8.210^6s, finish Wed 18 Jul 2018 01:32:33.

## ...

585728 iterations done in 8.9410^5 seconds. Should take 94. days or 8.110^6s, finish Tue 17 Jul 2018 06:49:08.

589824 iterations done in 9.0010^5 seconds. Should take 94. days or 8.110^6s, finish Tue 17 Jul 2018 06:33:24.

593920 iterations done in 9.0610^5 seconds. Should take 94. days or 8.110^6s, finish Tue 17 Jul 2018 06:19:52.

598016 iterations done in 9.1210^5 seconds. Should take 94. days or 8.110^6s, finish Tue 17 Jul 2018 06:06:05.

602112 iterations done in 9.1810^5 seconds. Should take 94. days or 8.110^6s, finish Tue 17 Jul 2018 05:54:54.

606208 iterations done in 9.2410^5 seconds. Should take 94. days or 8.110^6s, finish Tue 17 Jul 2018 05:40:30.

## ...

839680 iterations done in 1.28*10^6 seconds. Should take 94. days or 8.1*10^6s, finish Tue 17 Jul 2018 02:00:47.

843776 iterations done in 1.28*10^6 seconds. Should take 93. days or 8.1*10^6s, finish Tue 17 Jul 2018 01:56:44.

847872 iterations done in 1.29*10^6 seconds. Should take 93. days or 8.1*10^6s, finish Tue 17 Jul 2018 01:56:47.

## ...

1384448 iterations done in 2.1010^6 seconds. Should take 93. days or 8.010^6s, finish Mon 16 Jul 2018 15:28:02.

1388544 iterations done in 2.10*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 15:26:05.

1392640 iterations done in 2.11*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 15:22:14.

1396736 iterations done in 2.12*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 15:19:43.

1400832 iterations done in 2.12*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 15:17:50.

1404928 iterations done in 2.13*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 15:16:37.

1409024 iterations done in 2.13*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 15:12:43.

1413120 iterations done in 2.14*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 15:10:03.

## ...

1556480 iterations done in 2.3610^6 seconds. Should take 93. days or 8.010^6s, finish Mon 16 Jul 2018 13:02:16.

1560576 iterations done in 2.36*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 13:01:16.

1564672 iterations done in 2.37*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 13:01:54.

1568768 iterations done in 2.37*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 12:58:16.

1572864 iterations done in 2.38*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 12:48:06.

1576960 iterations done in 2.39*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 12:38:19.

1581056 iterations done in 2.39*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 12:29:01.

1585152 iterations done in 2.40*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 12:21:35.

## ...

1961984 iterations done in 2.9710^6 seconds. Should take 93. days or 8.010^6s, finish Mon 16 Jul 2018 12:11:01.

1966080 iterations done in 2.97*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 12:08:47.

1970176 iterations done in 2.98*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 12:07:51.

1974272 iterations done in 2.99*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 12:06:52.

1978368 iterations done in 2.99*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 12:07:06.

1982464 iterations done in 3.00*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 12:06:18.

## ...

2510848 iterations done in 3.7910^6 seconds. Should take 93. days or 8.010^6s, finish Mon 16 Jul 2018 08:37:25.

2514944 iterations done in 3.80*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 08:34:04.

2519040 iterations done in 3.81*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 08:31:27.

## ...

2777088 iterations done in 4.1910^6 seconds. Should take 93. days or 8.010^6s, finish Mon 16 Jul 2018 07:31:16.

2781184 iterations done in 4.20*10^6 seconds. Should take 93. days or 8.0*10^6s, finish Mon 16 Jul 2018 07:28:44.

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

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.

1 month ago

## June 5, 2018

I don't know where the problem is coming from, but the Day I dreamed that the Mathematica quit its kernel in Windows 10, it did just that. I'm trying to get some help in improving my code so Mathematica won't have to run so long. . Wish me luck!

18 days ago

# PREVIOUS UPDATE on 8/13/2017

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

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:

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.

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

## 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:

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.

I posted some about 12 kernels:

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

Which did lead to the following, great results:

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 ."

Attachments: