Große Zahlen

Rechnen mit Ziffern-Strings in Kalkulation und Basic

In diesem Kapitel werden einige Basic-Funktionen vorgestellt, mit deren Hilfe man in jedem Standard Kalkulations-Programmen (LibreOffice-Calc, MS-Excel, ...) beliebig genau rechnen kann. Alle modernen Programmiersprachen bieten spezielle Module zum Rechnen mit beliebiger Genauigkeit. Dazu verwendet man an Stelle der üblichen Daten-Typen Strings (Texte) aus Ziffern. Das gleiche Prinzip kann man auch mit Basic und mit jedem Kalkulations-Programm anwenden.
Beispiel: Exakte Berechnung von 2^256, einer Zahl mit 79 Stellen - mit LibreOffice oder MS-Excel:
115792089237316195423570985008687907853269984665640564039457584007913129639936
Basic LibreOffice-Basic, Visual Basic, VBA - Strings (Text, Zeichen)
Kalkulation Zahlen-Werkzeug der Informatik (LibreOffice, OpenOffice, MS-Excel, ...)
Auf dieser Seite
Ziffern-String Rechnen wie mit Papier und Bleistift
Genauigkeit Rechnen mit 'gewöhnlicher' und fast unbegrenzter Genauigkeit
Werte-Bereich Kleinste und größte Werte von 'gewöhnlichen' Zahlen und Ziffern-Strings
String-Funktionen Auswahl von Basic-Funktionen zur Arbeit mit Ziffern-Strings
Auf anderen Seiten
BigInt Genau Rechnen mit großen ganzen Zahlen
BigFloat Genau Rechnen mit großen oder kleinen Gleitkomma-Zahlen

Rechnen mit Ziffern-Strings:   Wie mit Papier & Bleistift
In der Schule lernt man zwar noch das Rechnen mit Papier und Bleistift, es gibt jedoch immer weniger Menschen, die diese Kunst noch beherrschen.
Wer sich an die dabei verwendeten Methoden (Algorithmen) noch erinnert, kann in jeder Programmiersprache Funktionen zur beliebig genauen Rechnung programmieren. 		Die gleichern Methoden werden von den speziellen Modulen der modernen Programmiersprachen verwendet, z.B. von → Perl (Math::BigInt, Math::BigFloat, Math::BigRat) oder → PHP (bcmath, gmp).

Kalkulations-Programme mit Basic-Funktionen

Jedes Standard Kalkulations-Programm (LibreOffice, OpenOffice, MS-Excel, ...) lässt sich mit Funktionen in der Programmiersprache → Basic (LibreOffice-Basic, Visual Basic, VBA) ergänzen. 		Man muss einige kleinere → Arbeiten erledigen, um Basic-Funktionen zu verwenden, das ist jedoch (mindestens für fortgeschrittene AnwenderInnen) lohnend und sehr empfehlenswert.

♦ Details zur Integration von VBA-Funktionen in Kalkulations-Programme.

String

Man kann in jede Zelle eines Kalkulations-Blatts einen Text eintragen wie z.B.
 A
1String
2="Text"
3 =TEXT(123;"0")
Das Beispiel zeigt, dass man den Text wahlweise direkt eintragen oder durch eine Formel berechnen kann. Zur Umwandlung von Zahlen in Text (String) bietet jedes gängige Kalkulations-Programm die Funktion =TEXT()
Ohne weitere Maßnahmen werden Texte (Strings) immer links-bündig formatiert.
Ein String verwendet ungefähr so viele Bytes Speicherplatz wie seine Länge in Zeichen beträgt.

Ziffern-String

Ein Text kann lediglich aus Ziffern bestehen (z.B. in A11, A12 ):
 A
10123
11="234"
12=TEXT(345;"0")
'Echte' Zahlen wie in A3 werden normalerweise rechts-bündig formatiert, Ziffern-Strings dagegen wie andere Texte links-bündig.
Echte Zahlen sind intern mit je 4 oder 8 Byte Speicherplatz organisiert.
Wenn ein Ziffern-String eindeutig als Zahl erkennbar ist, dann können die meisten modernen Programme damit sogar rechnen, z.B. mit einer Formel =A4+1
Das ist jedoch nicht verlässlich !

