Message Boards Message Boards

GROUPS:
Mathematics Mathematica High-Performance Computing Wolfram Language Numerical Computation
Marvin Ray Burns

How I calculated the digits of the MKB constant

Marvin Ray Burns, original investigator of the MRB constant
Posted 3 years ago
9212 Views
|
11 Replies
|
2 Total Likes
|

March 12, 2015

What about records of computing the integral analog of the MRB constant? (I call it the MKB constant.) See Google Scholar MKB constant.

Richard Mathar did a lot of work on it here , where M is the MRB constant and M1 is MKB:

enter image description here

M1 (MKB) can be written as and integral of a power of e:

enter image description here

I've gotten Matheamtica to compute 125 digits. However, they are not proven to be correct yet! They are

0.68765236892769436980931240936544016493963738490362254179507101010743\
366253478493706862729824049846818873192933433546612328629

. First we compute the real part as far as Mathematica will allow.

a1 = NIntegrate[Cos[x Pi] x^(1/x), {x, 1, Infinity}, 
  WorkingPrecision -> 100]

0.07077603931152880353952802183028200136575469620336299759658471973672\
987938741600037745028756981434374

a2 = NIntegrate[Cos[x Pi] x^(1/x), {x, 1, Infinity}, 
  WorkingPrecision -> 120]
a2 - a1

0.07077603931152880353952802183028200136575469620336302758317278266053\
31986618615110244568060496758380620699811570793175408

2.998658806292380331927444551064700651847986149432*10^-53

a3 = NIntegrate[Cos[x Pi] x^(1/x), {x, 1, Infinity}, 
  WorkingPrecision -> 150]
a3 - a2

0.07077603931152880353952802183028200136575469620336302758317278816361\
8457264385970709799491401005081151056924116255307801983594127144525095\
5653544005192

5.5030852586025244596853426853513292430889869429591759902612*10^-63

a4 = NIntegrate[Cos[x Pi] x^(1/x), {x, 1, Infinity}, 
  WorkingPrecision -> 200]
a4 - a3

0.07077603931152880353952802183028200136575469620336302758317278816361\
8457264382036580831881266177238210031756216795402920795214039271485948\
634659563768084109747493815003439875479076850383786911941519465

-3.9341289676101348278429410251678994599048811883800878730391469306948\
367511*10^-78

a5 = NIntegrate[Cos[x Pi] x^(1/x), {x, 1, Infinity}, 
  WorkingPrecision -> 250]
a5 - a4

0.07077603931152880353952802183028200136575469620336302758317278816361\
8457264382036580831881266177238209440733969109717926999044694539086929\
3857095687266500964737783523859835124762555195276023702167529617039725\
7261177753806842756198742365511173334813888

-5.9102224768568499379616934473239901924894999504143401327371546261745\
6363002821330856184541724766503*10^-103

Next we compute the imaginary part to the same precision.

b1 = NIntegrate[I Sin[x Pi] x^(1/x), {x, 1, Infinity}, 
   WorkingPrecision -> 100] - I/Pi

0.*10^-117 - 
 0.6840003894379321291827444599926611267109914826550016181302726087470\
544306934833279937664708191960468 I

b2 = NIntegrate[I Sin[x Pi] x^(1/x), {x, 1, Infinity}, 
   WorkingPrecision -> 120] - I/Pi
b2 - b1

0.*10^-137 - 
 0.6840003894379321291827444599926611267109914826549994343226304054256\
46767722886537984405858512438464223325361496951820797 I

0.*10^-117 + 
 2.1838076422033214076629705967900093606123067575826*10^-51 I

b3 = NIntegrate[I Sin[x Pi] x^(1/x), {x, 1, Infinity}, 
   WorkingPrecision -> 150] - I/Pi
b3 - b2

0.*10^-167 - 
 0.6840003894379321291827444599926611267109914826549994343226303771381\
5305812568206208637713014270949108628424796532117557865488349026349505\
4352728287677 I

0.*10^-137 + 
 2.8287493709597204475898028728369728973137041113531630645218*10^-62 I

b4 = NIntegrate[I Sin[x Pi] x^(1/x), {x, 1, Infinity}, 
   WorkingPrecision -> 200] - I/Pi
b4 - b3

0.*10^-218 - 
 0.6840003894379321291827444599926611267109914826549994343226303771381\
5305812497663815095983421272147867735031056071869477552727290571462108\
208123698276619850397331432861469605963724235550107655309644965 I

0.*10^-167 + 
 7.0542393541729592998801240893393740460248080312761058454887397227149\
1304910*10^-76 I

b5 = NIntegrate[I Sin[x Pi] x^(1/x), {x, 1, Infinity}, 
   WorkingPrecision -> 250] - I/Pi
b5 - b4

0.*10^-268 - 
 0.6840003894379321291827444599926611267109914826549994343226303771381\
5305812497663815095983421272147867223796451609148860995867828496814126\
9810848570299802270095261060286697622600207986034863822997401942304753\
4951409792726050072747412751162199808963072 I

0.*10^-218 + 
 5.1123460446272061655685946207464798122703884124663962338780532683279\
9843703703436946621273009904771*10^-102 I

b6 = NIntegrate[I Sin[x Pi] x^(1/x), {x, 1, Infinity}, 
   WorkingPrecision -> 300] - I/Pi
b6 - b5

0.*10^-318 - 
 0.6840003894379321291827444599926611267109914826549994343226303771381\
5305812497663815095983421272147867223796451609148860995867804988314557\
9408739051911924508290758754789975176921766748245229306743723292030351\
1357229649514450909272015113199881208930542548540913212596310791355732\
04151474091653439098975 I

0.*10^-268 + 
 2.3508499569040210951838787776180450230549672244567844123778963451625\
36786502744023594180143211599163475397637962318600032530*10^-127 I

Notice that WorkingPrecision->100 gave 51 consistant (correct) digits, WorkingPrecision->120 gave 62 correct digits, WorkingPrecision->150 gave 76 correct digits, WorkingPrecision->200 gave 102 correct digits, so it is not too much of a stretch to believe WorkingPrecision->250 gave 125 correct digits.

In[78]:= c = N[Abs[a5 + b5], 125]

Out[78]= 0.\
6876523689276943698093124093654401649396373849036225417950710101074336\
6253478493706862729824049846818873192933433546612328629

April 18, 2015

Going back to integral analog of the MRB constant'

enter image description here:

Using formula 5 on page 3 of http://arxiv.org/pdf/0912.3844v3.pdf

.enter image description here

We can compute a great deal of digits of the integral analog of the MRB constant' (I once called it the MKB constant, named after Marsha Kell-Burns my, now ex, wife.) In the paper Mathar simply calls it M1.

Until further notice in this post when we compute the imaginary part of M1, we will be concerned with the imaginary part's absolute value only,

This time we will compute the Imaginary part first to at least 500 digits:

  a[1] = 0; For[n = 1, n < 11, 
    a[n] = N[2/Pi - 
       1/Pi*NIntegrate[
         Cos[Pi*x]*x^(1/x)*(1 - Log[x])/x^2, {x, 1, Infinity}, 
         WorkingPrecision -> 100*n], 50 n]; Print[a[n] - a[n - 1]], 
    n++]; Print[a[11]]
\

giving

0.6840003894379321291827444599926611267109914826549994343226303771381530581249766381509598342127214787

0.*10^-101

0.*10^-151

0.*10^-201

0.*10^-251

0.*10^-301

0.*10^-351

0.*10^-401

0.*10^-451

0.*10^-501

0.6840003894379321291827444599926611267109914826549994343226303771381530581249766381509598342127214786722379645160914886099586780498831455794087390519118879988351918366211827085883779918191195794251385436100844782462528597869421390620796113023053439642582325892202911183326091512210367124716901047132601108752764946385830438156754378694878046808312868541961166205744280461776232345922905313658259576212809654022016030244583148587352474339130505540080799774619683572540292971258866450201101870835703060314349396491402064932644813564545345219868887520120

. Likewise the real part:

b[1] = 0; For[n = 1, n < 11, 
 b[n] = N[-1/Pi*
    NIntegrate[Sin[Pi*x]*x^(1/x)*(1 - Log[x])/x^2, {x, 1, Infinity}, 
     WorkingPrecision -> 100*n], 50 n]; Print[b[n] - b[n - 1]], 
 n++]; Print[b[11]]

giving

0.07077603931152880353952802183028200136575469620336302758317278816361845726438203658083188126617723821

0.*10^-102

0.*10^-152

0.*10^-202

0.*10^-252

0.*10^-302

0.*10^-352

0.*10^-402

0.*10^-452

0.*10^-502

0.07077603931152880353952802183028200136575469620336302758317278816361845726438203658083188126617723820944073396910971792699904464538475364292258443860652193330471222906120205483985764336623434898438270710499897053952312269178485299032185072743545220051257328105422174249313177670295863771714489658779291185716175115405623656039914848817528200250723061535734571065031458992196831648681239079549382556509741967588147362548743205919028695774572411439927516593391029992733107982746794845130889328251307263102570083031527430861023428334369104098217022622689

. Then the magnitude:

N[Sqrt[a[11]^2 + b[11]^2], 500]

giving

0.68765236892769436980931240936544016493963738490362254179507101010743\
3662534784937068627298240498468188731929334335466123286287665409457565\
9577211580255650416284625143925097120589697986500952590195706813170472\
5387265069668971286335322245474865156721299946377659227025219748069576\
0895993932096027520027641920489863095279507385793449828250341732295653\
3809181101532087948181335825805498812728097520936901677028741356923292\
2644964771090329726483682930417491673753430878118054062296678424687465\
624513174205

. That checks with the 200 digits computed by the quadosc command in mpmath by FelisPhasma at https://github.com/FelisPhasma/MKB-Constant .The function is defined here: http://mpmath.googlecode.com/svn/trunk/doc/build/calculus/integration.html#oscillatory-quadrature-quadosc

enter image description here

P.S.

I just now finished 750 digits, (about the max with formula 5 from the paper, as far as Mathematica is concerned).

Here is the work:

a[1] = 0; For[n = 1, n < 16, 
 a[n] = N[2/Pi - 
    1/Pi*NIntegrate[
      Cos[Pi*x]*x^(1/x)*(1 - Log[x])/x^2, {x, 1, Infinity}, 
      WorkingPrecision -> 100*n], 50 n]; Print[a[n] - a[n - 1]], 
 n++]; Print[a[16]]; 
b[1] = 0; For[n = 1, n < 16, 
 b[n] = N[-1/Pi*
    NIntegrate[Sin[Pi*x]*x^(1/x)*(1 - Log[x])/x^2, {x, 1, Infinity}, 
     WorkingPrecision -> 100*n], 50 n]; Print[b[n] - b[n - 1]], 
 n++]; Print[b[16]]; Print[N[Sqrt[a[16]^2 + b[16]^2], 750]]

0.6840003894379321291827444599926611267109914826549994343226303771381530581249766381509598342127214787

0.*10^-101

0.*10^-151

0.*10^-201

0.*10^-251

0.*10^-301

