# Pi-beräkningsbenchmark 🥧

## Vad är detta? 🤔

Detta är ett **prestandatest** som jämför hur snabbt olika programmeringsspråk kan beräkna talet **π (pi)** med många 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.

## Varför göra detta? 🎯

1. **Lära oss om programmeringsspråk** - Olika språk fungerar på olika sätt
2. **Förstå prestandaskillnader** - Varför är vissa språk snabbare än andra?
3. **Ha kul!** - Det är fascinerande att se hur 34 olika språk löser samma problem

## Hur fungerar testet? ⚙️

### Metoden: Machins formel

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)
```

**På enkel svenska:**
- 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 + ...
```

### Varför denna formel?

1. **Snabb konvergens:** Behöver få termer för hög precision
2. **Enkel implementation:** Bara division och multiplikation
3. **Hög noggrannhet:** Kan beräkna miljontals decimaler

### Implementation i alla språk:

Alla språk använder **samma algoritm**:
1. Beräkna `arctan(1/5)` med Taylor-serien
2. Beräkna `arctan(1/239)` med Taylor-serien
3. Kombinera: `π = 16 × arctan(1/5) - 4 × arctan(1/239)`

Detta garanterar att vi jämför **språkens prestanda**, inte olika algoritmer!

---

**Skapad med ❤️ för programmeringsentusiaster överallt!**