11.3 Matematisk programmering

Nar Python moter matematikk

Na som du kan grunnleggende Python, er det pa tide a bruke det til noe virkelig spennende: a utforske matematikk! Med et program kan du gjore tusenvis av beregninger pa sekunder -- noe som ville tatt timer for hand.

Tenk deg at du vil finne losningen av en vanskelig likning, tegne grafen til en funksjon, simulere 10 000 terningkast eller finne alle primtall opp til 100. Alt dette er et lite Python-program unna. La oss dykke inn!

Lose likninger numerisk -- prove og feile med stil

Noen likninger er vanskelige a lose analytisk med formler, men vi kan bruke programmering til a finne losninger numerisk. Det betyr at vi prover oss frem systematisk.

En numerisk losning finner en tilnarmet verdi av svaret ved a teste mange verdier. Vi definerer $f(x)$ som venstre side minus hoyre side av likningen, og leter etter $x$-verdier der $f(x)$ er veldig nar null -- eller skifter fortegn.

La oss prove med likningen $x^3 - 2x - 5 = 0$. Vi soker mellom $x = 1$ og $x = 3$:

def f(x):
    return x**3 - 2*x - 5

x = 1.0
steg = 0.001

while x <= 3.0:
    if abs(f(x)) < 0.01:
        print(f"Mulig losning: x = {x:.3f}, f(x) = {f(x):.4f}")
    x += steg

Programmet finner at losningen er omtrent $x \approx 2{,}094$. Vi kan sjekke: $2{,}094^3 - 2 \cdot 2{,}094 - 5 \approx 0$. Stemmer!

Denne metoden fungerer fordi datamaskinen kan teste tusenvis av verdier pa et oyeblikk. For likningen $x^2 - 4x + 1 = 0$ finner vi losningene $x \approx 0{,}268$ og $x \approx 3{,}732$, som stemmer med abc-formelen: $x = 2 \pm \sqrt{3}$.

Plotte funksjoner -- se matematikken

En av de kraftigste tingene vi kan gjore med programmering er a tegne grafer. Vi kan lage en enkel tekstgraf rett i terminalen:

for x in range(-5, 6):
    y = x**2
    stolper = "*" * y
    print(f"x = {x:3d} | {stolper} ({y})")

Dette tegner $f(x) = x^2$ med stjerner. Du kan tydelig se parabelformen: grafen er symmetrisk om $x = 0$ og stiger raskt for store $|x|$.

For finere grafer kan du bruke biblioteket matplotlib:

import matplotlib.pyplot as plt

x_verdier = []
y_verdier = []

for i in range(-50, 51):
    x = i / 10
    x_verdier.append(x)
    y_verdier.append(x**2)

plt.plot(x_verdier, y_verdier)
plt.xlabel("x")
plt.ylabel("f(x)")
plt.title("f(x) = x^2")
plt.grid(True)
plt.show()

Med matplotlib kan du ogsa plotte flere funksjoner i samme graf, legge til rutenett og aksetitler, og eksportere grafen som bilde. Det er et uvurderlig verktoy for a visualisere matematikk!

Monte Carlo-simulering -- terningkast pa datamaskinen

En av de mest spennende bruksomradene for programmering i matematikk er a simulere tilfeldige forsok. I stedet for a beregne sannsynlighet med formler, kan vi la datamaskinen gjenta forsoket tusenvis av ganger og telle utfallene. Denne metoden kalles Monte Carlo-simulering, oppkalt etter det berommte kasinoet i Monte Carlo.

Prinsippet er enkelt:

$$P(\text{hendelse}) \approx \frac{\text{antall gunstige utfall}}{\text{totalt antall forsok}}$$

Jo flere forsok vi gjor, desto narmere kommer vi den eksakte sannsynligheten. Med 10 000 forsok far vi vanligvis et godt estimat.

I Python bruker vi random-modulen:

import random

terning = random.randint(1, 6)     # Tilfeldig heltall fra 1 til 6
mynt = random.choice(["kron", "mynt"])  # Tilfeldig valg

La oss simulere 10 000 kast med to terninger og finne sannsynligheten for a fa summen 7:

import random

antall_forsok = 10000
antall_syv = 0

for i in range(antall_forsok):
    terning1 = random.randint(1, 6)
    terning2 = random.randint(1, 6)
    if terning1 + terning2 == 7:
        antall_syv += 1

sannsynlighet = antall_syv / antall_forsok
print(f"Estimert sannsynlighet: {sannsynlighet:.4f}")

