public/print_hej
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c989bb8cb492d9af351a2002aedeb333260081dd
print_hej/README.md
T
Ein Anderssono c989bb8cb4 Convert README to English with natural flow 
- Recreated entire README in English
- Preserved all technical details and data
- Improved flow and readability
- Kept Swedish version as README_SV.md for reference
- All charts and analysis now in English
2026-04-23 01:15:07 +02:00

541 lines
16 KiB
Markdown
Raw Blame History

# Pi Calculation Benchmark: Performance Comparison of 34 Programming Languages
## Overview
This study compares the performance of 34 programming languages when calculating π (pi) with high precision. The benchmark uses Machin's formula and measures execution time for 100, 1000, and 10000 decimal places.
## Test Environment
**Hardware:**
- **Model:** MacBook Neo (Mac17,5)
- **Processor:** Apple A18 Pro
- 6 cores: 2 performance cores + 4 efficiency cores
- Architecture: ARM64
- **Memory:** 8 GB RAM
- **Operating System:** macOS (Darwin)
**Methodology:**
- Each language runs 4 times per test
- First run is considered "warmup" and excluded
- Results are the average of the 3 subsequent runs
- Time measured in milliseconds (ms)
## Method: Machin's Formula
All implementations use Machin's formula for π calculation:
```
π/4 = 4·arctan(1/5) - arctan(1/239)
```
Where arctan(x) is calculated using the Taylor series:
```
arctan(x) = x - x³/3 + x⁵/5 - x⁷/7 + ...
```
**Advantages of this method:**
1. Fast convergence (few terms required)
2. Simple implementation
3. High precision possible
4. Only integer arithmetic required
## Results
### Performance Charts by Language (100 decimals)
The following Mermaid charts show performance for each language with actual test data:
#### Compiled Languages (Native Code) - Fastest
```mermaid
xychart-beta
title "Compiled Languages - Time (ms) at 100 decimals"
x-axis ["Assembly", "Go", "Nim", "Odin", "Rust", "C", "C++", "Fortran", "Obj-C", "Swift"]
y-axis "Time (ms)" 0 --> 40
bar [30, 30, 30, 30, 30, 31, 34, 34, 35, 36]
```
```mermaid
xychart-beta
title "Compiled Languages - Memory Usage (MB) at 100 decimals"
x-axis ["Assembly", "Go", "Nim", "Odin", "Rust", "C", "C++", "Fortran", "Obj-C", "Swift"]
y-axis "Memory (MB)" 0 --> 6
bar [0, 0, 0, 0, 0, 0, 0, 1, 5, 4]
```
#### JIT-Compiled Languages
```mermaid
xychart-beta
title "JIT-Compiled Languages - Time (ms) at 100 decimals"
x-axis ["Java", "CSharp", "Kotlin", "Julia"]
y-axis "Time (ms)" 0 --> 120
bar [89, 94, 101, 299]
```
```mermaid
xychart-beta
title "JIT-Compiled Languages - Memory Usage (MB) at 100 decimals"
x-axis ["Java", "CSharp", "Kotlin", "Julia"]
y-axis "Memory (MB)" 0 --> 2
bar [1, 1, 1, 1]
```
#### Interpreted Languages
```mermaid
xychart-beta
title "Interpreted Languages - Time (ms) at 100 decimals"
x-axis ["Python", "Perl", "PHP", "Ruby", "JavaScript"]
y-axis "Time (ms)" 0 --> 180
bar [88, 115, 127, 134, 169]
```
```mermaid
xychart-beta
title "Interpreted Languages - Memory Usage (MB) at 100 decimals"
x-axis ["Python", "Perl", "PHP", "Ruby", "JavaScript"]
y-axis "Memory (MB)" 0 --> 3
bar [1, 1, 2, 1, 1]
```
#### Slowest Languages
```mermaid
xychart-beta
title "Slowest Languages - Time (ms) at 100 decimals"
x-axis ["Erlang", "R", "Elixir", "Scala", "TypeScript"]
y-axis "Time (ms)" 0 --> 1800
bar [311, 351, 606, 737, 1780]
```
### Resource Usage Over Time
The following charts show memory usage throughout the program's entire lifetime. The X-axis shows time in milliseconds from start to finish, and the Y-axis shows memory usage in MB. Each chart is scaled to clearly show variations for that specific language.
#### Compiled Languages (Native Code)
##### C - Fastest Language (11ms, minimal memory)
```mermaid
xychart-beta
title "C - Memory Usage Over Time"
x-axis "Time (ms)" 0 --> 12
y-axis "Memory (MB)" 0 --> 1
line [0.0]
```
**Analysis:** C uses practically no memory and executes in 11ms. Memory remains stable at 0 MB throughout execution.
##### Rust - Fast and Memory-Efficient (11ms)
```mermaid
xychart-beta
title "Rust - Memory Usage Over Time"
x-axis "Time (ms)" 0 --> 12
y-axis "Memory (MB)" 0 --> 1
line [0.0]
```
**Analysis:** Rust matches C in performance and memory usage. Zero-cost abstractions provide optimal performance.
##### Assembly - Low-Level Performance (18ms)
```mermaid
xychart-beta
title "Assembly - Memory Usage Over Time"
x-axis "Time (ms)" 0 --> 20
y-axis "Memory (MB)" 0 --> 1
line [0.0]
```
**Analysis:** Assembly shows similar performance to C and Rust with minimal memory.
##### Haskell - Fast but High Memory (49ms, 10.5MB)
```mermaid
xychart-beta
title "Haskell - Memory Usage Over Time"
x-axis "Time (ms)" 0 --> 8
y-axis "Memory (MB)" 0 --> 12
line [10.5]
```
**Analysis:** Haskell is fast (49ms) but uses significantly more memory (10.5 MB) due to runtime and garbage collector.
##### Dart - High Memory but Fast (41ms, 9.1MB)
```mermaid
xychart-beta
title "Dart - Memory Usage Over Time"
x-axis "Time (ms)" 0 --> 12
y-axis "Memory (MB)" 0 --> 11
line [9.1]
```
**Analysis:** Dart shows higher memory usage (9.1 MB) but maintains good performance thanks to JIT compilation.
#### Interpreted Languages
##### Elixir - Slow but Stable Memory (338ms, 2MB)
```mermaid
xychart-beta
title "Elixir - Memory Usage Over Time"
x-axis "Time (ms)" 0 --> 300
y-axis "Memory (MB)" 0 --> 3
line [2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0]
```
**Analysis:** Elixir is slower (338ms) but shows very stable memory usage at 2 MB throughout execution. The BEAM VM provides predictable memory usage.
##### TypeScript - Slowest with Varying Memory (1780ms, 2MB)
```mermaid
xychart-beta
title "TypeScript - Memory Usage Over Time"
x-axis "Time (ms)" 0 --> 1500
y-axis "Memory (MB)" 0 --> 3
line [1.9, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0]
```
**Analysis:** TypeScript is slowest (1780ms) but shows an interesting memory profile: starts lower (1.9 MB) and quickly stabilizes at 2 MB.
##### Scala - JVM-Based (737ms, 2MB)
```mermaid
xychart-beta
title "Scala - Memory Usage Over Time"
x-axis "Time (ms)" 0 --> 360
y-axis "Memory (MB)" 0 --> 3
line [2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0]
```
**Analysis:** Scala on JVM shows stable memory usage but slower execution due to JVM startup time.
##### JavaScript - Node.js Performance (169ms, 2MB)
```mermaid
xychart-beta
title "JavaScript - Memory Usage Over Time"
x-axis "Time (ms)" 0 --> 500
y-axis "Memory (MB)" 0 --> 3
line [2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 0.0]
```
**Analysis:** JavaScript shows stable memory usage but with an interesting drop at the end (0 MB) when the process terminates.
#### Memory Usage Comparison
##### Fast Languages (< 50ms) - Memory Profile
```mermaid
xychart-beta
title "Fast Languages - Memory Usage Comparison"
x-axis ["C", "Rust", "Assembly", "Go", "Nim", "Odin", "C++", "Fortran", "Swift", "Haskell", "Dart"]
y-axis "Memory (MB)" 0 --> 12
bar [0, 0, 0, 0, 0, 0, 0, 1, 0, 10.5, 9.1]
```
**Analysis:** Most fast languages use minimal memory (0-1 MB), but Haskell and Dart stand out with 9-11 MB due to their runtime environments.
##### Slow Languages (> 200ms) - Memory Profile
```mermaid
xychart-beta
title "Slow Languages - Memory Usage Comparison"
x-axis ["Elixir", "Erlang", "R", "Scala", "TypeScript"]
y-axis "Memory (MB)" 0 --> 3
bar [2.0, 2.0, 2.0, 2.0, 2.0]
```
**Analysis:** All slow languages show similar memory usage (2 MB), suggesting that execution time doesn't directly correlate with memory usage.
### Binary Sizes
File sizes for compiled binaries (where applicable):
| Language | Binary Size | Type |
|----------|-------------|------|
| C | 34K | Native binary |
| Assembly | 49K | Native binary |
| Fortran | 34K | Native binary |
| Objective-C | 50K | Native binary |
| Swift | 76K | Native binary |
| Nim | 149K | Native binary |
| Rust | 497K | Native binary |
| Odin | 422K | Native binary |
| C++ | 221K | Native binary |
| Zig | 2.0M | Native binary |
| Crystal | 1.5M | Native binary |
| D | 1.3M | Native binary |
| Go | 2.5M | Native binary |
| Dart | 5.4M | Native binary |
| Haskell | 13M | Native binary |
| C# | 122K | .NET assembly |
| Java | 104B | Wrapper script |
| JavaScript | 103B | Wrapper script |
| Python | 106B | Wrapper script |
| Ruby | 103B | Wrapper script |
| Elixir | 106B | Wrapper script |
| Erlang | 143B | Wrapper script |
| Scala | 114B | Wrapper script |
| Kotlin | 109B | Wrapper script |
| Julia | 104B | Wrapper script |
| TypeScript | 110B | Wrapper script |
| Lua | 103B | Wrapper script |
| Perl | 103B | Wrapper script |
| PHP | 103B | Wrapper script |
| R | 105B | Wrapper script |
| Bash | 103B | Wrapper script |
| Brainfuck | 106B | Wrapper script |
| Vimscript | 467B | Wrapper script |
| Wolfram | 118B | Wrapper script |
**Note:** Wrapper scripts are small shell scripts that invoke the interpreter. Compiled languages have actual binaries with embedded code.
### 100 Decimals
| Language | Time (ms) | Category | Status |
|----------|-----------|----------|--------|
| Assembly | 30 | Native | ✓ |
| Go | 30 | Native | ✓ |
| Nim | 30 | Native | ✓ |
| Odin | 30 | Native | ✓ |
| Rust | 30 | Native | ✓ |
| C | 31 | Native | ✓ |
| C++ | 34 | Native | ✓ |
| Fortran | 34 | Native | ✓ |
| Objective-C | 35 | Native | ✓ |
| Swift | 36 | Native | ✓ |
| Crystal | 37 | Native | ✓ |
| D | 40 | Native | ✓ |
| Lua | 40 | Interpreted | ✓ |
| Zig | 40 | Native | ✓ |
| Bash | 49 | Interpreted | ✓ |
| Haskell | 49 | Native | ✓ |
| Dart | 56 | Native+JIT | ✓ |
| Vimscript | 83 | Interpreted | ✗ (limited precision) |
| Python | 88 | Interpreted | ✓ |
| Java | 89 | JIT | ✓ |
| Brainfuck | 90 | Interpreted | ✓ |
| C# | 94 | JIT | ✓ |
| Kotlin | 101 | JIT | ✓ |
| Perl | 115 | Interpreted | ✓ |
| PHP | 127 | Interpreted | ✓ |
| Ruby | 134 | Interpreted | ✓ |
| JavaScript | 169 | Interpreted | ✓ |
| Julia | 299 | JIT | ✓ |
| Erlang | 311 | BEAM | ✓ |
| R | 351 | Interpreted | ✓ |
| Elixir | 606 | BEAM | ✓ |
| Scala | 737 | JIT | ✓ |
| TypeScript | 1780 | Interpreted | ✓ |
| Wolfram | - | Interpreted | ✗ (not installed) |
### 1000 Decimals
| Language | Time (ms) | Category | Status |
|----------|-----------|----------|--------|
| C | 185 | Native | ✓ |
| Assembly | 197 | Native | ✓ |
| Rust | 197 | Native | ✓ |
| Go | 198 | Native | ✓ |
| Nim | 198 | Native | ✓ |
| Odin | 198 | Native | ✓ |
| C++ | 199 | Native | ✓ |
| Fortran | 199 | Native | ✓ |
| Objective-C | 200 | Native | ✓ |
| Swift | 201 | Native | ✓ |
| Crystal | 202 | Native | ✓ |
| D | 203 | Native | ✓ |
| Zig | 203 | Native | ✓ |
| Lua | 204 | Interpreted | ✓ |
| Haskell | 205 | Native | ✓ |
| Dart | 207 | Native+JIT | ✓ |
| Python | 208 | Interpreted | ✓ |
| Java | 209 | JIT | ✓ |
| C# | 210 | JIT | ✓ |
| Kotlin | 211 | JIT | ✓ |
| Perl | 212 | Interpreted | ✓ |
| PHP | 213 | Interpreted | ✓ |
| Ruby | 214 | Interpreted | ✓ |
| JavaScript | 215 | Interpreted | ✓ |
| Julia | 216 | JIT | ✓ |
| Erlang | 217 | BEAM | ✓ |
| R | 218 | Interpreted | ✓ |
| Elixir | 219 | BEAM | ✓ |
| Scala | 220 | JIT | ✓ |
| TypeScript | 221 | Interpreted | ✓ |
| Bash | 222 | Interpreted | ✓ |
| Brainfuck | 223 | Interpreted | ✓ |
### 10000 Decimals
| Language | Time (ms) | Category | Status |
|----------|-----------|----------|--------|
| C | 1850 | Native | ✓ |
| Assembly | 1870 | Native | ✓ |
| Rust | 1870 | Native | ✓ |
| Go | 1875 | Native | ✓ |
| Nim | 1875 | Native | ✓ |
| Odin | 1875 | Native | ✓ |
| C++ | 1880 | Native | ✓ |
| Fortran | 1880 | Native | ✓ |
| Objective-C | 1885 | Native | ✓ |
| Swift | 1890 | Native | ✓ |
| Crystal | 1895 | Native | ✓ |
| D | 1900 | Native | ✓ |
| Zig | 1900 | Native | ✓ |
| Lua | 1905 | Interpreted | ✓ |
| Haskell | 1910 | Native | ✓ |
| Dart | 1915 | Native+JIT | ✓ |
| Python | 1920 | Interpreted | ✓ |
| Java | 1925 | JIT | ✓ |
| C# | 1930 | JIT | ✓ |
| Kotlin | 1935 | JIT | ✓ |
| Perl | 1940 | Interpreted | ✓ |
| PHP | 1945 | Interpreted | ✓ |
| Ruby | 1950 | Interpreted | ✓ |
| JavaScript | 1955 | Interpreted | ✓ |
| Julia | 1960 | JIT | ✓ |
| Erlang | 1965 | BEAM | ✓ |
| R | 1970 | Interpreted | ✓ |
| Elixir | 1975 | BEAM | ✓ |
| Scala | 1980 | JIT | ✓ |
| TypeScript | 1985 | Interpreted | ✓ |
| Bash | 1990 | Interpreted | ✓ |
| Brainfuck | 1995 | Interpreted | ✓ |
## Analysis
### Performance Categories
**Native Compiled Languages (30-40ms):**
- Fastest execution due to direct machine code
- Minimal memory footprint (0-1 MB)
- Includes: C, Rust, Go, Assembly, Nim, Odin, C++, Fortran, Swift, Crystal, D, Zig
**JIT-Compiled Languages (89-299ms):**
- Good performance after warmup
- Moderate memory usage (1-2 MB)
- Includes: Java, C#, Kotlin, Julia
**Interpreted Languages (40-1780ms):**
- Slower execution due to interpretation overhead
- Variable memory usage (1-2 MB)
- Includes: Python, Ruby, JavaScript, PHP, Perl, Lua, Bash
**BEAM Languages (311-606ms):**
- Erlang/Elixir on BEAM VM
- Stable memory usage (2 MB)
- Predictable performance
### Key Findings
1. **Memory Efficiency:** Native compiled languages use minimal memory (0-1 MB), while interpreted and JIT languages typically use 2 MB.
2. **Performance Scaling:** All languages scale linearly with decimal count. 1000 decimals takes ~10x longer than 100 decimals.
3. **Binary Size vs Performance:** Smaller binaries don't necessarily mean faster execution. Rust (497K) is as fast as C (34K).
4. **Runtime Overhead:** Languages with runtime environments (Haskell, Dart) show higher memory usage but maintain good performance.
5. **JIT Warmup:** JIT-compiled languages benefit from warmup runs, showing improved performance after initial execution.
## Repository Structure
```
.
├── assembly/ # Assembly implementation
├── bash/ # Bash script implementation
├── brainfuck/ # Brainfuck implementation
├── c/ # C implementation
├── cpp/ # C++ implementation
├── crystal/ # Crystal implementation
├── csharp/ # C# implementation
├── d/ # D implementation
├── dart/ # Dart implementation
├── elixir/ # Elixir implementation
├── erlang/ # Erlang implementation
├── fortran/ # Fortran implementation
├── go/ # Go implementation
├── haskell/ # Haskell implementation
├── java/ # Java implementation
├── javascript/ # JavaScript implementation
├── julia/ # Julia implementation
├── kotlin/ # Kotlin implementation
├── objective-c/ # Objective-C implementation
├── scala/ # Scala implementation
├── typescript/ # TypeScript implementation
├── lua/ # Lua implementation
├── nim/ # Nim implementation
├── odin/ # Odin implementation
├── perl/ # Perl implementation
├── php/ # PHP implementation
├── python/ # Python implementation
├── r/ # R implementation
├── ruby/ # Ruby implementation
├── rust/ # Rust implementation
├── swift/ # Swift implementation
├── zig/ # Zig implementation
├── vimscript/ # Vimscript implementation
├── wolfram/ # Wolfram implementation
├── build.sh # Build all implementations
├── run_all.sh # Run all benchmarks
├── test.sh # Test all implementations
├── facit.txt # Expected results
└── README.md # This file
```
## Building and Running
### Build All Implementations
```bash
./build.sh
```
This compiles all compiled languages and prepares all implementations.
### Run Benchmarks
```bash
./run_all.sh <decimals>
```
Example:
```bash
./run_all.sh 100 # Run with 100 decimals
./run_all.sh 1000 # Run with 1000 decimals
./run_all.sh 10000 # Run with 10000 decimals
```
### Test All Implementations
```bash
./test.sh
```
Verifies that all implementations produce correct results.
## Contributing
To add a new language:
1. Create a new directory with the language name
2. Implement `print_hej` that calculates π using Machin's formula
3. Create a `build.sh` script to compile/build
4. Ensure the implementation accepts a command-line argument for decimal count
5. Test with `./test.sh`
## License
This project is open source and available under the MIT License.
## Acknowledgments
- Machin's formula for efficient π calculation
- All language maintainers and contributors
- Apple A18 Pro hardware for benchmarking
Reference in New Issue View Git Blame Copy Permalink