Rechnen mit Ziffern-Strings

 CD
112="12"
234="34"
3=C1+C2=BigInt_Add(D1;D2)
Konventionelle Rechnung
In Zelle C3 werden die beiden Werte der Zellen C1,C2 auf konventionelle Weise addiert.
Alle 3 Werte werden intern als binäre Zahlen dargestellt, auch die Addition wird in einem einzigen Schritt binär ausgeführt.
Das Ergebnis ist die Zahl 46.

● Vorteil: Die Rechnung wird sehr rasch ausgeführt.
● Nachteil: Zur internen Darstellung stehen für jede Zahl nur maximal 8 Byte zur Verfügung. Das bedeutet: Die Genauigkeit beträgt maximal 14-15 Dezimal-Ziffern, die größte darstellbare Zahl beträgt ca. 1.8E+308
♦ Details zur internen Darstellung von Gleitkomma-Zahlen nach Standard IEEE-754, sowie zu den Grenzen von Genauigkeit und Werte-Bereich.
► Anwendung: Die Grenzen sind für fast alle üblichen Anforderungen ausreichend, und werden von den meisten AnwenderInnen nicht einmal bemerkt. Im Normalfall rechnet man daher - so wie vorgesehen - intern mit binären Zahlen.
Rechnung mit Ziffern-Strings
In Zelle D3 werden die beiden Ziffern-Strings der Zellen D1,D2 mit Hilfe einer Basic-Funktion BigInt_Add() addiert. Alle 3 Werte werden intern als Strings (Zeichenketten, Text) dargestellt.

Die Basic-Funktion BigInt_Add() isoliert zuerst die Einer-Ziffern "2" und "4", wandelt sie in Zahlen um, addiert 2+4=6 und wandelt das Ergebnis in das Zeichen "6" um.
Danach werden die Zehner-Ziffern "1" und "3" isoliert, in Zahlen umgewandelt, addiert 1+3=4, das Ergebnis in das Zeichen "4" umgewandelt und an den Ergebnis-String links angefügt.
Das Ergebnis ist der String "46".

● Vorteil: Es gibt kaum Grenzen für Genauigkeit und Werte-Bereich: Ein String kann bis zu ca. 32000 Ziffern enthalten.
● Nachteil: Die Rechnung ist kompliziert und braucht sehr viel Zeit. Das ist allerdings relativ, denn die Addition von zwei 100stelligen Zahlen mit voller Genauigkeit erfordert ca. 1/10 Sekunde.
► Anwendung: In Sonderfällen, d.h. wenn besonders hohe Genauigkeit verlangt wird, oder wenn man mit besonders großen (oder kleinen) Zahlen rechnen will.

Basic-Modul BigInt

Diese Text-Datei enthält den Quelltext einiger Funktionen zum Rechnen mit ganzen Zahlen in der Programmiersprache → Basic (LibreOffice-Basic, Visual Basic, VBA).

Man kann einzelne Funktionen oder das gesamte Modul in jedes gängige → Kalkulations-Programm (LibreOffice-Calc, MS-Excel, ...) aufnehmen und im Kalkulationsblatt als 'Benutzer-definierte Funktionen' verwenden.

Wenn man mit ganzen Zahlen rechnen will, dann ist dieses Modul vorzuziehen, weil es schneller rechnet als das Gleitkomma-Modul.

♦ Details zum Basic-Modul BigInt

Basic-Modul BigFloat

Diese Text-Datei enthält den Quelltext einiger Funktionen zum Rechnen mit Gleitkomma-Zahlen in der Programmiersprache → Basic (LibreOffice-Basic, Visual Basic, VBA).

Man kann einzelne Funktionen oder das gesamte Modul in jedes gängige → Kalkulations-Programm (LibreOffice-Calc, MS-Excel, ...) aufnehmen und im Kalkulationsblatt als 'Benutzer-definierte Funktionen' verwenden.

♦ Details zum Basic-Modul BigFloat

Grenzen der Genauigkeit

Variablen-Typen

In Technik, Naturwissenschaften und Informatik versteht man unter 'Genauigkeit' von Zahlen normalerweise die kleinste noch darstellbare Änderung eines Zahlenwerts.

