Beliebig große Zahlen mit Tabellen-Kalkulation

Basic-Modul 'BigInt' für LibreOffice-Basic, MS-Visual Basic (VBA), OpenOffice-Basic


Ganze Zahlen beliebiger Größe und Genauigkeit

Die BigInt-Funktionen werden in Form von offenem, lesbaren Quelltext in der Programmieersprache → Basic transportiert. Sie sind nach dem 'Laden' des Basic-Moduls als 'Benutzer-definierte Funktionen' verfügbar.

Die Verwendung des Moduls ist frei, jedoch ohne Gewähr.

Beachten sie die allgemeinen → Hinweise zur Verwendung von Basic-Funktionen in der Tabellen-Kalkulation.


Ziffern-Strings

Die gleiche Methode wird von ähnlichen Modulen aller modernen Programmiersprachen verwendet.


Werte-Grenze

Mit Standard-Methoden kann man 'nur' Zahlen bis zu dieser maximalen Größe darstellen:
(2^1024)-1 = 8.9885E+307
das entspricht einem Ziffern-String aus 307 Zeichen.

Mit BigInt-Funktionen kann man diese Grenze fast beliebig überschreiten, z.B. die Berechnung von 2^10000 mit
=BigInt_Pow(2;10000)
Das Modul BigInt enthält Funktionen, um auch so große Werte anzuzeigen, in diesem Fall z.B.
1.99506E+3010
mit 3010 (genau berechnetenen !) Stellen. Man kann Mantisse und Exponent in Standard-Zahlen umwandeln und damit getrennt weiter rechnen.

Es gibt Arbeits-Bereiche, in denen man leicht an die Werte-Grenze stoßen kann, z.B. die Kombinatorik: Diese Formel ist mit Standard-Funktionen nicht mehr zu berechnen:
=FAKULTÄT(171)
Die entsprechende BigInt-Funktion
=BigInt_Fakt(171)
liefert das exakte Ergebnis (hier auf 30 Stellen genau angegeben)
1.24101807021766782342484052410E+309

Details zur → Werte-Grenze von 'gewöhnlichen' Zahlen


Funktion =Rest()
Diese Funktion (international Modulo-Funktion) liefert für Argumente mit >=20 Ziffern entweder falsche Ergebnisse (einige ältere Programm-Versionen) oder Fehler-Meldungen.

Einige neuere Versionen von LibreOffice leiden unter Problemen, insbesondere bei der Formatierung von Zellen und bei der Verwendung von Basic-Funktionen.
Es funktioniert mit MS-Excel, problemlos, mit LibreOffice oder OpenOffice leider je nach Version unterschiedlich.

BigInt-Funktionen

• Die ganzahlige Division unterscheidet sich von der 'gewöhnlichen' Gleitkomma-Division: Ein allfälliger Nachkomma-Rest wird abgeschnitten.

Die Rechenzeit nimmt mit großen Zahlen rasch zu. Testen sie daher eine Aufgabe zunächst mit einfachen Zahlen.
Beispiel: Man kann den Wert von 2^10000 genau berechnen, sollte davor jedoch 2^1000 berechnen, dann 2^2000 usw.

Bei Verwendung in LibreOffice oder OpenOffice muss man diese Zeile (am Beginn des Basic-Quelltextes)
' Option VBASupport 1
aktivieren, d.h. das führende ' Kommentar-Zeichen entfernen.

Ohne besondere Maßnahmen werden Ziffern-Strings normalerweise linksbündig formatiert. Sie können das Format rechtsbündig ändern: Die BigInt-Strings sehen dann genauso aus wie Standard-Zahlen.

Die meisten Kalkulations-Programme können auch mit gemischten Typen rechnen, z.B.
="12345"+6
Davon wird abgeraten: Wandeln sie Ziffern-Strings vorher 'kontrolliert' in Standard-Zahlen um !

FunktionHinweiseBeispiel
Basic-Modul-Test
BigInt_Version(Trigger) Gibt die Versions-Bezeichnung des Basic-Moduls zurück =BigInt_Version()
BigInt_Test(Argument) Gibt (nur) bei korrekter Modul-Funktion eine kleine Zahl <0.01 zurück =BigInt_Test(JETZT())
Typ-Umwandlung
BigInt_New(Zahl) Umwandlung einer (Standard)-Zahl in einen Ziffern-String =BigInt_New(12345)
=BigInt_New(A1)
=BigInt_New("987")
BigInt_Value(BigInt)
ist äquivalent zu
WERT(BigInt)
Umwandlung eines Ziffern-Strings in eine (Standard)-Zahl =BigInt_Value("12345")
=WERT(A1)
Alternativ sind dazu auch die ↓ Funktionen des 'Wissenschaftlichen Formats' verwendbar
Zufallszahlen
BigInt_Random(Digits;Trigger) Erzeugt eine positive ganze Zufallszahl mit der angegebenen Anzahl von Ziffern (Digits) =BigInt_Random(30;ZUFALLSZAHL())
BigInt_RandomSgn(Digits;Trigger) Erzeugt eine ganze Zufallszahl mit der angegebenen Anzahl von Ziffern (Digits) =BigInt_RandomSgn(30;ZUFALLSZAHL())
Arithmetik-Funktionen
BigInt_Abs(BigInt) Gibt den Absolut-Wert (ohne Vorzeichen) zurück =BigInt_Abs("-12345")
BigInt_Add(BigInt1;BigInt2) Addiert 2 BigInt-Werte =BigInt_Add("12345";A1)
BigInt_Sub(BigInt1;BigInt2) Subtrahiert 2 BigInt-Werte =BigInt_Sub("12345";A1)
BigInt_Mul(BigInt1;BigInt2) Multipliziert 2 BigInt-Werte =BigInt_Mul("12345";A1)
BigInt_Mul2(BigInt) Verdoppelt einen BigInt-Wert =BigInt_Mul2(A1)
BigInt_Pow(BigInt1;BigInt2) Potenziert die Basis BigInt1 mit dem Exponenten BigInt2 =BigInt_Pow(2;2048)
BigInt_Div(BigInt1;BigInt2) Dividiert BigInt1 durch BigInt2 und schneidet den Nachkomma-Rest ab =BigInt_Div(A1;"12345")
=BigInt_Mod(BigInt1;BigInt2) Gibt den Rest bei ganzzahliger Division von BigInt1 durch BigInt2 zurück (Modulo- oder Rest-Funktion) =BigInt_Mod("12345";3)
=BigInt_Fakt(BigInt) Berechnet die Fakultät-Funktion =BigInt_Fakt(171)
Wissenschaftliches Format
BigInt_Sci(BigInt;Digits) Gibt einen String (!) im 'Wissenschaftlichen Format' (Mantisse + Exponent) zurück.
Praktisch zum Anzeigen sehr großer Zahlenwerte.
A1=BigInt_Pow(2;2000)
A2=BigInt_Sci(A1;5)
ergibt den String
1.1481E+602
BigInt_SciMant(BigInt;Digits) Gibt die dezimale Mantisse als Standard-Zahl zurück =BigInt_SciMant(A1;5)
BigInt_SciExp(BigInt) Gibt den dezimalen Exponenten als Standard-Zahl zurück =BigInt_SciExp(A1)
Adressen und Formeln
BigInt_Adr(Adresse) Gibt die Adresse des Arguments als String in der Form "A1" zurück =BigInt_Adr(A1)
ist äquivalent zu
=ADRESSE(1;1;4)
BigInt_AdrAbs(Adresse) Gibt die Adresse des Arguments als String in der Form "$A$1" zurück =BigInt_AdrAbs(A1)
ist äquivalent zu
=ADRESSE(1;1;1)
BigInt_FormulaInternational(Adresse) Gibt den Formel-Text (internationale Version) zurück, welcher in der angegebenen Zelle enthalten ist =BigInt_FormulaInternational(A1)
BigInt_FormulaLocal(Adresse) Gibt den Formel-Text (lokale Version) zurück, welcher in der angegebenen Zelle enthalten ist (Wenn unbekannt, wird die internationale Version zurückgegeben) =BigInt_FormulaLocal(A1)
ist Äquivalent zu (wenn vorhanden)
=FORMEL(A1)
BigInt_AdrFormula(Adresse) Gibt Adresse und Formel-Text einer Zelle als String zurück =BigInt_AdrFormula(Adresse)
ergibt z.B.
A1=100/3
Sonstige Funktionen
BigInt_Sgn(BigInt) Gibt das Vorzeichen zurück, so wie die Funktion =VORZEICHEN() für Standard-Zahlen. =BigInt_Sgn(BigInt)
Ergebnis ist eine Zahl aus {-1,0,+1}
BigInt_Round(BigInt;Digits) Rundet eine BigInt-Zahl auf die angegebene Anzahl von signifikanten Dezimalziffern =BigInt_Round()
BigInt_Trim(BigInt) Entfernt führende Nullen aus einem Ziffern-String =BigInt_Trim("00123")

Test: Basic-Modul geladen ?


Diese Kalkulations-Formel gibt nur dann den Wert WAHR zurück, wenn das Basic-Modul BigInt funktioniert:
=WENN(ISTFEHLER(BigInt_Test(JETZT()));
FALSCH;
WENN(BigInt_Test(JETZT()<0,01);
WAHR;
FALSCH)
)
Die Zelle wird z.B. mit grünem Hintergrund formatiert, sowie mit einer bedingten Formatierung, die bei Wert=FALSCH einen roten Hintergrund anzeigt.

Diese Kalkulations-Formel gibt einen String (Text) zurück:
="Modul BigInt " & WENN(ISTFEHLER(BigInt_Test(JETZT()));
"muss aktiviert werden";
WENN(BigInt_Test(JETZT()<0,01);
"funktioniert";
"muss aktiviert werden")
)

Grundrechnungs-Arten

 ABC
1Stellen =GANZZAHL(ZUFALLSZAHL()*11)+15
2Z1=BigInt_Random(B1)=WERT(B2)
3Z2=BigInt_RandomSgn(B1)=WERT(B3)
Mit Taste F9 werden neue Zufalls-Werte berechnet. Bei oftmaliger Wiederholung findet man, dass die erzeugten BigInt-Zahlen manchmal um 1-2 Stellen kürzer sind als vorgegeben:
In diesem Fall wurde als führende Ziffer eine 0 erzeugt und anschließend gelöscht, so wie für führende Nullen üblich.



 ABC
4Addition: Z1+1=BigInt_Add(B2;1)=C2+1
5Addition: Z1+Z2=BigInt_Add(B2;B3)=C2+C3
6Subtraktion: Z1-Z2=BigInt_Sub(B2;B3)=C2-C3



 ABC
7Divisor: D=GANZZAHL(ZUFALLSZAHL()*100)*1000
8Division: Z1\D=BigInt_Div(B2;B7)=GANZZAHL(C2/C7))
9Rest: Modulo(Z1,D)=BigInt_Mod(B2;B7)=REST(C2;C7)
10Multiplikation:=BigInt_Mul(B7;B8)=C7*C8
11Addition:=BigInt_Mul(B9;B10)=C9*C10

Typ-Umwandlung


Darüber hinaus akzeptieren fast alle Funktionen des Moduls BigInt sowohl Standard-Zahlen als auch Ziffern-Strings als Argumente, ebenso die Adressen von Zellen, welche derartige Daten enthalten. Die Prüfung (Validierung) der Argument-Daten erfolgt jedoch in diesen Fällen wesentlich einfacher.

Alle diese Beispiele
=BigInt_Pow(2,128)
=BigInt_Pow("2",128)
=BigInt_Pow("2","128")
geben den berechneten Wert von 2^128 als String von 39 exakten Ziffern zurück.



Die Funktion BigInt_Value() liefert die gleichen Ergebnisse wie WERT(), z.B. für einen String aus 10 zufälligen Ziffern:
B1=BigInt_Random(10)
B2=BigInt_Value(B1)
B3=B2+1

Das Beispiel funktioniert auch mit 20 und mehr Ziffern. Bei der Umwandlung wird die Genauigkeit jedoch reduziert.
Man könnte zwar die Addition mit BigInt_Add() exakt ausführen, nach Umwandlung ist diese geringe Differenz jedoch nicht mehr erkennbar.



Weitere BigInt-Funktionen spalten große Zahlen in Mantisse und Exponent und geben beide als Standard-Zahlen zurück, mit denen man weiter rechnen kann:

Beispiel:
A1=BigInt_Pow(2,2048)
A2=BigInt_SciMant(A1)
A3=BigInt_SciExp(A1)
gibt in Zelle A2 die Mantisse als Zahl 3,2317 zurück, in Zelle A3 den dezimalen Exponenten 616 als Zahl.
Wer den Begriff Logarithmus kennt und richtig anwendet, kann danach weitere Rechnungen mit Standard-Methoden anschließen.