9.3 Matematikk med programmering

Programmering som verktøy i matematikk

I dei to førre kapitla lærte vi kva algoritmar er, og korleis vi skriv program i Python. No skal vi bruke desse ferdigheitene til å løyse ekte matematiske problem.

Datamaskina er fantastisk til oppgåver som krev mange berekningar eller gjentagingar. Der vi menneske fort blir trætte av å gjenta den same utrekninga 50 gonger, kan ein datamaskin gjere det på eit brøkdels sekund.

I dette kapitlet skal vi sjå på:
- Berekne renter og sparing over tid
- Simulere tilfeldige forsøk (terningkast)
- Finne nullpunkt til funksjonar
- Berekne statistiske mål med program

Berekne renter med løkker

Når du set pengar i banken, får du renter. Med rentesrente tener du renter på rentene. Vi kan bruke vekstfaktor og ei løkke for å berekne korleis ein sparesum veks 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 antalet år.

Men med eit program kan vi berekne dette steg for steg, og sjå kva som skjer kvart å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")

Teikne grafar med programmering

Eitt av dei kraftigaste verktøya i Python er moglegheita til å teikne grafar. Vi bruker eit tilleggsbibliotek som heiter matplotlib.

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

import matplotlib.pyplot as plt

# Lag ei liste med x-verdiar
x_verdier = []
y_verdier = []

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

# Teikn 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 reknar ut $f(x)$ for mange x-verdiar og let Python teikne punkta som ei samanhengande kurve. Jo tettare x-verdiane ligg, desto jamnar blir kurven.

Simulering: Terningkast

Med programmering kan vi simulere tilfeldige forsøk tusenvis av gonger og sjå om resultata samsvarar med det teorien seier.

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

La oss sjekke dette med eit 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 sannsynlegheit:", round(1/6, 4))

Døme på kjøring:

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

Jo fleire kast vi simulerer, desto næmare kjem den relative frekvensen den teoretiske sannsynlegheita. Dette kallast dei store tals lov.

Brute-force: Løyse likningar ved å prøve mange verdiar

Nokon gonger kan vi løyse likningar ved å la datamaskina prøve mange verdiar og sjå kva som passar best. Denne metoden kallast brute-force (rå kraft).

La oss seia vi vil løyse likninga $3x + 7 = 22$. Vi veit at svaret er $x = 5$, men datamaskina kan finne det ved å prøve:

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

For likningar med desimaltal kan vi leite etter verdien der uttrykket er nærmast null:

# Løys 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ærma løysing: x =", round(best_x, 2))

Denna metoden er ikkje den mest elegant, men ho fungerer for mange typar likningar!

Halveringsmetoden (biseksjonsmetoden)

Halveringsmetoden er ein smartare måte å finne nullpunkt på. I staden for å prøve alle verdiar, halverer vi søkeområdet i kvart steg.

Prinsippet: Viss $f(a)$ og $f(b)$ har ulikt forteikn, veit vi at det finst eit nullpunkt mellom $a$ og $b$. Vi sjekkar midtpunktet $\displaystyle m = \frac{a+b}{2}$. Viss $f(m)$ har same forteikn som $f(a)$, ligg nullpunktet mellom $m$ og $b$. Elles ligg det mellom $a$ og $m$.

def f(x):
    return x**2 - 7    # Vi leiter 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 halveringar gir ekstremt god nøyaktigheit
    m = (a + b) / 2
    if f(m) * f(a) > 0:
        a = m           # Nullpunktet ligg mellom m og b
    else:
        b = m           # Nullpunktet ligg 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 å berekne statistiske mål frå datasett. Her er eit program som bereknar 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 dei to midterste

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

# Testresultat frå ein prøve
resultat = [78, 85, 62, 91, 74, 88, 67, 95, 73, 80]

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

Resultat:

Gjennomsnitt: 79.3
Median: 79.0
Variasjonsbredde: 33

Oppsummering

I dette kapittelet har du lært:

- Rentas rente med løkker: Gang beløpet med vekstfaktoren i kvar runde — programmet gjer utrekninga år for år.
- Simulering: La datamaskinen gjenta eit tilfeldig forsøk tusenvis av gonger og samanlikn med teoretisk sannsyn.
- Halveringsmetoden: Finn nullpunkt ved å halvere intervallet der fortegnet skiftar, igjen og igjen.
- Statistikk: Gjennomsnitt, median og andre mål kan berast automatisk for store datasett.

Nøkkelbegrep

Husk