9.3 Matematikk med programmering

Regnekraft uten grenser

Tenk deg å gjenta samme renteutregning 50 ganger, eller kaste en terning 10 000 ganger og notere hvert kast. Du hadde gitt opp -- men datamaskinen gjør det på et brøkdels sekund, uten å bli sliten og uten å slurve. Det er nettopp dette som gjør programmering til et kraftig verktøy i matematikken: Alt som krever mange beregninger eller gjentakelser, er datamaskinens hjemmebane.

I de to forrige kapitlene lærte du å tenke i algoritmer og å skrive Python. Nå skal ferdighetene brukes på ekte matematiske problemer, og planen er ambisiøs: Vi skal beregne hvordan sparepenger vokser med rentesrente, år for år. Vi skal simulere tilfeldige forsøk -- tusenvis av terningkast -- og sammenligne med teorien. Vi skal løse likninger med rå regnekraft og med en smart metode som halverer søkeområdet igjen og igjen. Og vi skal la programmet regne ut statistiske mål fra hele datasett på et blunk.

Underveis møter du igjen gamle kjente fra tidligere kapitler -- vekstfaktoren, sannsynligheten og nullpunktene -- men nå med en datamaskin som gjør tungarbeidet. La oss sette i gang.

Renter år for år

Når du setter penger i banken, får du renter -- og med rentesrente får du renter av rentene. Formelen kjenner du fra eksponentialfunksjonene: $\displaystyle K_n = K_0 \cdot \left(1 + \frac{r}{100}\right)^n$, der $K_0$ er startbeløpet, $r$ rentesatsen og $n$ antall år. Men med et program kan vi se veksten år for år i stedet for å hoppe rett til svaret.

Ideen er enkel: Gang beløpet med vekstfaktoren én gang per runde i en løkke.

belop = 5000
rente = 4
for ar in range(1, 21):
    belop = belop * (1 + rente/100)
    print("År", ar, ":", round(belop, 2), "kr")

Det fine med program framfor formel er fleksibiliteten. Vil du vite når beløpet passerer 6000 kroner, lar du løkken sjekke underveis -- med 5000 kroner og 4 prosent skjer det i løpet av år 5. Og månedlig sparing med rente? Bare legg innskuddet til i hver runde: saldo = saldo * 1.003 + 500.

Datamaskinen kaster terning

Hva er sannsynligheten for en sekser? $\displaystyle \frac{1}{6} \approx 16{,}7\%$, sier teorien. Men stemmer det? Med programmering kan vi teste -- ikke med seks kast, men med ti tusen. Et dataeksperiment som etterligner en virkelig situasjon, kalles en simulering, og nøkkelen i Python er random.randint(1, 6), som gir et tilfeldig heltall fra 1 til 6 -- et digitalt terningkast.

import random
antall_seksere = 0
for i in range(10000):
    if random.randint(1, 6) == 6:
        antall_seksere = antall_seksere + 1
print(antall_seksere / 10000)

Simuleringer skinner når teorien blir vanskeligere. Hva er sjansen for at to terninger gir sum 7? Programmet kaster to terninger per runde og teller. Teorien sier $\displaystyle \frac{6}{36} = \frac{1}{6}$, siden 6 av 36 mulige utfall gir sum 7 -- og simuleringen lander pent rundt 0,167. Når regnestykket blir for komplisert, kan du alltid la datamaskinen prøve seg fram.

Likninger løst med rå kraft -- og med list

Noen likninger er stri tobakk for hånd, men trivielle for en datamaskin. Den enkleste metoden kalles brute force (rå kraft): prøv mange verdier og se hva som passer. Skal du løse $3x + 7 = 22$, kan du la en løkke teste alle heltall fra $-100$ til 100 og skrive ut den som stemmer -- programmet finner $x = 5$ på et øyeblikk. For desimalsvar lar du programmet lete etter verdien som gjør avviket minst, med små steg på for eksempel 0,01.

