رفتن به محتوا

Building a high-precision π calculator in Scratch

این محتوا هنوز به زبان شما در دسترس نیست.

🧮 Struggling with mathematical algorithms in Scratch? Need help with precision calculations? 🚀 Get Math Help

MA

MathWizard_Alex

Posted on March 14, 2024 • Advanced

🥧 Need help creating the fastest π calculator possible

Hey math enthusiasts! I’m working on a high-precision π calculator project and need help optimizing it for speed and accuracy. My current approach is too slow for multiple iterations.

My goals:

  • Calculate π to at least 10-15 decimal places
  • Use iterative methods for better precision
  • Optimize for speed - need thousands of iterations
  • Compare different mathematical approaches
  • Display results in real-time

I know the basic circumference/diameter approach, but that’s limited by Scratch’s decimal precision. I need algorithms that can converge quickly to π with high accuracy. Any advanced mathematical techniques would be amazing! 🔢

Current project: My π Calculator Attempt

NM

NumericalMethods_Sarah

Replied 2 hours later • ⭐ Best Answer

Excellent question @MathWizard_Alex! Creating high-precision π calculators is a fantastic way to explore numerical methods. Here are several powerful algorithms you can implement:

🧮 π Calculation Algorithm Comparison

Here’s how different methods compare for speed and accuracy:

flowchart TD A[🎯 Choose Algorithm] --> B{Precision Needed?} B -->|Low 3-5 digits| C[Simple Approximation] B -->|Medium 6-10 digits| D[Leibniz Series] B -->|High 10+ digits| E[Advanced Methods] C --> F[22/7 or 355/113] D --> G[Gregory-Leibniz Series] E --> H[Machin Formula] E --> I[Chudnovsky Algorithm] E --> J[Monte Carlo Method] F --> K[⚡ Fastest] G --> L[🐌 Slow Convergence] H --> M[⚡ Fast Convergence] I --> N[🚀 Ultra Fast] J --> O[🎲 Probabilistic] K --> P[π ≈ 3.14159] L --> P M --> P N --> P O --> P style A fill:#e1f5fe style E fill:#f3e5f5 style N fill:#e8f5e8 style P fill:#fce4ec

📊 Method 1: Leibniz Series (Educational)

Great for understanding convergence, but slow:

    when flag clicked
// Leibniz series: π/4 = 1 - 1/3 + 1/5 - 1/7 + 1/9 - ...
set [pi estimate v] to [0]
set [iterations v] to [0]
set [sign v] to [1]
set [denominator v] to [1]

repeat [10000]
change [pi estimate v] by ((sign) / (denominator))
set [sign v] to ((sign) * [-1])
change [denominator v] by [2]
change [iterations v] by [1]

// Display progress every 100 iterations
if <((iterations) mod [100]) = [0]> then
set [current pi v] to ((pi estimate) * [4])
say (join [π ≈ ] (current pi)) for [0.1] seconds
end
end

set [final pi v] to ((pi estimate) * [4])
say (join [Final π = ] (final pi))

🚀 Method 2: Machin Formula (Fast Convergence)

Much faster convergence using arctangent series:

    // Machin's formula: π/4 = 4*arctan(1/5) - arctan(1/239)
when flag clicked
set [pi result v] to [0]

// Calculate 4*arctan(1/5)
arctan series [1] [5] [4]
set [term1 v] to (arctan result)

// Calculate arctan(1/239)
arctan series [1] [239] [1]
set [term2 v] to (arctan result)

// Combine using Machin's formula
set [pi result v] to (((term1) - (term2)) * [4])
say (join [Machin π = ] (pi result))

// Custom block for arctan series
define arctan series (numerator) (denominator) (multiplier)
set [arctan result v] to [0]
set [x v] to ((numerator) / (denominator))
set [x power v] to (x)
set [factorial v] to [1]
set [sign v] to [1]

repeat [50]  // 50 terms gives excellent precision
set [term v] to (((sign) * (x power)) / (factorial))
change [arctan result v] by (term)

// Update for next iteration
set [x power v] to ((x power) * (x) * (x))
change [factorial v] by [2]
set [sign v] to ((sign) * [-1])
end

set [arctan result v] to ((arctan result) * (multiplier))

🎲 Method 3: Monte Carlo Estimation

Probabilistic approach - great for visualization:

    when flag clicked
// Monte Carlo method using random points in a circle
set [total points v] to [0]
set [points in circle v] to [0]
set [pi estimate v] to [0]

repeat [100000]
// Generate random point in unit square
set [x v] to (pick random [-100] to [100])
set [y v] to (pick random [-100] to [100])

// Convert to unit circle coordinates
set [x coord v] to ((x) / [100])
set [y coord v] to ((y) / [100])

// Check if point is inside unit circle
set [distance squared v] to (((x coord) * (x coord)) + ((y coord) * (y coord)))

change [total points v] by [1]
if <(distance squared) < [1]> then
change [points in circle v] by [1]