0.*10^-351

0.*10^-401

0.*10^-451

0.*10^-501

0.*10^-551

0.*10^-601

3.*10^-650

-4.*10^-700

-2.6*10^-749

0.68400038943793212918274445999266112671099148265499943432263037713815\
3058124976638150959834212721478672237964516091488609958678049883145579\
4087390519118879988351918366211827085883779918191195794251385436100844\
7824625285978694213906207961130230534396425823258922029111833260915122\
1036712471690104713260110875276494638583043815675437869487804680831286\
8541961166205744280461776232345922905313658259576212809654022016030244\
5831485873524743391305055400807997746196835725402929712588664502011018\
7083570306031434939649140206493264481356454534521986888752011950353818\
1776359577265099302389566135475579468144849763261779452665955246258699\
8679271659049208654746533234375478909962633090080006358213908728990850\
5026759549928935029206442637425786005036048098598304092996753145589012\
64547453361707037686708654522699


0.07077603931152880353952802183028200136575469620336302758317278816361845726438203658083188126617723821

0.*10^-102

0.*10^-152

0.*10^-202

0.*10^-252

0.*10^-302

0.*10^-352

0.*10^-402

0.*10^-452

0.*10^-502

2.*10^-551

-1.*10^-600

1.8*10^-650

1.27*10^-699

4.34*10^-749

0.07077603931152880353952802183028200136575469620336302758317278816361\
8457264382036580831881266177238209440733969109717926999044645384753642\
9225844386065219333047122290612020548398576433662343489843827071049989\
7053952312269178485299032185072743545220051257328105422174249313177670\
2958637717144896587792911857161751154056236560399148488175282002507230\
6153573457106503145899219683164868123907954938255650974196758814736254\
8743205919028695774572411439927516593391029992733107982746794845130889\
3282513072631025700830315274308610234283343691040982170226226904594029\
7055093272952022662549075225941956559080574835998923469310063614655255\
0629713179601483134045038416878054929072981851045829413286377842843667\
5378730394247519728064887287780998671021887797977772522419765594172569\
277490031071938177749184834961300

0.687652368927694369809312409365440164939637384903622541795071010107433662534784937068627298240498468188731929334335466123286287665409457565957721158025565041628462514392509712058969798650095259019570681317047253872650696689712863353222454748651567212999463776592270252197480695760895993932096027520027641920489863095279507385793449828250341732295653380918110153208794818133582580549881272809752093690167702874135692329226449647710903297264836829304174916737534308781180540622966784246874656245131742049004832216427665542900559350289936114782223424261285828326467186036500189315374147638489679365569122714398706519530651330568884655048857998738535162606116788633540389660052822237449082894798620397228331715198160243676576563833057235963591510865254600

Using formula 7 from http://arxiv.org/pdf/0912.3844v3.pdf,

enter image description here .

(Treating it as we did formula 5), First, the imaginary part to at least 1000 digits::

a[1] = 0; For[n = 1, n < 21, 
 a[n] = N[2/Pi + 
    1/Pi^2 NIntegrate[
      Sin[x Pi] x^(1/x) (1 - 3 x + 2 (x - 1) Log[x] + Log[x]^2)/
        x^4, {x, 1, Infinity}, WorkingPrecision -> 100 n], 50 n];
 Print[a[n] - a[n - 1]], n++]; Print[a[21]]

0.6840003894379321291827444599926611267109914826549994343226303771381530581249766381509598342127214787

0.*10^-101

0.*10^-151

0.*10^-201

0.*10^-251

0.*10^-301

0.*10^-351

0.*10^-401

0.*10^-451

0.*10^-501

0.*10^-551

0.*10^-601

0.*10^-651

0.*10^-701

0.*10^-751

0.*10^-801

0.*10^-851

0.*10^-901

-2.*10^-950

5.*10^-1000

0.684000389437932129182744459992661126710991482654999434322630377138153058124976638150959834212721478672237964516091488609958678049883145579408739051911887998835191836621182708588377991819119579425138543610084478246252859786942139062079611302305343964258232589220291118332609151221036712471690104713260110875276494638583043815675437869487804680831286854196116620574428046177623234592290531365825957621280965402201603024458314858735247433913050554008079977461968357254029297125886645020110187083570306031434939649140206493264481356454534521986888752011950353818177635957726509930238956613547557946814484976326177945266595524625869986792716590492086547465332343754789099626330900800063582139087289908505026759549928935029206442637425786005036048098598304092996753145589012645474533617070376867086545228223060940434935219252885333298390272342234952870883304116640409421452765284609364941205344122569781634782508368641126766528707019957340895061936246645065753101916781254557006989818409283317145837167345971516970849116096077030635788389165381066055992688

Then the real part to at least 1000 digits:

b[1] = 0; For[n = 1, n < 21, 
 b[n] = N[1/Pi^2 - 
    1/Pi^2 NIntegrate[
      Cos[Pi x] x^(1/x) (1 - 3 x + 2 (x - 1) Log[x] + Log[x]^2)/
        x^4, {x, 1, Infinity}, WorkingPrecision -> 100 n], 50 n];
 Print[b[n] - b[n - 1]], n++]; Print[b[21]]

0.07077603931152880353952802183028200136575469620336302758317278816361845726438203658083188126617723821

0.*10^-102

0.*10^-152

0.*10^-202

0.*10^-252

0.*10^-302

0.*10^-352

0.*10^-402

0.*10^-452

0.*10^-502

0.*10^-552

0.*10^-602

0.*10^-652

0.*10^-702

0.*10^-752

0.*10^-802

0.*10^-852

-3.*10^-901

8.*10^-951

-4.6*10^-1000

0.0707760393115288035395280218302820013657546962033630275831727881636184572643820365808318812661772382094407339691097179269990446453847536429225844386065219333047122290612020548398576433662343489843827071049989705395231226917848529903218507274354522005125732810542217424931317767029586377171448965877929118571617511540562365603991484881752820025072306153573457106503145899219683164868123907954938255650974196758814736254874320591902869577457241143992751659339102999273310798274679484513088932825130726310257008303152743086102342833436910409821702262269045940297055093272952022662549075225941956559080574835998923469310063614655255062971317960148313404503841687805492907298185104582941328637784284366753787303942475197280648872877809986710218877979777725224197655941725692774900310719381777491848349627938468198411955193898347075098152638657614980900350262780319142430252921925131515239611841070722530473939496294305264627977744876814858325335947117076721493110160508928494597906728688873533031986215124467678736429981544321187124269147141804397293341613

Then the magnitude:

In[97]:= N[Sqrt[a[21]^2 + b[21]^2], 1000]

Out[97]= 0.\
6876523689276943698093124093654401649396373849036225417950710101074336\
6253478493706862729824049846818873192933433546612328628766540945756595\
7721158025565041628462514392509712058969798650095259019570681317047253\
8726506966897128633532224547486515672129994637765922702521974806957608\
9599393209602752002764192048986309527950738579344982825034173229565338\
0918110153208794818133582580549881272809752093690167702874135692329226\
4496477109032972648368293041749167375343087811805406229667842468746562\
4513174204900483221642766554290055935028993611478222342426128582832646\
7186036500189315374147638489679365569122714398706519530651330568884655\
0488579987385351626061167886335403896600528222374490828947986203972283\
3171519816024367657656383305723596359151086525460036387486837632622334\
2987257095524637683005910353149353985736118868884201748241906260834981\
7303422370398413326428269921074045506558966667483453656748906071577744\
4147548424388220133662816274116986724576330176058912438027319979840883\
05950589130911719199

PPS. I just now finished a 1500 digit computation of the integral analog of the MRB constant, but I don't have any way of checking it other than to see that it confirms smaller computations. Which thing it does.

In[99]:= aa = 
 N[2/Pi + 1/Pi^2 NIntegrate[
     Sin[x Pi] x^(1/x) (1 - 3 x + 2 (x - 1) Log[x] + Log[x]^2)/
       x^4, {x, 1, Infinity}, WorkingPrecision -> 3000], 1500]

Out[99]= 0.\
6840003894379321291827444599926611267109914826549994343226303771381530\
5812497663815095983421272147867223796451609148860995867804988314557940\
8739051911887998835191836621182708588377991819119579425138543610084478\
2462528597869421390620796113023053439642582325892202911183326091512210\
3671247169010471326011087527649463858304381567543786948780468083128685\
4196116620574428046177623234592290531365825957621280965402201603024458\
3148587352474339130505540080799774619683572540292971258866450201101870\
8357030603143493964914020649326448135645453452198688875201195035381817\
7635957726509930238956613547557946814484976326177945266595524625869986\
7927165904920865474653323437547890996263309008000635821390872899085050\
2675954992893502920644263742578600503604809859830409299675314558901264\
5474533617070376867086545228223060940434935219252885333298390272342234\
9528708833041166404094214527652846093649412053441225697816347825083686\
4112676652870701995734089506193624664506575310191678125455700698981840\
9283317145837167345971516970849116096077030635788389165381066055992708\
4284702473154303800276803908560080204997803241058414188902018357202062\
9532415382916822796942734253441520784640814155687968986766443021927163\
6249354786973717955004441549085673392105556692081075647388204227896978\
1483978754685921758294318270385312597177598977912650715548994562461701\
1553879109152932039370312241134127950112036269188660519350584627066913\
4925878278209048717316088629321353274101519307401594635990058104175474\
300641475776727955287474213040

In[98]:= bb = 
 N[1/Pi^2 - 
   1/Pi^2 NIntegrate[
     Cos[Pi x] x^(1/x) (1 - 3 x + 2 (x - 1) Log[x] + Log[x]^2)/
       x^4, {x, 1, Infinity}, WorkingPrecision -> 3000], 1500]

Out[98]= 0.\
0707760393115288035395280218302820013657546962033630275831727881636184\
5726438203658083188126617723820944073396910971792699904464538475364292\
2584438606521933304712229061202054839857643366234348984382707104998970\
5395231226917848529903218507274354522005125732810542217424931317767029\
5863771714489658779291185716175115405623656039914848817528200250723061\
5357345710650314589921968316486812390795493825565097419675881473625487\
4320591902869577457241143992751659339102999273310798274679484513088932\
8251307263102570083031527430861023428334369104098217022622690459402970\
5509327295202266254907522594195655908057483599892346931006361465525506\
2971317960148313404503841687805492907298185104582941328637784284366753\
7873039424751972806488728778099867102188779797777252241976559417256927\
7490031071938177749184834962793846819841195519389834707509815263865761\
4980900350262780319142430252921925131515239611841070722530473939496294\
3052646279777448768148583253359471170767214931101605089284945979067286\
8887353303198621512446767873642998154432118712426914714180439729334146\
8345902382977472975053271988386946291215512340931334841526712825988330\
6521193975174379922254198045615178994412133135553490942451521573377205\
4086429300485891441696490339106907723915822537813700713422515725943626\
7756749980892097547020923938358076198570370106085596863039832425037481\
4946826330552459256977035009973219582010379262683780372730214991685800\
3676611833579648850161974289307066295385292264148146789532534018500663\
1153014589399140567464592864024

