public/print_hej
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

revmoed swedish

Browse Source
This commit is contained in:
Ein Anderssono
2026-04-23 09:48:37 +02:00
parent fa0097404a
commit b39062c62d
1 changed files with 0 additions and 726 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README_SV.md
-726
View File
@@ -1,726 +0,0 @@
# Pi-beräkningsbenchmark: Prestandajämförelse av 34 programmeringsspråk
## Sammanfattning
Denna studie jämför prestandan hos 34 programmeringsspråk vid beräkning av π (pi) med hög precision. Testet använder Machins formel och mäter exekveringstid för 100, 1000 och 10000 decimaler.
## Testmiljö
**Hårdvara:**
- **Modell:** MacBook Neo (Mac17,5)
- **Processor:** Apple A18 Pro
- 6 kärnor: 2 prestandakärnor + 4 effektivitetskärnor
- Arkitektur: ARM64
- **Minne:** 8 GB RAM
- **Operativsystem:** macOS (Darwin)
**Mätmetod:**
- Varje språk körs 4 gånger per test
- Första körningen räknas som "warmup" och exkluderas
- Resultatet är genomsnittet av de 3 efterföljande körningarna
- Tidsmätning i millisekunder (ms)
## Metod: Machins formel
Alla implementationer använder Machins formel för π-beräkning:
```
π/4 = 4·arctan(1/5) - arctan(1/239)
```
Där arctan(x) beräknas med Taylor-serien:
```
arctan(x) = x - x³/3 + x⁵/5 - x⁷/7 + ...
```
**Fördelar med denna metod:**
1. Snabb konvergens (få termer krävs)
2. Enkel implementation
3. Hög noggrannhet möjlig
4. Endast heltalsaritmetik krävs
## Resultat
### Prestandadiagram per språk (100 decimaler)
Följande Mermaid-diagram visar prestanda för varje språk med faktiska testdata:
#### Kompilerade språk (Native Code) - Snabbaste
```mermaid
xychart-beta
title "Kompilerade språk - Tid (ms) vid 100 decimaler"
x-axis ["Assembly", "Go", "Nim", "Odin", "Rust", "C", "C++", "Fortran", "Obj-C", "Swift"]
y-axis "Tid (ms)" 0 --> 40
bar [30, 30, 30, 30, 30, 31, 34, 34, 35, 36]
```
```mermaid
xychart-beta
title "Kompilerade språk - Minnesanvändning (MB) vid 100 decimaler"
x-axis ["Assembly", "Go", "Nim", "Odin", "Rust", "C", "C++", "Fortran", "Obj-C", "Swift"]
y-axis "Minne (MB)" 0 --> 6
bar [0, 0, 0, 0, 0, 0, 0, 1, 5, 4]
```
#### JIT-kompilerade språk
```mermaid
xychart-beta
title "JIT-kompilerade språk - Tid (ms) vid 100 decimaler"
x-axis ["Java", "CSharp", "Kotlin", "Julia"]
y-axis "Tid (ms)" 0 --> 120
bar [89, 94, 101, 299]
```
```mermaid
xychart-beta
title "JIT-kompilerade språk - Minnesanvändning (MB) vid 100 decimaler"
x-axis ["Java", "CSharp", "Kotlin", "Julia"]
y-axis "Minne (MB)" 0 --> 2
bar [1, 1, 1, 1]
```
#### Tolkade språk
```mermaid
xychart-beta
title "Tolkade språk - Tid (ms) vid 100 decimaler"
x-axis ["Python", "Perl", "PHP", "Ruby", "JavaScript"]
y-axis "Tid (ms)" 0 --> 180
bar [88, 115, 127, 134, 169]
```
```mermaid
xychart-beta
title "Tolkade språk - Minnesanvändning (MB) vid 100 decimaler"
x-axis ["Python", "Perl", "PHP", "Ruby", "JavaScript"]
y-axis "Minne (MB)" 0 --> 3
bar [1, 1, 2, 1, 1]
```
#### Långsammaste språk
```mermaid
xychart-beta
title "Långsammaste språk - Tid (ms) vid 100 decimaler"
x-axis ["Erlang", "R", "Elixir", "Scala", "TypeScript"]
y-axis "Tid (ms)" 0 --> 1800
bar [311, 351, 606, 737, 1780]
```
### Resursanvändning över tid
Följande diagram visar minnesanvändning genom programmets hela livstid. X-axeln visar tid i millisekunder från start till slut, och Y-axeln visar minnesanvändning i MB. Varje diagram är skalat för att tydligt visa variationer för just det språket.
#### Kompilerade språk (Native Code)
##### C - Snabbaste språket (11ms, minimalt minne)
```mermaid
xychart-beta
title "C - Minnesanvändning över tid"
x-axis "Tid (ms)" 0 --> 12
y-axis "Minne (MB)" 0 --> 1
line [0.0]
```
**Analys:** C använder praktiskt taget inget minne och kör på 11ms. Minnet är stabilt på 0 MB under hela körningen.
##### Rust - Snabb och minneseffektiv (11ms)
```mermaid
xychart-beta
title "Rust - Minnesanvändning över tid"
x-axis "Tid (ms)" 0 --> 12
y-axis "Minne (MB)" 0 --> 1
line [0.0]
```
**Analys:** Rust matchar C i prestanda och minnesanvändning. Nollkostnadsabstraktioner ger optimal prestanda.
##### Assembly - Låg-nivå prestanda (18ms)
```mermaid
xychart-beta
title "Assembly - Minnesanvändning över tid"
x-axis "Tid (ms)" 0 --> 20
y-axis "Minne (MB)" 0 --> 1
line [0.0]
```
**Analys:** Assembly visar liknande prestanda som C och Rust med minimalt minne.
##### Haskell - Snabb men högt minne (49ms, 10.5MB)
```mermaid
xychart-beta
title "Haskell - Minnesanvändning över tid"
x-axis "Tid (ms)" 0 --> 8
y-axis "Minne (MB)" 0 --> 12
line [10.5]
```
**Analys:** Haskell är snabb (49ms) men använder betydligt mer minne (10.5 MB) på grund av runtime och garbage collector.
##### Dart - Högt minne men snabb (41ms, 9.1MB)
```mermaid
xychart-beta
title "Dart - Minnesanvändning över tid"
x-axis "Tid (ms)" 0 --> 12
y-axis "Minne (MB)" 0 --> 11
line [9.1]
```
**Analys:** Dart visar högre minnesanvändning (9.1 MB) men bibehåller bra prestanda tack vare JIT-kompilering.
#### Tolkade språk
##### Elixir - Långsamt men stabilt minne (338ms, 2MB)
```mermaid
xychart-beta
title "Elixir - Minnesanvändning över tid"
x-axis "Tid (ms)" 0 --> 300
y-axis "Minne (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]
```
**Analys:** Elixir är långsammare (338ms) men visar mycket stabil minnesanvändning på 2 MB genom hela körningen. BEAM VM ger förutsägbar minnesanvändning.
##### TypeScript - Långsammast med varierande minne (1780ms, 2MB)
```mermaid
xychart-beta
title "TypeScript - Minnesanvändning över tid"
x-axis "Tid (ms)" 0 --> 1500
y-axis "Minne (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]
```
**Analys:** TypeScript är långsammast (1780ms) men visar intressant minnesprofil: startar lägre (1.9 MB) och stabiliseras snabbt på 2 MB.
##### Scala - JVM-baserad (737ms, 2MB)
```mermaid
xychart-beta
title "Scala - Minnesanvändning över tid"
x-axis "Tid (ms)" 0 --> 360
y-axis "Minne (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]
```
**Analys:** Scala på JVM visar stabil minnesanvändning men långsammare exekvering på grund av JVM startup-tid.
##### JavaScript - Node.js prestanda (169ms, 2MB)
```mermaid
xychart-beta
title "JavaScript - Minnesanvändning över tid"
x-axis "Tid (ms)" 0 --> 500
y-axis "Minne (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]
```
**Analys:** JavaScript visar stabil minnesanvändning men med en intressant minskning i slutet (0 MB) när processen avslutar.
#### Jämförelse av minnesanvändning
##### Snabba språk (< 50ms) - Minnesprofil
```mermaid
xychart-beta
title "Snabba språk - Minnesanvändning jämförelse"
x-axis ["C", "Rust", "Assembly", "Go", "Nim", "Odin", "C++", "Fortran", "Swift", "Haskell", "Dart"]
y-axis "Minne (MB)" 0 --> 12
bar [0, 0, 0, 0, 0, 0, 0, 1, 0, 10.5, 9.1]
```
**Analys:** De flesta snabba språk använder minimalt minne (0-1 MB), men Haskell och Dart sticker ut med 9-11 MB på grund av sina runtime-miljöer.
##### Långsamma språk (> 200ms) - Minnesprofil
```mermaid
xychart-beta
title "Långsamma språk - Minnesanvändning jämförelse"
x-axis ["Elixir", "Erlang", "R", "Scala", "TypeScript"]
y-axis "Minne (MB)" 0 --> 3
bar [2.0, 2.0, 2.0, 2.0, 2.0]
```
**Analys:** Alla långsamma språk visar liknande minnesanvändning (2 MB), vilket tyder på att exekveringstiden inte direkt korrelerar med minnesanvändningen.
### Binärstorlekar
Filstorlekar för kompilerade binärer (där tillämpligt):
| Språk | Binärstorlek | Typ |
|-------|--------------|-----|
| 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 |
**Notering:** Wrapper scripts är små shell-script som anropar tolken. Kompilerade språk har faktiska binärer med inbyggd kod.
### 100 decimaler
| Språk | Tid (ms) | Kategori | Status |
|-------|----------|----------|--------|
| C | 6 | Kompilerat (native) | ✓ |
| Assembly | 7 | Kompilerat (native) | ✓ |
| C++ | 7 | Kompilerat (native) | ✓ |
| Nim | 7 | Kompilerat (native) | ✓ |
| Odin | 7 | Kompilerat (native) | ✓ |
| Rust | 7 | Kompilerat (native) | ✓ |
| Fortran | 8 | Kompilerat (native) | ✓ |
| Objective-C | 8 | Kompilerat (native) | ✓ |
| Crystal | 9 | Kompilerat (native) | ✓ |
| Go | 9 | Kompilerat (native) | ✓ |
| Swift | 9 | Kompilerat (native) | ✓ |
| Lua | 10 | Tolkat (JIT) | ✓ |
| D | 12 | Kompilerat (native) | ✓ |
| Zig | 12 | Kompilerat (native) | ✓ |
| Bash | 14 | Tolkat (skript) | ✓ |
| Haskell | 19 | Kompilerat (native) | ✓ |
| Dart | 20 | Kompilerat/JIT | ✓ |
| Brainfuck | 32 | Esoteriskt | ✓ |
| Perl | 34 | Tolkat | ✓ |
| Python | 34 | Tolkat | ✓ |
| Java | 36 | JIT-kompilerat | ✓ |
| C# | 38 | JIT-kompilerat | ✓ |
| Kotlin | 47 | JIT-kompilerat | ✓ |
| PHP | 56 | Tolkat | ✓ |
| Ruby | 62 | Tolkat | ✓ |
| JavaScript | 77 | JIT-kompilerat | ✓ |
| Erlang | 119 | Tolkat (BEAM) | ✓ |
| Julia | 151 | JIT-kompilerat | ✓ |
| R | 156 | Tolkat | ✓ |
| Elixir | 281 | Tolkat (BEAM) | ✓ |
| Scala | 389 | JIT-kompilerat | ✓ |
| TypeScript | 884 | JIT-kompilerat | ✓ |
| Vimscript | 31 | Tolkat | ✗ (precision) |
| Wolfram | - | Tolkat | ✗ (ej konfigurerad) |
### 1000 decimaler
| Språk | Tid (ms) | Kategori | Status |
|-------|----------|----------|--------|
| Assembly | 4 | Kompilerat (native) | ✓ |
| C | 4 | Kompilerat (native) | ✓ |
| Go | 5 | Kompilerat (native) | ✓ |
| Rust | 5 | Kompilerat (native) | ✓ |
| Objective-C | 6 | Kompilerat (native) | ✓ |
| C++ | 7 | Kompilerat (native) | ✓ |
| Crystal | 7 | Kompilerat (native) | ✓ |
| D | 10 | Kompilerat (native) | ✓ |
| Odin | 10 | Kompilerat (native) | ✓ |
| Nim | 11 | Kompilerat (native) | ✓ |
| Zig | 12 | Kompilerat (native) | ✓ |
| Fortran | 17 | Kompilerat (native) | ✓ |
| Dart | 19 | Kompilerat/JIT | ✓ |
| Haskell | 19 | Kompilerat (native) | ✓ |
| Bash | 26 | Tolkat (skript) | ✓ |
| Lua | 29 | Tolkat (JIT) | ✓ |
| Brainfuck | 34 | Esoteriskt | ✓ |
| Python | 38 | Tolkat | ✓ |
| C# | 39 | JIT-kompilerat | ✓ |
| Java | 41 | JIT-kompilerat | ✓ |
| Kotlin | 49 | JIT-kompilerat | ✓ |
| PHP | 58 | Tolkat | ✓ |
| Ruby | 65 | Tolkat | ✓ |
| Swift | 78 | Kompilerat (native) | ✓ |
| Perl | 84 | Tolkat | ✓ |
| Erlang | 121 | Tolkat (BEAM) | ✓ |
| Julia | 151 | JIT-kompilerat | ✓ |
| R | 167 | Tolkat | ✓ |
| JavaScript | 195 | JIT-kompilerat | ✓ |
| Elixir | 280 | Tolkat (BEAM) | ✓ |
| Scala | 342 | JIT-kompilerat | ✓ |
| TypeScript | 960 | JIT-kompilerat | ✓ |
### 10000 decimaler
| Språk | Tid (ms) | Kategori | Status |
|-------|----------|----------|--------|
| C | 24 | Kompilerat (native) | ✓ |
| Objective-C | 25 | Kompilerat (native) | ✓ |
| Assembly | 27 | Kompilerat (native) | ✓ |
| Haskell | 50 | Kompilerat (native) | ✓ |
| Rust | 53 | Kompilerat (native) | ✓ |
| Crystal | 59 | Kompilerat (native) | ✓ |
| Go | 78 | Kompilerat (native) | ✓ |
| D | 79 | Kompilerat (native) | ✓ |
| Brainfuck | 109 | Esoteriskt | ✓ |
| C# | 116 | JIT-kompilerat | ✓ |
| Ruby | 128 | Tolkat | ✓ |
| Dart | 133 | Kompilerat/JIT | ✓ |
| Java | 134 | JIT-kompilerat | ✓ |
| Kotlin | 141 | JIT-kompilerat | ✓ |
| Julia | 161 | JIT-kompilerat | ✓ |
| Zig | 181 | Kompilerat (native) | ✓ |
| C++ | 185 | Kompilerat (native) | ✓ |
| Erlang | 254 | Tolkat (BEAM) | ✓ |
| PHP | 264 | Tolkat | ✓ |
| Python | 300 | Tolkat | ✓ |
| Elixir | 353 | Tolkat (BEAM) | ✓ |
| Scala | 435 | JIT-kompilerat | ✓ |
| R | 451 | Tolkat | ✓ |
| Odin | 459 | Kompilerat (native) | ✓ |
| Nim | 463 | Kompilerat (native) | ✓ |
| Fortran | 1088 | Kompilerat (native) | ✓ |
| Lua | 1543 | Tolkat (JIT) | ✓ |
| Perl | 2285 | Tolkat | ✓ |
| Bash | 4456 | Tolkat (skript) | ✓ |
| Swift | 6735 | Kompilerat (native) | ✓ |
| JavaScript | 10065 | JIT-kompilerat | ✓ |
| TypeScript | 10334 | JIT-kompilerat | ✓ |
## Prestandaanalys
### Kompilerade språk (Native Code)
**Definition:** Språk som kompileras direkt till maskinkod som exekveras av processorn utan mellanliggande lager.
**Karaktäristika:**
- Direkt exekvering av maskinkod
- Ingen runtime overhead
- Manuell minneshantering (oftast)
- Optimeringar vid kompileringstillfället
**Testresultat:**
- **Snabbaste:** C (24 ms för 10000 decimaler)
- **Mekanism:** Kompilerar till optimerad ARM64-maskinkod
- **Prestandaintervall:** 4-1088 ms (beroende på implementation och bibliotek)
**Exempel från testet:**
```
C: 24 ms (Native code, GMP library)
Assembly: 27 ms (Direct ARM64 instructions)
Rust: 53 ms (Native code, safe abstractions)
Go: 78 ms (Native code, GC overhead)
Fortran: 1088 ms (Native code, older implementation)
```
**Varierande prestanda inom kategorin:**
- **C/Assembly:** Direkt maskinkod, maximal prestanda
- **Rust/Zig:** Nollkostnadsabstraktioner, jämförbar med C
- **Go:** Sophämtning (GC) ger liten overhead
- **Fortran:** Äldre implementation, mindre optimerad
### JIT-kompilerade språk (Just-In-Time)
**Definition:** Språk som kompileras till bytecode vid utveckling, sedan kompileras till maskinkod vid körning.
**Karaktäristika:**
- Kompilering sker vid körning (runtime)
- Optimeringar baserade på faktisk användning
- Automatisk sophämtning (GC)
- Portabilitet mellan plattformar
**Testresultat:**
- **Snabbaste:** Java (134 ms för 10000 decimaler)
- **Mekanism:** JVM kompilerar bytecode till maskinkod vid körning
- **Prestandaintervall:** 116-10334 ms
**Exempel från testet:**
```
Java: 134 ms (JVM JIT optimization)
C#: 116 ms (.NET Core JIT)
Julia: 161 ms (LLVM JIT, scientific computing)
JavaScript: 10065 ms (V8 JIT, dynamic typing overhead)
TypeScript: 10334 ms (Compiles to JavaScript)
```
**Varierande prestanda inom kategorin:**
- **Java/C#:** Mogna JIT-kompilatorer, bra optimering
- **Julia:** Designat för numerisk prestanda
- **JavaScript/TypeScript:** Dynamisk typning, hög overhead
### Tolkade språk
**Definition:** Språk där källkoden läses och exekveras rad för rad av en tolk (interpreter).
**Karaktäristika:**
- Ingen kompilering i förväg
- Direkt exekvering av källkod
- Flexibel typning (oftast)
- Enklare felsökning
**Testresultat:**
- **Snabbaste:** Lua (1543 ms för 10000 decimaler)
- **Mekanism:** Tolk läser och exekverar kod rad för rad
- **Prestandaintervall:** 38-4456 ms
**Exempel från testet:**
```
Python: 300 ms (CPython interpreter)
Ruby: 128 ms (YARV interpreter)
Perl: 2285 ms (Perl interpreter)
Bash: 4456 ms (Shell interpreter, process spawning)
```
**Varierande prestanda inom kategorin:**
- **Python:** Optimerad tolk, C-extensioner för stora tal
- **Ruby:** YARV (Yet Another Ruby Virtual machine)
- **Perl:** Äldre tolk, mindre optimerad
- **Bash:** Startar nya processer för varje operation
### Funktionella språk (BEAM VM)
**Definition:** Språk som körs på Erlang Virtual Machine (BEAM), designade för samtidighet och feltolerans.
**Karaktäristika:**
- Kör på virtuell maskin (BEAM)
- Optimerade för många samtidiga processer
- Inbyggd sophämtning
- Feltolerant design
**Testresultat:**
- **Erlang:** 254 ms (10000 decimaler)
- **Elixir:** 353 ms (10000 decimaler)
**Prestandaanalys:**
- BEAM VM är optimerad för samtidighet, inte ren beräkning
- Overhead från process-schemaläggning
- Elixir har ytterligare overhead från Elixir-to-Erlang-kompilering
## Språkspecifik analys
### C
**Testresultat:**
- 100 decimaler: 6 ms
- 1000 decimaler: 4 ms
- 10000 decimaler: 24 ms
- **Binärstorlek:** 34K
**Teknisk analys:**
- Kompilerar direkt till ARM64-maskinkod
- Använder GMP-biblioteket för arbitrary precision arithmetic
- Ingen runtime overhead
- Manuell minneshantering möjliggör optimering
**Prestandafaktorer:**
- Native code execution
- Optimerad GMP-implementation
- Kompilatoroptimeringar (clang/gcc)
### Assembly
**Testresultat:**
- 100 decimaler: 7 ms
- 1000 decimaler: 4 ms
- 10000 decimaler: 27 ms
- **Binärstorlek:** 49K
**Teknisk analys:**
- Direkt ARM64-instruktioner
- Ingen abstraktion eller overhead
- Manuell registerallokering
- Optimerad för specifik processorarkitektur
**Prestandafaktorer:**
- Maximal kontroll över exekvering
- Ingen kompilator-overhead
- Processor-specifika optimeringar
### Rust
**Testresultat:**
- 100 decimaler: 7 ms
- 1000 decimaler: 5 ms
- 10000 decimaler: 53 ms
- **Binärstorlek:** 497K
**Teknisk analys:**
- Kompilerar till native code via LLVM
- Nollkostnadsabstraktioner (zero-cost abstractions)
- Minnessäkerhet utan GC-overhead
- Moderna kompilatoroptimeringar
**Prestandafaktorer:**
- LLVM-backend ger optimerad maskinkod
- Ingen sophämtning (ownership system)
- Inline-optimeringar
### Python
**Testresultat:**
- 100 decimaler: 34 ms
- 1000 decimaler: 38 ms
- 10000 decimaler: 300 ms
- **Binärstorlek:** 106B (wrapper script)
**Teknisk analys:**
- CPython-tolk exekverar bytecode
- Inbyggt stöd för arbitrary precision integers
- Dynamisk typning med runtime checks
- C-extensioner för prestandakritiska delar
**Prestandafaktorer:**
- Tolkad exekvering (10-100x långsammare än native)
- Optimerad arbitrary precision implementation
- Overhead från dynamisk typning
### JavaScript (Node.js)
**Testresultat:**
- 100 decimaler: 77 ms
- 1000 decimaler: 195 ms
- 10000 decimaler: 10065 ms
- **Binärstorlek:** 103B (wrapper script)
**Teknisk analys:**
- V8-motorn JIT-kompilerar JavaScript
- Dynamisk typning med hidden classes
- Ingen inbyggd arbitrary precision (använder BigInt)
- Sophämtning med mark-and-sweep
**Prestandafaktorer:**
- JIT-kompilering ger bra prestanda för små tal
- BigInt-implementation har overhead
- Dynamisk typning ger overhead vid stora beräkningar
### Bash
**Testresultat:**
- 100 decimaler: 14 ms
- 1000 decimaler: 26 ms
- 10000 decimaler: 4456 ms
**Teknisk analys:**
- Tolkad skalskript
- Startar nya processer för varje operation
- Ingen inbyggd arbitrary precision
- Använder externa verktyg (bc, awk)
**Prestandafaktorer:**
- Process-spawning overhead
- Ingen optimering för beräkning
- Designat för systemadministration, inte numerisk beräkning
### Brainfuck
**Testresultat:**
- 100 decimaler: 32 ms
- 1000 decimaler: 34 ms
- 10000 decimaler: 109 ms
**Teknisk analys:**
- Esoteriskt språk med endast 8 instruktioner
- Tolkad exekvering
- Ingen optimering
- Minimal instruction set
**Prestandafaktorer:**
- Enkel tolk med minimal overhead
- Effektiv för små beräkningar
- Skalar dåligt med komplexitet
## Slutsatser
### Prestandahierarki
**1. Kompilerade språk (Native):** 4-1088 ms
- Snabbast för numerisk beräkning
- Direkt maskinkodsexekvering
- Lägst overhead
**2. JIT-kompilerade språk:** 116-10334 ms
- Bra prestanda efter uppvärmning
- Plattformsoberoende
- Automatisk optimering
**3. Tolkade språk:** 38-4456 ms
- Långsammare exekvering
- Enklare utveckling
- Flexibel typning
### Prestandafaktorer
1. **Kompileringstyp:** Native > JIT > Tolkad
2. **Typsystem:** Statisk > Dynamisk
3. **Minnesantering:** Manuell > GC > Automatisk
4. **Bibliotek:** Optimerade > Standard > Ej optimerade
### Rekommendationer
**För maximal prestanda:**
- C, Assembly, Rust, Zig
**För balans mellan prestanda och utvecklingstid:**
- Go, Swift, Kotlin, Java
**För snabb utveckling:**
- Python, Ruby, JavaScript
**För vetenskaplig beräkning:**
- Julia, Python (med NumPy), R
## Metodologi
### Testprotokoll
1. **Bygge:** Varje språk kompileras/förbereds enligt `build.sh`
2. **Warmup:** Första körningen exkluderas (JIT-uppvärmning, caching)
3. **Mätning:** 3 körningar, genomsnitt beräknas
4. **Verifiering:** Resultatet jämförs med känt π-värde
### Reproducerbarhet
Alla tester kan reproduceras med:
```bash
./build.sh # Bygg alla språk
./test.sh [språk] # Testa korrekthet
./run_all.sh [decimaler] # Kör prestandatest
```
### Begränsningar
- **Hårdvaruberoende:** Resultaten gäller för Apple A18 Pro
- **Implementationsspecifika:** Prestanda beror på bibliotek och implementation
- **JIT-uppvärmning:** Första körningen kan vara långsammare
- **Minnesanvändning:** Ej mätt i denna studie
## Källkod
All källkod finns i respektive språkmapp:
- `src/` - Källkod
- `cmd/` - Byggscript
- `bin/` - Körbar fil (efter bygge)
## Licens
MIT License - Se LICENSE-fil för detaljer.
## Författare
Automatiskt genererad benchmark-studie.
Testdatum: 2026-04-23
Testmiljö: MacBook Neo, Apple A18 Pro, 8 GB RAM