// Optional: draw point in green
pen up
go to x: (x) y: (y)
set pen color to [#00ff00]
pen down
move [1] steps
pen up
else
// Optional: draw point in red
pen up
go to x: (x) y: (y)
set pen color to [#ff0000]
pen down
move [1] steps
pen up
end

// Calculate π estimate: π ≈ 4 * (points in circle / total points)
if <(total points) > [0]> then
set [pi estimate v] to ([4] * ((points in circle) / (total points)))
end

// Update display every 1000 points
if <((total points) mod [1000]) = [0]> then
say (join [Monte Carlo π ≈ ] (pi estimate)) for [0.1] seconds
end
end

⚡ Method 4: Optimized Chudnovsky-Style Algorithm

Extremely fast convergence (each term adds ~14 digits):

    // Simplified Chudnovsky-inspired algorithm
when flag clicked
set [pi inverse v] to [0]
set [k v] to [0]

repeat [10]  // Just 10 iterations for high precision!
// Calculate factorial terms (simplified)
set [factorial 6k v] to [1]
set [temp k v] to (k)
repeat ((k) * [6])
set [factorial 6k v] to ((factorial 6k) * (temp k))
change [temp k v] by [-1]
end

// Calculate the series term
set [numerator v] to ((factorial 6k) * ((13591409) + ((k) * [545140134])))
set [denominator v] to [1]

// Calculate 3^k and other terms
set [power 3k v] to [1]
repeat (k)
set [power 3k v] to ((power 3k) * [3])
end

set [denominator v] to ((power 3k) * [640320])

// Add term to series
if <((k) mod [2]) = [0]> then
change [pi inverse v] by ((numerator) / (denominator))
else
change [pi inverse v] by ([0] - ((numerator) / (denominator)))
end

change [k v] by [1]
end

// Convert to π
set [pi result v] to ([426880] / ((pi inverse) * [10005]))
say (join [Chudnovsky π = ] (pi result))

📈 Performance Optimization Tips

Speed Optimization:

    // Use efficient variable updates
define optimize calculation speed
// Pre-calculate constants
set [constant 1 v] to [3.14159265359]
set [constant 2 v] to [1.41421356237]

// Use integer arithmetic when possible
set [scaled value v] to ((original value) * [1000000])
// Do calculations with integers
set [result scaled v] to ((scaled value) * (other scaled value))
// Scale back down
set [final result v] to ((result scaled) / [1000000000000])

// Minimize expensive operations
if <(expensive calculation needed) = [true]> then
expensive calculation
set [expensive calculation needed v] to [false]
end

Precision Display:

    // Format π to desired decimal places
define format pi to (decimal places)
set [multiplier v] to [1]
repeat (decimal places)
set [multiplier v] to ((multiplier) * [10])
end

set [rounded pi v] to ([round v] of ((pi result) * (multiplier)))
set [formatted pi v] to ((rounded pi) / (multiplier))

// Create display string
set [pi string v] to (formatted pi)
if <(length of (pi string)) < ((decimal places) + [2])> then
// Add trailing zeros if needed
set [pi string v] to (join (pi string) [0])
end

🎯 Real-Time Comparison Display

    // Compare multiple methods simultaneously
when flag clicked
clear
set [comparison mode v] to [true]

// Start all methods
broadcast [start leibniz v]
broadcast [start machin v]
broadcast [start monte carlo v]

// Display comparison
forever
go to x: [-200] y: [150]
set pen color to [#000000]
write (join [Leibniz: ] (leibniz pi))

go to x: [-200] y: [100]
write (join [Machin: ] (machin pi))

go to x: [-200] y: [50]
write (join [Monte Carlo: ] (monte carlo pi))

go to x: [-200] y: [0]
set pen color to [#ff0000]
write (join [True π: ] [3.14159265358979323846])

wait [0.5] seconds
clear
end

🏆 Advanced Features

  • Convergence Analysis: Track how quickly each method approaches π
  • Error Calculation: Show the difference from the true value
  • Iteration Timing: Measure performance of different algorithms
  • Visual Representation: Graph the convergence over time

The Machin formula is your best bet for speed and accuracy in Scratch! It converges much faster than simple series and gives excellent precision with just 50-100 terms. 🎯

MA

MathWizard_Alex

Replied 5 hours later

@NumericalMethods_Sarah This is absolutely incredible! 🤯 Thank you so much!

I implemented the Machin formula and it’s giving me 12 decimal places of accuracy with just 30 iterations! The Monte Carlo visualization is also really cool - you can actually see π emerging from the random points.

Quick question: How can I optimize the factorial calculations for the Chudnovsky method? They seem to be the bottleneck.

OE

OptimizationExpert_David

Replied 1 hour later

@MathWizard_Alex Great question! For factorial optimization, use incremental calculation:

    // Optimized factorial calculation
define calculate factorial incrementally (n)
if <(n) = [0]> then
set [factorial result v] to [1]
else
if <(previous n) = ((n) - [1])> then
// Use previous result
set [factorial result v] to ((previous factorial) * (n))
else
// Calculate from scratch
set [factorial result v] to [1]
set [i v] to [1]
repeat (n)
set [factorial result v] to ((factorial result) * (i))
change [i v] by [1]
end
end
end

set [previous n v] to (n)
set [previous factorial v] to (factorial result)

This avoids recalculating the entire factorial each time! Also consider using Stirling’s approximation for very large factorials. 📈

VB

Vibelf_Community

Pinned Message • Moderator

🧮 Ready to Master Advanced Mathematical Programming?

Amazing mathematical discussion! For those interested in diving deeper into numerical methods and mathematical algorithms, our expert tutors can help you explore:

  • 🔢 Advanced numerical analysis techniques
  • 📊 Statistical and probabilistic algorithms
  • 🚀 High-performance computing methods
  • 🎯 Mathematical modeling and simulation

📚 Related Mathematical Topics

Want to become a mathematical programming expert? Get personalized guidance from our math specialists!