Beregning av $e$

Med 100 desimaler er tallet $e$ lik: $$ 2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274$$

I dette dokumentet skal vi se på ulike måter man kan beregne eller finne dette tallet.

1. Definisjonen (formel)
2. Sum av (u)endelig rekke
3. Stigning til eksponentialfunksjon
4. Metode 4

Definisjonen

Tallet $e$ er definert som en grenseverdi der $$e = \lim_{n \to \infty} \left(1+\frac{1}{n}\right)^n$$

def euler(n):
    return (1+1/n)**n

euler(6)

for i in range(10):
    print(f"n = 10^{i} gir: {euler(10**i)}")

n = 10^0 gir: 2.0
n = 10^1 gir: 2.5937424601000023
n = 10^2 gir: 2.7048138294215285
n = 10^3 gir: 2.7169239322355936
n = 10^4 gir: 2.7181459268249255
n = 10^5 gir: 2.7182682371922975
n = 10^6 gir: 2.7182804690957534
n = 10^7 gir: 2.7182816941320818
n = 10^8 gir: 2.7182817983473577
n = 10^9 gir: 2.7182820520115603

Plotting

import numpy as np
import matplotlib.pyplot as plt

# Definerer funksjonen fra koden din
def euler(n):
    return (1 + 1/n)**n

# Lager verdier for n = 10^0, 10^1, ..., 10^12
n_values = [10**i for i in range(18)]
e_values = [euler(n) for n in n_values]

# Plotter grafen
plt.figure(figsize=(10, 6))
plt.xlabel("n (log-skala)")
plt.ylabel("Verdi av $(1 + \\frac{1}{n})^n$")
plt.title("Konvergens mot e for $(1 + \\frac{1}{n})^n$")
plt.xscale('log')

# Plotter grafen
plt.plot(n_values, e_values, marker='o', linestyle='-', label=r'$(1 + \frac{1}{n})^n$')
plt.axhline(np.e, color='gray', linestyle='--', label='e ≈ 2,71828')

# Finish
plt.grid(True, which="both", ls=":")
plt.legend()
plt.tight_layout()
plt.show()

Som sum av en uendelig rekke

Den blir desverre ikke uendelig i python, men $$ e = \sum_{n=0}^{\infty} \frac{1}{n!} = 1 + \frac{1}{1} + \frac{1}{1 \cdot 2} + \frac{1}{1 \cdot 2 \cdot 3} + \cdots $$

# Beregner e ved å summere 1 / n!
# n! betyr n fakultet (1*2*3*...*n)

n = 10       # Antall ekstra ledd etter n = 0
e_sum = 1    # Starter med leddet for n = 0

fakultet = 1 

for i in range(1, n + 1):      # Starter på n = 1
    fakultet *= i              # Oppdaterer n!
    e_sum += 1 / fakultet      # Legger til 1 / n!

print(f"Med {n} ledd blir summen. {e_sum}.")

Med 10 ledd blir summen. 2.7182818011463845.

Mer presisjon

from decimal import Decimal, getcontext

# Øk presisjonen til 50 desimaler
getcontext().prec = 50

# Funksjon som estimerer e med høy presisjon
def euler(n):
    n = Decimal(n)                 # Gjør n til et Decimal-objekt for bedre presisjon
    return (1 + Decimal(1)/n) ** n # Bruk eksakt brøk, og opphøy i n

# Regn ut og skriv ut (1 + 1/n)^n for n = 10^0 til 10^17
for i in range(50):
    n = 10 ** i
    approx = euler(n)
    print(f"n = 10^{i:<2} ⇒ (1 + 1/n)^n ≈ {approx}")