Typisk utskrift: ca. $0{,}167$. Den eksakte sannsynligheten er $\displaystyle \frac{6}{36} = \frac{1}{6} \approx 0{,}1667$ (det er 6 gunstige utfall: $(1,6), (2,5), (3,4), (4,3), (5,2), (6,1)$ av totalt $36$ mulige). Simuleringen stemmer!

Du kan ogsa bruke Monte Carlo til a estimere $\pi$! Generer tilfeldige punkter $(x, y)$ i et enhetskvadrat og tell hvor mange som havner innenfor kvartsirkelen $x^2 + y^2 \leq 1$. Da er $\displaystyle \pi \approx 4 \cdot \frac{\text{innenfor}}{\text{totalt}}$, fordi arealet av kvartsirkelen er $\displaystyle \frac{\pi}{4}$.

Primtallsjakt med Python

Et primtall er et tall storre enn 1 som bare er delelig med 1 og seg selv. De forste primtallene er $2, 3, 5, 7, 11, 13, 17, 19, 23, \ldots$ A finne store primtall er viktig i kryptografi -- det er primtall som gor at nettbank og passord er trygge!

Her er et smart triks: for a sjekke om $n$ er et primtall, trenger vi bare a teste divisorer opp til $\sqrt{n}$. Hvorfor? Fordi hvis $n = a \cdot b$ og begge er storre enn $\sqrt{n}$, ville $a \cdot b > n$.

import math

tall = int(input("Skriv inn et tall: "))

if tall < 2:
    print(f"{tall} er ikke et primtall")
else:
    er_primtall = True
    for i in range(2, int(math.sqrt(tall)) + 1):
        if tall % i == 0:
            er_primtall = False
            break
    if er_primtall:
        print(f"{tall} er et primtall")
    else:
        print(f"{tall} er ikke et primtall")

For $n = 97$: $\sqrt{97} \approx 9{,}8$, sa vi sjekker bare 2, 3, 4, 5, 6, 7, 8, 9. Ingen deler 97, sa 97 er et primtall! Det er 25 primtall mellom 2 og 100.

Statistikk med Python

Nar vi har store datamengder, er programmering uvurderlig for a beregne statistiske mal. De viktigste er:

- Gjennomsnitt: $\displaystyle \bar{x} = \frac{x_1 + x_2 + \ldots + x_n}{n}$
- Median: Den midterste verdien i sortert rekkefolgje (for oddetall $n$: element nr. $n//2$; for partall $n$: gjennomsnittet av de to midterste)
- Typetall: Verdien som forekommer oftest
- Variasjonsbredde: Storste verdi minus minste verdi

karakterer = [4, 5, 3, 6, 5, 4, 5, 3, 4, 6]
sortert = sorted(karakterer)
n = len(sortert)

gjennomsnitt = sum(karakterer) / n
if n % 2 == 1:
    median = sortert[n // 2]
else:
    median = (sortert[n // 2 - 1] + sortert[n // 2]) / 2

typetall = max(set(karakterer), key=karakterer.count)
variasjonsbredde = max(karakterer) - min(karakterer)

print(f"Gjennomsnitt: {gjennomsnitt:.1f}")
print(f"Median: {median}")
print(f"Typetall: {typetall}")
print(f"Variasjonsbredde: {variasjonsbredde}")

Resultatet: Gjennomsnitt $= 4{,}5$, median $= 4{,}5$, typetall $= 4$ (og 5, begge forekommer 3 ganger), variasjonsbredde $= 3$.

Oppsummering

I dette kapittelet har du sett hvor kraftig kombinasjonen av Python og matematikk er:

- Numerisk likningslosning: Vi kan teste mange $x$-verdier systematisk for a finne der $f(x) \approx 0$, selv for likninger som er vanskelige a lose med formler.
- Plotte funksjoner: Vi kan lage tekstgrafer med stjerner eller bruke matplotlib for profesjonelle grafer som visualiserer matematiske sammenhenger.
- Monte Carlo-simulering: Ved a bruke tilfeldige tall kan vi estimere sannsynligheter gjennom mange forsok. Jo flere forsok, desto bedre estimat. Formelen er $\displaystyle P \approx \frac{\text{gunstige}}{\text{totalt}}$.
- Primtall: Vi kan sjekke om tall er primtall ved a teste divisorer opp til $\sqrt{n}$. Det er 25 primtall mellom 2 og 100.
- Statistikk: Python gjor det enkelt a beregne gjennomsnitt, median, typetall og variasjonsbredde for store datamengder med funksjoner som sum(), len(), sorted(), min() og max().

Programmering er ikke bare et hjelpemiddel -- det er en mate a tenke pa. Nar du larer a programmere, larer du a bryte ned problemer i sma steg, tenke logisk og automatisere losninger. Det er ferdigheter du far bruk for langt utover matematikktimene!