9.3 Matematikk med programmering

Programmering som verktøy i matematikk

I de to forrige kapitlene lærte vi hva algoritmer er, og hvordan vi skriver programmer i Python. Nå skal vi bruke disse ferdighetene til å løse ekte matematiske problemer.

Datamaskinen er fantastisk til oppgaver som krever mange beregninger eller gjentakelser. Der vi mennesker fort blir slitne av å gjenta den samme utregningen 50 ganger, kan en datamaskin gjøre det på et brøkdels sekund.

I dette kapittelet skal vi se på:
- Beregne renter og sparing over tid
- Simulere tilfeldige forsøk (terningkast)
- Finne nullpunkter til funksjoner
- Beregne statistiske mål med programmer

Beregne renter med løkker

Når du setter penger i banken, får du renter. Med rentesrente tjener du renter på rentene. Vi kan bruke vekstfaktor og en løkke for å beregne hvordan en sparesum vokser over tid.

Formelen for rentesrente er:

$$K_n = K_0 \cdot \left(1 + \frac{r}{100}\right)^n$$

der $K_0$ er startbeløpet, $r$ er rentesatsen i prosent, og $n$ er antall år.

Men med et program kan vi beregne dette steg for steg, og se hva som skjer hvert år:

startbelop = 10000
rente = 3.5        # 3,5 % rente per år
antall_ar = 10

belop = startbelop
for ar in range(1, antall_ar + 1):
    rente_dette_ar = belop * rente / 100
    belop = belop + rente_dette_ar
    print("Etter", ar, "år:", round(belop, 2), "kr")

print("Totalvekst:", round(belop - startbelop, 2), "kr")

Tegne grafer med programmering

Et av de kraftigste verktøyene i Python er muligheten til å tegne grafer. Vi bruker et tilleggsbibliotek som heter matplotlib.

Her er et program som tegner grafen til funksjonen $f(x) = x^2 - 4$:

import matplotlib.pyplot as plt

# Lag en liste med x-verdier
x_verdier = []
y_verdier = []

x = -5
while x <= 5:
    x_verdier.append(x)
    y_verdier.append(x**2 - 4)
    x = x + 0.1

# Tegn grafen
plt.plot(x_verdier, y_verdier)
plt.axhline(y=0, color='black', linewidth=0.5)
plt.axvline(x=0, color='black', linewidth=0.5)
plt.grid(True)
plt.title("Grafen til f(x) = x^2 - 4")
plt.xlabel("x")
plt.ylabel("f(x)")
plt.show()

Prinsippet er enkelt: vi regner ut $f(x)$ for mange x-verdier og lar Python tegne punktene som en sammenhengende kurve. Jo tettere x-verdiene ligger, desto jevnere blir kurven.

Simulering: Terningkast

Med programmering kan vi simulere tilfeldige forsøk tusenvis av ganger og se om resultatene samsvarer med det teorien sier.

Sannsynligheten for å kaste en sekser med en vanlig terning er $\displaystyle \frac{1}{6} \approx 0{,}167 = 16{,}7\%$.

La oss sjekke dette med et program:

import random

antall_kast = 10000
antall_seksere = 0

for i in range(antall_kast):
    terning = random.randint(1, 6)
    if terning == 6:
        antall_seksere = antall_seksere + 1

relativ_frekvens = antall_seksere / antall_kast
print("Antall kast:", antall_kast)
print("Antall seksere:", antall_seksere)
print("Relativ frekvens:", round(relativ_frekvens, 4))
print("Teoretisk sannsynlighet:", round(1/6, 4))

Eksempel på kjøring:

Antall kast: 10000
Antall seksere: 1672
Relativ frekvens: 0.1672
Teoretisk sannsynlighet: 0.1667

Jo flere kast vi simulerer, desto nærmere kommer den relative frekvensen den teoretiske sannsynligheten. Dette kalles de store talls lov.

Brute-force: Løse likninger ved å prøve mange verdier