n = 10^0  ⇒ (1 + 1/n)^n ≈ 2
n = 10^1  ⇒ (1 + 1/n)^n ≈ 2.5937424601
n = 10^2  ⇒ (1 + 1/n)^n ≈ 2.7048138294215260932671947108075308336779383827810
n = 10^3  ⇒ (1 + 1/n)^n ≈ 2.7169239322358924573830881219475771889643150188366
n = 10^4  ⇒ (1 + 1/n)^n ≈ 2.7181459268252248640376646749131465361138226492207
n = 10^5  ⇒ (1 + 1/n)^n ≈ 2.7182682371744896680350648244260464479744469326778
n = 10^6  ⇒ (1 + 1/n)^n ≈ 2.7182804693193768838197997084543563927516450266825
n = 10^7  ⇒ (1 + 1/n)^n ≈ 2.7182816925449662711985502257778132731535082712844
n = 10^8  ⇒ (1 + 1/n)^n ≈ 2.7182818148676362176529772430091766921532384267806
n = 10^9  ⇒ (1 + 1/n)^n ≈ 2.7182818270999043223766440238603328628250131640896
n = 10^10 ⇒ (1 + 1/n)^n ≈ 2.7182818283231311439497940012972294998851799338840
n = 10^11 ⇒ (1 + 1/n)^n ≈ 2.7182818284454538262181168330929975773921378551026
n = 10^12 ⇒ (1 + 1/n)^n ≈ 2.7182818284576860944460591946141537298947220026332
n = 10^13 ⇒ (1 + 1/n)^n ≈ 2.7182818284589093212688645315496861971531142076764
n = 10^14 ⇒ (1 + 1/n)^n ≈ 2.7182818284590316439511451762510736134575953810932
n = 10^15 ⇒ (1 + 1/n)^n ≈ 2.7182818284590438762193732418312906967848884785790
n = 10^16 ⇒ (1 + 1/n)^n ≈ 2.7182818284590450994461960484004131885345872966896
n = 10^17 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452217688783290574364455437268746429
n = 10^18 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452340011465571231398813229825294007
n = 10^19 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452352243733799297102360016915118461
n = 10^20 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353466960622103672715805702442603
n = 10^21 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353589283304384329751395681958435
n = 10^22 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353601515572612395454954790917852
n = 10^23 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602738799435202025310702923872
n = 10^24 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602861122117482682346294135575
n = 10^25 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602873354385710748049853256856
n = 10^26 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874577612533554620209168985
n = 10^27 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874699935215835277244760198
n = 10^28 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874712167484063342948319319
n = 10^29 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713390710886149518675232
n = 10^30 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713513033568430175710823
n = 10^31 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713525265836658241414382
n = 10^32 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526489063481047984738
n = 10^33 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526611386163328641773
n = 10^34 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526623618431556707477
n = 10^35 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526624841658379514047
n = 10^36 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526624963981061794704
n = 10^37 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526624976213330022770
n = 10^38 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526624977436556845577
n = 10^39 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526624977558879527857
n = 10^40 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526624977571111796085
n = 10^41 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526624977572335022908
n = 10^42 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526624977572457345590
n = 10^43 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526624977572469577859
n = 10^44 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526624977572470801086
n = 10^45 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526624977572470923408
n = 10^46 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526624977572470935640
n = 10^47 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526624977572470936864
n = 10^48 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526624977572470936986
n = 10^49 ⇒ (1 + 1/n)^n ≈ 2.7182818284590452353602874713526624977572470936998

Metode 2 - Let og finn

Gitt en funksjon $$f(x) = a^x $$ Der $a$ er et tall du velger selv. (Start med $a = 1$)

Oppgave: Bestem $a$ slik at $f'(x) = a^x$ og $f'(1) = a$.

Her får du bruk for numerisk derivasjon igjen. Newtons kvotient: $$ f'(x) \approx \frac{f(x+\Delta x) - f(x)}{\Delta x} $$

tall = 1
delta_x = 1e-6

def f(tall, x):
    return tall**x


def derivert(f, x, delta_x):
    stigningstall = (f(tall, x + delta_x) - f(tall, x))/delta_x
    return stigningstall 


print("Beregner stigningstall i x = 1")

stigningstall = derivert(f, 1, delta_x)
print(f"a = {stigningstall:.6f}")

Beregner stigningstall i x = 1
a = 1.386295

Metode 3a - En utrolig merkelig metode

La oss bruke tallene vi har samlet inn

Så lenge det fortsatt er lapper igjen:

• Start på nytt med summen 0 og antall trukne lapper 0.
• Trekk én lapp om gangen, legg sammen tallene, og tell hvor mange lapper du trekker.
• Når summen har blitt minst 100, stopp og noter hvor mange lapper du brukte denne gangen.
• Gjenta til du ikke har flere lapper igjen. (Om du ikke kommer til 100 med de siste lappene forkastes disse).
• Lag en liste med antall lapper du trakk i hver runde.

