Følger og rekker

Vi skal bruka tallfølger og rekker som introduksjon til iterative metodar.

Ei tallfølge er bare ein sekvens av tal. Den kan sjølsagt vera tilfeldig, men vi er mest opptatt av talfølger der vi har ein regel for kva tal som dukkar opp. For eksempel er ei aritmetisk talfølge laga ved at kvart ledd $a_n$ i følga blir danna ved at vi legg til eit bestemt tal, kalla differansen d, til det forrige talet $a_{n-1}$. Regelen er altså at

$a_n = a_{n-1} + d$.

For setja det heile "i gang", treng vi også det første leddet i følgen $a_0$. Så hvis vi tenkjer oss at differansen d = 2, og det første talet = 1, så kan vi skriva ut dei første ti ledda med følgande kode:

In [1]:
d = 2 #differansen
a = [0] * 10 #Vi lagar ei liste som vi fyller med 10 nullarar
a[0] = 1
N = 10 #antal ledd
for i in range(1,N):
    a[i] = a[i-1] + d

print(a)

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

Dette er eksempel på iterasjon i programmering. Vi har laga ei løkke der vi brukar den forrige verdien (det forrige leddet) til å rekna ut det neste. Men i dette tilfellet har vi også muligheten til å finna ledd nr n, direkte. Vi kan bruka den direkte formelen $a_n = a_0 + n\cdot d$:

In [2]:
ledd5 = a[0] + 5*d
print("ledd nr 5 er:",ledd5)

ledd nr 5 er: 11

Ei rekke liknar på ei følge, men i stadenfor å bare lista opp alle elementa, så summerer vi dei. Når vi summerer dei første ledda i ei aritmetiske følge, får vi ei aritmetisk rekke. Når vi summerer dei første 10 ledda i følgen over får vi delsummen $S_{10}$.

In [3]:
d = 2 #differansen
a = [0] * 10 #Vi lagar ei liste som vi fyller med 10 nullarar
a[0] = 1
S = a[0]
N = 10 #antal ledd
for i in range(1,N):
    a[i] = a[i-1] + d
    S += a[i]

print(a)
print("Summen av dei første ti ledda er:",S)

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
Summen av dei første ti ledda er: 100

I ei geometriske følge er ei følge der kvart ledd er lik det forrige multiplisert med eit bestemt tal, kalla kvotienten k. Med andre ord har vi her regelen

$a_n=a_{n−1}\cdot k$

No kan vi rekna ut dei første 10 når $a_0 = 1000$, og k = 1.02:

In [4]:
k = 1.02 #kvotienten
a = [0] * 10 #Vi lagar ei liste som vi fyller med 10 nullarar
a[0] = 1000
N = 10 #antal ledd
for i in range(1,N):
    a[i] = a[i-1] * k

print(a)

[1000, 1020.0, 1040.4, 1061.208, 1082.43216, 1104.0808032, 1126.162419264, 1148.68566764928, 1171.6593810022657, 1195.092568622311]

Dette er eit eksempel på rentersrente: Vi set inn 1000 kr i banken til 2% rente. Etter ni år har vi altså 1195,09 kr i banken. Også her fins det ein direkte formel vi kan bruka, nemlig

$a_n = a_0 \cdot k^n$

Så etter ni år har vi:

In [5]:
belop = a[0]*k**9
print("Beløpet etter ni år:",belop)

Beløpet etter ni år: 1195.092568622311

Når vi summerer ei geometriske følge, får vi altså ei geometrisk rekke. Hvis koeffisienten k er mindre enn 1, så vil rekka konvergera. Det betyr at delsummane $S_n$ vil nærma seg ei grense når n går mot uendelig. La oss sjå på eit eksempel der $a_0 = 0.5$ og k = 0.5. Etter ti iterasjonar får vi:

In [6]:
k = 0.5 #kvotienten
a = [0] * 10 #Vi lagar ei liste som vi fyller med 10 nullarar
a[0] = 0.5
S = a[0]
N = 10 #antal ledd
for i in range(1,N):
    a[i] = a[i-1] * k
    S += a[i]
print(S)

0.9990234375

Prøv sjøl med ulike verdiar av n. Summen vil i dette tilfelle konvergera mot 1 (korfor?). Generelt vi summen konvergera mot $\frac{a_0}{1-k}$

Kaotiske følger

Til slutt skal vi sjå at det ikkje alltid er mulig å finna ein regel som gir oss ledd nr n direkte, sjøl om vi har ein iterativ regel som gir oss kvart ledd vha iterasjonar. Feks. er den såkalte logistiske avbildningen som er gitt ved regelen:

$x_{n} = r·x_{n-1}·(1-x_{n-1})$

In [7]:
r = 3.81
x = 0.69
N = 5
for i in range(1,N):
    x = r * x*(1 - x)
    print(x)

0.8149590000000001
0.5745511558953897
0.9313244968392594
0.24368446980443034

Her kan du også prøva deg med ulike verdiar. Eksempelet over viser at vi kan ha rekna ut x iterativ uten nødvendigvis å bruka indeksar. For i setningen x = r * x*(1 - x), så står x-ane på høgre side for $x_{n-1}$, og x-en på venstre for $x_n$

In [ ]: