While preparing for the verifying of 7-million digits, I broke some speed records with two of my i9-14900K
6400MHZRAM (overclocked CPUs), using Mathematica 11.3 and the lightweight grid. They are generally faster than the 3 node MRB constant supercomputer with remote kernels!
Unless noted by the command Timing[], i.;e., the last yellow and the final two blue-highlighted columns in the fourth table, these are all absolute timings. How does your computer compare to these? What can you do with other software?
That light blue highlight, red text columns, which shows processor times result here->7200 corrected timing for 30k and was tweaked in 2025.
For the partial column of two 6000MHz 14900K' with red text and yellow highlight, see speed 100 300 1M XMP tweaked.
For column "=F" (highlighted in green) see linked "10203050100" .
At the bottom, see attached "kernel priority 2 computers.nb" for column =B,
"3 fastest computers together.nb" for column =C
and linked "speed records 5 10 20 30 K"
also speed 50K speed 100k, speed 300k and 30p0683 hour million.nb for column =D .
For the mostly red column including the single, record, 10,114 second 300,000 digit run " =E" is in the linked "3 fastest computers together 2.nb.}
For column "=J," see 574 s 100k , .106.1 sec 50k and 6897s 300k
The 27-hour million-digit computation is found here. <-Big notebook.
As for single-device records are concerned, the fourth table:
The yellow-highlighted column is documented here<-
(with the others already documented above).
On 6/16/2025, I broke the 10,000-digit record with a I=9-14900KS using Mathematica 11.3 Kernel:
In 3.97 s, absolute timing and 3.28 s timing:
On 6/16/2025, I broke the 20,000-digit record with a I=9-14900KS using Mathematica 11.3 Kernel:
In 16.316 s, absolute timing and 13.8594 s timing:
, using the following code:
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,
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 precision 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^2));];
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)/(3 ll t2 + t^3 z));
x, {l, 0, tsize - 1}], {j, 0, cores - 1},
Method -> "EvaluationsPerKernel" -> 32]];
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^-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[MRB = expM[prec];];
Print["Finished on ", DateString[], ". Processor time was ", t2[[1]],
" s."];
(*Print["error= ", N[test – MRB,20]];*)
Print["Enter MRB to print ", Floor[Precision[MRB]], " digits"];
This is another comparison of my fastest computers' timings in
calculating digits of CMRB: 
The blue column (using the Wolfram Lightweight Grid) is documented here.
The i9-12900KS column is documented here.
The i9-13900KS column is documented here.
The 300,000 digits result in the i9-13900KS column is here, where it ends with the following:
Finished on Mon 21 Nov 2022 19:55:52. Processor and actual time
were 6180.27 and 10114.4781964 s. respectively
Enter MRB1 to print 301492 digits. The error from a 6,500,000 or more digit
calculation that used a different method is
Out[72]= 0.*10^-301494
Remembering that the integrated analog of the MRB constant is 
NIntegrate[(-1)^n (n^(1/n) - 1), {n, 1, Infinity I},
Method -> "Trapezoidal", WorkingPrecision -> 20]
These results are from the Timing[] command:
The 14900KS at 7200 MHz (extreme tuning!) documented here
The i9-12900KS column is documented here.
"Windows10 2024 i9-14900KS 6000 MHZ RAM"
documentation here
Attachments:
