Check out my project here:
https://the-best-codes.github.io/projects/pi/
Happy Pi Day, fellow developers! 🥧✨
Today, we’re diving into the delicious world of mathematics to celebrate our favorite irrational number, π (Pi). And what better way to honor this mathematical constant than by calculating its digits? While mathematicians have reached mind-boggling digit counts (in the Trillions!), we can still go on our own JavaScript adventure to squeeze out as many digits of Pi as our devices can handle.
Reminder: Calculating an enormous number of pi digits is resource-intensive. Be prepared for your computer to work up a sweat if you leave the code running too long!
The Magic Code
The generateDigitsOfPi function is a beautiful example of a spigot algorithm in action. This type of algorithm “spigots” out digits of π one at a time in a stream (hence the name).
let q = 1n;
let r = 180n;
let t = 60n;
let i = 2n;
while (true) {
let digit = ((i * 27n – 12n) * q + r * 5n) / (t * 5n);
yield Number(digit);
let u = i * 3n;
u = (u + 1n) * 3n * (u + 2n);
r = u * 10n * (q * (i * 5n – 2n) + r – t * digit);
q *= 10n * i * (i++ * 2n – 1n);
t *= u;
}
}
// More code
function displayTenNextDigits() {
let digits = “”;
for (let i = 0; i < G_NUMBER_OF_DIGITS; i++) {
digits += generator.next().value;
}
// Do something with the digits here
}
Let’s crack the code:
Variables:
q, r, t: These hold BigInt values (large integers) used in the algorithm.
i: A counter variable.
The Loop:
The while(true) loop acts as the engine, continuously generating digits.
digit is calculated using a complex formula involving q, r, t, and i. This formula is based on the Bailey-Borwein-Plouffe (BBP) algorithm, renowned for its efficiency in pi calculation.
yield Number(digit): This special keyword pauses the function, returning the current digit (digit) and allowing you to resume later.
Under the Hood
While a full explanation of the BBP algorithm goes beyond this article (check out https://en.wikipedia.org/wiki/Bailey_… if you are curious!), here’s a simplified understanding:
The formula manipulates BigInt values (q, r, t) to progressively converge towards the actual digits of pi.
Each iteration calculates a new digit and updates the variables for the next round.
Unveiling the Hidden Digits
The second function, displayTenNextDigits(), takes the baton:
digits: An empty string to store the retrieved digits.
The Loop:
It iterates a predetermined number of times (G_NUMBER_OF_DIGITS) using a for loop.
Within the loop, it calls generator.next().value. Remember generateDigitsOfPi()? This retrieves the next pi digit using the yield statement.
Each retrieved digit is appended to the digits string.
Bringing it all Together
Here’s where you get creative! Replace the comment // Do something with the digits here with your desired output format. You can:
Use console.log(digits) to print the digits to the console.
Get fancy and visualize them using a JavaScript charting library like Chart.js.
Challenge yourself to write the digits to a file (be aware, this might take a significant amount of time for a large number of digits).
Remember:
Adjust G_NUMBER_OF_DIGITS based on your machine’s capabilities. Start small and gradually increase as you experiment.
This is for educational purposes. Calculating an extreme number of digits might overload your system.
Take a pie break every now and then; after all, it’s a celebration!
Check out how I used the base code:
Happy coding, and may your Pi Day be as infinite and transcendental as the number itself! 🎉
This article was written with the assistance of AI.
Fun fact about Pie:
The mirror image of PI.E is (an admittedly sloppy) 3.14:
Article by BestCodes
https://the-best-codes.github.io/
