[Mathematik] Große Potenzen berechnen

  • Allgemein

Es gibt 4 Antworten in diesem Thema. Der letzte Beitrag () ist von petaod.

    [Mathematik] Große Potenzen berechnen

    Hallo,

    ich wollte große Potenzen wie exemplarisch
    2^8832 und dergleichen berechnen.

    Dafür nutze ich die Logarithmus-Gesetze,

    a^b, lässt sich genauso gut auch als 10^(b*log10(a)) schreiben, das wiederum als 10^floor(b*log10(a)) * 10^(b*log10(a)-floor(b*log10(a)))

    Der Vorteil an dieser Schreibweise:
    Durch die Isolation, wird auf der linken Seite des Terms lediglich 10^n berechnet. Das heißt, das Resultat ist eine Zahl mit n Nullen (einfach die 10, n mal multipliziert).

    Auf der rechten Seite des Terms erhalten wir eine kleine Komma-Zahl. Der Trick ist nun, diese Komma-Zahl entsprechend korrekt zu verschieben.

    Hier mal die Implementierung:

    C#-Quellcode

    1. public static string CalculateBigPower(double basis, int exponent)
    2. {
    3. StringBuilder sb = new StringBuilder();
    4. int amountZeroes = (int)((double)exponent * Math.Log10(basis));
    5. double specification = (double)exponent * Math.Log10(basis) - amountZeroes;
    6. specification = Math.Pow(10, specification);
    7. int specificationAmount = (int)(Math.Log10(specification) + 1) + amountZeroes;
    8. string data = (specification + "").Replace(",", "");
    9. for (int i = 0; i < specificationAmount; i++)
    10. {
    11. if (i < data.Length)
    12. sb.Append(data[i]);
    13. else sb.Append("0");
    14. }
    15. return sb.ToString();
    16. }


    Das Problem ist halt: Die Zahl stimmt für die ersten 15 Stellen, danach endet aber auch schon die Kommazahl.
    Gibt es eine Möglichkeit beliebig genau, b*log(a) auszurechnen? So auf 200 Stellen nach dem Komma?

    Lieben Dank!
    _
    DotNETWork (Generische Tcp-Klasse, verschlüsselt!)
    MonogameMinecraftClone (Minecraft-Klon)
    NeuroEvolution (Implementation zweier Lernmethoden für neuronale Netze)
    Die Klassen sind mir bereits bekannt. Wollte aber _ eigens einen implementieren.

    Log10(x) auf beliebig viele Nachkommastellen zu berechnen ist aber auch rechen-intensiv oder ?
    _
    DotNETWork (Generische Tcp-Klasse, verschlüsselt!)
    MonogameMinecraftClone (Minecraft-Klon)
    NeuroEvolution (Implementation zweier Lernmethoden für neuronale Netze)

    φConst schrieb:

    rechen-intensiv
    Das läuft letzten Endes alles auf eine Reihenentwicklung hinaus.
    Mit einer eigenen LargeBigDouble-Klasse ( :thumbsup: ) mit { +, -, * und ggf. / } wärst Du dabei.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    VB-Fragen über PN / Konversation werden ignoriert!