Beispiel:
Die Angabe der → Kreiszahl mit Pi=3.14 ist auf 3 Dezimal-Stellen genau.
Diese Formulierung ist anschaulich und einfach überprüfbar. Diese Angabe ist ein relatives Maß, denn der maximale Fehler ist proportional zum jeweiligen Wert. Auch der Begriff 'Auflösung' ist zutreffend.

Variablen-Typ
Die Genauigkeit (Auflösung) ist in der Informatik vom Typ abhängig, d.h. von der Anzahl der zum Speichern verwendeten Bits und von den dazu verwendeten Regeln. 2 verschiedene Zahlen-Werte müssen sich mindestens in 1 Bit ihrer Speicherform unterscheiden.

■ Für Ganze Zahlen (Byte, Integer, Long) beträgt die Auflösung (absolute Genauigkeit) unabhängig vom Zahlenwert stets +/-1 unabhängig vom Wert.
Beispiel: ZahlenWert=100
Auflösung = +/-1, das ist in diesem Fall 1% vom Zahlenwert. Die nächst-liegenden Zahlenwerte sind 99 und 101.

• Das gilt auch für ganzzahlige Ziffern-Strings. Dieser Typ wird allerdings nur für sehr große Zahlenwerte verwendet, daher ist die relative Genauigkeit meist sehr groß.
Beispiel: Bei Berechnung von 2^256 beträgt der Abstand zur nächsten darstellbaren ganzen Zahl nur ca. P=1E-77 des Zahlenwerts. Die Genauigkeit ist daher sehr viel besser als bei der konventionellen Berechnung (Typ Double ) mit P=4E-16
■ Für Gleitkomma-Zahlen (Single, Double) ist die Auflösung vom Wert abhängig. Die Werte werden intern in → Mantisse und Exponent zerlegt und getrennt gespeichert. Die Genauigkeit P hängt davon ab, wieviele Bits für die Mantisse verwendet werden:
Single: 25 Bit; P=2^(-25) = 2.98E-8
Double: 51 Bit; P=2^(-51) = 4.44E-16

Beispiel: Zahlenwert=100.0, Typ=Single
Die kleinste unterscheidbare Differenz ist
100 * 2^(-25) = 0.000003
der nächst-liegende unterscheidbare Zahlenwert ist daher 100.000003

Es ist in der Praxis leichter verständlich, die Genauigkeit in Dezimal-Ziffern anzugeben:
DecZiffern = Bits * ln(2) / ln(10)
Das ergibt für die Typen Single (25 Bit) und Double (51 Bit):
25 * ln(2) / ln(10) = 7.53
51 * ln(2) / ln(10) = 15.35
Da es nur ganze Dezimal-Ziffern gibt, beträgt die Genauigkeit von 'Double' Zahlen je nach Wert entweder 15 oder 16 Dezimal-Stellen. Alle evtl. nachfolgenden Ziffern sind zufällig !
• Der Typ Double ist besonders wichtig, weil jedes Kalkulations-Programm diesen Typ (ungefragt) für Gleitkomma-Zahlen und große ganze Zahlen verwendet.

• Bei Ziffern-Strings ist die Genauigkeit von der Anzahl der berechneten Ziffern abhängig und damit frei wählbar. Das bedeutet: Man sollte mit BigFloat-Funktionen mindestens auf 20 Dezimal-Stellen genau rechnen, um mit dem großen Aufwand einen Vorteil zu erzielen.

Genauigkeit

Die Grenze der Genauigkeit erreicht man gelegentlich bei der Berechnung kleiner Differenzen von großen Zahlen, z.B.
 AB
11E20=TEXT(A1;"0")
21=TEXT(A2;"0")
3=A1+A2=BigInt_Add(B1;B2)
4=A3-A1=BigInt_Sub(B3;B1)

■ Das Beispiel zeigt in Spalte A die konventionelle Addition von +1 zu einer großen Zahl.
Das Ergebnis in Zelle A3 ist falsch, nämlich identisch mit der Zahl in A1
Die Grenze der Genauigkeit (ca. 15 Dezimal-Stellen) wird überschritten, daher kann ein Kalkulations-Programm diese Rechnung prinzipiell nicht ausführen.

Auch das Ergebnis der Subtraktion in Zelle A4 ist falsch. Hier handelt es sich nicht um ein Problem der Formatierung, sondern um eine Rechnung die man mit konventionellen Methoden nicht ausführen kann.
■ In Spalte B wird die gleiche Aufgabe mit Ziffern-Strings ausgeführt. Diese Methode rechnet zwar langsamer, jedoch absolut genau:

Das Ergebnis der Addition in Zelle B3 beträgt so wie erwartet =100000000000000000001

Das Ergebnis der Subtraktion in Zelle B4 beträgt so wie erwartet =1

Die Anwendung von Ziffern-Strings ist kaum begrenzt: Man kann die gleiche Rechnung auch mit Werten wie 1E100 in Zelle A1 oder mit ="1E1000" in Zelle B1 genau und richtig ausführen.

Mit Ziffern-Strings wird allerdings viel langsamer gerechnet. Daher verwendet man natürlich konventionelle Methoden für einfache Rechnungen mit geringen Anforderungen:
Mit dem Wert 1E15 (und kleineren Zahlen) in Zelle A1 rechnen beide Methoden richtig.

Grenzen des Werte-Bereichs

Variablen-Typen

Der Werte-Bereich gibt die kleinste und die größte Zahl an, die man mit einem bestimmten Variablen-Typ darstellen kann.
Dieser Bereich hängt - ebenso wie die Genauigkeit - davon ab, wieviele Bits man zum Speichern eines Typs verwendet, und welche Regeln man dabei anwendet.

■ Für Ganze Zahlen (Byte, Integer, Long) kann man die Anzahl der darstellbaren Zahlen aus jener der verwendeten Bits berechnen. Bei 'Unsigned' Typen (ohne Vorzeichen) beginnt der Werte-Bereich bei 0, 'Signed'-Typen sind symmetrisch zum Nullpunkt angelegt:
Byte: 8 Bit; R = 2^8 = 256; Bereich: 0 ... 255
Integer: 16 Bit, R = 2^16 = 65536; Bereich: -32768 ... +32767
Long: 32 Bit; R = 2^32 = 4294967296; Bereich: -2147483648 ... 2147483647

• Für Ziffern-Strings gibt es keine praktischen Grenzen: Ein String kann derzeit ca. 32000 Ziffern enthalten und damit größere Zahlen darstellen als man in der Praxis benötigt. Mit selbst definierten Variablen-Typen könnte man sogar noch größere Zahlen darstellen. 		■ Gleitkomma-Zahlen (Single, Double) werden intern in → Mantisse und Exponent zerlegt und getrennt gespeichert. Der Werte-Bereich R hängt davon ab, wieviele Bits für den Exponenten verwendet werden. Der Werte-Bereich wird meist für sehr große und sehr kleine absolute Werte getrennt angegeben.
• Beim Typ Single werden für den Exponenten 7 Bit (+1 Bit Vorzeichen) verwendet:
Single: 7 Bit; R = exp(2^7 * ln(2));
Bereich: -3.4E+38 ... +3.4E+38
bzw. -3.4E-38 ... +3.4E-38
• Beim Typ Double werden für den Exponenten 10 Bit (+1 Bit Vorzeichen) verwendet:
Double: 10 Bit; R = exp(2^10 * ln(2))
Bereich: -1.8E+308 ... +1.8E+308
bzw. -1.8E-308 ... +1.8E-308

• Der Typ Double ist besonders wichtig, weil jedes Kalkulations-Programm diesen Typ (ungefragt) für Gleitkomma-Zahlen und große ganze Zahlen verwendet.

• Bei Ziffern-Strings ist die Werte-Grenze von der Anzahl der berechneten Ziffern abhängig und damit frei wählbar.

Beispiel

