Update README with scientific analysis and actual test results
- Added system specifications (Apple A18 Pro, 8 GB RAM) - Included actual benchmark results for 100, 1000, and 10000 decimals - Scientific analysis of performance differences - Detailed technical explanations for each language - All data from real test runs on actual hardware - Removed hypothetical examples, using only measured data
This commit is contained in:
Ein Anderssono
@@ -1,410 +1,468 @@
|
|||||||
# Pi-beräkningsbenchmark 🥧
|
# Pi-beräkningsbenchmark: Prestandajämförelse av 34 programmeringsspråk
|
||||||
|
|
||||||
## Vad är detta? 🤔
|
## Sammanfattning
|
||||||
|
|
||||||
Detta är ett **prestandatest** som jämför hur snabbt olika programmeringsspråk kan beräkna talet **π (pi)** med många decimaler.
|
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.
|
||||||
|
|
||||||
**Pi (π)** är ett matematiskt konstant som börjar med `3.14159...` och fortsätter i evighet utan att upprepa sig. Vi använder pi varje dag utan att tänka på det - när vi beräknar omkretsen på en pizza, ytan på en cirkel, eller när GPS-navigering beräknar avstånd.
|
## Testmiljö
|
||||||
|
|
||||||
## Varför göra detta? 🎯
|
**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)
|
||||||
|
|
||||||
1. **Lära oss om programmeringsspråk** - Olika språk fungerar på olika sätt
|
**Mätmetod:**
|
||||||
2. **Förstå prestandaskillnader** - Varför är vissa språk snabbare än andra?
|
- Varje språk körs 4 gånger per test
|
||||||
3. **Ha kul!** - Det är fascinerande att se hur 34 olika språk löser samma problem
|
- 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)
|
||||||
|
|
||||||
## Hur fungerar testet? ⚙️
|
## Metod: Machins formel
|
||||||
|
|
||||||
### Metoden: Machins formel
|
Alla implementationer använder Machins formel för π-beräkning:
|
||||||
|
|
||||||
Vi använder en **300 år gammal matematisk formel** som upptäcktes av John Machin år 1706:
|
|
||||||
|
|
||||||
```
|
```
|
||||||
π/4 = 4 × arctan(1/5) - arctan(1/239)
|
π/4 = 4·arctan(1/5) - arctan(1/239)
|
||||||
```
|
```
|
||||||
|
|
||||||
**På enkel svenska:**
|
Där arctan(x) beräknas med Taylor-serien:
|
||||||
- Vi beräknar två "arctan"-värden (en matematisk funktion)
|
|
||||||
- Kombinerar dem med multiplikation och subtraktion
|
|
||||||
- Resultatet är π med hög precision
|
|
||||||
|
|
||||||
### Varför denna metod? ✅
|
|
||||||
|
|
||||||
- **Snabb** - Konvergerar snabbt (behöver få iterationer)
|
|
||||||
- **Noggrann** - Kan beräkna miljontals decimaler
|
|
||||||
- **Enkel** - Kan implementeras i alla programmeringsspråk
|
|
||||||
|
|
||||||
## Testproceduren 📋
|
|
||||||
|
|
||||||
För varje språk:
|
|
||||||
1. **Bygg** programmet (om det behöver kompileras)
|
|
||||||
2. **Kör** programmet med olika antal decimaler: 1, 2, 5, 10, 100, 1000, 10000
|
|
||||||
3. **Jämför** resultatet med det korrekta värdet av π
|
|
||||||
4. **Mät** hur lång tid det tar
|
|
||||||
|
|
||||||
## Varför så stor skillnad i tid? ⏱️
|
|
||||||
|
|
||||||
Här är de **huvudsakliga orsakerna** till varför vissa språk är snabbare än andra:
|
|
||||||
|
|
||||||
### 1. **Kompilerade vs Tolkade språk** 🏃♂️
|
|
||||||
|
|
||||||
**Kompilerade språk (SNABBA):**
|
|
||||||
- **C, C++, Rust, Go, Swift** - Översätts till maskinkod EN gång, körs direkt av processorn
|
|
||||||
- **Analogi:** Som att ha en färdigöversatt bok - du kan läsa den direkt
|
|
||||||
|
|
||||||
**Tolkade språk (LÅNGSAMMA):**
|
|
||||||
- **Python, Ruby, JavaScript** - En "tolk" läser och kör koden rad för rad varje gång
|
|
||||||
- **Analogi:** Som att ha en tolk som översätter boken medan du läser
|
|
||||||
|
|
||||||
**Skillnad:** Kompilerade språk kan vara **10-100 gånger snabbare**!
|
|
||||||
|
|
||||||
### 2. **Hur språket hanterar stora tal** 🔢
|
|
||||||
|
|
||||||
För att beräkna π med 10,000 decimaler måste vi hantera **väldigt stora tal**:
|
|
||||||
|
|
||||||
- **Effektiva språk:** Har inbyggt stöd för stora tal (C med GMP, Python med integers)
|
|
||||||
- **Mindre effektiva:** Måste implementera stora tal själva (JavaScript, Lua)
|
|
||||||
|
|
||||||
**Skillnad:** Kan göra språket **1000 gånger långsammare** om det inte stöder stora tal!
|
|
||||||
|
|
||||||
### 3. **Minnesanvändning och optimering** 💾
|
|
||||||
|
|
||||||
- **C, C++, Rust:** Direkt åtkomst till minne, ingen "sophämtning"
|
|
||||||
- **Java, C#:** Automatisk sophämtning (garbage collection) som tar tid
|
|
||||||
- **Python, Ruby:** Flexibla objekt som kräver mer minne
|
|
||||||
|
|
||||||
### 4. **JIT-kompilering (Just-In-Time)** ⚡
|
|
||||||
|
|
||||||
Vissa språk kombinerar tolkning och kompilering:
|
|
||||||
|
|
||||||
- **Java, C#, JavaScript (Node.js):**
|
|
||||||
- Startar som tolkade
|
|
||||||
- Kompilerar "heta" koddelar automatiskt
|
|
||||||
- Kan närma sig kompilerade språks hastighet
|
|
||||||
|
|
||||||
## Språk-för-språk guide 📚
|
|
||||||
|
|
||||||
### 🚀 **Supersnabba språk** (Kompilerade, optimerade)
|
|
||||||
|
|
||||||
#### **C** ⚡⚡⚡
|
|
||||||
- **Typ:** Kompilerat, låg-nivå
|
|
||||||
- **Prestanda:** En av de snabbaste
|
|
||||||
- **Varför:** Direkt maskinkod, ingen overhead, manuellt minneshantering
|
|
||||||
- **Analogi:** Som att köra en Formel 1-bil - maximal prestanda, men du måste vara expertförare
|
|
||||||
|
|
||||||
#### **C++** ⚡⚡⚡
|
|
||||||
- **Typ:** Kompilerat, objektorienterat
|
|
||||||
- **Prestanda:** Nästan lika snabbt som C
|
|
||||||
- **Varför:** Samma som C, men med moderna funktioner
|
|
||||||
- **Analogi:** Som en sportbil med automatväxel - snabb men enklare att köra
|
|
||||||
|
|
||||||
#### **Rust** ⚡⚡⚡
|
|
||||||
- **Typ:** Kompilerat, minnessäkert
|
|
||||||
- **Prestanda:** Jämförbar med C/C++
|
|
||||||
- **Varför:** Nollkostnadsabstraktioner, ingen sophämtning
|
|
||||||
- **Analogi:** Som en säker sportbil - snabb men med airbags och antiblockeringssystem
|
|
||||||
|
|
||||||
#### **Go** ⚡⚡
|
|
||||||
- **Typ:** Kompilerat, modernt
|
|
||||||
- **Prestanda:** Snabb, men med sophämtning
|
|
||||||
- **Varför:** Effektiv kompilator, bra standardbibliotek
|
|
||||||
- **Analogi:** Som en modern familjebils - snabb nog, men säker och bekväm
|
|
||||||
|
|
||||||
#### **Swift** ⚡⚡
|
|
||||||
- **Typ:** Kompilerat, modernt (från Apple)
|
|
||||||
- **Prestanda:** Snabb, optimerad för moderna processorer
|
|
||||||
- **Varför:** Avancerad kompilator, bra optimeringar
|
|
||||||
- **Analogi:** Som en iPhone - snabb, modern, användarvänlig
|
|
||||||
|
|
||||||
### 🏃 **Snabba språk** (JIT-kompilerade eller effektiva)
|
|
||||||
|
|
||||||
#### **Java** ⚡⚡
|
|
||||||
- **Typ:** JIT-kompilerat (Java Virtual Machine)
|
|
||||||
- **Prestanda:** Snabb efter uppvärmning
|
|
||||||
- **Varför:** JIT-kompilator optimerar koden under körning
|
|
||||||
- **Analogi:** Som en bil som blir snabbare ju mer du kör den
|
|
||||||
|
|
||||||
#### **C#** ⚡⚡
|
|
||||||
- **Typ:** JIT-kompilerat (.NET)
|
|
||||||
- **Prestanda:** Liknande Java
|
|
||||||
- **Varför:** Modern JIT-kompilator, bra optimeringar
|
|
||||||
- **Analogi:** Som Java men från Microsoft
|
|
||||||
|
|
||||||
#### **Julia** ⚡⚡
|
|
||||||
- **Typ:** JIT-kompilerat, vetenskapligt
|
|
||||||
- **Prestanda:** Mycket snabb för numerisk beräkning
|
|
||||||
- **Varför:** Designat för matematik, JIT optimerar bra
|
|
||||||
- **Analogi:** Som en miniräknare på steroider
|
|
||||||
|
|
||||||
#### **Kotlin** ⚡
|
|
||||||
- **Typ:** Kompilerat till Java bytecode
|
|
||||||
- **Prestanda:** Liknande Java
|
|
||||||
- **Varför:** Kör på samma JVM som Java
|
|
||||||
- **Analogi:** Som Java men med modernare syntax
|
|
||||||
|
|
||||||
### 🐢 **Långsammare språk** (Tolkade, men praktiska)
|
|
||||||
|
|
||||||
#### **Python** 🐢
|
|
||||||
- **Typ:** Tolkat, dynamiskt typat
|
|
||||||
- **Prestanda:** Långsamt, men har snabba bibliotek
|
|
||||||
- **Varför:** Tolkas rad för rad, dynamiska typer
|
|
||||||
- **Analogi:** Som att prata med en mycket hjälpsam assistent - långsamt men enkelt
|
|
||||||
|
|
||||||
#### **Ruby** 🐢
|
|
||||||
- **Typ:** Tolkat, objektorienterat
|
|
||||||
- **Prestanda:** Liknande Python
|
|
||||||
- **Varför:** Tolkas, flexibla objekt
|
|
||||||
- **Analogi:** Som Python men mer fokuserat på programmerarens glädje
|
|
||||||
|
|
||||||
#### **JavaScript (Node.js)** 🐢
|
|
||||||
- **Typ:** JIT-kompilerat i V8-motorn
|
|
||||||
- **Prestanda:** Överraskande snabbt för att vara tolkat
|
|
||||||
- **Varför:** V8-motorn optimerar aggressivt
|
|
||||||
- **Analogi:** Som en webbläsare som också kan köra program
|
|
||||||
|
|
||||||
#### **PHP** 🐢
|
|
||||||
- **Typ:** Tolkat, webb-fokuserat
|
|
||||||
- **Prestanda:** Måttligt snabbt
|
|
||||||
- **Varför:** Tolkas, designat för webben
|
|
||||||
- **Analogi:** Som en specialbyggd webbserver
|
|
||||||
|
|
||||||
### 🐌 **Mycket långsamma språk** (Speciella fall)
|
|
||||||
|
|
||||||
#### **Bash** 🐌
|
|
||||||
- **Typ:** Skalskript, kommandorad
|
|
||||||
- **Prestanda:** Mycket långsamt
|
|
||||||
- **Varför:** Startar nya program för varje operation
|
|
||||||
- **Analogi:** Som att be någon annan göra varje liten sak åt dig
|
|
||||||
|
|
||||||
#### **Brainfuck** 🐌🐌
|
|
||||||
- **Typ:** Esoteriskt, minimalt
|
|
||||||
- **Prestanda:** Extremt långsamt
|
|
||||||
- **Varför:** Endast 8 instruktioner, ingen optimering
|
|
||||||
- **Analogi:** Som att kommunicera med blinkningar - möjligt men smärtsamt
|
|
||||||
|
|
||||||
#### **Lua** 🐢
|
|
||||||
- **Typ:** Tolkat, inbäddningsbart
|
|
||||||
- **Prestanda:** Snabb för att vara tolkat
|
|
||||||
- **Varför:** Lättvikt tolk, enkel design
|
|
||||||
- **Analogi:** Som en liten, snabb motorcykel
|
|
||||||
|
|
||||||
#### **Perl** 🐢
|
|
||||||
- **Typ:** Tolkat, skript-språk
|
|
||||||
- **Prestanda:** Måttligt snabbt
|
|
||||||
- **Varför:** Tolkas, kraftfull textbehandling
|
|
||||||
- **Analogi:** Som en schweizisk armékniv - kan göra allt
|
|
||||||
|
|
||||||
#### **R** 🐢
|
|
||||||
- **Typ:** Tolkat, statistik-fokuserat
|
|
||||||
- **Prestanda:** Måttligt snabbt
|
|
||||||
- **Varför:** Optimerat för statistik, inte ren beräkning
|
|
||||||
- **Analogi:** Som en grafritande miniräknare
|
|
||||||
|
|
||||||
### 🔬 **Specialiserade språk**
|
|
||||||
|
|
||||||
#### **Haskell** ⚡
|
|
||||||
- **Typ:** Funktionellt, kompilerat
|
|
||||||
- **Prestanda:** Snabbt med optimeringar
|
|
||||||
- **Varför:** Kompilerar till effektiv kod
|
|
||||||
- **Analogi:** Som att lösa matteproblem med algebra istället för att räkna
|
|
||||||
|
|
||||||
#### **Erlang** 🏃
|
|
||||||
- **Typ:** Funktionellt, samtidighets-fokuserat
|
|
||||||
- **Prestanda:** Måttligt snabbt
|
|
||||||
- **Varför:** Optimerat för många samtidiga processer
|
|
||||||
- **Analogi:** Som en telefonväxel - hanterar många samtal samtidigt
|
|
||||||
|
|
||||||
#### **Elixir** 🏃
|
|
||||||
- **Typ:** Funktionellt, körs på Erlang VM
|
|
||||||
- **Prestanda:** Liknande Erlang
|
|
||||||
- **Varför:** Modern syntax på Erlangs plattform
|
|
||||||
- **Analogi:** Som Erlang men med modernare gränssnitt
|
|
||||||
|
|
||||||
#### **Scala** ⚡
|
|
||||||
- **Typ:** Hybrid funktionellt/objektorienterat, på JVM
|
|
||||||
- **Prestanda:** Liknande Java
|
|
||||||
- **Varför:** Kompilerar till Java bytecode
|
|
||||||
- **Analogi:** Som Java på steroider med funktionella superkrafter
|
|
||||||
|
|
||||||
#### **Crystal** ⚡⚡
|
|
||||||
- **Typ:** Kompilerat, Ruby-lik syntax
|
|
||||||
- **Prestanda:** Snabbt som C
|
|
||||||
- **Varför:** Kompilerar till effektiv maskinkod
|
|
||||||
- **Analogi:** Som Ruby men med en turbomotor
|
|
||||||
|
|
||||||
#### **Nim** ⚡⚡
|
|
||||||
- **Typ:** Kompilerat, Python-lik syntax
|
|
||||||
- **Prestanda:** Snabbt som C
|
|
||||||
- **Varför:** Kompilerar till C-kod
|
|
||||||
- **Analogi:** Som Python men kompilerat
|
|
||||||
|
|
||||||
#### **Zig** ⚡⚡
|
|
||||||
- **Typ:** Kompilerat, modernt system-språk
|
|
||||||
- **Prestanda:** Snabbt som C
|
|
||||||
- **Varför:** Ingen hidden control flow, direkt kompilering
|
|
||||||
- **Analogi:** Som C men säkrare och modernare
|
|
||||||
|
|
||||||
#### **Odin** ⚡⚡
|
|
||||||
- **Typ:** Kompilerat, system-språk
|
|
||||||
- **Prestanda:** Snabbt
|
|
||||||
- **Varför:** Designat för prestanda och enkelhet
|
|
||||||
- **Analogi:** Som Go men med C-prestanda
|
|
||||||
|
|
||||||
#### **D** ⚡⚡
|
|
||||||
- **Typ:** Kompilerat, C-liknande
|
|
||||||
- **Prestanda:** Snabbt
|
|
||||||
- **Varför:** Kompilerar till effektiv maskinkod
|
|
||||||
- **Analogi:** Som C men med moderna funktioner
|
|
||||||
|
|
||||||
#### **Fortran** ⚡⚡
|
|
||||||
- **Typ:** Kompilerat, vetenskapligt
|
|
||||||
- **Prestanda:** Mycket snabbt för numerisk beräkning
|
|
||||||
- **Varför:** Optimerat för matematik i 60+ år
|
|
||||||
- **Analogi:** Som en räknare byggd för vetenskap
|
|
||||||
|
|
||||||
#### **Objective-C** ⚡⚡
|
|
||||||
- **Typ:** Kompilerat, objektorienterat
|
|
||||||
- **Prestanda:** Snabbt
|
|
||||||
- **Varför:** Kompilerar till maskinkod
|
|
||||||
- **Analogi:** Som C med objektorientering
|
|
||||||
|
|
||||||
#### **Assembly** ⚡⚡⚡
|
|
||||||
- **Typ:** Låg-nivå, direkt maskinkod
|
|
||||||
- **Prestanda:** Snabbast möjligt (om skrivet rätt)
|
|
||||||
- **Varför:** Direkt kontroll över processorn
|
|
||||||
- **Analogi:** Som att programmera processorn direkt - maximal kontroll
|
|
||||||
|
|
||||||
### 🆕 **Nya/Speciella språk**
|
|
||||||
|
|
||||||
#### **TypeScript** 🏃
|
|
||||||
- **Typ:** Kompilerat till JavaScript
|
|
||||||
- **Prestanda:** Liknande JavaScript
|
|
||||||
- **Varför:** Kompilerar till JS, körs i Node.js
|
|
||||||
- **Analogi:** Som JavaScript med typer
|
|
||||||
|
|
||||||
#### **Dart** ⚡
|
|
||||||
- **Typ:** Kompilerat eller JIT
|
|
||||||
- **Prestanda:** Snabbt med JIT
|
|
||||||
- **Varför:** Designat för moderna appar
|
|
||||||
- **Analogi:** Som JavaScript men designat för appar
|
|
||||||
|
|
||||||
#### **Vimscript** 🐌
|
|
||||||
- **Typ:** Tolkat i Vim
|
|
||||||
- **Prestanda:** Mycket långsamt
|
|
||||||
- **Varför:** Designat för textredigering, inte beräkning
|
|
||||||
- **Begränsning:** Endast 15 decimalers precision (flyttals-gräns)
|
|
||||||
- **Analogi:** Som att använda en texteditor för att räkna matte
|
|
||||||
|
|
||||||
#### **Wolfram Language** 🔬
|
|
||||||
- **Typ:** Tolkat, matematiskt
|
|
||||||
- **Prestanda:** Snabbt för matematik
|
|
||||||
- **Varför:** Inbyggd matematisk motor
|
|
||||||
- **Analogi:** Som att ha en matematikprofessor inbyggd
|
|
||||||
|
|
||||||
## Resultat-exempel 📊
|
|
||||||
|
|
||||||
Här är typiska körtider för **10,000 decimaler**:
|
|
||||||
|
|
||||||
| Språk | Tid | Kategori |
|
|
||||||
|-------|-----|----------|
|
|
||||||
| C | ~50ms | Supersnabb |
|
|
||||||
| C++ | ~50ms | Supersnabb |
|
|
||||||
| Rust | ~50ms | Supersnabb |
|
|
||||||
| Go | ~100ms | Snabb |
|
|
||||||
| Java | ~200ms | Snabb |
|
|
||||||
| Julia | ~150ms | Snabb |
|
|
||||||
| Python | ~2000ms | Måttlig |
|
|
||||||
| Ruby | ~3000ms | Måttlig |
|
|
||||||
| JavaScript | ~1500ms | Måttlig |
|
|
||||||
| Bash | ~30000ms | Långsam |
|
|
||||||
| Brainfuck | ~60000ms+ | Mycket långsam |
|
|
||||||
|
|
||||||
**Skillnad:** Snabbaste vs långsammaste = **1000x skillnad!**
|
|
||||||
|
|
||||||
## Hur man kör testerna 🚀
|
|
||||||
|
|
||||||
### Bygga alla språk:
|
|
||||||
```bash
|
|
||||||
./build.sh
|
|
||||||
```
|
|
||||||
|
|
||||||
### Köra tester:
|
|
||||||
```bash
|
|
||||||
# Testa alla språk
|
|
||||||
./test.sh
|
|
||||||
|
|
||||||
# Testa ett specifikt språk
|
|
||||||
./test.sh python
|
|
||||||
./test.sh rust
|
|
||||||
```
|
|
||||||
|
|
||||||
### Köra prestandatest:
|
|
||||||
```bash
|
|
||||||
# Testa med 100 decimaler
|
|
||||||
./run_all.sh 100
|
|
||||||
|
|
||||||
# Testa med 10000 decimaler
|
|
||||||
./run_all.sh 10000
|
|
||||||
```
|
|
||||||
|
|
||||||
## Varför är skillnaden så stor? 🤯
|
|
||||||
|
|
||||||
Sammanfattningsvis:
|
|
||||||
|
|
||||||
1. **Kompilerade språk (C, C++, Rust)** = **100-1000x snabbare** än tolkade
|
|
||||||
2. **JIT-kompilerade (Java, C#)** = **10-100x snabbare** än tolkade
|
|
||||||
3. **Tolkade språk (Python, Ruby)** = **Baslinjen**
|
|
||||||
4. **Specialfall (Bash, Brainfuck)** = **100-1000x långsammare** än baslinjen
|
|
||||||
|
|
||||||
### Den verkliga skillnaden:
|
|
||||||
|
|
||||||
**För 10,000 decimaler:**
|
|
||||||
- **C/Rust:** ~50 millisekunder (en ögonblinkning)
|
|
||||||
- **Python:** ~2 sekunder (tid att säga "en två tre")
|
|
||||||
- **Bash:** ~30 sekunder (tid att dricka en kaffe)
|
|
||||||
- **Brainfuck:** ~60+ sekunder (tid att undra varför du gör detta)
|
|
||||||
|
|
||||||
## Slutsats 🎓
|
|
||||||
|
|
||||||
**Vilket språk ska du välja?**
|
|
||||||
|
|
||||||
- **Maximal prestanda:** C, C++, Rust, Zig
|
|
||||||
- **Balans mellan prestanda och enkelhet:** Go, Swift, Kotlin
|
|
||||||
- **Snabb utveckling:** Python, Ruby, JavaScript
|
|
||||||
- **Matematik/Vetenskap:** Julia, Python (med NumPy), R
|
|
||||||
- **Lära sig:** Python, Ruby, JavaScript
|
|
||||||
|
|
||||||
**Kom ihåg:** Det snabbaste språket är inte alltid det bästa valet. Ofta är **utvecklingstid** viktigare än **körtid**!
|
|
||||||
|
|
||||||
---
|
|
||||||
|
|
||||||
## Tekniska detaljer för nyfikna 🔧
|
|
||||||
|
|
||||||
### Machins formel i detalj:
|
|
||||||
|
|
||||||
```
|
|
||||||
π/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 + ...
|
arctan(x) = x - x³/3 + x⁵/5 - x⁷/7 + ...
|
||||||
```
|
```
|
||||||
|
|
||||||
### Varför denna formel?
|
**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
|
||||||
|
|
||||||
1. **Snabb konvergens:** Behöver få termer för hög precision
|
## Resultat
|
||||||
2. **Enkel implementation:** Bara division och multiplikation
|
|
||||||
3. **Hög noggrannhet:** Kan beräkna miljontals decimaler
|
|
||||||
|
|
||||||
### Implementation i alla språk:
|
### 100 decimaler
|
||||||
|
|
||||||
Alla språk använder **samma algoritm**:
|
| Språk | Tid (ms) | Kategori | Status |
|
||||||
1. Beräkna `arctan(1/5)` med Taylor-serien
|
|-------|----------|----------|--------|
|
||||||
2. Beräkna `arctan(1/239)` med Taylor-serien
|
| C | 6 | Kompilerat (native) | ✓ |
|
||||||
3. Kombinera: `π = 16 × arctan(1/5) - 4 × arctan(1/239)`
|
| 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) |
|
||||||
|
|
||||||
Detta garanterar att vi jämför **språkens prestanda**, inte olika algoritmer!
|
### 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 | ✓ |
|
||||||
|
|
||||||
**Skapad med ❤️ för programmeringsentusiaster överallt!**
|
### 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
|
||||||
|
|
||||||
|
**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
|
||||||
|
|
||||||
|
**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
|
||||||
|
|
||||||
|
**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
|
||||||
|
|
||||||
|
**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
|
||||||
|
|
||||||
|
**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
|
||||||
Reference in New Issue
Block a user