# Natural Logarithm of 10 (Log(10))

## The Natural Logarithm of 10 (Log(10))

Kim, S. Normality Analysis of Current World Record Computations for Catalan’s Constant and Arc Length of a Lemniscate with a=1. arXiv Preprint arXiv:1908.08925

This world record computation of 1,200,000,000,100 digits by Seungmin Kim was done from Fri Jul 31 18:13:07 2020 to Tue Aug 18 10:02:59 2020 using the Primary Machin-like Formula (4 terms) algorithm. This time again after most of my computations, I have verified the calculation using the Secondary Machin-like Formula (4 terms) algorithm from Wed Aug 19 10:48:52 2020 to Sun Sep 6 12:14:40 2020.
Validation file generated by y-cruncher v0.7.8 Build 9506 for computation, and y-cruncher v0.7.8 Build 9506 for the verification run:
Computation: https://web.archive.org/web/20200915115810/http://www.numberworld.org/y-cruncher/records/2020_8_18_log10.txt
Verification: https://web.archive.org/web/20200915075933/http://www.numberworld.org/y-cruncher/records/2020_9_6_log10.txt

$\ln(a\cdot 10^n) = \ln a + n \ln 10$

An important identity of $$\ln 10$$ enabling effective computation of natural logarithms of numbers with scientific notation (Wikipedia)

Natural logarithm of 10 is defined as the logarithm function value of 10 where the base is $$e$$ (of which the function is also the inverse function of the exponential function). All natural logarithms of any natural number larger than 1 are proved irrational and transcendental with the Lindemann–Weierstrass theorem. It also has the BBP-type representation $$\ln 10 = \frac{1}{16} \sum_{k = 0}^\infty \left(\frac{24}{4k+1}+\frac{20}{4k+2}+\frac{6}{4k+3}+\frac{1}{4k+4}\right) \frac{1}{16^k}$$ (Source), which could be useful in verifying future record computations because it does not have to compute all the digits again after the first computation.

The Machin-like formulas are based on the identity of inverse hyperbolic cotangent $$coth^{-1} x = \frac{1}{2}[\ln(1 + \frac{1}{x}) - \ln(1 - \frac{1}{x})]$$, as the inverse hyperbolic cotangent has a trivial series expansion formula. This is trivial to induce and is in material discussed in calculus textbooks. If such similar equations are added or subtracted as appropriate to leave only one logarithm value on the right side, that becomes the quickly converging formulas used for computations.

$\ln 10 = 239 coth^{-1} 99 - 59 coth^{-1} 449 + 113 coth^{-1} 4801 - 33 coth^{-1} 8749 \\ = 478 coth^{-1} 251 + 180 coth^{-1} 449 - 126 coth^{-1} 4801 + 206 coth^{-1} 8749$

Primary (4 terms) and secondary (4 terms) Machin-like formulas for $$\ln 10$$

Same as all other mathematical constants, I have used y-cruncher by Mr. Alexander J. Yee for this computation. This program is commonly used for stress testing and benchmarking overclocked PC builds (obviously this program performs a very rigorous computation), along with fellow mathematical computing program Prime95 and linear algebra program Linpack.
The computation was theoretically about twice as intensive as Pi and half as intensive as Apéry’s constant. Unlike other series, the natural logarithms have multiple separate inverse hyperbolic cotangent series to compute the final result so each series are quite less intensive than ordinary but there are multiple series computations and accumulations. The primary formula and the secondary formula took around the same time as both have the same 4 terms.

Computation:
System information:
Operating System: Linux 5.5.6-1.el7.x86_64 x86_64
Processor(s):
Name: Intel(R) Xeon(R) CPU E5-2699 v3 @ 2.30GHz
Logical Cores: 72
Physical Cores: 36
Sockets: 2
NUMA Nodes: 2
Base Frequency: 2,299,987,856 Hz

My first computation used two Xeon CPU sockets from the Haswell era (and thus supports AVX2 SIMD vector operations that are used crucially in vector computations like y-cruncher) as I decided the Xeon Scalable Skylake Purley processors that support AVX-512 was overkill since I was gonna confront I/O bottlenecks anyways. The time would not have had much difference from using just one CPU socket. I have optimized I/O throughput further by changing the Bytes/Seek parameter and allocating more I/O Buffer to reach RAID-level performance in my file systems.

