PDA

Archiv verlassen und diese Seite im Standarddesign anzeigen : Ab n-te m Stellen von x^y herausfinden - geht das?


Gliese
2021-05-24, 16:25:41
Wenn man nur die ersten Stellen von x^y rausfinden will, ohne die Zahl komplett auszurechnen, kann man über den Logarithmus gehen und wenn man die letzten Stellen von x^y finden will, geht das über die diskrete Exponentialfunktion.

Dafür habe ich schon ein Python3-Script gebaut, das per Default die ersten und letzten Stellen von 3↑↑4 (= 3^3^3^3) im Dezimalsystem berechnet (abgespeckte Version):

#!/usr/bin/python3

import math
from decimal import Decimal, getcontext

first_n = 80
last_n = 80
getcontext().prec = first_n * 2

def z_to_str(system, value):
if system == 10:
return str(value)
raise ValueError("Not supported yet - in Arbeit")

system = Decimal(10)
base = Decimal(3)
exponent = Decimal(3**3**3)

logged_exp = exponent / (system.ln() / base.ln())
logged_exp = logged_exp.next_plus() # bugfix
left, right = str(logged_exp).split(".")

symbols = math.ceil(logged_exp)

full = None
if symbols > first_n + last_n:
first = z_to_str(system, system ** Decimal("0." + right))
first = first.replace(".", "")
first = first[:first_n].ljust(first_n, "0")
last = z_to_str(system, pow(base, exponent, system ** last_n)).zfill(last_n)
else:
full = str(base ** exponent)

print("Basis...: " + str(base))
print("Exponent: " + str(exponent))
print("Stellen.: " + str(symbols))
if full is None:
print("Anfang..: " + first)
print("Ende....: " + last)
else:
print("Zahl....: " + full)


Nun wäre es schön, wenn ich so eine Funktion bauen könnte:
def get_symbols(system, base, exponent, start, length)
Die Funktion soll die Zahl base^exponent (Zahlensystem system) nicht ganz ausrechnen, weil sie zu groß wäre, sondern in der Mitte ab start genau length Stellen ausgeben. Ich möchte damit Stück für Stück durch die Zahl iterieren und (stichprobenartige) Statistiken anlegen.

Ist das irgendwie möglich? Oder gibt es dafür überhaupt gar keine Methode?

Ich weiß nicht, mit welchen Begriffen ich Google füttern soll, ich kriege nur Unsinn raus bzw. höchstens, dass es für die Kreiszahl Pi auf Hex-Basis so eine Formel gibt, nicht ob es für x^y sowas möglich wäre.

Monger
2021-05-24, 16:45:31
Wenn die Zahl größer wird (und davon gehe ich aus) kommst du mit int nicht weit. Float scheidet eh aus. Schau dir mal numpy an, und wenn das als Bibliothek nicht reicht, erweitere deine Suche. Irgendwo gibts bestimmt ein geeignetes Framework.

Gast
2021-05-25, 14:25:09
Wenn dir ganze Zahlen reichen: python3 untersützt beliebig lange Integer.


In [1]: 14**524
Out[1]: 37246948237604578546166409174918930434644355152560741637223801785960134216365643 37987469851356156468201559809834948106419266083433777206305202942331547497926600 67133237325545099091160128023861886607536830518323528932662469509481165522936005 59477350929681143079229085835417369910623529531852831412776017947771398013615561 04326941629375104195420792596991475017775527290409513175024854327506217161504977 09448157057245815110359767842970184021742642358216138014960598811627153786764392 82338097151702631417301510248250130867896496725494108586372605748863563313059144 46600438930609581087993268494255171567616

Gast
2021-05-30, 05:46:09
Ich weiß nicht, ob es einfacher geht, als die letzten n+m Stellen zu berechnen. Diese bekommst du durch modulare Exponentiation modulo 10^{n+m}.

Gliese
2021-06-01, 00:48:44
1. Ich weiß bereits, dass Python beliebig lange Integers unterstützt - auch beliebig genaue Floats (über das Decimal-Module und dann getcontext().prec), nur steigt der Rechenaufwand gefühlt quadratisch, je weiter ich mich vom "Rand" (Links/Rechts) entferne.
2. "modulare Exponentiation" = Diskrete Exponentialfunktion = nur zur Berechnung der letzten Stellen hilfreich - hierfür kenne ich bereits das Vorgehen.
3. Ich möchte jedoch (Stich-)Proben von irgendwo aus der Mitte holen (z.B. ab Stelle n=1.500.000.000.000 genau m=50.000.000 Stellen (die bequem in den Arbeitsspeicher passen) von insgesamt 3.638.334.640.025 Stellen für 3↑↑4).

Sieht wohl so aus, dass es für mein Vorhaben grundsätzlich gar keine Methode/Vorgehen gibt, daher werden mir die bekannten Frameworks wie Numpy etc. nix bringen.

Schade. :frown:

Gast
2021-06-03, 19:41:57
BBP-Formeln wie für die Ziffern von pi gibt es vielleicht nur für manche irrationale Zahlen, polylogarithmische Zahlen:
https://mathoverflow.net/questions/219816/on-bailey-borwein-plouffe-formula-for-irrational-numbers
https://www.davidhbailey.com//dhbpapers/bbp-formulas.pdf

Du müsstest x^y als unendliche Summe \sum_{k >= 0}p(k)/{q(k)b^k} mit p,q Polynome von deg(p) < deg(q) schreiben.

Gast
2021-06-03, 19:46:44
PS: Da du Dezimalstellen willst, müsstest du b = 10 wählen. Der Ausdruck wird aber wohl keine ganze Zahl ergeben

Gast
2021-06-05, 10:20:44
Die Summe sollte nach Dirichlets Irrationalitätskriterium außer in trivialen Fällen p(k) = 0 wirklich irrational sein. https://sriasat.wordpress.com/2013/03/19/an-irrationality-criterion/

Ich hab die Rechnung nicht ausge-x-t, aber ein kurzer Überschlag sieht ganz danach aus.

Gliese
2021-06-06, 13:00:15
Hab mir das mal angeschaut.
Wikipedia (https://en.wikipedia.org/wiki/Bailey%E2%80%93Borwein%E2%80%93Plouffe_formula) selbst sagt:
Given a number a , there is no known systematic algorithm for finding appropriate p(k), q(k), and b; such formulas are discovered experimentally.
Für einige sind Reihen bekannt, darunter:
Pi, log(2), Pi², Pi*log(2), Pi*Wurzel(3)*log(2), Pi³
aber ich kann keine Reihe für Exponentiation finden. :frown:

Wenn ich das in Python eingebe, kriege ich raus: log(Wurzel(2))

z=0
for k in range(1, 1000):
z+=0.5/(k*2**k)

print(z)



Mit dieser Reihe kriege ich raus: log(3^n)

import math
z=0
n=3
for k in range(0, 1000):
# z+=(2*1/(k*2**k) - 1/(k*4**k))*n # k=1..INF
z+=n/4**k*(1/(2*k+1)) # k=0..INF

print(z, math.e**z) # 3.295836866004329 26.999999999999996

Mit 3^n ohne den Logarithmus wäre ich zumindest mit b=4 (auf andere Binär-Basen umrechenbar) schon einem Teilziel näher (mich interessiert nicht nur b=10 !).

Gäbe es eine Reihe für Potenzen ohne Logarithmus, dann könnte ich auch 2^n oder 3^n, mit n=0.5 wählen und könnte die n-te Stelle von Wurzel(2), Wurzel(3) ... ausrechnen.
Die deutsche Version des Artikels (https://de.wikipedia.org/wiki/Bailey-Borwein-Plouffe-Formel) stellt jedoch klar:
Vermutlich gibt es für Quadratwurzeln Wurzel(2), Wurzel(3), Wurzel(5), die Eulersche Zahl e ... keine BBP-Reihe, da das (vermutlich) keine polylogarithmischen Konstanten sind.
Somit fallen wohl generell Reihen in Form von x^y ins Wasser. So wie ich es verstanden habe.