Die → Fakultät-Funktion ist ein Beispiel, mit dem man rasch an der Grenze des Werte-Bereichs anlangt:
Mit 17!=3.56E+14 erreicht man die Grenze der ↑ Genauigkeit, mit 170! = 7.26E+306 die Werte-Grenze.
Die Berechnung von 171! ist mit konventionellen Methoden nicht mehr möglich.
In der Praxis kommt es oft vor, dass eine Differenz (Subtraktion) oder ein Quotient (Division) von 2 großen Zahlen zu berechnen ist, und das Ergebnis noch innerhalb der konventionellen Werte-Genzen liegt:
In diesem Fall ist es sinnvoll, nur einen Teil der Aufgabe mit Ziffern-Strings zu rechnen, den restlichen Teil jedoch konventionell (und daher sehr rasch).

Strings in Basic

In diesem Kapitel werden nur wenige ausgewählte String-Funktionen vorgestellt, die für Ziffern-Strings Bedeutung haben. ♦ Details zur allgemeinen String (Text, Zeichen) Programmierung und zu anderen Basic String-Funktionen.

Umwandlung Zahl -> Text

Die hier vorgestellten Funktionen arbeiten mit einzelnen Ziffern, d.h. mit Texten (Strings, Zeichenketten).
Die Standard-Funktion =TEXT() wandelt Zahlen in Text um. Diese Funktion erhält 2 Argumente:
Wert ... Der zu verwendende Zahlenwert
Textformat ... Ein Format-String, genauso wie zur Verwendung eines 'Benutzerinnen-definierten' Formats.

Beispiel: Wenn A1=12, dann gibt =TEXT(A1;"0000") den String 0012 zurück. Strings (Texte) werden ohne weitere Maßnahmen linksbündig angezeigt.

• Die Funktionen der Basic-Module → BigInt und → BigFlt akzeptieren sowohl Zahlen als auch Strings als Argumente. Die Umwandlung Zahl->Text ist daher nicht notwendig.
Unabhängig davon enthalten die beiden Module eigene Funktionen zur Umwandlung, die den Konstruktor-Methoden von Klassen nachgebildet sind:
BigInt_New() und BigFlt_New() akzeptieren eine Zahl als Argument und geben Ziffern-Strings zurück.

Umwandlung Text-> Zahl

Die Standard-Funktion =WERT() wandelt Ziffern-Strings in Zahlen um. Die dazu verwendeten Algorithmen sind die gleichen wie zur Decodierung manuell eingetragener Ziffern-Texte.

Beispiel: Wenn A2="0034" dann gibt =WERT(A2) die Zahl 34 zurück. Zahlen werden ohne weitere Maßnahmen immer rechtsbündig angezeigt.

Alle Funktionen der Basic-Module → BigInt und → BigFlt geben Ziffern-Strings zurück. Man kann =WERT() zur Umwandlung in Zahlen verwenden. Dabei wird jedoch intern der Typ → Double Precision verwendet, d.h. die Zahl wird auf maximal 15-16 Dezimalstellen gerundet.

Formatierung als Text

Man kann jede beliebige Zelle (wie üblich mit dem Menü Format | Zelle) als Text formatieren. In derartigen Zellen kann man allerdings keine Formel berechnen, da auch sie als Text angezeigt wird.

Typ-Umwandlung in Basic

Zur Umwandlung (Type Casting) von Variablen-Typen bietet Basic u.a. die Standard-Funktionen CDbl(), CInt(), CStr(), die auch in den Beispielen dieser Seite verwendet werden.
Wenn man aus Zahlen ein bestimmtes String-Format erzeugen will, dann eignet sich dazu die Basic-Funktion =Format()
Sie entspricht der Kalkulations-Fubnktion =TEXT().

Anzahl der Ziffern, Länge

Mit dieser Formel kann man die Anzahl der Dezimal-Ziffern jeder beliebigen Zahl berechnen:
=GANZZAHL(LN(Zahl)/LN(10))+1
Ersetzen sie 'Zahl' durch eine Zahl (z.B. 12345) oder durch die Adresse einer Kalkulations-Zelle (z.B. A1)
Die Standard-Funktion =LÄNGE gibt (je nach Programm und Version) nur die Anzahl der Zeichen in einem String korrekt an. Diese Variante gibt auch die Anzahl der Ziffern einer Zahl richtig an:
=LÄNGE("#"&A1)-1
Ersetzen sie A1 durch die gewünschte Adresse.

Zum Inhaltsverzeichnis Homepage von PS-Trainer   >   Entwicklung   >   Basic   >   Große Zahlen