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!
UPDATE
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.
UPDATE
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.
UPDATE
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.
UPDATE
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!!!
UPDATE
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.
UPDATE
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.
UPDATE
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!!!
UPDATE
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.
UPDATE
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.
UPDATE
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.
UPDATE
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.
UPDATE
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.
UPDATE
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.