In[109]:= c1500 = Sqrt[aa^2 + bb^2]

Out[109]= \
0.68765236892769436980931240936544016493963738490362254179507101010743\
3662534784937068627298240498468188731929334335466123286287665409457565\
9577211580255650416284625143925097120589697986500952590195706813170472\
5387265069668971286335322245474865156721299946377659227025219748069576\
0895993932096027520027641920489863095279507385793449828250341732295653\
3809181101532087948181335825805498812728097520936901677028741356923292\
2644964771090329726483682930417491673753430878118054062296678424687465\
6245131742049004832216427665542900559350289936114782223424261285828326\
4671860365001893153741476384896793655691227143987065195306513305688846\
5504885799873853516260611678863354038966005282223744908289479862039722\
8331715198160243676576563833057235963591510865254600363874868376326223\
3429872570955246376830059103531493539857361188688842017482419062608349\
8173034223703984133264282699210740455065589666674834536567489060715777\
4441475484243882201336628162741169867245763301760589124380273199798408\
8305950589130911719198776146941477264898934365742508503405073273852990\
3546587114217499635584514475429656959327732862489935076490012861232249\
2446704232200904844779690044774489466704342791971033325818579375177198\
9865742583276770011926585495711579480114327818546199372349313180236079\
1389248808154759564302727311223193005229640892474022665093207969297797\
9723087954832182561714039165214592519432072341006090867558444590500046\
6707963346545638317950978935794173691635274461184852166407791838662429\
40408834876470623546535579027725

Mathar gives a simple scheme to find better formulas at http://arxiv.org/pdf/0912.3844v3.pdf . I could use some help in programming it: (I keep getting erroneous results!) Does anyone get the right results here?

enter image description here

Below, where the upper limit of the following integrals shows Infinity, it is meant to be the (Ultraviolet limit of the sequence) as mentioned by Mathar here:

enter image description here

Until further notice in this post when we compute the imaginary part of M1, we will be concerned with the imaginary part's absolute value only,

I derived a new formula for computing the integral analog of the MRB constant':

f[x_]:=x^(1/x);-((2 I)/\[Pi]^3) + 1/\[Pi]^2 - (
 2 I)/\[Pi] + (I/Pi)^3*
  Integrate[(-1)^x*D[f[x], {x, 3}], {x, 1, Infinity}]

In traditional form that is M1=

enter image description here

Using it I computed 2000 digits in only 10.8 minutes:

In[131]:= Timing[f[x_] = x^(1/x); 
 a = N[1/\[Pi]^2 + (1/Pi)^3*
     NIntegrate[Sin[Pi*x]*D[f[x], {x, 3}], {x, 1, Infinity}, 
      WorkingPrecision -> 4000], 2000]; 
 b = N[2/\[Pi]^3 + 
    2/\[Pi] + (1/Pi)^3*
     NIntegrate[Cos[Pi x]*D[f[x], {x, 3}], {x, 1, Infinity}, 
      WorkingPrecision -> 4000], 2000]; 
 Print[N[Sqrt[a^2 + b^2], 2000]]]

During evaluation of In[131]:= 0.68765236892769436980931240936544016493963738490362254179507101010743366253478493706862729824049846818873192933433546612328628766540945756595772115802556504162846251439250971205896979865009525901957068131704725387265069668971286335322245474865156721299946377659227025219748069576089599393209602752002764192048986309527950738579344982825034173229565338091811015320879481813358258054988127280975209369016770287413569232922644964771090329726483682930417491673753430878118054062296678424687465624513174204900483221642766554290055935028993611478222342426128582832646718603650018931537414763848967936556912271439870651953065133056888465504885799873853516260611678863354038966005282223744908289479862039722833171519816024367657656383305723596359151086525460036387486837632622334298725709552463768300591035314935398573611886888420174824190626083498173034223703984133264282699210740455065589666674834536567489060715777444147548424388220133662816274116986724576330176058912438027319979840883059505891309117191987761469414772648989343657425085034050732738529903546587114217499635584514475429656959327732862489935076490012861232249244670423220090484477969004477448946670434279197103332581857937517719898657425832767700119265854957115794801143278185461993723493131802360791389248808154759564302727311223193005229640892474022665093207969297797972308795483218256171403916521459251943207234100609086755844459050004667079633465456383179509789357941736916352744611848521664077918386624294040883487647062354653558109265769644276994369741555722263494599492834558291937955573706480722982389806312472239746286527176248883116124285469947303667188075506826507811479428582807366599407544908560990699866167233307144245764835741501174979679166078765231145175411199825822532170091858833628202128777966026600647843068442894310401343003939117236867245656732686719139206716028255819141802331701942027248337771633882445225049334329008827371320849006472846226868011129149192754883153995560921671208059671732704499253517327447921147157

Out[131]= {653.145, Null}

I am presently computing 10,000 digits using that formula. Come back here for results!

That formula didn't work out; I will try one of the following formulas.

Here are 2 more, more advanced formulas; remember f(x) is x^(1/x):

enter image description here

I did finish a 5,000 digit computation using M1=

enter image description here

in 48.11 minutes.

Here are the 5000 digits:of the magnitude:

0.68765236892769436980931240936544016493963738490362254179507101010743366253478493706862729824049846818873192933433546612328628766540945756595772115802556504162846251439250971205896979865009525901957068131704725387265069668971286335322245474865156721299946377659227025219748069576089599393209602752002764192048986309527950738579344982825034173229565338091811015320879481813358258054988127280975209369016770287413569232922644964771090329726483682930417491673753430878118054062296678424687465624513174204900483221642766554290055935028993611478222342426128582832646718603650018931537414763848967936556912271439870651953065133056888465504885799873853516260611678863354038966005282223744908289479862039722833171519816024367657656383305723596359151086525460036387486837632622334298725709552463768300591035314935398573611886888420174824190626083498173034223703984133264282699210740455065589666674834536567489060715777444147548424388220133662816274116986724576330176058912438027319979840883059505891309117191987761469414772648989343657425085034050732738529903546587114217499635584514475429656959327732862489935076490012861232249244670423220090484477969004477448946670434279197103332581857937517719898657425832767700119265854957115794801143278185461993723493131802360791389248808154759564302727311223193005229640892474022665093207969297797972308795483218256171403916521459251943207234100609086755844459050004667079633465456383179509789357941736916352744611848521664077918386624294040883487647062354653558109265769644276994369741555722263494599492834558291937955573706480722982389806312472239746286527176248883116124285469947303667188075506826507811479428582807366599407544908560990699866167233307144245764835741501174979679166078765231145175411199825822532170091858833628202128777966026600647843068442894310401343003939117236867245656732686719139206716028255819141802331701942027248337771633882445225049334329008827371320849006472846226868011129149192754883153995560921671208059671732704499253517327447529208297180672654123457301218758892278525894167935930983363218877512533994251978272092700003994136520699813263053327399132641690231179063314931546906927612775633995348209911166678724589467821767106592498663827057034363632241807121831546175498178011687284590439293322231263406301066863589072717290630291441982684113819198880100231182613587798104863611185433976009254862585527222843445901958943153561148829083242874018226480554274231391324767376148485531787767908124831873688579979114662856184612164534836370699371440464263768724668291617743681719766849740663590277737977490693183461320266666793472116774276618408124767965369796362732668987556797338128876129264558867657737417548617146808592137056879602982206609613881069490166381528825180204703315896719667069923077454352649723496033985893188309150391579573916059639453655188856334980355047281560296288150836680499821806918067869468571687709518088408966653716009356556714281694904914038988996962213833530636987279769672200413448893419914190954063100962251649102614676944333201213024711868954772741991675045198246947499574872027800654821823797116399297131866662866832215332914761325880983081211272181775518951539503852063119472301382766303820851467743266039356123495461914463960644386394228342211998370152351720235034997434035743513051754761571835043769475528640144621307760159481496713401409374957729200400650100318226988524015127382509490642900236553851499823658269458873976032051355393161653806016080446394196719312454167915154602448638624354575153334932298393406734174580316934939632892851077461038399470015366439910136971186909599331204517462262508377673477745789645309425145559198802530351403897927622891172233239135167420567162398873965477371498335087310395422796362380227536212159184529243644094285328763286873653399867593200891823468738537356817916009007206857590792983184556882143118383332812491747733056313117179696094921120670802012310012864110800437831852620698327457619035904268498030693438632685623213366864129523404256345542376567721287706234359125016588483777876970236084456277023948551334490591022594253744077631232660869593809453087749830900393202787736482133628148979992109544954840067942735030391105496026321872468122542495017023785810605820545392820104069279893067324597299043883381251767370331206913429284614563732308018369972360638019778425246546329838131639355043236388708044857300408692365733932897876809202025693305332974091411983635619038514442263783801745983300121464879550146672827072002317686396598587702487509572349422593441184802476344187280014450860069307120621758277552124841158659386176036703247124389223327008210072318671884895179305778728051888524412158486781863155034447221379906386062559915129172725833420555901857729690605950941678587057025641848365090809750870051863842805803189784976076099574956436664131457150096711473033060684065060747340764998195621425524824611657787212347497307297184843276100338110267863618974154272345482369968216663233417338501929114697679974461999040589290327155974468087040862022522065912789

I'm getting closer to 10K digits of M1: Using enter image description here , where f(x)=x^(1/x).

I got approx. 10K digits of the imaginary part, but the real part was a little garbled.

Finally using

enter image description here , where f(x) = x^(1/x) ,

.I got about 10000 digits of M1 in about 12 hours. (It showed that the 5000 digit computation was only correct to 4979 digits, though.) Here is a rough program to get it:

   f[x_]:=x^(1/x);  Print[DateString[]]; Print[T0 = SessionTime[]]; prec = 10000; 
  Timing[Print[
  a = N[Re[-(136584/Pi^10) - (34784*I)/Pi^9 + 
       5670/Pi^8 + (786*I)/Pi^7 - 90/Pi^6 - 
                 (4*I)/Pi^5 - 3/Pi^4 - (2*I)/Pi^3 + 
       1/Pi^2 - (2*I)/Pi] - 
             (1/Pi)^10*
      NIntegrate[Cos[Pi*x]*D[f[x], {x, 10}], {x, 1, Infinity}, 
       WorkingPrecision -> prec, 
                 PrecisionGoal -> prec], prec]]; 
 Print[SessionTime[] - T0, " seconds"]; 
     Print[
  N[b = -Im[-(136584/Pi^10) - (34784*I)/Pi^9 + 
        5670/Pi^8 + (786*I)/Pi^7 - 90/Pi^6 - 
                   (4*I)/Pi^5 - 3/Pi^4 - (2*I)/Pi^3 + 
        1/Pi^2 - (2*I)/Pi] + 
             (1/Pi)^10*
      NIntegrate[Sin[Pi*x]*D[f[x], {x, 10}], {x, 1, Infinity}, 
       WorkingPrecision -> prec, 
                 PrecisionGoal -> prec], prec]]]; Print[
 SessionTime[] - T0, " seconds"]; 
  Print[N[Sqrt[a^2 + b^2], prec]]; Print[DateString[]];