from numpy import mean

liste_antall = [2,2,3,2,4,3,2,2,3,4,3]


print("Vi har nå denne lista")
print(liste_antall)
print("")
print("Gjennomsnittet er:")
print(mean(liste_antall))

Vi har nå denne lista
[2, 2, 3, 2, 4, 3, 2, 2, 3, 4, 3]

Gjennomsnittet er:
2.727272727272727

Simulering

# Gitt en liste med tall
liste = []
liste_antall = []

while len(liste) > 0:
    summen = 0 
    antall = 0
    while summen < 100:
        if len(liste) == 0:
            break
        tall = liste.pop()
        summen += tall
        antall += 1
        print(f"\nTall nummer {antall}. Tallet er {tall}")
        print(f"Runde {len(liste_antall)+1}. Summen er nå: {summen}")
    print(f"Legger til {antall} i lista")     
    liste_antall.append(antall)
   

print(liste_antall) 

Tall nummer 1. Tallet er 5
Runde 1. Summen er nå: 5

Tall nummer 2. Tallet er 4
Runde 1. Summen er nå: 9

Tall nummer 3. Tallet er 3
Runde 1. Summen er nå: 12

Tall nummer 4. Tallet er 2
Runde 1. Summen er nå: 14

Tall nummer 5. Tallet er 2
Runde 1. Summen er nå: 16

Tall nummer 6. Tallet er 3
Runde 1. Summen er nå: 19

Tall nummer 7. Tallet er 4
Runde 1. Summen er nå: 23

Tall nummer 8. Tallet er 2
Runde 1. Summen er nå: 25

Tall nummer 9. Tallet er 3
Runde 1. Summen er nå: 28

Tall nummer 10. Tallet er 2
Runde 1. Summen er nå: 30

Tall nummer 11. Tallet er 2
Runde 1. Summen er nå: 32
Legger til 11 i lista
[11]

Gjennomsnittlig antall trekk for å kommer over 100

from numpy import mean

liste_antall = [2,2,3,2,4,3,2,2,3,4,3]


print("Vi har nå denne lista")
print(liste_antall)
print("")
print("Gjennomsnittet er:")
print(mean(liste_antall))

Vi har nå denne lista
[2, 2, 3, 2, 4, 3, 2, 2, 3, 4, 3]

Gjennomsnittet er:
2.727272727272727

Metode 2b - Velg tilfeldige tall

Vi behøver ikke å lage en liste i forkant. Vi kan trekke tilfeldige tall direkte.

Funksjonen random returnerer et tilfeldig tall mellom 0 og 1.

Psudokode

Trekk et tilfeldig tall. Så lenge summen er mindre enn 1, trekk et tall til. Hold tellinga på hvor mange tall du trekker. Når summen overstiger 1 legger du til antallet nummer du trakk i en liste.

import numpy as np
from random import random
liste_antall = []

n = 1000000

for i in range(n):
    summen = 0
    antall = 0
    while summen < 1:
        tall = random()
        summen += tall
        antall += 1
    liste_antall.append(antall)
#print(liste_antall)
print(f"Antall forsøk: {n}.") 
print(f"Estimat for e: {np.mean(liste_antall)}")

Antall forsøk: 1000000.
Estimat for e: 2.717751

# Tilfeldige tall mellom 1 og 99.
from random import randint
liste = []
for i in range(100):
    tall = randint(1,99)

    liste.append(tall)

print(liste)

[93, 60, 27, 19, 92, 26, 3, 53, 33, 99, 49, 94, 34, 39, 79, 74, 35, 88, 81, 91, 11, 84, 8, 66, 67, 64, 87, 34, 22, 44, 61, 90, 96, 71, 17, 90, 72, 10, 21, 82, 84, 96, 38, 78, 80, 44, 3, 6, 39, 61, 28, 29, 8, 94, 66, 36, 96, 80, 33, 91, 45, 33, 74, 69, 88, 16, 44, 13, 83, 70, 1, 83, 73, 88, 97, 34, 67, 71, 68, 6, 22, 8, 10, 52, 60, 18, 43, 34, 89, 14, 64, 63, 20, 4, 20, 17, 64, 34, 52, 7]