Noen ganger kan vi løse likninger ved å la datamaskinen prøve mange verdier og se hvilken som passer best. Denne metoden kalles brute-force (rå kraft).

La oss si vi vil løse likningen $3x + 7 = 22$. Vi vet at svaret er $x = 5$, men datamaskinen kan finne det ved å prøve:

for x in range(-100, 101):
    if 3 * x + 7 == 22:
        print("Løsning: x =", x)

For likninger med desimaltall kan vi lete etter verdien der uttrykket er nærmest null:

# Løs 2.5*x - 8.3 = 0
best_x = -100
minste_avvik = abs(2.5 * (-100) - 8.3)

x = -100
while x <= 100:
    avvik = abs(2.5 * x - 8.3)
    if avvik < minste_avvik:
        minste_avvik = avvik
        best_x = x
    x = x + 0.01

print("Tilnærmet løsning: x =", round(best_x, 2))

Denne metoden er ikke den mest elegante, men den fungerer for mange typer likninger!

Halveringsmetoden (biseksjonsmetoden)

Halveringsmetoden er en smartere måte å finne nullpunkter på. I stedet for å prøve alle verdier, halverer vi søkeområdet i hvert steg.

Prinsippet: Hvis $f(a)$ og $f(b)$ har ulikt fortegn, vet vi at det finnes et nullpunkt mellom $a$ og $b$. Vi sjekker midtpunktet $\displaystyle m = \frac{a+b}{2}$. Hvis $f(m)$ har samme fortegn som $f(a)$, ligger nullpunktet mellom $m$ og $b$. Ellers ligger det mellom $a$ og $m$.

def f(x):
    return x**2 - 7    # Vi leter etter x der x^2 = 7

a = 2     # f(2) = 4 - 7 = -3 (negativ)
b = 3     # f(3) = 9 - 7 = 2  (positiv)

for i in range(50):     # 50 halveringer gir ekstremt god nøyaktighet
    m = (a + b) / 2
    if f(m) * f(a) > 0:
        a = m           # Nullpunktet er mellom m og b
    else:
        b = m           # Nullpunktet er mellom a og m

print("Nullpunkt: x =", round(m, 10))
print("Sjekk: f(x) =", round(f(m), 15))

Resultat: $x \approx 2{,}6457513111$ (som er $\sqrt{7}$!)

Statistikk med programmering

Python er perfekt for å beregne statistiske mål fra datasett. Her er et program som beregner gjennomsnitt, median og variasjonsbredde:

def gjennomsnitt(data):
    return sum(data) / len(data)

def median(data):
    sortert = sorted(data)
    n = len(sortert)
    if n % 2 == 1:
        return sortert[n // 2]         # Odde antall: midterste verdi
    else:
        midt1 = sortert[n // 2 - 1]
        midt2 = sortert[n // 2]
        return (midt1 + midt2) / 2     # Par antall: snitt av de to midterste

def variasjonsbredde(data):
    return max(data) - min(data)

# Testresultater fra en prøve
resultater = [78, 85, 62, 91, 74, 88, 67, 95, 73, 80]

print("Gjennomsnitt:", gjennomsnitt(resultater))
print("Median:", median(resultater))
print("Variasjonsbredde:", variasjonsbredde(resultater))

Resultat:

Gjennomsnitt: 79.3
Median: 79.0
Variasjonsbredde: 33

Oppsummering

I dette kapittelet har du lært:

- Rentesrente med løkker: Gang beløpet med vekstfaktoren i hver runde — programmet gjør utregningen år for år.
- Simulering: La datamaskinen gjenta et tilfeldig forsøk tusenvis av ganger og sammenlign med teoretisk sannsynlighet.
- Halveringsmetoden: Finn nullpunkter ved å halvere intervallet der fortegnet skifter, igjen og igjen.
- Statistikk: Gjennomsnitt, median og andre mål kan beregnes automatisk for store datasett.

Nøkkelbegreper

Husk