Pi tot op 62biljoen decimalen

[outremer]

https://www.scientias.nl/getal-pi-opnie ... en-bekend/

de laatste 10 cijfers in die ongelooflijke reeks : 7817924264

ik vroeg me nu af, aangezien de decimalen van pi oneindig verder blijven lopen zonder zich te herhalen, betekent dit dan dat elke combinatie van 10 getallen wel ergens zal verschijnen ?
of is het toch zo dat niet elke combinatie zal voorkomen ?
of weten we dat gewoonweg niet ?

[RedCat]

Weten we (nog) niet, zie bv:
https://oeis.org/wiki/Disjunctive_numbe ... _number.3F
It is not known whether π = 3.1415926535897932384626433832795... is a disjunctive number.

Voor achtergronden van disjunctive numbers (= disjunctieve getallen), zie bv:
https://en.wikipedia.org/wiki/Disjunctive_sequence

In het kort:
Een rijk getal (= disjunctief getal = disjunctive number) is een reeel getal waarvan de cijfers achter de komma een disjunctieve rij vormen.
Een disjunctieve rij is een oneindige rij (over een eindig alfabet van karakters; in ons geval
de 10 cijfers 0 t/m 9) waarin elke eindige rij (in ons geval: elk getal) voorkomt als een deelrij.

[tempelier]

Het is zelfs mogelijk dat in de decimalen sommige cijfers totaal ontbreken.

[Hypercharge]

Als de decimalen willekeurig neergezet worden zal elke rij decimalen zich herhalen. Elk aantal decimalen zal zich herhalen. Zelfs zestig biljoen. Pi is echter niet willekeurig. De decimalen kunnen worden uitgerekend.

[efdee]

Hebben zoveel decimalen enig nut?

[irArjan]

wordt gebruikt in getaltheorie volgens mij. Niet per se in engineering

[efdee]

Maakt men zich ook zo druk om
e = 2,71828182845905 = exp(1)
of andere getallen?

[Xilvo]

Maakt men zich ook zo druk om
e = 2,71828182845905 = exp(1)
of andere getallen?

Ik denk het niet. Pi spreekt nu eenmaal meer aan en er zijn eerdere records die gebroken kunnen worden.
Meestal is het een demonstratie van wat een nieuwe supercomputer kan.

[wnvl1]

Opvallend is dat de benodigde tijd om N digits van pi te berekenen O(N) is en het benodigde geheugen O(log N).
Dat valt best mee om progressie te boeken.

https://cs.uwaterloo.ca/~alopez-o/math- ... ode12.html

[joneo]

Hebben zoveel decimalen enig nut?

Praktisch nut? Nee. Bij cirkel met een doorsnede van onze Melkweg zijn ca 35 decimalen genoeg om de omtrek te bepalen met de nauwkeurigheid van de afmeting van een proton.
Boeiend en leuk is het wel. Ik heb 10 jaar geleden vanuit Exel een poster gemaakt van ca 50.000 decimalen, elke decimaal met een eigen kleur.

[Math-E-Mad-X]

Opvallend is dat de benodigde tijd om N digits van pi te berekenen O(N) is en het benodigde geheugen O(log N).
Dat valt best mee om progressie te boeken.

https://cs.uwaterloo.ca/~alopez-o/math- ... ode12.html

Ik neem aan dat je verwijst naar dit stukje:

An interesting new method was recently proposed by David Bailey, Peter Borwein and Simon Plouffe. It can compute the Nth hexadecimal digit of Pi efficiently without the previous N-1 digits. The method is based on the formula:

\(\pi = \sum_{i = 0}^\infty (1 16^i) ((4 8i + 1) - (2 8i + 4) - (1 8i + 5) - (1 8i + 6))\)

in O(N) time and O(log N) space. (See references.)

Maar daar staat dus niet wat jij zegt. Er staat dat het berekenen van het N-de cijfer gedaan kan worden in O(N) time and O(log N) space. Dat is dus niet hetzelfde als het berkenen van de eerste N cijfers.

[RedCat]

\(\displaystyle \pi = \sum_{i = 0}^\infty \left[ \frac{1}{16^i} \left( \frac{4}{8i + 1} - \frac{2}{8i + 4} - \frac{1}{8i + 5} - \frac{1}{8i + 6} \right) \right]\)

zie https://observablehq.com/@rreusser/comp ... fe-formula
(mooie pagina, waar ook voorbeelden en programmeercode gegeven wordt)

[CoenCo]

[Edit]: oeps, er waren al heel veel reacties die ik niet had gezien

[wnvl1]

Klopt, de complexiteit gaat maximum naar \( O(N^2)\) voor N cifers als je ze allemaal wil berekenen. Het geheugen blijft wel mooi beperkt met die O(logN).

[wnvl1]

Eens geprobeerd met deze code met integer berekeningen. Duurt 35s om de miljoenste hexadecimale digit te berekenen op mijn PC met python.

Code: Selecteer alles

import time
import matplotlib.pyplot as plt

D = 14        # number of digits of working precision
M = 16 ** D
SHIFT = (4 * D)
MASK = M - 1

def S(j, n):
    # Left sum
    s = 0
    k = 0
    while k <= n:
        r = 8*k+j
        s = (s + (pow(16,n-k,r)<<SHIFT)//r) & MASK
        k += 1
    # Right sum
    t = 0
    k = n + 1
    while 1:
        xp = int(16**(n-k) * M)
        newt = t + xp // (8*k+j)
        # Iterate until t no longer changes
        if t == newt:
            break
        else:
            t = newt
        k += 1
    return s + t

def pi(n):
    n -= 1
    x = (4*S(1, n) - 2*S(4, n) - S(5, n) - S(6, n)) & MASK
    return "%014x" % x

# x axis values
n_array = [1000, 10000, 100000, 200000, 300000, 400000, 1000000]
# corresponding y axis values
tijd = [0]*len(n_array)

for i in range(len(n_array)):
    start = time.time()
    pi(n_array[i])
    end = time.time()
    tijd[i] = end - start


# plotting the points
plt.plot(n_array, tijd)

# naming the x axis
plt.xlabel('hexadecimale digit van pi')
# naming the y axis
plt.ylabel('Tijd (s)')

# giving a title to my graph
plt.title('Pi')

# function to show the plot
plt.show()

Gebaseerd op
https://web.archive.org/web/20150627225 ... 8Python%29