Men det finnes en smartere idé: halveringsmetoden (biseksjonsmetoden) for å finne nullpunkter. Prinsippet: Hvis $f(a)$ og $f(b)$ har ulikt fortegn, må grafen krysse null et sted mellom $a$ og $b$. Sjekk midtpunktet $\displaystyle m = \frac{a+b}{2}$: Har $f(m)$ samme fortegn som $f(a)$, ligger nullpunktet mellom $m$ og $b$; ellers mellom $a$ og $m$. Halver, halver, halver -- og intervallet krymper lynraskt rundt svaret.

La oss finne $\sqrt{7}$, altså nullpunktet til $f(x) = x^2 - 7$. Vi starter med $a = 2$ (der $f(2) = -3$, negativ) og $b = 3$ (der $f(3) = 2$, positiv). Etter 50 halveringer i en løkke melder programmet $x \approx 2{,}6457513111$ -- kvadratroten av 7 med ti desimaler. Samme metode knekker $x^3 - 2x - 5 = 0$: Fortegnsskifte mellom $f(1) = -6$ og $f(3) = 16$, og etter 40 halveringer står svaret der: $x \approx 2{,}0946$. Ikke elegant algebra -- bare systematisk, ustoppelig halvering.

Statistikk og grafer på autopilot

Husker du gjennomsnitt, median og variasjonsbredde fra statistikken? Med ti tall går det greit for hånd -- med tusen blir det program. Og det fine er at de statistiske målene er som skapt for funksjoner: Gjennomsnittet er sum(data) / len(data) -- summen delt på antallet. Medianen krever litt mer: Sortér listen med sorted(data); er antallet odde, er medianen den midterste verdien, ellers snittet av de to midterste. Variasjonsbredden er kort og godt max(data) - min(data).

Med prøveresultatene [78, 85, 62, 91, 74, 88, 67, 95, 73, 80] svarer programmet umiddelbart: gjennomsnitt 79,3, median 79,0 og variasjonsbredde 33. Samme funksjoner virker på hundre tusen tall uten å nøle.

Python tegner også grafer, med tilleggsbiblioteket matplotlib. Prinsippet er enkelt: Regn ut $f(x)$ for mange tette x-verdier, og la plt.plot(x_verdier, y_verdier) tegne punktene som en sammenhengende kurve -- jo tettere punkter, desto jevnere kurve. Slik kan du tegne $f(x) = x^2 - 4$ fra $-5$ til $5$ med steg på 0,1 og se parabelen vokse fram.

Og dette er bare begynnelsen: Med verktøyene fra disse tre kapitlene kan du utforske tallmønstre, bygge dine egne kalkulatorer -- som et program som beregner hele strømregningen med forbruk, nettleie og 25 prosent MVA -- og visualisere data. Det viktigste er å eksperimentere: Programmering lærer du med fingrene på tastaturet.

Fortellingen om datamaskinen som regnehjelp

Tre kapitler om algoritmisk tenkning ender her, med datamaskinen som fullverdig mattepartner. Rentesrente beregnet vi med en løkke som ganger med vekstfaktoren år for år -- og så 5000 kroner mer enn dobles til 10 956 på 20 år med 4 prosent rente. Simuleringer med random.randint kastet terning ti tusen ganger, og den relative frekvensen la seg tett inntil teoriens sannsynlighet -- akkurat som de store talls lov lover.

Likninger angrep vi på to måter: brute force, som prøver mange verdier systematisk, og den elegante halveringsmetoden, som finner nullpunkter ved å halvere intervallet der fortegnet skifter -- og ga oss $\sqrt{7}$ med ti desimaler. Og statistikken ble automatisk: gjennomsnitt, median og variasjonsbredde som korte funksjoner, pluss grafer tegnet med matplotlib.

Den røde tråden er datamaskinens natur: Den gjentar uten å bli sliten. Din jobb er å formulere algoritmen -- maskinens jobb er å kjøre den ti tusen ganger. Med den arbeidsdelingen kan du utforske matematikk som ellers ville vært utenfor rekkevidde.