wie kann ich 60 hoch 60 berechnen ohne umständilich 60 * 60 * 60 * 60 usw schreiben zu müssen

habe auch schon an eine schleife gedacht. ich denke aber wegen performance-gründen, das eine mathematische formel schneller brechnet ist als immer wieder schleifen zudurchlaufen


Moderiert von Klabautermann: Topic aus Off Topic verschoben am Mo 25.10.2004 um 23:57

Willkommen in der wunderbaren Welt der Logarithmengesetze:



Gruß,
Jörg

60 ^ 60
= (60 ^ 30) ^ 2
= ((60 ^ 15) ^ 2) ^ 2
= ((60 ^ 14 * 60) ^ 2) ^ 2
= (((60 ^ 7) ^ 2 * 60) ^ 2) ^ 2
= (((60 ^ 6 * 60) ^ 2 * 60) ^ 2) ^ 2
= ((((60 ^ 3) ^ 2 * 60) ^ 2 * 60) ^ 2) ^ 2
= ((((60 ^ 2 * 60) ^ 2 * 60) ^ 2 * 60) ^ 2) ^ 2

Naja, das das auf ne Rekursion rausläuft, sollte jetzt ersichtlich werden

Anyone who is capable of being elected president should on no account be allowed to do the job.
Ich code EdgeMonkey - In dubio pro Setting.

thx check das gleich mal ab....

unter dem richtigen begriff bin ich auch in der hilfe fündig geworden.



muss es doch dann heissen und wie kriege ich den spass in einen integer wert? für ne progress?

User-Xy2004 hat folgendes geschrieben:

..und wie kriege ich den spass in einen integer wert? für ne progress?

gar nicht.. 60^60 = 4887367798068925748932275227377460386566085017600000000000000 und das oberste Limit für einen Integer (bzw eigentlich unsigned integer) ist 4294967296. Also doch etwas niedriger..!

Servus!

Man gebe den Begriff "Power" ein und verwende die Hilfe...

Gruß,

Adrian

@User-Xy: Wie wärs denn, wenn du gleich mal schreiben würdest, was du machen willst. Oder sollen wir hier noch ewig rumraten?

Motzi hat folgendes geschrieben:

60^60 = 4887367798068925748932275227377460386566085017600000000000000

Das kann nicht stimmen. 10^60 hat schon 61 Stellen. 60^60 müßte nach meiner Überlegung alleine mindestens 60 Nullen am Ende haben, und noch einiges davor. Deine Zahl ist viel zu klein - an deiner Aussage ändert sich aber natürlich nichts..

Edit: 60^60= 6^60 * 10^60

6^60 = 48873677980689257489322752273774603865660850176
10^60 = 1 0000000000 0000000000 0000000000 0000000000 0000000000 0000000000



Moderiert von Christian S.: Code-Tags hinzugefügt, damit Zahl gescrollt wird

Gausi hat folgendes geschrieben:

Motzi hat folgendes geschrieben: 60^60 = 4887367798068925748932275227377460386566085017600000000000000 Das kann nicht stimmen. 10^60 hat schon 61 Stellen. 60^60 müßte nach meiner Überlegung alleine mindestens 60 Nullen am Ende haben, und noch einiges davor. Deine Zahl ist viel zu klein - an deiner Aussage ändert sich aber natürlich nichts..

Hast recht.. da is was beim kopieren verloren gegangen.. Das richtige Ergebnis ist:

Motzi hat folgendes geschrieben:

4887367798068925748932275227377460386566085017600000000000000

Diese Nullen vertreten symbolisch die insgesamt sechzig Nullen, die eigentlich dahin gehören.

*editzulangsam*

Naja, auf die paar Nullen kommts ja auch nicht an, wenn man die Zahl für ne Progressbar braucht
Ich würde aber auch gerne wissen, was er machen möchte...wahrscheinlich alle möglichen Schachpartien auflisten oder so

bei x:=exp(60*ln(60))komme da irgend wie immer zu folgendem ergebnis 4,88736779806893E106 deshalb meine frage nach der kovertierung nach integer. das es ein bisschen mehr wird konnte ich mir ja schon denken aber dann gleich soviel das es sich nicht mehr mit ner progress anzeigen lässt. naja... man könnt jetzt wieder umständilich über umständliche tricks wie division usw nachdenken. aber ich lasse das dann mal so laufen.

im übrigen ich bastel grad an einem wörterbuchgeneartor, welcher die file.dic gleich passed auf 1000 zu schneidet und beid dem ich auch mal neustarten kann, dh den prozeß mal unterbrechen um ihn später wieder fortzusetzen. soweit geht das ding auch schon. da ich doch nu schon mehrere tage auf ein ergebniss warte und auch noch ein paar tage warten muß bis fertg is hätte ich gerne ne progress die mit es verrät.

Ich habe keine Ahnung von Wörterbuchgeneratoren, aber ich gebe mal noch nen Hinweis zu dem Zahlenproblem.

Du willst das in einer Progressbar verwenden. Ich nehme also mal an, dass du irgendeine Operation/Rechnung/sonstwas hast, welche überschlagsweise 60^60 Schritte benötigt. Da musst du, wie du richtig erkannt hast, ein paar Tage drauf warten. Ich will mal etwas erläutern, was ein "paar Tage" in dem Fall sind:

Schau dir folgendes Gedankenspiel an.

Annahme: 3 GHz Rechner, 1 Takt = 1 Rechenschritt (völlig utopisch)

pro Sekunde kannst du also 3*10^9 Operationen durchführen. Rechnen wir großzügig mit 10^10 Operationen pro Sekunde. (also mit nem ~10GHz Rechner)

1 Jahr hat 31.536.000 Sekunden. Rechnen wir großzügig mit 10^8 (das ist ungefähr das 3fache). In einem Jahr machst du also 10^18 Rechenschritte.

Für deine 60^60 (~10^106, rechnen wir großzügig mit 10^100, das sind 0.0001% deines Problems) Operationen benötigst du also knappe 10^82 Jahre.

Das Universum existiert seit ca. 15.000.000.000 Jahren. Rechnen wir großzügig mit 10^11 Jahren, das wären 100 Milliarden Jahre.

Du benötigst also 10^71 mal so lange, wie ein normales Universum existiert.

Und wenn du deine Berechnung aufteilst auf mehrere Rechner, und du hättest für jeden Erdenbürger 10 Rechner (großzügig 10 Milliarden Menschen, also 10^12 Rechner), dann könntest du etwas Zeit einsparen, und würdest nur 10^59 Universen Zeit brauchen.

Klar, was ich mit "auf die paar Nullen kommts nicht an" meinte? du kannst die 60 Nullen am Ende locker weglassen, und würdest trotzdem ein paar Milliarden Jahre brauchen, selbst wenn jeder Rechner auf der Welt an deinem Problem arbeitet...

Wieso gibt

1,15292150460685E18
und nicht 3600?

hmm es gibt doch int64.. warum gibt es eigentlich nicht int128 etc. für größere zahlen? ^^

habe mir die sache heute nochmal angesehn. die formel kann irgendwie nicht ganz richtig sein. ob wohl sie programmier-technisch richtig ist. der fehler liegt wohl ehr in meiner in meiner kunst zurechnen. wo bei ich mit 60 hoch 60 eine relativ hohe zahl genommen habe

also nochmal, mit kleien beträgen:


wenn ich 10*10*10*10 // IntToStr(10*10*10*10) // rechne komme ich auf 10000 - was konkret richtig ist
wenn ich 10 hoch 4 // FloatToStr(exp(10*ln(4))) // rechne was meiner auffassung nach das gleiche ist komme ich aber auf 1048576 - was zwar mathematisch richtig sein mag ab nicht mein ergebnis ist

weiß den hier jemand was ich meine und wie ich zum richtigen ergebnis komme? ich habe es mit zahlen leiden nicht so...


kurz noch ein paar wort zu der ansicht von gausi.
sehr intressantes gedankenspiel. von den math. grössen habe ich zwar nicht so viel verstanden, aber kappiert worau es hinaus läuft
ich hoffe in wenigen jahren sind rechner mit 10 und mehr GHz für geld zukaufen zukönnen.
kleiner scherz. wenn das nicht in einer akzeptablen zeit machbar ist (akzeptabel=so 8 monate bis 1 jahr) werde ich diese idee wieder verwerfen

Du hast die e-Funktion falschrum angewendet. Aus

wird
z:=exp(y*ln(x));.

GTA-Place hat folgendes geschrieben:

Wieso gibt markieren Delphi-Quelltext     1: exp(60*ln(2)); 1,15292150460685E18 und nicht 3600?

Noch nie was von Logaritmen gehört?
Basis und Exponent sind da vetauscht. Mit anderen Worten rechnest du 60 zur Basis 2 aus.

2^60 = 1,15[..]*10^18

Für 60^2 müsstest du exp(2*ln(60)) angeben.

von logaritmen cosinus und sonem zeugs habe ich vor jahren in der schule mal was von gehört. aber auch da ist leider nicht viel haft geblieben. wie ich eingesteh muß.
von soviel zahlen wirr war wird mir schlecht.
ich gebe es erstmal an der stelle auf. das prog läuft ja soweit.

aber danke an alle die sich meiner angenommen haben.