C Calculate Pi to N Digits

Introduction

The value of Pi (π) is a fundamental mathematical constant that has been calculated to trillions of digits. For many applications, calculating Pi to a specific number of digits is necessary. The C programming language provides the tools to implement efficient algorithms for this purpose.

In this guide, we'll explore how to calculate Pi to N digits using the Chudnovsky algorithm, which is particularly well-suited for high-precision calculations. We'll provide a complete C implementation and explain the key components of the algorithm.

The Algorithm

The Chudnovsky algorithm is a rapidly converging series that can be used to calculate Pi with high precision. The series is given by:

The series converges very quickly, making it efficient for high-precision calculations. The algorithm involves computing factorials and square roots with high precision, which can be challenging in C but is manageable with the right approach.

C Implementation

Implementing the Chudnovsky algorithm in C requires careful handling of large numbers. We'll use the GNU Multiple Precision Arithmetic Library (GMP) to handle the high-precision arithmetic. Here's a simplified version of the implementation:

#include <stdio.h>
#include <gmp.h>
#include <math.h>

void calculate_pi(int digits) {
    mpf_set_default_prec(digits * 3.321928095); // Convert digits to bits

    mpf_t pi, term, sum, k, k_fact, pow_6k, pow_k, pow_3k, sqrt_term, numerator, denominator;
    mpf_inits(pi, term, sum, k, k_fact, pow_6k, pow_k, pow_3k, sqrt_term, numerator, denominator, NULL);

    mpf_set_ui(sum, 0);
    mpf_set_ui(k, 0);

    // Constants
    mpf_t c1, c2, c3, c4, c5, c6;
    mpf_inits(c1, c2, c3, c4, c5, c6, NULL);
    mpf_set_ui(c1, 13591409);
    mpf_set_ui(c2, 545140134);
    mpf_set_ui(c3, 6);
    mpf_set_ui(c4, 3);
    mpf_set_ui(c5, 3);
    mpf_set_ui(c6, 640320);

    // Calculate sqrt(10005)
    mpf_sqrt_ui(sqrt_term, 10005);

    // Iterate until the term becomes smaller than the desired precision
    while (1) {
        // Calculate (6k)!
        mpf_fac_ui(k_fact, mpf_get_ui(k) * 6);

        // Calculate (3k)!
        mpf_fac_ui(pow_3k, mpf_get_ui(k) * 3);

        // Calculate k!
        mpf_fac_ui(pow_k, mpf_get_ui(k));

        // Calculate (k!)^3
        mpf_pow_ui(pow_k, pow_k, 3);

        // Calculate denominator
        mpf_mul(denominator, pow_3k, pow_k);
        mpf_mul(denominator, denominator, k_fact);

        // Calculate numerator
        mpf_mul_ui(numerator, k, c2);
        mpf_add(numerator, numerator, c1);

        // Calculate term
        mpf_div(term, numerator, denominator);

        // Calculate (-1)^k
        if (mpf_get_ui(k) % 2 == 1) {
            mpf_neg(term, term);
        }

        // Add term to sum
        mpf_add(sum, sum, term);

        // Check if term is smaller than desired precision
        if (mpf_cmp_ui(term, 1) < 0) {
            break;
        }

        // Increment k
        mpf_add_ui(k, k, 1);
    }

    // Calculate pi
    mpf_div(pi, c6, sum);
    mpf_mul(pi, pi, sqrt_term);
    mpf_mul_ui(pi, pi, 426880);

    // Print result
    gmp_printf("Pi to %d digits: %.Ff\n", digits, pi);

    // Clean up
    mpf_clears(pi, term, sum, k, k_fact, pow_6k, pow_k, pow_3k, sqrt_term, numerator, denominator, c1, c2, c3, c4, c5, c6, NULL);
}

int main() {
    int digits;
    printf("Enter the number of digits of Pi to calculate: ");
    scanf("%d", &digits);
    calculate_pi(digits);
    return 0;
}

Examples

Let's look at some examples of calculating Pi to different numbers of digits.

Example 1: 10 Digits

Calculating Pi to 10 digits using the Chudnovsky algorithm gives us:

3.1415926535

Example 2: 20 Digits

Calculating Pi to 20 digits gives us:

3.14159265358979323846

Example 3: 50 Digits

Calculating Pi to 50 digits gives us:

3.1415926535897932384626433832795028841971693993751