See attached 10000MKB.pdf and 10KMKB.nb for work and digits.

On May 5, I computed another 10,000 digits in 9.55 hours see attached faster10KMKB.

On May 6, I computed another 10,000 digits in a blistering fast 5.1 hours see attached fastest10KMKB.nb.

On May 9, I improved that timing to 4.8 hours (17355 seconds). Here is the code I used:

d = 15; f[x_] = x^(1/x); ClearAll[a, b, h];
h[n_] := Sum[
  StirlingS1[n, k]*Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1,
    n}]; h[0] = 1; g = 
 2 I/Pi - Sum[-I^(n + 1) h[n]/Pi^(n + 1), {n, 1, d}]; Print[
 DateString[]];
Print[T0 = SessionTime[]]; prec = 10000;
Print[N[a = -Re[g] + (1/Pi)^(d + 1)*
      NIntegrate[
       Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
       WorkingPrecision -> prec*(105/100), 
       PrecisionGoal -> prec*(105/100)], prec]];
Print[SessionTime[] - T0, " seconds"];
Print[N[b = 
    Im[g] - (1/Pi)^(d + 1)*
      NIntegrate[
       Simplify[Sin[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
       WorkingPrecision -> prec*(105/100), 
       PrecisionGoal -> prec*(105/100)], prec]];
Print[SessionTime[] - T0, " seconds"]; Print[
 N[Sqrt[a^2 + b^2], prec]]; Print[DateString[]];

April 20, 2015

FelisPhasma has been helpful in providing me with a little competition in computing the integral analog of the MRB constant. See https://github.com/FelisPhasma/MKB-Constant.

I've never done this before. But I so much would like to see others breaking these records that I'm going to give away a program that is practically guaranteed to break my record of 10,000 digits, for the integral analog of the MRB constant in a day or so. The program could use some "clean up" if you care to go that far. (The imaginary part is given as a positive, real constant: it actually starts with a negative sign and of course ends with I.)

Here it is:

f[x_] = x^(1/x); Print[DateString[]]; Print[
 T0 = SessionTime[]]; prec = 11000; Timing[
 Print[a = 
   N[Re[(633666648 I)/\[Pi]^13 - 
       33137280/\[Pi]^12 - ((824760 I)/\[Pi]^11) - 
       136584/\[Pi]^10 - (34784 I)/\[Pi]^9 + 
       5670/\[Pi]^8 + (786 I)/\[Pi]^7 - 90/\[Pi]^6 - (4 I)/\[Pi]^5 - 
       3/\[Pi]^4 - (2 I)/\[Pi]^3 + 
       1/\[Pi]^2 - (2 I)/\[Pi]] + (1/Pi)^12*
      NIntegrate[Cos[Pi x]*D[f[x], {x, 12}], {x, 1, Infinity}, 
       WorkingPrecision -> prec, PrecisionGoal -> prec], prec]];
 Print[SessionTime[] - T0, " seconds"];
 Print[N[b = -Im[(633666648 I)/\[Pi]^13 - 
        33137280/\[Pi]^12 - ((824760 I)/\[Pi]^11) - 
        136584/\[Pi]^10 - (34784 I)/\[Pi]^9 + 
        5670/\[Pi]^8 + (786 I)/\[Pi]^7 + 90/\[Pi]^6 - (4 I)/\[Pi]^5 - 
        3/\[Pi]^4 - (2 I)/\[Pi]^3 + 
        1/\[Pi]^2 - (2 I)/\[Pi]] - (1/Pi)^13*
      NIntegrate[Cos[Pi x]*D[f[x], {x, 13}], {x, 1, Infinity}, 
       WorkingPrecision -> prec, PrecisionGoal -> prec], 
   prec]]]; Print[SessionTime[] - T0, " seconds"]; Print[
 N[Sqrt[a^2 + b^2], prec]]; Print[DateString[]];

Will anyone let me know you are running this program to break my record?

Edit: On Sat 2 May 2015 19:03:45 I started a 15,000 digit, new record computation of the real and imaginary parts and magnitude of the integral analog of the MRB constant, (where the imaginary part is given as a positive, real constant), using the following code.

 f[x_] = x^(1/x); ClearAll[a];
   h[n_] := Sum[
     StirlingS1[n, k]*Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1,
       n}]; h[0] = 1; g = -2 I/Pi + 
     Sum[-I^(n + 1) h[n]/Pi^(n + 1), {n, 1, 18}]; Print[DateString[]];
   Print[T0 = SessionTime[]]; prec = 15000;
   Print[N[a = 
       Re[g] + (1/Pi)^19*
         NIntegrate[
          Simplify[Sin[Pi*x]*D[f[x], {x, 19}]], {x, 1, Infinity}, 
          WorkingPrecision -> prec*(105/100), 
          PrecisionGoal -> prec*(105/100)], prec]];
   Print[SessionTime[] - T0, " seconds"];
   Print[N[b = -Im[g] + (1/Pi)^19*
         NIntegrate[
          Simplify[Cos[Pi*x]*D[f[x], {x, 19}]], {x, 1, Infinity}, 
          WorkingPrecision -> prec*(105/100), 
          PrecisionGoal -> prec*(105/100)], prec]];
   Print[SessionTime[] - T0, " seconds"]; Print[
    N[Sqrt[a^2 + b^2], prec]]; Print[DateString[]];

The formula behind this computation is enter image description here

Edit: The program took 33.75 hours,The full run is attached in 15KMKB3.nb.

Edit May 9, 2015: I better than halved my time! I computed 15000 digits in 14.83 hours. See fastestMKB15K.nb/. The faster formula is

enter image description here

If you still want me to write out a code for more digits, for you to break that record, let me know.

May 11, 2015

Still talking about the integral analog of the MRB constant:enter image description here

Here are my speed records -- can you beat any of them?

enter image description here

Here is a graph of those speed records with a trendline:

enter image description here

The 20,000 digit run is attached as MKB20K.nb, and MKB20K.pdf,

Here is the algorithm used:

enter image description here

Here is the code:

d = 30; f[x_] = x^(1/x); ClearAll[a, b, h];
a[n_] := Sum[
  StirlingS1[n, k]*Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1,
    n}]; a[0] = 1; g = 
 2 I/Pi - Sum[-I^(n + 1) a[n]/Pi^(n + 1), {n, 1, d}]; Print[
 DateString[]];
Print[T0 = SessionTime[]]; prec = 20000;
Print[N[a = -Re[g] - (1/Pi)^(d)*
      NIntegrate[
       Simplify[Cos[Pi*x]*D[f[x], {x, d}]], {x, 1, Infinity}, 
       WorkingPrecision -> prec*(105/100), 
       PrecisionGoal -> prec*(105/100)], prec]];
Print[SessionTime[] - T0, " seconds"];
Print[N[b = 
    Im[g] + (1/Pi)^(d + 1)*
      NIntegrate[
       Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
       WorkingPrecision -> prec*(105/100), 
       PrecisionGoal -> prec*(105/100)], prec]];
Print[SessionTime[] - T0, " seconds"]; Print[
 N[Sqrt[a^2 + b^2], prec]]; Print[DateString[]];

I just now completed a 25,000 digit computation. It took 63.7 hours and confirmed the 20,000 digits. I updated MKB20K.nb and MKB20K.pdf. Here is the algorithm and the code I used:

enter image description here

d = 35; f[x_] = x^(1/x); ClearAll[a, b, h];
h[n_] := Sum[
  StirlingS1[n, k]*Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1,
    n}]; h[0] = 1; g = 
 2 I/Pi - Sum[-I^(n + 1) h[n]/Pi^(n + 1), {n, 1, d}]; Print[
 DateString[]];
Print[T0 = SessionTime[]]; prec = 25000;
Print[N[a = -Re[g] + (1/Pi)^(d + 1)*
      NIntegrate[
       Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
       WorkingPrecision -> prec*(105/100), 
       PrecisionGoal -> prec*(105/100)], prec]];