Start Date: Fri Jul 31 18:13:07 2020
End Date: Tue Aug 18 10:02:59 2020
Total Computation Time: 1470494.849 seconds
Start-to-End Wall Time: 1525791.855 seconds
CPU Utilization: 1070.37 % + 15.05 % kernel overhead
Multi-core Efficiency: 14.87 % + 0.21 % kernel overhead

The multi-core efficiency improved slightly with good Bytes/Seek optimization compared to the computation of Log(2), and of course did not reach the utilization possible by the CPUs since I was using swap storage (Dr. Ian Cutress’s Lemniscate Constant calculation had a multi-core efficiency of 94.04 % and CPU utilization of 9027.61 %, which means that the CPU was not bottlenecked by other factors). I also used the Cilk Plus Work-Stealing multiprocessing framework along with the dynamic version of y-cruncher.

Memory:
Working Memory: 696,086,196,992 ( 648 GiB)
Total Memory: 697,932,185,600 ( 650 GiB)
Logical Largest Checkpoint: 2,242,654,353,976 (2.04 TiB)
Logical Peak Disk Usage: 6,516,333,392,080 (5.93 TiB)
Logical Disk Bytes Read: 420,720,903,373,472 ( 383 TiB)
Logical Disk Bytes Written: 368,315,890,119,480 ( 335 TiB)

Disk operation was similar to the verification computation of Log(2) and was similarly less than a half compared to Apéry’s constant because the algorithm is easier and is split to smaller computations, and this contributed to a faster computation along with more RAM.
One caveat is that HDD I/O speeds are again great bottlenecks to virtually any other component, and perhaps having Optane DIMMs or even more normal RAM can help the speed of the computation speed greatly.

Verification:
System information:
Operating System: Linux 3.10.0-693.21.1.el7.x86_64 x86_64
Processor(s):
Name: Intel(R) Xeon(R) Gold 5220 CPU @ 2.20GHz
Logical Cores: 72
Physical Cores: 36
Sockets: 2
NUMA Nodes: 2
Base Frequency: 2,194,728,160 Hz

Start Date: Wed Aug 19 10:48:52 2020
End Date: Sun Sep 6 12:14:40 2020
Total Computation Time: 1520754.941 seconds
Start-to-End Wall Time: 1560348.114 seconds
CPU Utilization: 932.46 % + 37.40 % kernel overhead
Multi-core Efficiency: 12.95 % + 0.52 % kernel overhead

Memory:
Working Memory: 748,959,060,352 ( 698 GiB)
Total Memory: 751,290,873,600 ( 700 GiB)
Logical Largest Checkpoint: 2,252,980,350,032 (2.05 TiB)
Logical Peak Disk Usage: 6,533,333,252,760 (5.94 TiB)
Logical Disk Bytes Read: 426,298,248,606,512 ( 388 TiB)
Logical Disk Bytes Written: 373,070,460,848,488 ( 339 TiB)

This build has a slower filesystem than the system used for computation, and thus caused the verification computation to take more time even with two Cascade Lake Xeon CPU sockets that support AVX-512. CPU utilization was impacted because of slower disk even when the CPU was more recent. Total Computation Time and Disk R/W were slightly higher.

I hope computing and sharing the results can result in more insight that can be used by mathematicians for new mathematical knowledge.

If you want to take a look at the digits for the Natural Logarithm of 10 (Log(10)), you can download it from This Link (Almost 2 TB total but don’t worry, it will just redirect to a registry with a link to download).

Note that digits are released as an Attribution-NonCommercial-NoDerivatives 4.0 International License, meaning no commercial purposes and you cannot distribute a remixed, transformed, or built upon version without my consent. You must also give appropriate credit, provide a link to the license, and indicate if changes were made even if it is not a prohibited use case.

Archive for computation results in the y-cruncher website: https://web.archive.org/web/20200915070251/http://www.numberworld.org/y-cruncher/
Special thanks to Mr. Alexander J. Yee for developing and releasing y-cruncher and providing advice, and the Internet Archive for hosting the computed digits.

Tags:

Categories:

Updated: