Fact-checked by Grok 2 weeks ago

Chudnovsky algorithm

The Chudnovsky algorithm is a rapidly converging infinite series formula for computing the mathematical constant π to high precision, developed by American mathematicians David and Gregory Chudnovsky and published in 1988.^[1] It derives from modular equations and elliptic integrals inspired by the work of Srinivasa Ramanujan, providing approximately 14 decimal digits of accuracy per term in the summation, which makes it one of the fastest known methods for such calculations.^[2]^[1] The core formula is given by

\frac{1}{\pi} = 12 \sum_{n=0}^{\infty} \frac{(-1)^n (6n)! (13591409 + 545140134 n)}{(3n)! (n!)^3 640320^{3n + 3/2}},

where the series is evaluated using techniques like binary splitting to handle large integers efficiently and minimize computational overhead from divisions.^[1]^[2] This expression stems from the Chudnovskys' exploration of complex multiplication on elliptic curves and Ramanujan's class invariants, yielding a convergence rate superior to earlier series like those based on arctangents.^[1] Since its introduction, the algorithm has been pivotal in breaking world records for π digit computations, including the current record of 300 trillion digits as of April 2025, due to its balance of rapid convergence and implementability on modern hardware with arbitrary-precision arithmetic libraries.^[2]^[1]^[3] It remains a standard in both academic research and hobbyist projects for high-precision π evaluation, often optimized with parallel processing and specialized division algorithms to handle the intensive integer operations involved.^[1]

History and Development

Origins in Ramanujan's Work

The foundations of the Chudnovsky algorithm trace back to the groundbreaking work of Srinivasa Ramanujan in the early 20th century, particularly his explorations of modular forms and elliptic integrals for approximating π. In 1914, Ramanujan published a seminal paper detailing how modular equations of various degrees could yield highly efficient series expansions for 1/π, derived from the complete elliptic integral of the first kind and transformations under the modular group. These approximations leveraged the interplay between elliptic functions and hypergeometric series, providing convergence rates far superior to contemporary methods like those based on arctangents.^[4] Central to Ramanujan's approach were class invariants, algebraic numbers constructed from theta functions associated with singular moduli, which served as precursors to fast-converging π series. For imaginary quadratic fields with discriminant d, particularly Heegner numbers such as d = -163—where the class number is 1—these invariants enable extraordinarily accurate approximations, as the j-invariant at the corresponding point yields values extremely close to integers when exponentiated with π. Ramanujan's insights into these structures, drawn from his notebooks and the 1914 paper, highlighted how such numbers amplify the precision of elliptic integral evaluations for π, foreshadowing later algorithmic accelerations.^[5] Ramanujan also developed specific formulae for 1/π incorporating continued fractions and theta functions, such as those linking the Rogers-Ramanujan continued fraction to modular eta functions and yielding hypergeometric representations. These expressions, often involving products of theta series, allowed for compact, rapidly convergent sums that approximated π to many decimal places with few terms—for instance, one such series converges at a rate of about 8 decimal digits per term. His work in the 1910s, though initially unpublished in full detail, laid the theoretical groundwork for these techniques. Ramanujan's π series remained largely unproven until their rediscovery and rigorous validation in the 1980s by mathematicians including Jonathan and Peter Borwein, who provided analytic proofs using elliptic function theory and modular forms. This revival in the late 1980s spurred adaptations, such as those by the Chudnovsky brothers, who built upon these foundations to engineer practical computational algorithms.

Chudnovsky Brothers' Formulation

David Volfovich Chudnovsky (born January 22, 1947) and Gregory Volfovich Chudnovsky (born April 17, 1952) are Soviet-born American mathematicians who emigrated to the United States in the 1970s and established their careers at Columbia University as research associates in the Department of Mathematics.^[6] Both brothers specialized in number theory and algebraic geometry, with Gregory receiving a MacArthur Fellowship in 1981 for his contributions to these fields, often in collaboration with David.^[7] In 1988, the Chudnovsky brothers published their formulation of an efficient series for computing π, derived from Srinivasa Ramanujan's foundational ideas on modular forms, incorporating the j-invariant and principles of complex multiplication.^[8] This work appeared in the proceedings of the Ramanujan Centenary Conference, emphasizing approximations rooted in elliptic integrals and class invariants to achieve rapid convergence.^[9] Motivated by the computational challenges of the 1980s, where supercomputers like Japan's NEC SX series were pushing records to hundreds of millions of digits, the brothers sought a more efficient algorithm to surpass these limits without relying on institutional resources.^[10] Their approach addressed the era's hardware constraints by prioritizing series that maximized digits per computational step, enabling personal-scale high-precision calculations. The brothers' initial application of their formulation came in 1989, when they computed π to 1,011,196,691 decimal places—over a billion digits—using the Cray 2 and IBM 3090 supercomputers at IBM's Thomas J. Watson Research Center, funded through grants including from the National Science Foundation.^[10] This achievement marked a world record at the time and demonstrated the practical power of their algorithm amid the decade's competitive race for π precision.^[11]

Mathematical Foundation

Hypergeometric Series Basis

The generalized hypergeometric series provides a foundational framework for many special functions in mathematics, extending the binomial series to more parameters. It is defined as

{}_p F_q \left( \begin{matrix} a_1, \dots, a_p \\ b_1, \dots, b_q \end{matrix} ; z \right) = \sum_{k=0}^{\infty} \frac{(a_1)_k \cdots (a_p)_k}{(b_1)_k \cdots (b_q)_k} \frac{z^k}{k!},

where the Pochhammer symbol, or rising factorial, is given by (a)_k = a(a+1) \cdots (a+k-1) for positive integer k, with (a)_0 = 1.^[12] This series converges absolutely for |z| < 1 and can be analytically continued elsewhere, making it versatile for representing solutions to differential equations and integrals.^[12] In computations involving \pi, hypergeometric series arise through connections to modular forms and elliptic integrals, where the complete elliptic integral of the first kind K(k) = \frac{\pi}{2} {}_2F_1\left(\frac{1}{2}, \frac{1}{2}; 1; k^2\right) links the series directly to periods of elliptic curves, which are encoded by modular forms.^[13] These relations stem from the transformation properties of modular functions, such as the elliptic modulus \lambda(\tau), which parameterize families of hypergeometric evaluations yielding \pi. Heegner numbers, which are square-free positive integers d such that the class number of the imaginary quadratic field \mathbb{Q}(\sqrt{-d}) is 1, play a crucial role in selecting parameters for hypergeometric series that accelerate convergence in \pi formulas.^[14] Specifically, these numbers correspond to discriminants where the minimal class number ensures the highest order of vanishing in associated modular forms, leading to series with terms decreasing faster than exponential rates tied to larger class numbers.^[15] Hypergeometric series are particularly efficient for high-precision arithmetic in \pi computations due to their rapid convergence when optimized via such number-theoretic parameters, allowing fewer terms to achieve arbitrary digit precision with recursive term evaluation that minimizes overhead in multiple-precision operations.^[16] This structure supports scalable summation without excessive intermediate swell, outperforming slower-converging alternatives like arctangent series for large-scale calculations.

The Chudnovsky Formula

The Chudnovsky formula provides a rapidly convergent infinite series for the reciprocal of π, derived from the theory of modular functions and elliptic integrals. It expresses \frac{1}{\pi} as:

\frac{1}{\pi} = 12 \sum_{k=0}^{\infty} \frac{(-1)^k (6k)! (545140134k + 13591409)}{(3k)! (k!)^3 (640320)^{3k + 3/2}}

This series originates from evaluating the j-function at a specific complex argument τ associated with the quadratic field of discriminant -163, which has class number 1, linking directly to Ramanujan's work on class number 1 invariants and their connections to nearly integer values of e^{π√d} for Heegner discriminants d.^[17] The integer constants 545140134 and 13591409 arise from solving a modular equation of degree 17 that relates the singular moduli for the elliptic curve with complex multiplication by the ring of integers in ℚ(√-163). Meanwhile, the base 640320 is chosen such that (640320)^3 = -j(τ), where τ = (1 + √(-163))/2 and j(τ) is the value of the modular j-invariant at this point, with the equivalent formulation using the constant 426880 √10005 satisfying 640320^{3/2} / 12 = 426880 √10005 exactly, ensuring the series aligns with the algebraic structure of the period relations.^[17] The asymptotic convergence of the series is exceptionally fast, with each additional term contributing approximately 14.1816474627 digits of precision to the value of π, due to the dominant (640320)^{-3} factor in the denominator's growth rate. This rate stems from the hypergeometric nature of the series, where the ratio of consecutive terms approaches 1/(640320)^3 in magnitude.^[17]

Algorithm Mechanics

Iterative Computation Process

The iterative computation process for the Chudnovsky algorithm begins by estimating the number of terms N required to achieve the desired precision in decimal digits of \pi. Specifically, N \approx D / 14.18, where D is the number of desired digits, as each term in the series contributes approximately 14.18 decimal digits of accuracy due to the rapid convergence rate determined by the modulus $640320^3.^[18]^[19] Next, initialize a sum S = 0 and iterate over k = 0 to N-1. For each k, compute the k-th term using arbitrary-precision integer arithmetic to handle the large numbers involved: the numerator is (-1)^k \cdot (6k)! \cdot (13591409 + 545140134k), and the denominator is (3k)! \cdot (k!)^3 \cdot 640320^{3k}. Add the term to S. Factorials are computed iteratively to avoid redundant calculations, with each subsequent factorial built from the previous one (e.g., (k+1)! = (k)! \cdot (k+1)), and powers of 640320 are accumulated multiplicatively.^[20]^[2] The constant factor involving \sqrt{640320^{3/2}} (equivalent to $640320 \sqrt{640320}) is handled separately to maintain exact rational arithmetic in the sum. This term is factored out, so the partial sum S approximates the series without the square root; the final expression for $1/\pi is then $12 S / 640320^{3/2}, or equivalently \pi = 640320^{3/2} / (12 S). In practice, \sqrt{640320} is precomputed to sufficient precision using high-precision floating-point methods or approximated via integer square root algorithms, and the full constant is incorporated at the end. For record computations requiring extreme precision, modular arithmetic is employed to verify the square root integration without floating-point errors.^[20]^[1] After summing to N terms, compute \pi by inverting the result: first obtain $1/\pi \approx 12 S / 640320^{3/2}, then take the reciprocal. Truncation after N terms guarantees the desired precision because the series is alternating and decreasing, with the error bounded by the magnitude of the (N+1)-th term, which is less than $10^{-D} for the chosen N. This ensures all D digits are correct, as subsequent terms contribute negligibly.^[20]^[2]

Precision and Convergence

The Chudnovsky algorithm demonstrates exceptional convergence properties, yielding approximately 14.18 decimal digits of π per term in its hypergeometric series summation. This rate arises from the dominant exponential decay factor (640320^{-3})^k in the general term, where the base corresponds to roughly $10^{-14.18}, ensuring that each additional term contributes a fixed, substantial increase in precision independent of the total number of digits computed.^[21]^[22] In terms of computational complexity, the algorithm achieves a time complexity of O(n (\log n)^3) for producing n digits of π, when employing binary splitting to evaluate the series and fast Fourier transform-based multiplication for handling large integers. This bound reflects the cost of recursively splitting the sum into subseries and performing multiplications on O(n)-bit numbers, which dominate the overall runtime. The space complexity is linear, O(n), primarily due to the storage requirements for partial sums and intermediate values at full precision.^[23] Compared to Machin-like formulas relying on arctangent series, which often demand millions of terms for high-precision results owing to their slower convergence (typically yielding fewer than 2 digits per term in the primary series), the Chudnovsky approach requires significantly fewer iterations—on the order of n/14 terms—making it vastly more efficient for large n. This advantage is particularly pronounced in the iterative summation process, where the rapid decay minimizes the number of operations needed.^[24]

Implementations and Enhancements

Binary Splitting Optimization

Binary splitting is a divide-and-conquer recursion technique designed to efficiently evaluate the partial sums of hypergeometric series, such as the one underlying the Chudnovsky algorithm, by representing them as ratios of large integers rather than using floating-point arithmetic. This method avoids the accumulation of rounding errors and minimizes the growth of intermediate values, making it suitable for high-precision computations. In the context of the Chudnovsky series, it transforms the summation into a tree of recursive subcomputations, where each node combines results from child intervals.^[25] The core of binary splitting involves computing a partial sum S(a, b) = \sum_{k=a}^{b-1} t_k, where t_k denotes the k-th term of the series, as S(a, b) = P(a, b) / Q(a, b) with P(a, b) and Q(a, b) being multi-precision integers. To evaluate this, select a midpoint m = \lfloor (a + b)/2 \rfloor, and recursively compute the left and right sub-sums S(a, m) = P(a, m)/Q(a, m) and S(m, b) = P(m, b)/Q(m, b). The combined values follow the recurrences:

\begin{align} P(a, b) &= P(a, m) \cdot Q(m, b) + P(m, b) \cdot Q(a, m), \\ Q(a, b) &= Q(a, m) \cdot Q(m, b). \end{align}

For the base case when b = a + 1, set P(a, a+1) to the numerator of t_a and Q(a, a+1) to its denominator, both scaled appropriately to maintain integer arithmetic. These operations are performed depth-first or in a balanced tree fashion until the full sum from a = 0 to b = N is obtained.^[25] This approach offers significant computational advantages over naive term-by-term summation, which requires O(N^2) multiplications for N terms due to repeated scaling of accumulated sums. Binary splitting reduces this to O(N \log N) multiplications by exploiting the recursive structure, with overall bit complexity O(M(d) (\log N)^2), where d is the precision in bits and M(d) is the cost of multiplying two d-bit numbers (typically O(d \log d \log \log d) using fast algorithms like Schönhage-Strassen). Additionally, the method supports natural parallelism, as left and right subtrees can be evaluated concurrently on multiprocessor systems.^[25]^[26] In the Chudnovsky algorithm, binary splitting excels at managing the complex factorial components in each term, such as (6k)!, (3k)!, and (k!)^3, along with powers like $640320^{3k}. These are computed using a multiplicative variant of the recurrence—P(a, b) = P(a, m) \cdot P(m, b) and analogous for denominators—with base cases for single factors, enabling efficient evaluation of the products without computing enormous intermediate factorials in a linear pass. This integration keeps the overall summation scalable for the large N (often millions of terms) needed for record-breaking precision in \pi.^[25]

Software and Hardware Applications

The Chudnovsky algorithm has been implemented in various software tools optimized for high-precision computations of π, with y-cruncher standing out as a primary multi-threaded program developed by Alexander J. Yee in the 2010s. This software leverages custom arbitrary-precision arithmetic routines and binary splitting techniques to achieve scalable performance across multiple cores, enabling computations up to trillions of digits.^[27]^[28] Other implementations utilize established libraries for arbitrary-precision arithmetic, such as the GNU Multiple Precision Arithmetic Library (GMP), which provides efficient handling of large integers and rationals in C-based programs. For instance, custom C++ implementations often integrate GMP to compute π via the Chudnovsky series, balancing speed and precision for educational or research purposes. In Python, the mpmath library facilitates straightforward implementations by supporting arbitrary-precision floating-point operations, allowing users to evaluate the algorithm's hypergeometric terms with configurable digit depths.^[21] MATLAB and Simulink also offer built-in support through symbolic math toolboxes, where the algorithm can be scripted for iterative summation and visualized in simulations.^[2] On the hardware side, early applications by the Chudnovsky brothers in 1988 involved a custom-built supercomputer named mzero, assembled from commercial off-the-shelf components to perform parallel arithmetic operations for π calculations exceeding one billion digits. Modern deployments favor high-memory CPU configurations in cloud environments, such as Google Cloud's N2-highmem virtual machines with up to 128 vCPUs and 864 GB of RAM per instance, which in 2022 supported the computation of π to 100 trillion digits using y-cruncher.^[29]^[30] These setups prioritize CPU parallelism over GPUs due to the algorithm's reliance on sequential big-integer operations, though hybrid CPU-GPU explorations are emerging for preprocessing tasks. A key challenge in these applications is memory management for intermediate results, which can reach terabyte scales for trillion-digit computations; records in 2024 and 2025 addressed this by employing high-capacity SSD arrays for temporary storage and data spilling, reducing RAM bottlenecks during binary splitting evaluations—for example, the April 2025 computation of 300 trillion digits utilized a KIOXIA NVMe SSD cluster with y-cruncher.^[31]^[32]^[33]

Performance and Impact

Efficiency Metrics

The Chudnovsky algorithm exhibits strong practical performance for high-precision computations of π, particularly when implemented with techniques like binary splitting for series evaluation. On modern multi-core systems from the 2020s, such as high-end desktops with 18-24 cores, it can compute approximately 1 trillion decimal digits in roughly one day. For instance, the y-cruncher implementation achieved this on a single PC in about 32 hours using an Intel processor at stock speeds.^[34]^[27] Resource utilization scales predictably with precision requirements. Memory consumption is linear in the number of digits, accounting for intermediate big-integer storage and buffers during modular arithmetic and series summation. CPU time is predominantly spent on FFT-based multiplications for handling the large integers involved, with each term in the series requiring operations proportional to the precision level.^[35] In comparisons with other methods, the Chudnovsky algorithm outperforms the Bailey–Borwein–Plouffe (BBP) algorithm in digits per second for sequential digit computation, owing to its superior convergence of roughly 14 digits per term versus BBP's logarithmic extraction suited for individual digits.^[2]^[36] A key limitation emerges at ultra-high precision, where I/O operations become a bottleneck due to the enormous storage demands—around 500 terabytes for 100 trillion digits—slowing verification and output handling even on high-bandwidth systems.^[30]

World Record Achievements

The Chudnovsky algorithm has powered numerous world records in computing digits of π, beginning with the pioneering efforts of brothers Gregory and David Chudnovsky, who in 1989 calculated over 1 billion digits using a custom-built supercomputer based on an IBM 3090 and Cray-2, marking a significant leap in precision computation at the time.^[29]^[37] This achievement not only demonstrated the algorithm's efficiency but also pushed the boundaries of available hardware, requiring approximately 148 hours of processing across the machines. Subsequent records built on this foundation, with key contributors including software developer Alexander Yee, whose y-cruncher program optimized implementations of the Chudnovsky formula for multi-threaded and large-scale computing.^[27] In 2009, Fabrice Bellard set a record of 2.7 trillion digits using a variant closely related to the Chudnovsky formula on a single desktop computer, completing the task in 90 days and highlighting the algorithm's accessibility for high-performance personal systems.^[1] By 2011, Shigeru Kondo extended this to 10 trillion digits with y-cruncher, utilizing dual Xeon processors and taking about 371 days, further validating the algorithm's scalability.^[38] The pace accelerated in 2016 when Peter Trueb computed 22.4 trillion digits in 105 days on a single server, employing y-cruncher to test storage and memory limits.^[39] Google Cloud teams, led by Emma Haruka Iwao, achieved 31.4 trillion digits in 2019 over 121 days using distributed cloud resources, underscoring the algorithm's suitability for massive parallel processing. In 2020, Timothy Mullican reached 50 trillion digits in 88 days on a personal workstation, emphasizing ongoing refinements in y-cruncher.^[40] The 2021 record of 62.8 trillion digits by Thomas Keller and the University of Applied Sciences Graubünden took 108 days on a supercomputer, reinforcing the Chudnovsky algorithm's robustness across diverse hardware.^[41] Continuing the trend, Google Cloud computed 100 trillion digits in 2022, spanning 157 days on high-memory virtual machines, which served to benchmark cloud infrastructure scalability.^[30] In 2024, the StorageReview Lab team first hit 105 trillion digits in 75 days using dual AMD EPYC processors and extensive SSD storage, then surpassed it with 202 trillion digits in 100 days on a distributed setup with 15 PB of NVMe SSDs, testing the limits of storage density and data throughput.^[31]^[42] The most recent milestone came in April 2025, when Linus Media Group and KIOXIA calculated 300 trillion digits using y-cruncher on a cluster of AMD EPYC servers with WEKA software for distributed storage, completing the computation and verification in 226 days and establishing new benchmarks for petabyte-scale data handling.^[3]^[33] Each of these records has tested the frontiers of computational hardware, from custom supercomputers to cloud and distributed systems, while verifying the Chudnovsky algorithm's consistent convergence and precision under extreme scales, often requiring terabytes to petabytes of storage for intermediate results.^[38] These achievements not only advance numerical analysis but also drive innovations in software optimization and storage technologies.

References

[1]
[PDF] Computation of 2700 billion decimal digits of Pi using a Desktop ...
The evaluation of the Chudnovsky formula involves a lot of integer divisions be- cause of the GCD trick. So having a good division algorithm is critical. We.
[2]
Computing π - MATLAB & Simulink - MathWorks
The Algebraic-Geometric Mean Algorithm. The Chudnovsky formula is a power series: Each new term in the partial sum adds a fixed number of digits of accuracy.
[3]
[PDF] Modular equations and approximations to π
For example, let us take the modular equation of the 5th degree, viz. uv. 3. + vu. 3. = 2 u2v2 -. 1.
[4]
[PDF] Ramanujan, Modular Equations, and Approximations to Pi or How to ...
elliptic integrals and the very rapid approximation of . This connection was rst made explicit by Ramanujan in his 1914 paper \Modular Equations and.
[5]
FOUNDATION TO SUPPORT 21 AS 'GENIUSES' FOR 5 YEARS ...
Chudnovsky, 29, a Soviet-born mathematician who ... brother, David, also a mathematician. Both are research associates at Columbia University. ... 1980 ...
[6]
Gregory V. Chudnovsky - MacArthur Foundation
Jun 1, 1981 · Gregory Chudnovsky has made original contributions in a wide range of mathematical fields, particularly in number theory.Missing: 1947 1952
[7]
Approximations and complex multiplication according to Ramanujan
This talk revolves around two focuses: complex multiplications (for elliptic curves and Abelian varieties) in connection with algebraic period relations.
[8]
Approximations and complex multiplication according to Ramanujan
Chudnovsky's algorithm, rooted in elliptic curve theory and based on Ramanujan-like series, provides extremely fast convergence and is used in modern record ...
[9]
[PDF] The Quest for Pi David H. Bailey, Jonathan M. Borwein, Peter B ...
Jun 25, 1996 · This article gives a brief history of the analysis and computation of the mathematical constant π = 3.14159..., including a number of the ...
[10]
Mathematics: As American as Apple Pi | TIME
Jun 19, 1989 · The feat was accomplished by David and Gregory Chudnovsky, Soviet emigre brothers who took jingoistic pride in beating the Japanese. “They may ...Missing: billion living
[11]
15.2 Definitions and Analytical Properties
The hypergeometric function F ⁡ ( a , b ; c ; z ) is defined by the Gauss series on the disk | z | < 1 , and by analytic continuation elsewhere.
[12]
[1302.0548] Ramanujan-type formulae for $1/π$: the art of translation
Feb 3, 2013 · We outline an elementary method for proving numerical hypergeometric identities, in particular, Ramanujan-type identities for 1/\pi.
[13]
Heegner Number -- from Wolfram MathWorld
The Heegner numbers therefore correspond to binary quadratic form discriminants -d which have class number h(-d) equal to 1, except for Heegner numbers -1 and ...
[14]
On a Ramanujan-type series associated with the Heegner number 163
Feb 13, 2024 · Bagis and Glasser, in 2013, introduced a conjectural Ramanujan-type series related to the class number h(-d) = 1 for a quadratic form with discriminant d = 163.Missing: numbers | Show results with:numbers
[15]
10 trillion digits of pi: A case study of summing hypergeometric ...
They are also the most efficient way known to compute constants, such as π and e, to high precision. Binary splitting is a low complexity algorithm for summing ...
[16]
https://www.ideals.illinois.edu/items/28571
[17]
[PDF] redA few Methods for Computing - Computer Science and Engineering
In 1994 David and Gregory Chudnovsky ... This series yields 14 decimal digits per term. ... This means that each iteration of this algorithm approximately doubles ...
[18]
[PDF] 10 Trillion Digits of Pi: A Case Study of summing Hypergeometric ...
Load Balancing: The size of the recursive tasks pro- duced by the Binary Splitting algorithm for a series such as the one in the Chudnovsky Formula are ...
[19]
Approximations and complex multiplication according to Ramanujan ...
APPROXIMATIONS AND COMPLEX MULTIPLICATION tions ... D.V. Chudnovsky, G.V. Chudnovsky, Applications of pad~ approximations to the Grothendieck conjecture on.
[20]
Pi - Chudnovsky
Nov 19, 2021 · The current darling of the π world is the Chudnovsky algorithm which is similar to the arctan formula but it converges much quicker. It is also rather ...
[21]
Pi Formulas -- from Wolfram MathWorld
This series gives 14 digits accurately per term. The same equation in ... involving the first 9 digits of pi. See also. BBP Formula, Digit-Extraction ...
[22]
Formulas and Algorithms - Numberworld.org
Oct 25, 2023 · Chudnovsky (1988): O(n log(n)3). Ramanujan's (1910): O(n log(n)3). References: Chudnovsky Formula · Ramanujan's Formula. ArcCoth(n) - Inverse ...
[23]
Chudnovsky formula vs. Machin type formulae for calculating π
Mar 16, 2017 · However, the Chudnovsky formula, which convergence rate is 14 digits per term only, is found to be most efficient.π and rapid series for the inverse tangent - MathOverflowChudnovsky algorithm and Pi precision - MathOverflowMore results from mathoverflow.net
[24]
[PDF] Fast multiprecision evaluation of series of rational numbers - GiNaC
The binary splitting algorithm is asymptotically faster than step-by-step evaluation of the sum – which has binary complexity O(N2) – because it pushes as much ...<|control11|><|separator|>
[25]
[PDF] Jonathan Borwein, Pi and the AGM
Sep 26, 2017 · we have to sum of order n terms. Using divide and conquer (also called binary splitting or FEE) this can be done with bit-complexity. O(M( ...
[26]
y-cruncher - A Multi-Threaded Pi Program - Numberworld.org
By Alexander J. Yee · Able to compute Pi and other constants to trillions of digits. · Two algorithms are available for most constants. · Multi-Threaded - Multi- ...FAQ · Records set by y-cruncher · Algorithms and Internals · Version HistoryMissing: implementations | Show results with:implementations
[27]
[PDF] A Fast Self-correcting π Algorithm - arXiv
Dec 21, 2019 · Pi and the AGM: A Study in. Analytic Number Theory and Computational ... [9] David Chudnovsky and Gregory Chudnovsky. The computation of ...
[28]
The Chudnovsky Brothers and the Mountains of Pi | The New Yorker
Feb 24, 1992 · The Chudnovsky brothers discovered their own formula in 1984, and it attacks pi with great ferocity and elegance. The Chudnovsky formula is the ...
[29]
Calculating 100 trillion digits of pi on Google Cloud
a world record at the time. Then, in 2021, scientists at the University of Applied Sciences ...
[30]
105 Trillion Pi Digits: The Journey to a New Pi Calculation Record
Mar 13, 2024 · StorageReview and our partners have just solved Pi to 105 trillion places, a new world record that bests the prior record by five percent.
[31]
News (2024) - Numberworld.org
Parallelizing at the highest level of an algorithm tends to result in memory usage that grows linearly with the # of threads until the entire working set is in ...
[32]
Calculated pi with 487 billion digits by diskized GMP
Sep 1, 2023 · ... y-cruncher and checked the result of a match. On the same PC, y-cruncher can calculate 1 trillion digits of pi in 32 hours. Why so fast ...
[33]
Large Multiplication - Numberworld.org
Oct 15, 2023 · The largest multiplication that y-cruncher can theoretically do is (6.7 * 1017) x (6.7 * 1017) decimal digits. This is achieved with the 64-bit ...
[34]
Calculating pi on Python - Adrian Hensler
BBP Algorithm: Approximately 91.56 seconds; Chudnovsky Algorithm (mpmath): Approximately 0.011 seconds. These results show a stark contrast in performance. The ...Missing: per | Show results with:per
[35]
GENERAL COMPUTATIONAL UPDATE: - CECM, SFU
... 1988 Scientific American Article [PostScript 112k] is also available. BILLIONS. In 1989, The Chudnovsky Brothers computed 1,011,196,961 digits of using. This ...Missing: original formula
[36]
Records set by y-cruncher - Numberworld.org
Aug 10, 2025 · Run the main computation using the built-in Chudnovsky or Ramanujan formulas. Do not use a custom formula implementation. You must run the above ...
[37]
22.4 trillion digits of pi
Chudnovsky Terms 1 583 677 621 196. Timeline. Start Time Fri Jul 29 15:06:20 2016. End Time Fri Nov 11 07:01:43 2016. Computation Time 7 664 613 seconds ...
[38]
News (2020) - Numberworld.org
Mar 1, 2020 · This time to Timothy Mullican who computed 50 trillion digits of Pi on a dated (but still powerful) personal computer. As the previous ...
[39]
New value of pi calculated by Swiss university at over 62 trillion digits
Mar 14, 2022 · A new most accurate value of pi has been calculated in Switzerland by the University of Applied Sciences.
[40]
StorageReview Lab Breaks Pi Calculation World Record with Over ...
Jun 28, 2024 · In March 2024, the StorageReview Lab Team achieved a world record by calculating pi to 105 trillion digits. Utilizing a dual-processor AMD EPYC ...
[41]
Most accurate value of pi | Guinness World Records
The calculation used the Chudnovsky algorithm and the Y-Cruncher program and took over 226 days to complete. Records change on a daily basis and are not ...Missing: timeline | Show results with:timeline
[42]
Kioxia and Linus Media Group Set World Record for Pi Calculation
May 19, 2025 · A groundbreaking 300 trillion digits were calculated and have been officially verified and confirmed by Guinness World Records.