11.3 Matematisk modellering med kode

Nar matematikken blir levende

I matematikk lager vi ofte modeller -- forenklede beskrivelser av virkeligheten. En modell kan fortelle oss hvordan en befolkning vokser, hvordan penger oker pa en sparekonto, eller hvordan en sykdom sprer seg.

Med papir og blyant kan du kanskje beregne 5--10 tidspunkter for du gir opp. Men med Python kan du beregne tusenvis av tidspunkter pa et oyeblikk, lage tabeller, og finne noyaktig nar noe viktig skjer. La oss utforske to grunnleggende vekstmodeller og se hvordan programmering gjor dem levende.

Lineær vekst -- jevnt og trutt

Den enkleste modellen er lineær vekst: noe oker med et fast belop for hvert tidssteg. Matematisk skriver vi dette som:

$$y = ax + b$$

der $a$ er den faste endringen per steg (stigningstallet) og $b$ er startverdien.

Tenk pa en sparebosse der du putter inn 500 kr hver maned. Har du 2000 kr fra for, sa har du etter $x$ maneder:

$$y = 500x + 2000$$

Med Python kan vi lage en hel tabell:

saldo = 2000
innskudd = 500

print(f"Start: {saldo} kr")
for maned in range(1, 13):
    saldo = saldo + innskudd
    print(f"Maned {maned:>2}: {saldo} kr")

Pa 12 maneder har du $2000 + 12 \cdot 500 = 8000$ kr. Enkelt og forutsigbart -- det er lineær vekst i et notteskall.

Men nar nar du 10 000 kr? Med en while-lokke kan Python finne svaret:

saldo = 2000
maned = 0
while saldo < 10000:
    saldo += 500
    maned += 1
print(f"Du nar 10 000 etter {maned} maneder")

Svaret er 16 maneder. Vi kan verifisere: $500 \cdot 16 + 2000 = 10\,000$. Stemmer!

Eksponentiell vekst -- nar det akselererer

Tenk pa penger i banken med rente. Hvis du har 5000 kr og far 3 % arlig rente, sa far du forste ar $5000 \cdot 0{,}03 = 150$ kr i rente. Men andre ar far du rente pa 5150 kr, altså $5150 \cdot 0{,}03 = 154{,}50$ kr. Renten oker hvert ar fordi du far rente pa renten!

Dette er eksponentiell vekst: en storrelse oker med en fast prosentandel for hvert tidssteg. Modellen er:

$$y = a \cdot b^x$$

der $a$ er startverdien og $b$ er vekstfaktoren. For 3 % vekst er $\displaystyle b = 1 + \frac{3}{100} = 1{,}03$.

I Python:

saldo = 5000
vekstfaktor = 1.03

for aar in range(1, 21):
    saldo = saldo * vekstfaktor
    print(f"Ar {aar:>2}: {saldo:.2f} kr")

Etter 20 ar: $5000 \cdot 1{,}03^{20} \approx 9030{,}56$ kr. Pengene har nesten doblet seg!

En tommelfingerregel sier at doblingstiden er omtrent $\displaystyle \frac{72}{p}$ ar, der $p$ er rentesatsen i prosent. Med 3 % rente: $\displaystyle \frac{72}{3} = 24$ ar.

Forskjellen mellom lineær og eksponentiell vekst er dramatisk over tid. Lineær vekst oker jevnt. Eksponentiell vekst starter sakte, men akselererer og tar til slutt fullstendig av.

Lose likninger med systematisk proving

Noen likninger er vanskelige a lose for hand, men med Python kan vi finne tilnærmede losninger ved a prove mange verdier. Metoden kalles numerisk losning.

La oss finne $\sqrt[3]{100}$ -- altså det tallet $x$ der $x^3 = 100$:

beste_x = 0
minste_avvik = 1000

for i in range(10001):
    x = i / 1000    # Verdier fra 0.000 til 10.000
    avvik = abs(x**3 - 100)
    if avvik < minste_avvik:
        minste_avvik = avvik
        beste_x = x

print(f"x = {beste_x:.3f}")
print(f"Sjekk: {beste_x}^3 = {beste_x**3:.3f}")

Python prover 10 001 verdier og finner den som gir $x^3$ nærmest $100$. Svaret er $x \approx 4{,}642$. Jo flere verdier vi prover, desto mer noyaktig blir svaret.

Denne metoden er overraskende kraftig. Vi kan ogsa bruke den til a finne nar ting skjer, som nar en spareplan nar et mal eller nar en eksponentiell vekst krysser en lineær vekst.

Utforske matematiske monstre

En av de goyeste tingene med programmering er a utforske matematiske monstre. La oss se pa Fibonacci-tallene: $1, 1, 2, 3, 5, 8, 13, 21, \ldots$ -- der hvert tall er summen av de to forrige.

a, b = 1, 1
for i in range(20):
    print(f"F({i+1}) = {a}")
    a, b = b, a + b

Noe magisk skjer nar vi beregner forholdet mellom pafolgende Fibonacci-tall:

$$\frac{F_{n+1}}{F_n} \to \varphi = \frac{1 + \sqrt{5}}{2} \approx 1{,}6180$$

Dette tallet kalles det gylne snitt og dukker opp overalt -- i naturen, i kunst og i arkitektur.

Programmering lar oss oppdage slike monstre fordi vi raskt kan beregne hundrevis av verdier og se hva som skjer. Det er matematisk utforskning pa sitt beste!

Oppsummering

Vi har sett hvordan Python gjor matematiske modeller levende:

- Lineær vekst ($y = ax + b$): fast okning per steg. Grafen er en rett linje.
- Eksponentiell vekst ($y = a \cdot b^x$): prosentvis okning per steg. Vekstfaktoren er $\displaystyle b = 1 + \frac{p}{100}$.
- Doblingstid kan estimeres med $\displaystyle \frac{72}{p}$ ar.
- Numerisk losning: prove mange verdier med en lokke for a finne tilnærmede svar.
- Fibonacci-tallene viser hvordan programmering avslorer skjulte monstre (det gylne snitt).

Med programmering handler ikke matematikk bare om a finne riktig svar -- det handler om a utforske, eksperimentere og oppdage. Datamaskinen er din laboratoriepartner i denne utforskningen.