9.3 Programmering med følger og rekker

Programmering er et kraftig supplement til analytisk matematikk. Når vi studerer følger og rekker, gir Python oss muligheten til å:

- Generere hundrevis av ledd umiddelbart, selv for kompliserte rekursive formler
- Visualisere konvergens og divergens grafisk
- Eksperimentere med parametre og se effekten umiddelbart
- Modellere praktiske situasjoner der analytiske formler er kompliserte

I dette kapitlet bruker vi tre typer løkker:
- for-løkke: Når vi vet nøyaktig hvor mange iterasjoner vi trenger (f.eks. "beregn de første 50 leddene")
- while-løkke: Når vi itererer til en betingelse er oppfylt (f.eks. "kjør til feilen er under $10^{-6}$")

Vi bruker matplotlib for plotting og math for matematiske funksjoner.

# Geometrisk følge: a_n = 100 * 0.85^(n-1)
a1 = 100
k = 0.85
for n in range(1, 21):
    a_n = a1 * k**(n - 1)
    print(f"a_{n:>2} = {a_n:.4f}")

Rekursive følger oppdaterer variabelen i hver iterasjon:

# Rekursiv: a_{n+1} = 0.7 * a_n + 15, a_1 = 200
a = 200
print(f"a_1 = {a:.4f}")
for n in range(2, 21):
    a = 0.7 * a + 15
    print(f"a_{n:>2} = {a:.4f}")
# Grenseverdi: L = 0.7L + 15 => L = 50

Delsummer beregnes med en akkumulerende variabel:

import matplotlib.pyplot as plt

N = 100
S = 0
n_verdier = []
s_verdier = []

for n in range(1, N + 1):
    S += 1 / n**2       # Legg til neste ledd
    n_verdier.append(n)
    s_verdier.append(S)

plt.plot(n_verdier, s_verdier, "b-", linewidth=1.5)
plt.axhline(y=3.14159**2/6, color="red", linestyle="--",
            label=r"$\pi^2/6 \approx 1.6449$")
plt.xlabel("n")
plt.ylabel("$S_n$")
plt.title("Delsummer av $\\sum 1/n^2$")
plt.legend()
plt.grid(True)
plt.show()

En while-løkke er nyttig når vi ikke vet på forhånd hvor mange iterasjoner vi trenger. Et typisk brukstilfelle er å iterere til en følge har konvergert til ønsket presisjon.

Eksempel: Finne antall ledd til grenseverdien er nådd

# Geometrisk følge a_n = 500 * 0.9^(n-1)
# Finn første n slik at a_n < 1
a = 500
n = 1
while a >= 1:
    a = a * 0.9
    n += 1
print(f"Første n med a_n < 1: n = {n}, a_n = {a:.6f}")

Eksempel: Iterasjon til konvergens

# Rekursiv: a_{n+1} = (a_n + 3/a_n) / 2  (kvadratrot av 3 med Newton-metoden)
import math

a = 2.0       # Startgjetning
toleranse = 1e-10
n = 0

while True:
    a_ny = (a + 3 / a) / 2
    n += 1
    if abs(a_ny - a) < toleranse:
        break
    a = a_ny

print(f"sqrt(3) = {a_ny:.12f}  (etter {n} iterasjoner)")
print(f"math.sqrt(3) = {math.sqrt(3):.12f}")

Newton-metoden konvergerer ekstremt raskt (kvadratisk konvergens): antall korrekte desimaler omtrent fordobles per iterasjon.

Oppsummering

Læringspunkter:
- For-løkker passer når antall iterasjoner er kjent; while-løkker når man itererer til en betingelse er oppfylt (f.eks. «første ledd under 200»).
- Rekursive følger programmeres ved å oppdatere en variabel: a = p*a + q inne i løkka.
- Delsummer $S_N$ beregnes ved å akkumulere ledd i en sumvariabel — og kan brukes til å utforske konvergens numerisk.
- Numeriske metoder som Newtons metode ($\displaystyle a_{n+1} = \frac{1}{2}(a_n + \frac{c}{a_n})$ for $\sqrt{c}$) er rekursive følger som konvergerer raskt.
- Leibniz-rekken $\displaystyle \frac{\pi}{4} = 1 - \frac{1}{3} + \frac{1}{5} - \cdots$ konvergerer svært langsomt — valg av algoritme betyr mye.