👀 Voorbeeld - \(\pi\) via kansrekenen, volledig

In de bonusoefening op pagina 3.3.3 simuleerde je het proces van het kiezen van willekeurige punten volgens een uniforme verdeling. Voor de volledigheid staat hier de hele code:

from random import randint

coordinaten = []
for i in range(1000):
    coordinaten.append((randint(-100,100)/100, randint(-100,100)/100))

def in_cirkel(x, y):
    return x**2 + y**2 <= 1

def schat_pi(punten):
    aantal_in_cirkel = 0

    for (x, y) in punten:
        if in_cirkel(x, y):
            aantal_in_cirkel += 1

    kans = aantal_in_cirkel / len(punten)

    return 4 * kans

schatting = schat_pi(coordinaten)
print(schatting)

Probeer deze code eens uit in de sandbox (als je dat nog niet gedaan hebt), voor een verschillend aantal coördinaten. Probeer het een paar keer met een heel klein aantal coördinaten en een paar keer met een groot aantal coördinaten.

Je zal sterk uiteenlopende resulaten krijgen die niet altijd even dicht bij de gekende waarde van \(\pi\) liggen. Hoe meer coördinaten je gebruikt, hoe dichter bij \(\pi\) je resultaat zal liggen. Dit is inherent aan het gebruik van random simulatie waarbij onze punten dus willekeurig worden gegenereerd.

Zoals je merkt, zijn simulaties die (volledig) steunen op willekeurige getallen, pas bruikbaar als je enorm veel herhalingen doet. Het is bovendien ook onmogelijk om te weten hoeveel herhalingen je moet doen om een nauwkeurig resulaat te behalen.

Vooraleer we verder gaan met geavanceerdere technieken, gaan we eens kijken wat er gebeurt als we de punten in het vierkant niet willekeurig kiezen.

👀 Voorbeeld - π schatten zonder willekeur

In het vorige voorbeeld maakten we een lijst met willekeurige punten en gebruikten we daarna:

schatting = schat_pi(coordinaten)

om π te benaderen.

Die aanpak werkte, maar had een nadeel:

• soms zat de schatting dicht bij π
• soms zat ze er behoorlijk naast
• hoe meer punten, hoe betrouwbaarder het resultaat

We kunnen ook een andere aanpak gebruiken.

In plaats van punten willekeurig te kiezen, plaatsen we de punten netjes op een rooster.

Bijvoorbeeld bij n = 4:

(-1,1)     •   •   •   •

           •   •   •   •

           •   •   •   •

(-1,-1)    •   •   •   •      (1,-1)

De punten liggen gelijkmatig verdeeld over het vierkant.

Als n = 4, dan gebruiken we dus:

4 × 4 = 16 punten

Als n = 100, dan gebruiken we:

100 × 100 = 10000 punten

Daarna kunnen we opnieuw onze bestaande functie gebruiken:

schat_pi(coordinaten)

💻 Programmeeroefening - π schatten met een rooster

Schrijf de functie schat_pi_rooster(n).

De functie moet:

• een lege lijst coordinaten maken
• alle roosterpunten toevoegen aan die lijst
• daarna schat_pi(coordinaten) uitvoeren
• het resultaat retourneren

Werk stap voor stap:

Stap 1

Maak een lege lijst:

coordinaten = []

Stap 2

Gebruik twee geneste for-lussen om alle roosterpunten te doorlopen.

Er zijn:

• n rijen
• n kolommen

Stap 3

Zet elke rij en kolom om naar een coördinaat tussen -1 en 1.

Gebruik hiervoor:

x = -1 + 2 * rij / (n - 1)
y = -1 + 2 * kolom / (n - 1)

Controle:

• rij 0 → -1
• laatste rij → 1

Stap 4

Voeg elk punt toe aan de lijst:

coordinaten.append((x, y))

Stap 5

Gebruik je bestaande functie:

return schat_pi(coordinaten)

Je mag geen gebruik maken van random.