Print[SessionTime[] - T0, " seconds"];
Print[N[b = 
    Im[g] - (1/Pi)^(d + 1)*
      NIntegrate[
       Simplify[Sin[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
       WorkingPrecision -> prec*(105/100), 
       PrecisionGoal -> prec*(105/100)], prec]];
Print[SessionTime[] - T0, " seconds"]; Print[
 N[Sqrt[a^2 + b^2], prec]]; Print[DateString[]];

Here is new a graph of those speed records with a trendline: enter image description here

Edit:

On Tue 26 May 2015 06:21:00, I started a 30,000 digit computation using the following code.

Does any one else want to try to break the record?

 $MaxExtraPrecision = 100; d = 43; f[x_] = x^(1/x); ClearAll[a, b, h];
h[n_] := Sum[
  StirlingS1[n, k]*Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1,
    n}]; h[0] = 1; g = 
 2 I/Pi - Sum[-I^(n + 1) h[n]/Pi^(n + 1), {n, 1, d}]; Print[
 DateString[]];
Print[T0 = SessionTime[]]; prec = 30000;
Print[N[a = -Re[g] + (1/Pi)^(d + 1)*
      NIntegrate[
       Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
       WorkingPrecision -> prec*(105/100), 
       PrecisionGoal -> prec*(105/100)], prec]];
Print[SessionTime[] - T0, " seconds"];
Print[N[b = 
    Im[g] - (1/Pi)^(d + 1)*
      NIntegrate[
       Simplify[Sin[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
       WorkingPrecision -> prec*(105/100), 
       PrecisionGoal -> prec*(105/100)], prec]];
Print[SessionTime[] - T0, " seconds"]; Print[
 N[Sqrt[a^2 + b^2], prec]]; Print[DateString[]];

Edit: My first full 30,0000 run finished on Sun 31 May 2015 00:45:09.

Time span: {"4.767 days", "114.4 hours", "6864 minutes", "411849 seconds"} See attached MKB30K2.nb worksheet.

Here is an updated speed record plot, with trendline. (I think the 30,000 digit run can be done faster.)

enter image description here

Here is an extensive record of records of computing the integral analog of the MRB constant:

enter image description here

![enter image description here][62]

Here is a graph of those records. (The progression of computed digits is so extreme, it is almost unbelievable!) enter image description here

6

June 5, 2015

I think I came up with a rough program that computes any "prec" digits of the integral analog of the MRB constant. It chooses, d, the best (or close to the best) order of derivative to use in Mathar's algorithm mentioned in a previous post (formula (12) at http://arxiv.org/pdf/0912.3844v3.pdf ), Then uses the appropriate code that integrates the integral analog of the constant. It shows the real and imaginary parts as postive real constants and the value the integral, and gives some timings. It could use a lot of cleanup! I hope someone can help me test it with varying values of prec. Please reply your intentions to use it and results.If no one else can clean it up I will after I tested it more.

prec = 2000; d = Ceiling[0.264086 + 0.00143657 prec]; If[
 Mod[d, 4] == 0, f[x_] = x^(1/x); ClearAll[a, b, h];
 a[n_] := 
  Sum[StirlingS1[n, k]*
    Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1, n}]; a[0] = 1;
 g = 2 I/Pi - Sum[-I^(n + 1) a[n]/Pi^(n + 1), {n, 1, d}];
 Print[DateString[]];
 Print[T0 = SessionTime[]];
 Print[N[a = -Re[g] - (1/Pi)^(d + 1)*
      NIntegrate[
       Simplify[Sin[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
       WorkingPrecision -> prec*(105/100), 
       PrecisionGoal -> prec*(105/100)], prec]];
 Print[SessionTime[] - T0, " seconds"];
 Print[N[b = 
    Im[g] - (1/Pi)^(d + 1)*
      NIntegrate[
       Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
       WorkingPrecision -> prec*(105/100), 
       PrecisionGoal -> prec*(105/100)], prec]];
 Print[SessionTime[] - T0, " seconds"];
 Print[N[Sqrt[a^2 + b^2], prec]]; Print[DateString[]];, 
 If[Mod[d, 4] == 1, f[x_] = x^(1/x); ClearAll[a, b, h];
  h[n_] := 
   Sum[StirlingS1[n, k]*
     Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1, n}];
  h[0] = 1; g = 2 I/Pi - Sum[-I^(n + 1) h[n]/Pi^(n + 1), {n, 1, d}];
  Print[DateString[]];
  Print[T0 = SessionTime[]];
  Print[N[
    a = -Re[g] - (1/Pi)^(d + 1)*
       NIntegrate[
        Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
        WorkingPrecision -> prec*(105/100), 
        PrecisionGoal -> prec*(105/100)], prec]];
  Print[SessionTime[] - T0, " seconds"];
  Print[N[
    b = Im[g] + (1/Pi)^(d + 1)*
       NIntegrate[
        Simplify[Sin[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
        WorkingPrecision -> prec*(105/100), 
        PrecisionGoal -> prec*(105/100)], prec]];
  Print[SessionTime[] - T0, " seconds"];
  Print[N[Sqrt[a^2 + b^2], prec]]; Print[DateString[]];, 
  If[Mod[d, 4] == 2, f[x_] = x^(1/x); ClearAll[a, b, h];
   a[n_] := 
    Sum[StirlingS1[n, k]*
      Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1, n}];
   a[0] = 1; g = 2 I/Pi - Sum[-I^(n + 1) a[n]/Pi^(n + 1), {n, 1, d}];
   Print[DateString[]];
   Print[T0 = SessionTime[]];
   Print[N[
     a = -Re[g] - (1/Pi)^(d)*
        NIntegrate[
         Simplify[Cos[Pi*x]*D[f[x], {x, d}]], {x, 1, Infinity}, 
         WorkingPrecision -> prec*(105/100), 
         PrecisionGoal -> prec*(105/100)], prec]];
   Print[SessionTime[] - T0, " seconds"];
   Print[N[
     b = Im[g] + (1/Pi)^(d + 1)*
        NIntegrate[
         Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
         WorkingPrecision -> prec*(105/100), 
         PrecisionGoal -> prec*(105/100)], prec]];
   Print[SessionTime[] - T0, " seconds"];
   Print[N[Sqrt[a^2 + b^2], prec]]; Print[DateString[]];, 
   If[Mod[d, 4] == 3, f[x_] = x^(1/x); ClearAll[a, b, h];
    h[n_] := 
     Sum[StirlingS1[n, k]*
       Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1, n}];
    h[0] = 1; g = 2 I/Pi - Sum[-I^(n + 1) h[n]/Pi^(n + 1), {n, 1, d}];
    Print[DateString[]];
    Print[T0 = SessionTime[]];
    Print[
     N[a = -Re[g] + (1/Pi)^(d + 1)*
         NIntegrate[
          Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
          WorkingPrecision -> prec*(105/100), 
          PrecisionGoal -> prec*(105/100)], prec]];
    Print[SessionTime[] - T0, " seconds"];
    Print[
     N[b = Im[g] - (1/Pi)^(d + 1)*
         NIntegrate[
          Simplify[Sin[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
          WorkingPrecision -> prec*(105/100), 
          PrecisionGoal -> prec*(105/100)], prec]];
    Print[SessionTime[] - T0, " seconds"];
    Print[N[Sqrt[a^2 + b^2], prec]]; Print[DateString[]];]]]]

Here are some of my best timings to compare with the program's results:

digits  seconds
1000    38.8650545
2000    437.4906125
3000    889.473875
4000    1586.000714
5000    2802.591704
6000    4569.41586
7000    6891.057587
8000    9659.318566
9000    13491.43967
10000   17355
11000   
12000   
13000   
14000   
15000   53385.02323
16000   
17000   
18000   
19000   
20000   123876.4331
21000   
22000   
23000   
24000   
25000   229130.3088
26000   
27000   
28000   
29000   
30000   411848.6322

Edit: On Fri 5 Jun 2015 20:41:45 I started a 35,000 digit computation with the above "automated" program.

Edit: The 35,000 digit computation should be done by 10:24:38 am EDT | Sunday, June 14, 2015. In the above "automated" program I forgot to adjust the MaxExtraPrecision, but that shouldn't affect the accuracy in that program. It already computed the real part of the integral to 35,000 digits and the first 30,000 of those are the same as the real part of my previously mentioned 30,000 digit calculation. I will keep you posted.

Edit: The 35,000 digit computation finished on Sun 14 Jun 2015 06:52:29, taking 727844 seconds. It is attached as 35KMKB.nb. The first 30,000 digits of those are the same as the ones of my previously mentioned 30,000 digit calculation. (That shows the computation didn't take any "wild" turns because of the lack of MaxExtraPrecision.) Further it is a good check of the 30,000 digit run, as all of the bigger computations are of the smaller, because they all are calculated with distinct formulas using different orders of the derivative of x^(1/x).

Feb 28, 2016

For 2000 digits Mathematica 10. 2.0 shows some remarkable improvement over 10.1.2 with the above "automated program" for computing the digits of the integral analog of the MRB constant.

I will post some speed records that are strictly what the program produces in V 10.2.0, below, no picking and choosing of the methods by a human being. Some results will naturally be slower than my previously mentioned speed records, because I tried so very many methods and recorded only the fastest results.

digits          seconds

2000    256.3853590 
3000    794.4361122
4000       1633.5822870
5000        2858.9390025
10000      17678.7446323 
20000      121431.1895170
40000       I got error msg

to be continued

I have to change the program for 40,000 digits! I'll post the new program when I get 40,000 to work.

As of Wed 29 Jul 2015 11:40:10, one of my computers was happily and busily churning away at 40,000 digits of the integral analog of the MRB constant, using the following formula.

Edit: Mathematica crashed at 11:07 PM 8/4/2016

(I used MKB as a symbol for the integral analog because it is called the MKB constant. You can find the name MKB constant at http://www.ebyte.it/library/educards/constants/MathConstants.html .) If you can weed through my code, at the bottom of this reply, you might want to check the formula for the placement of pluses, minuses and imaginary units!!! A little hint when checking if the formula matches the code, d is 80 so Mod[d,4] =0.

f[x_] = x^(1/x) : a[n_] := 
  Sum[StirlingS1[n, k]*
    Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1, n}]; a[0] = 1;
g = 2 I/Pi - Sum[-I^(n + 1) a[n]/Pi^(n + 1), {n, 1, 80}]
MKB = -g + (I/Pi)^81*
   Integrate[f[x]*D[f[x], {x, 81}], {x, 1, Infinity}]

Here is the code,cleaned up a little: This is the version from Aug 6, 2015 452 pm; for the first time the imaginary part is signed and shown to be multiplied by the imaginary unit!

Block[{$MaxExtraPrecision = 200}, prec = 4000; f[x_] = x^(1/x);
 ClearAll[a, b, h];
 Print[DateString[]];
 Print[T0 = SessionTime[]];

 If[prec > 35000, d = Ceiling[0.002 prec], 
  d = Ceiling[0.264086 + 0.00143657 prec]];

 h[n_] := 
  Sum[StirlingS1[n, k]*
    Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1, n}];

 h[0] = 1;
 g = 2 I/Pi - Sum[-I^(n + 1) h[n]/Pi^(n + 1), {n, 1, d}];

 sinplus1 := 
  NIntegrate[
   Simplify[Sin[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
   WorkingPrecision -> prec*(105/100), 
   PrecisionGoal -> prec*(105/100)];

 cosplus1 := 
  NIntegrate[
   Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
   WorkingPrecision -> prec*(105/100), 
   PrecisionGoal -> prec*(105/100)];

 middle := Print[SessionTime[] - T0, " seconds"];

 end := Module[{}, Print[SessionTime[] - T0, " seconds"];
   Print[c = Abs[a + b]]; Print[DateString[]]];


 If[Mod[d, 4] == 0, 
  Print[N[a = -Re[g] - (1/Pi)^(d + 1)*sinplus1, prec]];
  middle;
  Print[N[b = -I (Im[g] - (1/Pi)^(d + 1)*cosplus1), prec]];
  end];


 If[Mod[d, 4] == 1, 
  Print[N[a = -Re[g] - (1/Pi)^(d + 1)*cosplus1, prec]];
  middle;
  Print[N[b = -I (Im[g] + (1/Pi)^(d + 1)*sinplus1), prec]]; end];

 If[Mod[d, 4] == 2, 
  Print[N[a = -Re[g] + (1/Pi)^(d + 1)*sinplus1, prec]];
  middle;
  Print[N[b = -I (Im[g] + (1/Pi)^(d + 1)*cosplus1), prec]];
  end];

 If[Mod[d, 4] == 3, 
  Print[N[a = -Re[g] + (1/Pi)^(d + 1)*cosplus1, prec]];
  middle;
  Print[N[b = -I (Im[g] - (1/Pi)^(d + 1)*sinplus1), prec]];
  end];]

Come back to see if I decided whether to try the 40K run again.

EDIT: It looks like I've only got one more test for the program (if it passes) before I retry the 40,000 digit calculation!

EDIT:On Thu 6 Aug 2015 17:23:18, I restarted the 40K run with Windows 10.

EDIT: My first thought was the program took up too much RAM, apparently over 115 GB! ( I have 64GB installed and a 51 GB paging file; nevertheless, Windows 10 closed the Mathematica kernel to keep from the computer from loosing data. Can someone else try the 40K run on their computer? It should take 2 weeks on a fast one. Please let me know if you try it and let me know the results, so I will know I don't have a problem with my computer., If two weeks is too great of a commitment, can you try taking note on the RAM used for two progressively larger runs, like 20K and 30 K? I will do the same, and we can compare notes. Thank You!

EDIT: I've been monitoring memory usage for smaller runs and found the program only uses minimal memory! This makes the action of Windows 10 (closing Mathematica kernel to avoid data loss) all the more a mystery! Could the 40K run really use up all of that RAM?

I know there are quite a few of you viewing this post; however, is anyone out there working on these calculations?.

Aug 10, 2016

V. 11 is about 1.25 times faster with my newest program for calculating MKB, (the integral analog of the MRB sum). V 10. 4 calculated 20,000 digits in 121431.1895170 seconds and V 11 did it in 96979.6545388 seconds. I've got a little more testing to do, (about 1 day's worth), then I'll try 40,000 digits again, which should take about 12 days. I will post all my updates here, so you might want to save this message as a favorite so you won't loose it.

Update 1

The 40 K automatically started against my wishes on Thu 11 Aug 2016 15:42:08, (due to my pasting two codes at once). I'll keep you informed, how it goes.

Update 2

Windows 10 is pushing an update. Wednesday is the latest it will let me restart. I will restart now with all the updates I can get, Then deffer further ones and hopefully get 12 restart free days to do my 40K.

Update 3

I ran all the updates I could find, differed further ones and restarted 40K on Sun 14 Aug 2016 10:32:40.

Update 4

Widows 10 stopped the calculation! AGAIN! Can anyone else try it and see if you get anywhere? Here is my latest code:

(*Other program:For large calculations.Tested for 1000-35000 digits-- \
see post at \
http://community.wolfram.com/groups/-/m/t/366628?p_p_auth=KA7y1gD4 \
and search for "analog" to find pertinent replies.Designed to include \
40000 digits.A157852 is saved as c,the real part as a and the \
imaginary part as b.*)Block[{$MaxExtraPrecision = 200}, 
 prec = 40000(*Replace 40000 with number of desired digits.40000 \
digits should take two weeks on a 3.5 GH Pentium processor.*); 
 f[x_] = x^(1/x);
 ClearAll[a, b, h];
 Print[DateString[]];
 Print[T0 = SessionTime[]];
 If[prec > 35000, d = Ceiling[0.002 prec], 
  d = Ceiling[0.264086 + 0.00143657 prec]];
 h[n_] := 
  Sum[StirlingS1[n, k]*
    Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1, n}];
 h[0] = 1;
 g = 2 I/Pi - Sum[-I^(n + 1) h[n]/Pi^(n + 1), {n, 1, d}];
 sinplus1 := 
  NIntegrate[
   Simplify[Sin[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
   WorkingPrecision -> prec*(105/100), 
   PrecisionGoal -> prec*(105/100)];
 cosplus1 := 
  NIntegrate[
   Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
   WorkingPrecision -> prec*(105/100), 
   PrecisionGoal -> prec*(105/100)];
 middle := Print[SessionTime[] - T0, " seconds"];
 end := Module[{}, Print[SessionTime[] - T0, " seconds"];
   Print[c = Abs[a + b]]; Print[DateString[]]];
 If[Mod[d, 4] == 0, 
  Print[N[a = -Re[g] - (1/Pi)^(d + 1)*sinplus1, prec]];
  middle;
  Print[N[b = -I (Im[g] - (1/Pi)^(d + 1)*cosplus1), prec]];
  end];
 If[Mod[d, 4] == 1, 
  Print[N[a = -Re[g] - (1/Pi)^(d + 1)*cosplus1, prec]];
  middle;
  Print[N[b = -I (Im[g] + (1/Pi)^(d + 1)*sinplus1), prec]]; end];
 If[Mod[d, 4] == 2, 
  Print[N[a = -Re[g] + (1/Pi)^(d + 1)*sinplus1, prec]];
  middle;
  Print[N[b = -I (Im[g] + (1/Pi)^(d + 1)*cosplus1), prec]];
  end];
 If[Mod[d, 4] == 3, 
  Print[N[a = -Re[g] + (1/Pi)^(d + 1)*cosplus1, prec]];
  middle;
  Print[N[b = -I (Im[g] - (1/Pi)^(d + 1)*sinplus1), prec]];
  end];] (*Marvin Ray Burns,Aug 06 2015*)

Sometime in 2017,

To try to get windows 10 from closing Mathematica during the computation I tried the instructions found at https://www.autoitscript.com/forum/topic/177749-stopping-windows-10-from-auto-closing-programs-to-free-up-ram/ . I will record progress in this spot as I did before.

UPDATE I followed the memory usage on my computer and it did use around 64 GB of RAM. And then Windows closed down the Mathematica kernel. I assume that If I can ever afford to maximize my RAM to its 128GB limit the computation will be successful!

Anyone have better luck?

Nov, 2017

Concentrating on integral analog of the MRB constant:

Search "integral analog" in the above messages for understanding of the integral anaolg of the MRB constant. And search "For 2000 digits Mathematica 10. 2.0" for my history of calculating 40,000 digits of it.

. The basic program I wrote to calculate the Integral analog of the MRB constant is 

(*Other program:For large calculations.Tested for 1000-35000 digits-- \
see post at \
http://community.wolfram.com/groups/-/m/t/366628?p_p_auth=KA7y1gD4 \
and search for "analog" to find pertinent replies.Designed to include \
40000 digits.A157852 is saved as c,the real part as a and the \
imaginary part as b.*)Block[{$MaxExtraPrecision = 200}, 
 prec = 40000(*Replace 40000 with number of desired digits.40000 \
digits should take two weeks on a 3.5 GH Pentium processor.*);
 f[x_] = x^(1/x);
 ClearAll[a, b, h];
 Print[DateString[]];
 Print[T0 = SessionTime[]];
 If[prec > 35000, d = Ceiling[0.264086 + 0.0017 prec], 
  d = Ceiling[0.264086 + 0.00143657 prec]];
 h[n_] := 
  Sum[StirlingS1[n, k]*
    Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1, n}];
 h[0] = 1;
 g = 2 I/Pi - Sum[-I^(n + 1) h[n]/Pi^(n + 1), {n, 1, d}];
 sinplus1 := 
  NIntegrate[
   Simplify[Sin[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
   WorkingPrecision -> prec*(105/100), 
   PrecisionGoal -> prec*(105/100)];
 cosplus1 := 
  NIntegrate[
   Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
   WorkingPrecision -> prec*(105/100), 
   PrecisionGoal -> prec*(105/100)];
 middle := Print[SessionTime[] - T0, " seconds"];
 end := Module[{}, Print[SessionTime[] - T0, " seconds"];
   Print[c = Abs[a + b]]; Print[DateString[]]];
 If[Mod[d, 4] == 0, 
  Print[N[a = -Re[g] - (1/Pi)^(d + 1)*sinplus1, prec]];
  middle;
  Print[N[b = -I (Im[g] - (1/Pi)^(d + 1)*cosplus1), prec]];
  end];
 If[Mod[d, 4] == 1, 
  Print[N[a = -Re[g] - (1/Pi)^(d + 1)*cosplus1, prec]];
  middle;
  Print[N[b = -I (Im[g] + (1/Pi)^(d + 1)*sinplus1), prec]]; end];
 If[Mod[d, 4] == 2, 
  Print[N[a = -Re[g] + (1/Pi)^(d + 1)*sinplus1, prec]];
  middle;
  Print[N[b = -I (Im[g] + (1/Pi)^(d + 1)*cosplus1), prec]];
  end];
 If[Mod[d, 4] == 3, 
  Print[N[a = -Re[g] + (1/Pi)^(d + 1)*cosplus1, prec]];
  middle;
  Print[N[b = -I (Im[g] - (1/Pi)^(d + 1)*sinplus1), prec]];
  end];] (*Marvin Ray Burns,

I think I found out why the integral analog of the MRB constant is so hard to calculate to prec=40000 digits! I've been using too high of an order of the derivative of x^(1/x). I've been running out of memory because of using the 80th derivative from d = Ceiling[0.002 prec], because the 58th derivative from Ceiling[0.264086 + 0.00143657 prec] was apparently to small leaving an error statement. I just now asked myself, why make such a big jump? When my big computer gets back from its tuneup I think I will try Ceiling[0.00146 prec] = 59th derivative.

EDIT

I tried Ceiling[0.00146 prec] and Ceiling[0.00145 prec] in Mathematica 11.0 and lost the kernel both times after 6 - 12 hours!

I'm now trying Ceiling[0.0017 prec] with v 10.4. It's been over 12 hours and I've not lost the kernel yet. Wish me luck!

EDIT

I got the following error message and a real part that does not agree with previous computations.

"NIntegrate failed to converge to prescribed accuracy after 9 recursive bisections in x near {x} = {<<42008>>}. NIntegrate obtained -<<42012>> and <<42014>> for the integral and error estimates."

I'm now trying Ceiling[0.0018 prec] with v 10.4....

Ceiling[0.0018 prec] with v 10.4 gave the same error.

I'm working on a new program that uses less memory; stay tuned!

March 13, 2018

I'm now trying Ceiling[0.0019 prec] with v 11.2...., at Mon 12 Mar 2018 05:40:13 Here is a record of the memory used by the program. At times the computer may use significantly more.

"Mon 12 Mar 2018 10:30:00" 14 GB DDR3 RAM

"Mon 12 Mar 2018 13:00:00" 15 GB DDR3 RAM

"Mon 12 Mar 2018 14:00:00" 16 GB DDR3 RAM

"Mon 12 Mar 2018 14:30:00" 17 GB DDR3 RAM

"Mon 12 Mar 2018 15:00:00" 18 GB DDR3 RAM

"Mon 12 Mar 2018 22:30:00" 24 GB DDR3 RAM

"Mon 12 Mar 2018 24:00:00" 26 GB DDR3 RAM

"Tue 13 Mar 2018 06:30:00" 33 GB DDR3 RAM

"Tue 13 Mar 2018 07:30:00" 14 GB DDR3 RAM

"Tue 13 Mar 2018 08:00:00" 15 GB DDR3 RAM

"Tue 13 Mar 2018 08:30:00" 16 GB DDR3 RAM

"Tue 13 Mar 2018 11:30:00" 19 GB DDR3 RAM

"Tue 13 Mar 2018 12:00:00" 20 GB DDR3 RAM

"Tue 13 Mar 2018 14:00:00" 22 GB DDR3 RAM

"Tue 13 Mar 2018 14:30:00" 5 GB DDR3 RAM

"Tue 13 Mar 2018 15:00:00" 6 GB DDR3 RAM

"Tue 13 Mar 2018 16:30:00" 8 GB DDR3 RAM

"Tue 13 Mar 2018 18:30:00" 11 GB DDR3 RAM

"Tue 13 Mar 2018 19:30:00" 13 GB DDR3 RAM

"Tue 13 Mar 2018 20:30:00" 14 GB DDR3 RAM

"Tue 13 Mar 2018 21:00:00" 8 GB DDR3 RAM

"Tue 13 Mar 2018 21:30:00" 11 GB DDR3 RAM

"Wed 14 Mar 2018 07:30:00" 26 GB DDR3 RAM

"Wed 14 Mar 2018 07:30:00" 26 GB DDR3 RAM

"Wed 14 Mar 2018 08:00:00" 25 GB DDR3 RAM.Total used by programs 44.54 GB DDR3 RAM.

"Wed 14 Mar 2018 20:00:00" 37 GB DDR3 RAM.Total used by programs 40.32 GB DDR3 RAM.

"Thu 15 Mar 2018 08:00:00" 0 GB DDR3 RAM.Total used by programs 3.84 GB DDR3 RAM.

Update:

V 11.2 cut off its kernel sometime between "Mon 14 Mar 2018 20:00:00" and "Mon 15 Mar 2018 08:00:00."

It seems to me that V11 under Windows 10 cuts off my RAM intensive operations.

The last success I had was using V10.2 under Windows 7. I am trying that combination again, this time for the 40 k digits. Below is the code I used than and am using now. At first I just changed only "prec=35000" to "prac=40000" and got an errant answer for the real part. And I got memory use starting out at

"Thu 15 Mar 2018 08:53:47" 0.3 GB, total computer use 3.84 GB

"Thu 15 Mar 2018 11:48:47" 04.3 GB, total computer use 7.68 GB

"Thu 15 Mar 2018 13:00:00" 01.3 GB, total computer use 5.12 GB

"Thu 15 Mar 2018 14:00:00" 01.3 GB, total computer use 5.12 GB

So now I also changed the coefficient of prec from "d = Ceiling[0.264086 + 0.00143657 prec]" to "d = Ceiling[ 0.002 prec]." I think I can get by with .002 because 10.3 in Windows 7 seems to use less memory that the V 11's in Windows 10.

prec = 40000; d = Ceiling[0.002 prec]; If[Mod[d, 4] == 0, 
 f[x_] = x^(1/x); ClearAll[a, b, h];
 a[n_] := 
  Sum[StirlingS1[n, k]*
    Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1, n}]; a[0] = 1;
 g = 2 I/Pi - Sum[-I^(n + 1) a[n]/Pi^(n + 1), {n, 1, d}];
 Print[DateString[]];
 Print[T0 = SessionTime[]];
 Print[N[a = -Re[g] - (1/Pi)^(d + 1)*
      NIntegrate[
       Simplify[Sin[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
       WorkingPrecision -> prec*(105/100), 
       PrecisionGoal -> prec*(105/100)], prec]];
 Print[SessionTime[] - T0, " seconds"];
 Print[N[b = 
    Im[g] - (1/Pi)^(d + 1)*
      NIntegrate[
       Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
       WorkingPrecision -> prec*(105/100), 
       PrecisionGoal -> prec*(105/100)], prec]];
 Print[SessionTime[] - T0, " seconds"];
 Print[N[Sqrt[a^2 + b^2], prec]]; Print[DateString[]];, 
 If[Mod[d, 4] == 1, f[x_] = x^(1/x); ClearAll[a, b, h];
  h[n_] := 
   Sum[StirlingS1[n, k]*
     Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1, n}];
  h[0] = 1; g = 2 I/Pi - Sum[-I^(n + 1) h[n]/Pi^(n + 1), {n, 1, d}];
  Print[DateString[]];
  Print[T0 = SessionTime[]];
  Print[N[
    a = -Re[g] - (1/Pi)^(d + 1)*
       NIntegrate[
        Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
        WorkingPrecision -> prec*(105/100), 
        PrecisionGoal -> prec*(105/100)], prec]];
  Print[SessionTime[] - T0, " seconds"];
  Print[N[
    b = Im[g] + (1/Pi)^(d + 1)*
       NIntegrate[
        Simplify[Sin[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
        WorkingPrecision -> prec*(105/100), 
        PrecisionGoal -> prec*(105/100)], prec]];
  Print[SessionTime[] - T0, " seconds"];
  Print[N[Sqrt[a^2 + b^2], prec]]; Print[DateString[]];, 
  If[Mod[d, 4] == 2, f[x_] = x^(1/x); ClearAll[a, b, h];
   a[n_] := 
    Sum[StirlingS1[n, k]*
      Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1, n}];
   a[0] = 1; g = 2 I/Pi - Sum[-I^(n + 1) a[n]/Pi^(n + 1), {n, 1, d}];
   Print[DateString[]];
   Print[T0 = SessionTime[]];
   Print[N[
     a = -Re[g] - (1/Pi)^(d)*
        NIntegrate[
         Simplify[Cos[Pi*x]*D[f[x], {x, d}]], {x, 1, Infinity}, 
         WorkingPrecision -> prec*(105/100), 
         PrecisionGoal -> prec*(105/100)], prec]];
   Print[SessionTime[] - T0, " seconds"];
   Print[N[
     b = Im[g] + (1/Pi)^(d + 1)*
        NIntegrate[
         Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
         WorkingPrecision -> prec*(105/100), 
         PrecisionGoal -> prec*(105/100)], prec]];
   Print[SessionTime[] - T0, " seconds"];
   Print[N[Sqrt[a^2 + b^2], prec]]; Print[DateString[]];, 
   If[Mod[d, 4] == 3, f[x_] = x^(1/x); ClearAll[a, b, h];
    h[n_] := 
     Sum[StirlingS1[n, k]*
       Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1, n}];
    h[0] = 1; g = 2 I/Pi - Sum[-I^(n + 1) h[n]/Pi^(n + 1), {n, 1, d}];
    Print[DateString[]];
    Print[T0 = SessionTime[]];
    Print[
     N[a = -Re[g] + (1/Pi)^(d + 1)*
         NIntegrate[
          Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
          WorkingPrecision -> prec*(105/100), 
          PrecisionGoal -> prec*(105/100)], prec]];
    Print[SessionTime[] - T0, " seconds"];
    Print[
     N[b = Im[g] - (1/Pi)^(d + 1)*
         NIntegrate[
          Simplify[Sin[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
          WorkingPrecision -> prec*(105/100), 
          PrecisionGoal -> prec*(105/100)], prec]];
    Print[SessionTime[] - T0, " seconds"];
    Print[N[Sqrt[a^2 + b^2], prec]]; Print[DateString[]];]]]]

Memory use:

"Thu 15 Mar 2018 16:30:46" .3 GB. Total used by programs 3.8 GB.

Here is a break down of the memory use as of 16:45 March 17, 2018

enter image description here

Mar 18, 2018, 8:10 AM

Just in case I rum out of memory, I increased the size of my paging file!

enter image description here

"Sun 17 Mar 2018 16:00:00" 15 GB. Total used by programs 49.92 GB.

enter image description here

enter image description here

I no longer believe the V 11's use a lot more memory. If I hadn't increased my paging file Windows would have closed Mathematica already!

enter image description here

I might be slowing the computation down a little, but I don't want to take any chances of running out of memory, so I increased the paging file 1 more time. enter image description here enter image description here The computer has been commiting up to 160 GB of total RAM for a while now. enter image description here Finally, the committed memory is going down. enter image description here

My computer is acting real sluggish right now. Mathematica is using a minimum amount of DDR3 RAM, but the computer is still committing a near record of virtual RAM. enter image description here My computer is acting too funny, so I aborted the evaluation. The kernel remained running and overall memory remained maxed out. I tried to retrieve a and b (the variables with the real and imaginary parts of the solution), but the computer wouldn't recall them for me. The computer won't evaluate any Mathematica operations. I am restarting my computer and inspecting the damage!

Update:

Windows said it found no errors on my hard drive; that's great!

I'm going to replace my Intel 6 core processor with a faster 8 -core Intel Xeon E5-2687W v2 CPU, and ad an additional hard drive. The new processor and my motherboard both take 128 GB RAM, but ECC is the only 16G DDR3 mims I can find. I'm not sure if my MSI Big Bang-XPower II will take ECC. 40,000 digits of the integral analog might have to wait for me to get a new system. I am working on a new program to compute the MRB constant in little steps, and will use it on my new processor.

Attachments:
15KMKB3.nb
35KMKB.nb
MKB30K2 (1).nb
fastest10KMKB.nb
POSTED BY: Marvin Ray Burns
Answer
11 Replies
Sort By:

I got substantial improvement in calculating the digits of MKB by using V11.3 in May 2018, my new computer (processor Intel(R) Core(TM) i7-7700 CPU @ 3.60GHz, 3601 MHz, 4 Core(s), 8 Logical Processor(s) with 16 GB 2400 MH DDR4 RAM):

Digits  Seconds
2000    67.5503022
3000    217.096312
4000    514.48334
5000    1005.936397
10000   8327.18526
 20000 2*35630.379241 ~71000

They are found in the attached 2018 quad MKB.nb.

They are twice as fast,(or more) as my old records with the same program using Mathematica 10.2 in July 2015 on my old big computer (a six core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz 3.20 GHz with 64 GB of 1066 MHz DDR3 RAM):

digits          seconds

2000    256.3853590 
3000    794.4361122
4000       1633.5822870
5000        2858.9390025
10000      17678.7446323 
20000      121431.1895170
40000       I got error msg
Attachments:
2018 quad MKB.nb
POSTED BY: Marvin Ray Burns
Answer

You might get tired of hearing this, but I made another improvement to my MKB computation formula and am trying to get 40,000 digits from it.

Code

 MaxMemoryUsed[(*Other program:For large calculations.Tested for \
 1000-35000 digits-- see post at \
 http://community.wolfram.com/groups/-/m/t/366628?p_p_auth=KA7y1gD4 \
 and search for "analog" to find pertinent replies.Designed to include \
 40000 digits.A157852 is saved as c,the real part as a and the \
 imaginary part as b.*)
  Block[{$MaxExtraPrecision = 200}, 
   prec = 40000(*Replace 40000 with number of desired digits.40000 \
 digits should take two weeks on a 3.5 GH Pentium processor.*);
   f[x_] = x^(1/x);
   ClearAll[a, b, h];
   Print[DateString[]];
   Print[T0 = SessionTime[]];
   If[prec > 35000, d = Ceiling[0.264086 + 0.0019 prec], 
    d = Ceiling[0.264086 + 0.00143657 prec]];
   h[n_] := 
    Sum[StirlingS1[n, k]*
      Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1, n}];
   h[0] = 1;
   g = 2 I/Pi - Sum[-I^(n + 1) h[n]/Pi^(n + 1), {n, 1, d}];
   sinplus1 := 
    NIntegrate[
     Simplify[Sin[Pi*x]*Simplify[D[f[x], {x, d + 1}]]], {x, 1, 
      Infinity}, WorkingPrecision -> prec*(105/100), 
     PrecisionGoal -> prec*(105/100)];
   cosplus1 := 
    NIntegrate[
     Simplify[Cos[Pi*x]*Simplify[D[f[x], {x, d + 1}]]], {x, 1, 
      Infinity}, WorkingPrecision -> prec*(105/100), 
     PrecisionGoal -> prec*(105/100)];
   middle := Print[SessionTime[] - T0, " seconds"];
   end := Module[{}, Print[SessionTime[] - T0, " seconds"];
     Print[c = Abs[a + b]]; Print[DateString[]]];
   If[Mod[d, 4] == 0, 
    Print[N[a = -Re[g] - (1/Pi)^(d + 1)*sinplus1, prec]];
    middle;
    Print[N[b = -I (Im[g] - (1/Pi)^(d + 1)*cosplus1), prec]];
    end];
   If[Mod[d, 4] == 1, 
    Print[N[a = -Re[g] - (1/Pi)^(d + 1)*cosplus1, prec]];
    middle;
    Print[N[b = -I (Im[g] + (1/Pi)^(d + 1)*sinplus1), prec]]; end];
   If[Mod[d, 4] == 2, 
    Print[N[a = -Re[g] + (1/Pi)^(d + 1)*sinplus1, prec]];
    middle;
    Print[N[b = -I (Im[g] + (1/Pi)^(d + 1)*cosplus1), prec]];
    end];
   If[Mod[d, 4] == 3, 
    Print[N[a = -Re[g] + (1/Pi)^(d + 1)*cosplus1, prec]];
    middle;
    Print[N[b = -I (Im[g] - (1/Pi)^(d + 1)*sinplus1), prec]];
    end];] (*Marvin Ray Burns,Aug 06 2015*)]

Output so far:

Fri 18 May 2018 08:03:35

65.6633081

Here are the results from the task manager:

enter image description here
POSTED BY: Marvin Ray Burns
Answer

My computer is getting so sluggish that it has become nearly impossible to get snippets of RAM use! I was able to determine that it is, however, still working on the 40,000 digits. I'll let it do its job!
POSTED BY: Marvin Ray Burns
Answer

June 5, 2018

Mathematica got hung up on the 40k run again! this time it complained about the dynamics stopping working and wouldn't quit complaining. I think it needs a smarter program! Anyone else want to try to beat this world record??

POSTED BY: Marvin Ray Burns
Answer

Shutterstock has found the MKB constant, I(2N), at least 2 times! enter image description here enter image description here

enter image description here
POSTED BY: Marvin Ray Burns
Answer

Here is a comparison between some of the last few versions of Mathematica computing the MKB constant on similar computers.

digits    seconds
            V10.3       v11.3   V12.0
2000       256            67      67
3000       794           217     211
4000       1633          514     492
5000       2858          1005    925
10000      17678         8327    7748
20000      121431       71000   66177
30000      411848      ?        229560

For documentation of the 229560 seconds 30000 digit computation see "mkb 30k v12p0 2020.nb."

For documentation of the 411848 seconds 30000 digit computation see "MKB30K2 (1).nb."

Attachments:
MKB30K2 (1).nb
mkb 30k v12p0 2020.nb
POSTED BY: Marvin Ray Burns
Answer

I made a quicker program for calculating the digits of the MKB constant in V12.1.0 enter image description here

Module[{$MaxExtraPrecision = 200, sinplus1, cosplus1, middle, end, a, 
  b, c, d, g, h}, prec = 5000; f[x_] = x^(1/x);
  Print[DateString[]];
  Print[T0 = SessionTime[]];

   d = Ceiling[0.264086 + 0.00143657 prec];
  h[n_] := 
    Sum[StirlingS1[n, k]*
        Sum[(-j)^(k - j)*Binomial[k, j], {j, 0, k}], {k, 1, n}];
  h[0] = 1;
  g = 2 I/Pi - Sum[-I^(n + 1) h[n]/Pi^(n + 1), {n, 1, d}];
  sinplus1 := Module[{},
     NIntegrate[
       Simplify[Sin[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
       WorkingPrecision -> prec*(105/100), 
       PrecisionGoal -> prec*(105/100)]];
  cosplus1 := Module[{},
     NIntegrate[
       Simplify[Cos[Pi*x]*D[f[x], {x, d + 1}]], {x, 1, Infinity}, 
       WorkingPrecision -> prec*(105/100), 
       PrecisionGoal -> prec*(105/100)]];
  middle := Module[{}, Print[SessionTime[] - T0, " seconds"]];
  end := Module[{}, Print[SessionTime[] - T0, " seconds"];
      Print[N[Sqrt[a^2 - b^2], prec]]; Print[DateString[]]];
  If[Mod[d, 4] == 0, 
    Print[N[a = -Re[g] - (1/Pi)^(d + 1)*sinplus1, prec]];
    middle;
    Print[N[b = -I (Im[g] - (1/Pi)^(d + 1)*cosplus1), prec]];
    end];
  If[Mod[d, 4] == 1, 
    Print[N[a = -Re[g] - (1/Pi)^(d + 1)*cosplus1, prec]];
    middle;
    Print[N[b = -I (Im[g] + (1/Pi)^(d + 1)*sinplus1), prec]]; end];
  If[Mod[d, 4] == 2, 
    Print[N[a = -Re[g] + (1/Pi)^(d + 1)*sinplus1, prec]];
    middle;
    Print[N[b = -I (Im[g] + (1/Pi)^(d + 1)*cosplus1), prec]];
    end];
  If[Mod[d, 4] == 3, 
    Print[N[a = -Re[g] + (1/Pi)^(d + 1)*cosplus1, prec]];
    middle;
    Print[N[b = -I (Im[g] - (1/Pi)^(d + 1)*sinplus1), prec]];
    end];]

Whether it will allow me to calculate more digits is a question that will be answered in a week or two.

Here is a comparison of timings on similar computers.

 digits    seconds

                                              (Impoved code)
             V10.3       v11.3   V12.0         V12.1 
 2000       256            67      67           58
 3000       794           217     211          186
 4000       1633          514     492          447
 5000       2858          1005    925          854
 10000      17678         8327    7748        7470
 20000      121431       71000   66177
 30000      411848      ?        229560

Seethe following cloud notebook for the results from my improved code. https://www.wolframcloud.com/obj/bmmmburns/Published/2nd%2040k%20mkb%20prep.nb
POSTED BY: Marvin Ray Burns
Answer

I finally computed 40,000 digits of the MKB constant!!!!!

(March 30, 2021, approximately 8:00 am) The new 40,000 digit record took 362945 seconds, while the 35,000 digits old record took 727,844 seconds. That's more 2.29 times as fast: (40000/362945)/(35000/727844.) = 2.291867126660277. See attached first 40 K MKB.nb and 35KMKB (1).nb

Here is the short, very fast code.

g[x_] = x^(1/x); t = (Timing[
    test = -(I NIntegrate[(g[(1 + t I)])/(Exp[Pi t]), {t, 0, 
           Infinity}, WorkingPrecision -> 40000, 
          Method -> "Trapezoidal", MaxRecursion -> 18] + I/Pi)])[[1]];
t

The recommended setting for MaxRecursion (M.R.) is found in the following table.

digits     M.R.
2048      10
3000      11
4096      12

10000     13
40000     18

40000/2048+9 Here are the new speed records 

digits       seconds
2000        23
3000        96
4000       165
5000        442
6000        623
10000      3250
40000      362945=101 hours

Documentation is available from the Wolfram Cloud here. (40,000 digits are saved at the bottom by the name of "test.") Here is a redo of the 10K run, where "test" is 40,000 digits of which 35,000 have been computed by very different methods.

 g[x_] =  x^(1/x); t = (Timing[ t10k = -(I NIntegrate[(g[(1 + t I)])/(Exp[Pi t]), {t, 0,  Infinity}, WorkingPrecision -> 10000,  Method -> "Trapezoidal", MaxRecursion -> 13] + I/Pi)])[[1]];t


 (*3250.55*)

 N[test - t10k, 10000]

  (* 0.*10^-10001 + 0.*10^-10001 I*)

"Thu 1 Apr 2021 11:42:14" I computed a much faster 40,000 digits of the MKB constant.

g[x_] = x^(1/x); t = (Timing[
test3 = -(I NIntegrate[(g[(1 + t I)])/(Exp[Pi t]), {t, 0, 
Infinity}, WorkingPrecision -> 40000, 
Method -> "Trapezoidal", MaxRecursion -> 15] + I/Pi)])[[1]];

175,551seconds That's more 473% as fast as the old 35,000 digit record!!!: (40000/175551)/(35000/727844.)=4.738347911921403

Here are the new speed records 

digits       seconds
2000        23
3000        96
4000       165
5000        442
6000        623
10000      3250
40000      175551=49  hours

The new recommended setting for MaxRecursion (M.R.) and expected time (ET) is found in the following table.

       digits    M.R.   
      1031  default
      2410      10
      4456      11    
      8000      12
      16000    13
      32000    14
      64000    15
      128000   16
Attachments:
35KMKB (1).nb
first 40 K MKB.nb
POSTED BY: Marvin Ray Burns
Answer

On Tue 6 Apr 2021 04:13:58, I computed 64,000 digits of the MKB constant using the following code.

g[x_] = x^(1/x); t = 
 Timing[t64k = -(I NIntegrate[(g[(1 + t I)])/(Exp[Pi t]), {t, 0, 
          Infinity}, WorkingPrecision -> 64000, 
         Method -> "Trapezoidal", MaxRecursion -> 15] + I/Pi)][[1]];
t

I verified it to 40,000 digits, See attached 64KMKB.nb.

Here are the new speed records 

digits       seconds
2000        23
3000        96
4000       165
5000        442
6000        623
10000      3250
40000      175551=49  hours
64000      393847=109  hours, faster than the 35,000 using the long code.

As mentioned in a previous post: The 35,000 digit computation finished on Sun 14 Jun 2015 06:52:29, taking 727844 seconds

Attachments:
64KMKB.nb
POSTED BY: Marvin Ray Burns
Answer

Here is proof of the faster integral I'm using is indeed exactly equal to the MKB constant integral. In the following hypothesis, the MKB constant integral=LHS and the faster integral I'm using=RHS.

g(x)=x^(1/x), M1=hypothesis Which is the same as

enter image description here because Changing the upper limit to 2N + 1 increases MI by 2i/π.

by Ariel Gershon.

Iimofg->1

Cauchy's Integral Theorem

Lim surface h gamma r=0

Lim surface h beta r=0

limit to 2n-1

limit to 2n-

Plugging in equations [5] and [6] into equation [2] gives us:

leftright

Now take the limit as N→∞ and apply equations [3] and [4] : QED He went on to note that

enter image description here
POSTED BY: Marvin Ray Burns
Answer

I found the 64,000 digit computation was accurate only to 54,390 decimal places; see attached 54390 confirmed MKB digits.nb. The MRB constant supercomputer 2 is presently working on a more accurate 64,000 digit computation of MKB with MaxRecusion->17, a 72,000 digit computation of MKB with MaxRecusion->17 to confirm the new 64,000, (a 72,000 with MaxRecusion->18, and a 80,000 with MaxRecusion->18) both to confirm the 72,000 digits.

The new recommended setting for MaxRecursion (M.R.), as hypothesized by practice, is found in the following table. It starts out at digits≈2^(M.R.+1) but then goes down. I found that out in the 64,000 digit computation, which I used MaxRecusion->15 for. It gave the 54390 digit accuracy, as revealed by a MaxReusion->16 try of 70,000 digits in "54390 confirmed MKB digits.nb."

       digits    M.R.   
      1031  default
      2410      10
      4453      11    
      8182      12
      19734     13
      31286     14
      54390     15
      65942     16
      77494     17
      89046     18
Attachments:
54390 confirmed ...nb
POSTED BY: Marvin Ray Burns
Answer
Reply to this discussion
Community posts can be styled and formatted using the Markdown syntax.
Tag limit exceeded
Note: Only the first five people you tag will receive an email notification; the other tagged names will appear as links to their profiles.
Reply Preview
Attachments
Remove
or Discard

Group Abstract Group Abstract